OGC3DTilesSystem.cpp

#include "OGC3DTilesSystem.h"
#include "OGC3DTilesBounds.h"
 
#include "../OGC3DTilesUtils.h"
#include "../OGC3DTilesAccessParser.h"
#include "../OGC3DTilesAssetsParser.h"
#include "../OGC3DTilesTileset.h"
#include "../OGC3DTilesSubtree.h"
#include "../Components/OGC3DTilesComponent.h"
 
#include "Context.h"
#include "ViewContext.h"
#include "EntityStore.h"
#include "ExtensionRegistry.h"
 
#include "Services/Time.h"
#include "Services/QualityService.h"
#include "Services/Variables.h"
 
#include "Components/Core/ModelComponent.h"
#include "Components/Core/MeshComponent.h"
#include "Components/Core/SceneComponent.h"
#include "Components/Core/SubMeshRenderComponent.h"
 
#include "Systems/Core/CameraSystem.h"
#include "Systems/Core/TransformSystem.h"
 
#include "Resources/MeshManager.h"
#include "Resources/ModelManager.h"
#include "Resources/VertexFormats.h"
#include "Resources/MaterialManager.h"
#include "Resources/MaterialInstance.h"
#include "Resources/DefaultMaterial.h"
#include "Resources/Texture.h"
 
#include "Renderer/RenderResource.h"
 
#include "Foundation/Logging/Logger.h"
#include "Foundation/HashFunctions.h"
 
#include <glm/gtc/matrix_transform.hpp>
#include <glm/gtx/quaternion.hpp>
 
#include <chrono>
#include <algorithm>
#include <vector>
#include <bitset>
#include <string>
 
using namespace Cogs::Core;
 
constexpr int MAX_NUM_ACTIVE_MODEL_REQUESTS = 64;    // Max number of active model requests in total
constexpr int MAX_NUM_ACTIVE_SUBTREES_REQUESTS = 8;
constexpr int MAX_NUM_ACTIVE_SUBTILESET_REQUESTS = 8;
constexpr int MAX_NUM_MODEL_REQUESTS_PER_FRAME = 24; // Max number of new model req. per frame
constexpr float DEFAULT_GRACE_PERIOD_BEFORE_TREE_TRAVERSAL = 0.0;
constexpr float DEFAULT_GRACE_PERIOD_BEFORE_TILE_REMOVAL = 2.0;
 
// The 'formulae' for the base-color of the bboxes. The 'r' variable will be randomized from <0 .. 1.0>.
#define BBOX_BASE_COLOR_FORMAT glm::vec4(r, 1.0, r, 0.5)
 
// Adds the full URL of the tile/model to the name. Used when debugging
#define DEBUG_ADD_URL_TO_MODEL_NAMES false
// Check all incoming models to see if they already exists
#define DEBUG_CHECK_IF_INCOMING_MODEL_EXISTS false
 
namespace {
  // (un)freezing tree-traversal (bool)
  const Cogs::StringView lodFreezeName = "OGC3DTiles.lodFreeze";
  // Color each tile according to its depth in the tree
  const Cogs::StringView colorTilesAccordingToTreeDepthName = "OGC3DTiles.debug.colorTilesAccordingToTreeDepth";
  // Max number of active http(s) requests (integer)
  const Cogs::StringView maxNumActiveModelRequestsName = "OGC3DTiles.requests.maxConcurrent";
  // Max number of http(s) requests to be scheduled per frame (integer)
  const Cogs::StringView maxNumModelRequestsPerFrameName = "OGC3DTiles.requests.maxPerFrame";
  // Grace period in seconds before tree-traversal starts
  const Cogs::StringView gracePeriodBeforeTreeTraversalName = "OGC3DTiles.timing.gracePeriodBeforeTreeTraversal";
  // Grace period before tiles outside view will be deleted
  const Cogs::StringView gracePeriodBeforeTileRemovalName = "OGC3DTiles.timing.gracePeriodBeforeTileRemoval";
 
  Cogs::Logging::Log logger = Cogs::Logging::getLogger("OGC3DTilesSystem");
 
  uint32_t createUniqueComponentId()  {
    static uint32_t idCounter = 1;
    if (idCounter == 0) idCounter++;
    return idCounter++;
  }
 
  std::vector<MaterialInstanceHandle> debugTileTreeDepthColorMaterials;
}
 
OGC3DTilesSystem::OGC3DTilesSystem(Cogs::Memory::Allocator* allocator, Cogs::ComponentIndex capacity)
  : ComponentSystemWithDataPool(allocator, capacity)
{
}
 
OGC3DTilesSystem::~OGC3DTilesSystem() = default;
 
void
OGC3DTilesSystem::initialize(Cogs::Core::Context* context)
{
  ComponentSystem::initialize(context);
 
  if (!context->variables->exist(maxNumActiveModelRequestsName)) {
    context->variables->set(maxNumActiveModelRequestsName, MAX_NUM_ACTIVE_MODEL_REQUESTS);
  }
 
  if (!context->variables->exist(maxNumModelRequestsPerFrameName)) {
    context->variables->set(maxNumModelRequestsPerFrameName, MAX_NUM_MODEL_REQUESTS_PER_FRAME);
  }
 
  if (!context->variables->exist(gracePeriodBeforeTreeTraversalName)) {
    context->variables->set(gracePeriodBeforeTreeTraversalName, DEFAULT_GRACE_PERIOD_BEFORE_TREE_TRAVERSAL);
  }
 
  if (!context->variables->exist(gracePeriodBeforeTileRemovalName)) {
    context->variables->set(gracePeriodBeforeTileRemovalName, DEFAULT_GRACE_PERIOD_BEFORE_TILE_REMOVAL);
  }
 
  if (!context->variables->exist(lodFreezeName)) {
    context->variables->set(lodFreezeName, false);
  }
 
  if (!context->variables->exist(colorTilesAccordingToTreeDepthName)) {
    context->variables->set(colorTilesAccordingToTreeDepthName, false);
  }
 
  // Build a couple of the permutations of the custom debug material for coloring
  // tiles according to tree-depth.
  Cogs::Core::MaterialHandle baseMaterialHandle = context->materialManager->loadMaterial("Materials/OGC3DTilesDebugMaterial.material");
  context->materialManager->processLoading();
 
  for (int i = 1; i < 8; ++i) {
    glm::vec4 color = glm::vec4(i & 0b1 ? 1.0 : 0.0, i & 0b10 ? 1.0 : 0.0, i & 0b100 ? 1.0 : 0.0, 1.0);
    MaterialInstanceHandle materialInstance = context->materialInstanceManager->createMaterialInstance(baseMaterialHandle);
    materialInstance->setPermutation("FlatShaded");
    if (VariableKey key = materialInstance->material->getVec4Key("diffuseColor"); key != NoProperty) {
      materialInstance->setVec4Property(key, color);
    }
    debugTileTreeDepthColorMaterials.push_back(materialInstance);
  }
}
 
bool
OGC3DTilesSystem::componentIsStale(Context* context, uint32_t id)
{
  OGC3DTilesSystem * system = ExtensionRegistry::getExtensionSystem<OGC3DTilesSystem>(context);
 
  for (auto& comp : system->pool) {
    OGC3DTilesDataHolder& h = system->getData(&comp);
    OGC3DTilesData* componentState = h.data.get();
    if (componentState->uniqueComponentId == id) {
      return false;
    }
  }
 
  return true;
}
 
std::string
OGC3DTilesSystem::compileURL(const std::string& baseURL, const std::string& tilesetPath, const std::string& modelPath)
{
  return baseURL + (baseURL.empty() ? "" : "/") +
    tilesetPath + (tilesetPath.empty() ? "" : "/") +
    modelPath;
}
 
void
OGC3DTilesSystem::printDebugStats(const OGC3DTilesData* componentState)
{
  LOG_DEBUG(logger, "== OGC3DTiles debug stats ['%s'] ==", componentState->baseURL.c_str());
 
  int totalNumTiles = 0;
  int totalNumRequests = 0;
  for (auto const& [tileset, state] : componentState->states) {
    totalNumTiles += (int)state.tileCache.size();
    totalNumRequests += (int)state.modelRequests.size();
  }
 
  LOG_DEBUG(logger, " Total num tiles in cache(s): %d", totalNumTiles);
  LOG_DEBUG(logger, " Num models in request-queue: %d", totalNumRequests);
  LOG_DEBUG(logger, " Max traversal depth: %d, Num canceled model requests: %d",
    componentState->statistics.traversedDepth, componentState->statistics.numberOfCancelledRequests);
}
 
void
OGC3DTilesSystem::applyMaterialToAllModels(const OGC3DTilesData* componentState, MaterialInstanceHandle materialHandle)
{
  for (auto tileset : componentState->tilesets) {
    for (auto const& [tileId, models] : componentState->states.at(tileset).tileCache) {
      for (const LoadedModel& model : models) {
        applyMaterialToModel(model, materialHandle);
      }
    }
  }
}
 
void
OGC3DTilesSystem::applyMaterialToModel(const OGC3DTilesSystem::LoadedModel& model, MaterialInstanceHandle materialHandle)
{
  EntityPtr entity = this->context->store->getEntity(model.uniqueName, false);
  if (entity) {
    ModelComponent* modelComponent = entity->getComponent<ModelComponent>();
    modelComponent->inheritMaterial = materialHandle ? true : false;
    modelComponent->materialInstance = materialHandle;
    modelComponent->setChanged();
  }
}
 
void
OGC3DTilesSystem::update(Cogs::Core::Context* context)
{
  CpuInstrumentationScope(SCOPE_OGC3DTILES, "OGC3DTilesSystem::update");
 
  // Skip updating if we are lod-freezing
  if (context->variables->get(lodFreezeName, false)) {
    return;
  }
 
  // Has the camera moved?
  const CameraData& cameraData = this->context->cameraSystem->getMainCameraData();
  // FIXME: Should we add some kind of tolerance to the camera-movement check? The camera in VR is
  // constantly moving which will always trigger a tree-traversal. Maybe we should be able to adjust
  // the slack?
  bool cameraMoved = cameraData.rawViewProjection != this->lastCameraViewProjection;
 
  for (OGC3DTilesComponent& component : this->pool) {
    OGC3DTilesDataHolder& h = this->getData(&component);
    OGC3DTilesData* componentState = h.data.get();
 
    if (componentState->overrideMaterial != component.overrideMaterial) {
      // The override material has changed. We need to apply this to all loaded models.
      applyMaterialToAllModels(componentState, component.overrideMaterial);
      componentState->overrideMaterial = component.overrideMaterial;
    }
 
    if (componentState->detailFactor < 0.0) {
      componentState->detailFactor = 0.0;
    }
 
    if (component.baseURL != componentState->baseURL && componentState->tilesets.empty()) { // Populate component values
      componentState->parentEntity = component.getContainer();
      initializeTileset(&component, componentState);
    }
 
    if (cameraMoved) { // Camera moved? Update the componentState
      if (componentState->showTileBBoxes && !component.showTileBBoxes) {
        // Remove all bbox indicators
        for (auto tileset : componentState->tilesets) {
          for (auto const& [tileId, entity] : componentState->states[tileset].bboxIndicatorCache) {
            this->context->store->removeChild(componentState->parentEntity, entity.get());
            this->context->store->destroyEntity(entity->getId());
          }
          componentState->states[tileset].bboxIndicatorCache.clear();
        }
      }
 
      componentState->showTileBBoxes = component.showTileBBoxes;
      componentState->neverDiscardRootTiles = component.neverDiscardRootTiles;
      componentState->detailFactor = component.detailFactor;
      componentState->waitForTileSiblings = component.waitForTileSiblings;
      componentState->enableCaching = component.enableCaching;
      componentState->colorTileAccordingToTreeDepth = context->variables->get(colorTilesAccordingToTreeDepthName, false);
      componentState->dontRenderLeaves = component.dontRenderLeaves;
    }
 
    const double now = this->context->time->getAnimationTime();
 
    if (!componentState->tilesets.empty()) { // Are we ready yet?
      float gracePeriodBeforeTreeTraversal = DEFAULT_GRACE_PERIOD_BEFORE_TREE_TRAVERSAL;
      if (const Variable* var = context->variables->get(gracePeriodBeforeTreeTraversalName); var) {
        gracePeriodBeforeTreeTraversal = var->getFloat();
      }
 
      bool needsTraversal = false;
      if (gracePeriodBeforeTreeTraversal > 0) { // Delayed traversal?
        const double delta = now - this->timestampOfLastCameraMovement;
        needsTraversal = delta > gracePeriodBeforeTreeTraversal;
        if (needsTraversal) {
          cameraMoved = true; // Fake a camera movement to ensure timestamps gets updated
        }
      }
      else { // No delayed traversal. Always traverse if camera moved.
        needsTraversal = cameraMoved;
      }
 
      if (needsTraversal || hasPendingRequests(componentState) || componentState->requiresTraversal) {
        float gracePeriodBeforeTileRemoval = DEFAULT_GRACE_PERIOD_BEFORE_TILE_REMOVAL;
        if (const Variable* var = context->variables->get(gracePeriodBeforeTileRemovalName); var) {
          gracePeriodBeforeTileRemoval = var->getFloat();
        }
 
        componentState->statistics.traversedDepth = 0;
        componentState->statistics.numberOfCancelledRequests = 0;
        componentState->statistics.numberOfPendingRequests = 0;
        componentState->statistics.numberOfVisitedSubTilesets = 0;
        componentState->numberOfModelsBeingPrepared = 0;
        componentState->requiresTraversal = false;
 
        // Tileset #0 in the tileset-list is always the main tileset
        traverseTileset(&component, componentState, componentState->tilesets[0], gracePeriodBeforeTileRemoval);
 
        // Check all tilesets (except the main tileset) and their timestamp to see if they recently fell
        // out of view and needs to be traversed (ie. pruned).
        for (auto const& tileset : componentState->tilesets) {
          double timestamp = componentState->states[tileset].timestampOfLastTraversal;
          if (tileset != componentState->tilesets[0] &&
              componentState->states[tileset].candidateForDelayedTraversal &&
              (now - timestamp) >= gracePeriodBeforeTileRemoval) {
            traverseTileset(&component, componentState, tileset, gracePeriodBeforeTileRemoval);
            componentState->states[tileset].candidateForDelayedTraversal = false;
          }
        }
      }
 
      this->processSubTilesetRequests(&component, componentState);
    }
 
#if 0 // For debugging
    LOG_DEBUG(logger, " Max traversal depth: %d, Num requests: %d, Num cancelled: %d, Num pending: %d",
      componentState->statistics.traversedDepth,
      componentState->modelRequests.size(),
      componentState->statistics.numberOfCancelledRequests,
      componentState->statistics.numberOfPendingRequests);
#endif
 
    if (cameraMoved) {
      this->timestampOfLastCameraMovement = now;
      this->lastCameraViewProjection = cameraData.rawViewProjection;
    }
 
    // Is there still work to be done? If so, notify the engine. This is required as
    // the "update()" method is not necessarily called every frame.
    if (this->hasPendingRequests(componentState)) {
      this->context->engine->setDirty();
    }
  }
}
 
void
OGC3DTilesSystem::cancelStaleModelRequests(OGC3DTilesData* componentState, const OGC3DTilesTileset::Tileset* tileset, const Node& node) const
{
  // Check the list of models currently in view against the model-request queue.
  // If a model is in the queue but not in the view -- try to cancel the request.
 
  std::vector<std::string> toBeCancelled;
  toBeCancelled.reserve(node.tile.URLs.size());
 
  for (auto const& url : node.tile.URLs) {
    if (!componentState->states[tileset].modelRequests.contains(url)) {
      bool found = false;
      for (auto const& model : componentState->states[tileset].tileCache[node.tile.tileId]) {
        if (model.URL == url) {
          found = true;
          break;
        }
      }
 
      if (!found) {
        this->context->modelManager->cancelModelLoad(componentState->states[tileset].modelRequests[url].second);
        componentState->statistics.numberOfCancelledRequests += 1;
        toBeCancelled.emplace_back(url);
      }
    }
  }
 
  for (auto const& url : toBeCancelled) {
    componentState->states[tileset].modelRequests.erase(url);
  }
 
  for (auto const& [tileId, child] : node.children) {
    cancelStaleModelRequests(componentState, tileset, child); // ** Recursive **
  }
}
 
void
OGC3DTilesSystem::cleanupPendingSubtreeRequests(OGC3DTilesData* componentState, const OGC3DTilesTileset::Tileset* tileset) const
{
  OGC3DTilesData::State * state = &componentState->states[tileset];
  const std::unordered_map<std::string, OGC3DTiles::Coord> subtreeRequestsCopy = state->subtreeRequests;
 
  for (const auto& [subtreeURL, coord] : subtreeRequestsCopy) {
    const uint64_t key = OGC3DTilesSystem::makeCacheKey(coord);
    if (state->subtreeCache.contains(coord.level) && state->subtreeCache[coord.level].contains(key) &&
      state->subtreeCache[coord.level][key]->pendingRequests == 0) {
      const uint64_t subtreeGUID = Cogs::hash(subtreeURL);
      state->subtreeRequests.erase(subtreeURL);
      state->subtreeFetchIds.erase(subtreeGUID);
    }
  }
}
 
bool
OGC3DTilesSystem::hasPendingRequests(const OGC3DTilesData* componentState) const
{
  const bool subTilesetsState = !componentState->subTilesetRequests.empty();
  const bool modelsPreparedState = componentState->numberOfModelsBeingPrepared > 0;
  const bool tilesetFetches = !componentState->tilesetFetchIds.empty();
 
  if (subTilesetsState || modelsPreparedState || tilesetFetches) {
    return true;
  }
 
  for (auto tileset : componentState->tilesets) {
    const bool modelRequestsState = !componentState->states.at(tileset).pendingModelRequests.empty() || !componentState->states.at(tileset).modelRequests.empty();
    const bool subtreeRequestsState = !componentState->states.at(tileset).subtreeRequests.empty();
 
    if (modelRequestsState || subtreeRequestsState) {
      return true;
    }
  }
 
  return false;
}
 
void
OGC3DTilesSystem::traverseTileset(const OGC3DTilesComponent* component, OGC3DTilesData* componentState, const OGC3DTilesTileset::Tileset* tileset, float gracePeriodBeforeTileRemoval)
{
  std::unordered_set<const OGC3DTilesTileset::Tileset*> visitedTilesets;
 
  Node rootNode;
  rootNode.tile.depth = 0;
 
  componentState->states[tileset].pendingModelRequests.clear();
 
  const TransformComponent* componentTransform = componentState->parentEntity->getComponent<TransformComponent>();
  const glm::mat4 globalTransform = this->context->transformSystem->getLocalToWorld(componentTransform);
 
  // FIXME: We are only checking the root-node to see if the tileset is in "implicit tiling"-mode.
  // It is not clear if the 3DTiles-standard allows for subsections of the tree to be in
  // other modes.
  if (tileset->root.useImplicitTiling) { // Implicit tree?
    // Quad- or Oct-tree mode?
    OGC3DTiles::Coord rootCoord{ 0, 0, 0, tileset->root.implicitTiling.isOctTree ? 0 : -1 };
    OGC3DTilesSubtree::Subtree const* rootSubtree = OGC3DTilesSystem::getSubtreeForTileCoord(componentState, tileset, rootCoord);
    if (rootSubtree) { // Is the root subtree loaded and available?
      rootNode = buildImplicitTree(componentState, tileset, rootCoord, globalTransform);
    }
  }
  else { // Each tile has an explicit BBOX defined
    rootNode = buildExplicitTree(componentState, tileset, &tileset->root, "", tileset->root.transform, globalTransform, visitedTilesets);
  }
 
  if (rootNode.valid) {
    std::unordered_map<uint64_t, OGC3DTilesSystem::TileCandidate> tilesInView;
    collectTileCandidates(componentState, &rootNode, tilesInView);
 
#if 0
    LOG_DEBUG(logger, "Tiles in view: %d\n", (int)tilesInView.size());
    OGC3DTilesSystem::printDebugStats(componentState);
#endif
 
    // Add models which are in view but not yet loaded to the request queue.
    loadMissingModels(componentState, tileset, tilesInView);
 
    // Set visibility for already loaded models
    calculateTileVisibilities(componentState, tileset, &rootNode);
  }
 
  // Cancel model-requests which are no longer valid (ie. models not currently in
  // the viewport but has pending requests).
  cancelStaleModelRequests(componentState, tileset, rootNode);
 
  const size_t numReleased = pruneTileCache(componentState, tileset, gracePeriodBeforeTileRemoval);
#if 0
  if (numReleased != 0) {
    LOG_DEBUG(logger, "Released %zu model(s) (frame #%d)", numReleased, context->time->getFrame());
  }
#else
  (void)numReleased;
#endif
 
  processModelRequests(componentState, tileset, context->time->getFrame());
 
  componentState->states[tileset].timestampOfLastTraversal = this->context->time->getAnimationTime();
  componentState->states[tileset].candidateForDelayedTraversal = true;
 
  if (tileset->root.useImplicitTiling) {
    processSubtreeRequests(component, componentState, tileset);
    cleanupPendingSubtreeRequests(componentState, tileset);
  }
 
  for (auto subTileset : visitedTilesets) {
    assert(subTileset != componentState->tilesets[0] && "Don't traverse the main tileset twice!");
    traverseTileset(component, componentState, subTileset, gracePeriodBeforeTileRemoval);
  }
}
 
bool
OGC3DTilesSystem::extractAndStoreOptionalSessionKeys(OGC3DTilesData* componentState, const std::string& url) const
{
  const std::string_view sessionToken = "session=";
  const std::string_view keyToken = "key=";
 
  size_t sessionTokenPos = url.find(sessionToken);
  size_t sessionTokenEndPos = url.find("&");
  if (sessionTokenPos != std::string::npos) {
    size_t len = sessionTokenEndPos == std::string::npos ? std::string::npos : (sessionTokenEndPos - (sessionTokenPos + sessionToken.size()));
    const std::string session = url.substr(sessionTokenPos + sessionToken.size(), len);
 
    if (!componentState->optionalSessionKey.empty() && componentState->optionalSessionKey != session) {
      LOG_WARNING(logger, "Multiple session keys ('session=') for one domain is not supported.");
    }
    componentState->optionalSessionKey = "session="+session;
    LOG_DEBUG(logger, "Found session key '%s' in URL", session.c_str());
    return true;
  }
  else {
    LOG_DEBUG(logger, "No optional session key in URL '%s'", url.c_str());
  }
 
  // Sometimes the access "key=" key to use for tiles and other sub-tilesets are found in the URL of the main dataset.
  // This is the case for Google datasets via Cesium f.ex. Confusing...
  size_t keyTokenPos = url.find(keyToken);
  size_t keyTokenEndPos = url.find("&");
  if (keyTokenPos != std::string::npos) {
    size_t len = keyTokenEndPos == std::string::npos ? std::string::npos : (keyTokenEndPos - (keyTokenPos + keyToken.size()));
    const std::string key = url.substr(keyTokenPos + keyToken.size(), len);
 
    if (!componentState->optionalAccessKey.empty() && componentState->optionalAccessKey != key) {
      LOG_WARNING(logger, "Multiple access-keys ('key=') for one domain is not supported.");
    }
    componentState->optionalAccessKey = "key="+key;
    LOG_DEBUG(logger, "Found access key '%s' in URL", key.c_str());
    return true;
  }
  else {
    LOG_DEBUG(logger, "No optional access key in URL '%s'", url.c_str());
  }
 
  return false;
}
 
std::string
OGC3DTilesSystem::addOptionalURLParameters(const OGC3DTilesData* componentState, const std::string& url) const
{
  std::string result = url;
  bool hasParams = url.find("?") != std::string::npos;
 
  // Append optional session key
  if (result.find(componentState->optionalSessionKey) == std::string::npos) {
    result += hasParams ? "&" : "?";
    result += componentState->optionalSessionKey;
    hasParams = true;
  }
 
  // Some servers requires an alternative way to authenticate (e.g. tile.googleapis.com)
  if (result.find(componentState->optionalAccessKey) == std::string::npos) {
    result += hasParams ? "&" : "?";
    result += componentState->optionalAccessKey;
    hasParams = true;
  }
 
  if (!componentState->additionalURLParameters.empty()) {
    result += hasParams ? "&" : "?";
    result += componentState->additionalURLParameters;
  }
 
  return result;
}
 
void
OGC3DTilesSystem::initializeTileset(OGC3DTilesComponent* component, Cogs::Core::OGC3DTilesData* componentState)
{
  LOG_INFO(logger, "Initializing a OGC3DTilesComponent with baseURL='%s'.", component->baseURL.c_str());
  componentState->baseURL = component->baseURL;
  componentState->additionalURLParameters = component->additionalURLParameters;
 
  // Notify the users that we are currently initializing the tileset.
  context->engine->invokeComponentNotifyCallback(*component, (int)OGC3DTilesNotification::TilesetInitializing, nullptr, 0);
 
  componentState->assetsFetchId = Cogs::Core::DataFetcherManager::NoFetchId;
  if (component->assetId >= 0) { // Fetch tileset.json via an assets-lookup (most likely cesium.com)
    LOG_DEBUG(logger, "Fetching assets:\n URL='%s'\n accessToken='%s'\n AssetID=%d", component->baseURL.c_str(), component->accessToken.c_str(), component->assetId);
    componentState->assetsFetchId = fetchAndInitializeAsset(component, componentState->uniqueComponentId);
  }
  else { // Fetch the tileset.json directly
    std::string tilesetURL = component->baseURL + "/tileset.json";
    tilesetURL = addOptionalURLParameters(componentState, tilesetURL);
    const uint64_t tilesetGUID = Cogs::hash(tilesetURL);
 
    if (componentState->tilesetFetchIds.contains(tilesetGUID)) {
      LOG_ERROR(logger, "Tileset '%s' is already being fetched [%lu]", tilesetURL.c_str(), componentState->tilesetFetchIds[tilesetGUID]);
      return;
    }
    tilesetURL = this->addOptionalURLParameters(componentState, tilesetURL);
    componentState->tileBaseURL = component->baseURL; // Default tilebase URL
    componentState->tilesetFetchIds[tilesetGUID] = fetchAndInitializeTileset(tilesetGUID, tilesetURL, component, componentState->uniqueComponentId);
  }
}
 
Cogs::Core::DataFetcherManager::FetchId
OGC3DTilesSystem::fetchAndInitializeAsset(OGC3DTilesComponent * component, uint32_t uniqueComponentId)
{
  return Cogs::Core::OGC3DTilesAssetsParser::fetch(this->context, component->baseURL, component->accessToken, component->assetId,
    [thisp = this, component, uniqueComponentId](const OGC3DTilesAssetsParser::TilesAsset* tilesAsset) {
      if (OGC3DTilesSystem::componentIsStale(thisp->context, uniqueComponentId)) { // Has component been destructed in the meanwhile?
        return;
      }
 
      OGC3DTilesDataHolder& h = thisp->getData(component);
      OGC3DTilesData* componentState = h.data.get();
 
      // The 'tileset.json' name should be fetched from the assets.json file -- if not we'll use the std URL.
      std::string tilesetURL = component->baseURL + "/tileset.json";
      componentState->tileBaseURL = component->baseURL; // Default tilebase URL
 
      if (tilesAsset != nullptr) {
        LOG_DEBUG(logger, "Got asset data URL: '%s'", tilesAsset->url.c_str());
        tilesetURL = tilesAsset->url;
 
        thisp->extractAndStoreOptionalSessionKeys(componentState, tilesetURL);
 
        // Extract the base-URL/domain
        size_t pos = tilesetURL.find_first_of('/', std::string("https://").size()+1);
        if (pos == std::string::npos) {
          pos = tilesetURL.size();
        }
        componentState->tileBaseURL = tilesetURL.substr(0, pos);
 
        // Choose between regular bearer access-token or optional access-key.
        if (!tilesAsset->bearerToken.empty()) {
          // This is the standard alternative to setting 'Authentication: Bearer <token>' in the HTTP-header of each request.
          LOG_DEBUG(logger, "Appending bearer-token auth to tile requests URLs ('%s')", tilesAsset->bearerToken.c_str());
          componentState->optionalAccessKey = "access_token=" + tilesAsset->bearerToken;
        }
 
        LOG_DEBUG(logger, "Tiles URL base is: '%s'", componentState->tileBaseURL.c_str());
      }
      else {
        if (component->assetId >= 0) {
          LOG_ERROR(logger, "Could not fetch asset data from '%s'\n", component->baseURL.c_str());
        }
      }
 
      tilesetURL = thisp->addOptionalURLParameters(componentState, tilesetURL);
 
      //
      // Fetch the main tileset JSON
      //
      const uint64_t tilesetGUID = Cogs::hash(tilesetURL);
      if (componentState->tilesetFetchIds.contains(tilesetGUID)) {
        LOG_ERROR(logger, "Tileset '%s' is already being fetched [%lu]", tilesetURL.c_str(), componentState->tilesetFetchIds[tilesetGUID]);
        return;
      }
 
      componentState->tilesetFetchIds[tilesetGUID] = thisp->fetchAndInitializeTileset(tilesetGUID, tilesetURL, component, uniqueComponentId);
      componentState->assetsFetchId = Cogs::Core::DataFetcherManager::NoFetchId;
    });
}
 
uint64_t
OGC3DTilesSystem::fetchAndInitializeTileset(const uint64_t tilesetGUID, const std::string & tilesetURL, OGC3DTilesComponent * component, uint32_t uniqueComponentId)
{
  return Cogs::Core::OGC3DTilesTileset::fetch(this->context, tilesetURL,
    [thisp=this, component, tilesetGUID, uniqueComponentId](OGC3DTilesTileset::Tileset* mainTileset) {
      if (OGC3DTilesSystem::componentIsStale(thisp->context, uniqueComponentId)) { // Has component been destructed in the meanwhile?
        return;
      }
 
      OGC3DTilesDataHolder& h = thisp->getData(component);
      OGC3DTilesData* componentState = h.data.get();
 
      if (mainTileset != nullptr) {
        componentState->states[mainTileset] = OGC3DTilesData::State();
        componentState->originalRootTransform = mainTileset->root.transform;
        mainTileset->root.transform = glm::mat4(1.0);
        LOG_INFO(logger, "Loaded tileset is of type '%s' [%p]", mainTileset->root.useImplicitTiling ? "IMPLICIT" : "EXPLICIT", mainTileset);
 
        Cogs::Geometry::DBoundingBox bbox =
          OGC3DTilesUtils::boundingVolumeConverter(mainTileset->root.boundingVolume, mainTileset->root.transform);
        glm::vec3 center = (bbox.max - bbox.min) * 0.5 + bbox.min;
 
        LOG_INFO(logger, "Tileset center: <%.2f, %.2f, %.2f> [%p]", center.x, center.y, center.z, mainTileset);
        LOG_INFO(logger, "Tileset bbox: <%.2f, %.2f, %.2f>|<%.2f, %.2f, %.2f> [%p]", bbox.min.x, bbox.min.y, bbox.min.z, bbox.max.x, bbox.max.y, bbox.max.z, mainTileset);
        LOG_INFO(logger, "Tileset bounding volume: %s", mainTileset->root.boundingVolume.toString().c_str());
 
#if 1
        // If BBOX'es are switched on we'll add the global bbox right away. This makes it way easier to locate
        // the dataset if the offsets are large. NOTE: This needs to be done before the tileset-offset is set.
        if (component->showTileBBoxes) {
          Cogs::Geometry::DBoundingBox globalBBox =
            OGC3DTilesUtils::boundingVolumeConverter(mainTileset->root.boundingVolume, mainTileset->root.transform);
          thisp->addBBoxIndicatorToScene(componentState, mainTileset, 0, globalBBox);
        }
#endif
 
        // If the tileset is in sparse/implicit-mode, we'll always load and cache the root subtree-file.
        if (mainTileset->root.useImplicitTiling) {
          LOG_INFO(logger, "  Tree-structure is of type '%s' [%p]", mainTileset->root.implicitTiling.isOctTree ? "OCT" : "QUAD", mainTileset);
          OGC3DTiles::Coord rootCoord = OGC3DTiles::Coord{ 0, 0, 0, mainTileset->root.implicitTiling.isOctTree ? 0 : -1 };
          thisp->requestSubtree(componentState, mainTileset, rootCoord);
        }
 
        componentState->tilesets.push_back(mainTileset);
 
        // Notify the users that the tileset has finished setting up.
        thisp->context->engine->invokeComponentNotifyCallback(*component,
          (int) OGC3DTilesNotification::TilesetReady,
          reinterpret_cast<const double *>(glm::value_ptr(componentState->originalRootTransform)),
          16*sizeof(double));
      }
      else {
        LOG_ERROR(logger, "Failed to initialize OGC3DTilesComponent (baseURL='%s')", component->baseURL.c_str());
      }
 
      componentState->tilesetFetchIds.erase(tilesetGUID);
 
      LOG_DEBUG(logger, "Tileset fetched, initialized and ready");
      thisp->context->engine->setDirty();
      componentState->requiresTraversal = true;
    });
}
 
size_t
OGC3DTilesSystem::pruneTileCache(OGC3DTilesData* componentState, const OGC3DTilesTileset::Tileset* tileset, float gracePeriodBeforeTileRemoval) const
{
  // Do we need to perform any pruning?
  const float qualityDelta = componentState->enableCaching ?
    this->context->qualityService->ogc3DTilesSystemCacheControl - this->context->qualityService->ogc3DTilesSystemToleranceScale :
    -1.0f;
  if (qualityDelta >= 0.0) {
    return 0;
  }
 
  std::set<std::pair<double, uint64_t>> toBeRemoved; // set<pair<timestamp, tileId>>
  const double now = this->context->time->getAnimationTime();
 
  // Collect tileId candidates
  bool tileHidden = false;
  for (const auto& [tileId, loadedModels] : componentState->states[tileset].tileCache) {
    if (componentState->neverDiscardRootTiles &&
      tileset == componentState->tilesets[0] &&
      tileId  == 0) { // Only applies to the main tileset
      continue;
    }
 
    // Any models in the tile too old?
    for (const LoadedModel& lm : loadedModels) {
      if (lm.timestampLastUsed + gracePeriodBeforeTileRemoval < now) {
        toBeRemoved.emplace(std::make_pair(lm.timestampLastUsed, tileId));
        break;
      }
    }
 
    // Hide all models which might be deleted later.
    for (const LoadedModel& lm : loadedModels) {
      if (lm.timestampLastUsed < now) {
        EntityPtr entity = this->context->store->getEntity(lm.uniqueName, false);
        if (entity) {
          SceneComponent* sceneComponent = entity->getComponent<SceneComponent>();
          sceneComponent->visible = false;
          tileHidden = true;
          sceneComponent->setChanged();
        }
      }
    }
  }
 
  if (tileHidden) {
    this->context->engine->setDirty();
  }
 
  if (toBeRemoved.empty()) {
    return 0; // Nothing to do
  }
 
  std::list<std::pair<double, uint64_t>> sortedByTimestamp(toBeRemoved.begin(), toBeRemoved.end());
  sortedByTimestamp.sort([](const std::pair<double, uint64_t>& a, const std::pair<double, uint64_t>& b) { return a.first > b.first; });
 
  // Perform the removal from the scene
  size_t numRemoved = 0;
  // Try to cap the number of tiles to be removed based on how "bad" the current quality situation is.
  const size_t numToBeRemoved = sortedByTimestamp.size() * size_t(-qualityDelta);
 
  for (const auto& [timestamp, tileId] : sortedByTimestamp) {
    removeTileFromScene(componentState, tileset, tileId);
    numRemoved++;
 
    if (numRemoved >= numToBeRemoved) { // Enough removed?
      break;
    }
  }
 
  return numRemoved;
}
 
void
OGC3DTilesSystem::setVisibilityForAllTiles(const OGC3DTilesData* componentState, bool onoff) const
{
  // Set all tiles to visible.
  for (auto tileset : componentState->tilesets) {
    for (const auto& [tileId, loadedModels] : componentState->states.at(tileset).tileCache) {
      setTileVisibility(componentState, tileset, tileId, onoff);
    }
  }
}
 
void
OGC3DTilesSystem::setTileVisibility(const OGC3DTilesData* componentState, const OGC3DTilesTileset::Tileset* tileset, uint64_t tileId, bool onoff) const
{
  if (!componentState->states.at(tileset).tileCache.contains(tileId)) {
    //LOG_WARNING(logger, "Tried to change visibility of a tile not loaded to '%s': %s", onoff ? "TRUE" : "FALSE", tileId.c_str());
    return;
  }
 
  const std::vector<LoadedModel>& loadedModels = componentState->states.at(tileset).tileCache.at(tileId);
  for (const LoadedModel& lm : loadedModels) {
    if (!modelIsReady(lm.modelHandle)) {
      continue;
    }
 
    if (!lm.isValid) {
      continue; // Node/model is registered but has no content.
    }
 
    EntityPtr entity = this->context->store->getEntity(lm.uniqueName, false);
    if (entity) {
      SceneComponent* sceneComponent = entity->getComponent<SceneComponent>();
      if (sceneComponent->visible != onoff) {
        sceneComponent->setChanged();
      }
      sceneComponent->visible = onoff;
    }
    else {
      LOG_WARNING(logger, "Could not find '%s' for visibility toggling (tileset %p)", lm.URL.c_str(), tileset);
    }
  }
}
 
bool
OGC3DTilesSystem::modelIsReady(const ModelHandle& modelhandle) const
{
  if (!modelhandle->isResident()) {
    return false;
  }
 
  if (modelhandle->hasAttachedResource()) {
    auto r = modelhandle->getAttachedResource();
    if (!r->isActive()) {
      return false;
    }
  }
 
  // Check mesh/geometry
  for (auto& mesh : modelhandle->meshes) {
    if (!mesh->isInitialized() && mesh->getCount() == 0) {
      continue;
    }
 
    if (!mesh->hasAttachedResource() || !mesh->isActive()) {
      return false;
    }
 
    if (mesh->hasAttachedResource()) {
      auto r = mesh->getAttachedResource();
      if (!r->isActive()) {
        return false;
      }
    }
  }
 
  // Check materials/textures
  for (auto& material : modelhandle->materials) {
    if (!material->isResident()) {
      return false;
    }
 
    for (auto tv : material->textureVariables) {
      if (!tv.texture.handle->isResident()) {
        return false;
      }
    }
  }
 
  return true;
}
 
void
OGC3DTilesSystem::removeTileFromScene(OGC3DTilesData* componentState, const OGC3DTilesTileset::Tileset* tileset, uint64_t tileId) const
{
  const std::vector<LoadedModel>& loadedModels = componentState->states[tileset].tileCache[tileId];
  for (const LoadedModel& lm : loadedModels) {
    if (!lm.isValid) {
      continue; // Node/Model is registeres but has no content
    }
 
    EntityPtr entity = this->context->store->getEntity(lm.uniqueName, false);
    if (entity) {
      this->context->store->removeChild(componentState->parentEntity, entity.get());
      this->context->store->destroyEntity(entity->getId());
    }
    else {
      // This might happen if a node was requested and registered but removed before it could be properly added to
      // the scene.
      LOG_WARNING(logger, "removeTileFromCache(): Entity '%s' (%s) not found.", lm.URL.c_str(), lm.uniqueName.c_str());
    }
  }
 
  if (componentState->showTileBBoxes) {
    removeBBoxIndicatorFromScene(componentState, tileset, tileId);
  }
 
  componentState->states[tileset].tileCache.erase(tileId);
}
 
void
OGC3DTilesSystem::processModelRequests(OGC3DTilesData* componentState, const OGC3DTilesTileset::Tileset* tileset, uint32_t frameNumber) const
{
  std::vector<const std::string*> finished;
  const double now = this->context->time->getAnimationTime();
 
  for (const auto& [URL, pair] : componentState->states[tileset].modelRequests) {
    TileCandidate tileCandidate = pair.first;
    ModelHandle modelHandle = pair.second;
    if (this->modelIsReady(modelHandle)) {
      finished.emplace_back(&URL);
 
#if DEBUG_CHECK_IF_INCOMING_MODEL_EXISTS // Sanity check while developing
      const std::vector<LoadedModel>& loadedModels = componentState->tileCache[tileCandidate.tileId];
      bool alreadyLoaded = std::any_of(loadedModels.begin(), loadedModels.end(), [&url=URL](const LoadedModel & item) { return item.URL == url; });
      if (alreadyLoaded) {
        LOG_ERROR(logger, "Incoming model '%s' is already loaded", URL.c_str());
        assert(alreadyLoaded && "Incoming model is already loaded for this tile!");
        continue;
      }
#endif
 
#if DEBUG_ADD_URL_TO_MODEL_NAMES
      // A unique name based on TileID + Full URL + ptr-value of tileset.
      const std::string uniqueName = (tileset->root.useImplicitTiling ? OGC3DTiles::Coord::fromHash(tileCandidate.tileId).toString() : std::to_string(tileCandidate.tileId)) + " - "  + URL;
#else
      // A unique name based on TileID + ptr-value of tileset.
      std::string uniqueName = tileset->root.useImplicitTiling ? OGC3DTiles::Coord::fromHash(tileCandidate.tileId).toString() : std::to_string(tileCandidate.tileId);
      uniqueName += " - ";
      uniqueName += std::to_string(uint64_t(tileset));
#endif
 
      if (this->context->store->findEntity(uniqueName)) {
        // The model was already added. This can happen if a tile goes in and out of view, gets
        // in the "might get deleted" phase -- but then suddenly get back into view and
        // therefore rescheduled.
        continue;
      }
 
      LoadedModel loadedModel;
      loadedModel.modelHandle = modelHandle;
      loadedModel.timestampLastUsed = now;
      loadedModel.URL = URL;
      loadedModel.uniqueName = uniqueName;
      loadedModel.frameNumberAtArrival = frameNumber;
 
      if (!OGC3DTilesSystem::modelIsEmpty(modelHandle)) {
        addModelToScene(loadedModel.uniqueName, tileCandidate, modelHandle, componentState);
        loadedModel.isValid = true;
        componentState->requiresTraversal = true; // Ensure re-traversal to recalc visibility for all existing nodes wrt new nodes.
        this->context->engine->setDirty();
      }
      componentState->states[tileset].tileCache[tileCandidate.tileId].emplace_back(loadedModel);
    }
    else if (modelHandle->hasFailedLoad()) {
      LOG_ERROR(logger, "processModelRequests(): Could not load '%s'", URL.c_str());
      finished.emplace_back(&URL);
    }
    else if (modelHandle->hasFailedActivation()) {
      // FIXME: What does "failed activation" actually mean?
      LOG_ERROR(logger, "processModelRequests(): Model failed to activate!");
      // FIXME: We used to assert here, but that will crash the app. Too strict?
      finished.emplace_back(&URL);
    }
  }
 
  for (const std::string* URL : finished) {
    componentState->states[tileset].modelRequests.erase(*URL);
  }
}
 
bool
OGC3DTilesSystem::requestModel(OGC3DTilesData* componentState, const OGC3DTilesTileset::Tileset* tileset, const TileCandidate& tile, const std::string URL) const
{
#if 0 // Sanity check
  // Sometimes a content-URL is not a model but a completely new tileset json-file. This should have been
  // handled earlier, not here!
  if (URL.find(".json") != std::string::npos) {
    LOG_ERROR(logger, "Internal error: A sub-tileset was requested as model; '%s'.", URL.c_str());
    assert(false && "Internal error");
    return false;
  }
#endif
 
  if (!componentState->states[tileset].modelRequests.contains(URL)) {
    const std::vector<LoadedModel>& loadedModels = componentState->states[tileset].tileCache[tile.tileId];
    bool alreadyLoaded = std::ranges::any_of(loadedModels.cbegin(), loadedModels.cend(), [&URL](LoadedModel const& item) { return item.URL == URL; });
    if (!alreadyLoaded) {
      ModelHandle handle = context->modelManager->loadModel(URL, NoResourceId, ModelLoadFlags::None);
      componentState->states[tileset].modelRequests[URL] = std::pair(tile, handle);
      return true;
    }
    else {
      //LOG_DEBUG(logger, "Tile '%s' (%s) has already been loaded.\n", URL.c_str(), tile.tileId.c_str());
    }
  }
  else {
    //LOG_DEBUG(logger, "Tile '%s' (%s) has already been requested.\n", URL.c_str(), tile.tileId.c_str());
    return true;
  }
  return false;
}
 
void
OGC3DTilesSystem::loadMissingModels(OGC3DTilesData* componentState, const OGC3DTilesTileset::Tileset* tileset, const std::unordered_map<uint64_t, TileCandidate>& tilesInView) const
{
  std::vector<const TileCandidate*> sortedTilesInView;
  sortedTilesInView.reserve(tilesInView.size());
  for (auto it = tilesInView.cbegin(); it != tilesInView.cend(); ++it) {
    sortedTilesInView.emplace_back(&it->second);
  }
 
#if 1
  // Sort tilesInView according to distance from camera instead of the default "level"-sorting.
  const glm::vec3 cameraPos = getCurrentCameraPosition();
  std::ranges::sort(sortedTilesInView.begin(), sortedTilesInView.end(),
    [cameraPos](TileCandidate const* a, TileCandidate const* b) {
      const double distA = OGC3DTilesUtils::distanceFromBBox(cameraPos, a->bbox);
      const double distB = OGC3DTilesUtils::distanceFromBBox(cameraPos, b->bbox);
      return distA < distB;
    });
#endif
 
  const double now = this->context->time->getAnimationTime();
  size_t maxNumRequestsPerFrame = context->variables->get(maxNumModelRequestsPerFrameName, MAX_NUM_MODEL_REQUESTS_PER_FRAME);
  size_t maxNumActiveRequests = context->variables->get(maxNumActiveModelRequestsName, MAX_NUM_ACTIVE_MODEL_REQUESTS);
  size_t numScheduled = 0;
  componentState->states[tileset].pendingModelRequests.reserve(sortedTilesInView.size());
 
  for (const auto* tilecandidate : sortedTilesInView) {
    for (std::string URL : tilecandidate->URLs) {
      // Is the limit for total number of active requests reached?
      if (componentState->states[tileset].modelRequests.size() >= maxNumActiveRequests) {
        // Register as pending
        componentState->states[tileset].pendingModelRequests.emplace(tilecandidate->tileId);
      }
      else { // Start a new request
        if (numScheduled < maxNumRequestsPerFrame) {
          if (requestModel(componentState, tileset, *tilecandidate, addOptionalURLParameters(componentState, URL))) {
            numScheduled++;
            if (componentState->showTileBBoxes) {
              addBBoxIndicatorToScene(componentState, tileset, tilecandidate->tileId, tilecandidate->bbox);
            }
          }
        }
        else {
          // We need to register all requests that are still pending.
          componentState->states[tileset].pendingModelRequests.emplace(tilecandidate->tileId);
        }
      }
    }
 
    // Model already loaded? Update timestamp to prevent culling.
    if (componentState->states[tileset].tileCache.contains(tilecandidate->tileId)) {
      std::vector<LoadedModel>& loadedModels = componentState->states[tileset].tileCache[tilecandidate->tileId];
      for (LoadedModel& m : loadedModels) {
        m.timestampLastUsed = now;
      }
    }
  }
 
  componentState->statistics.numberOfPendingRequests = (int) componentState->states[tileset].pendingModelRequests.size();
}
 
// Only relevant for IMPLICIT trees
std::string
OGC3DTilesSystem::buildSubtreeURL(const OGC3DTilesData* componentState, const OGC3DTilesTileset::Tileset* tileset, const OGC3DTiles::Coord& coord)
{
  std::string path = std::string(tileset->root.implicitTiling.subTreeURLScheme);
  path = path.replace(path.find("{level}"), 7, std::to_string(coord.level));
  path = path.replace(path.find("{x}"), 3, std::to_string(coord.x));
  path = path.replace(path.find("{y}"), 3, std::to_string(coord.y));
  if (coord.z >= 0) {
    path = path.replace(path.find("{z}"), 3, std::to_string(coord.z));
  }
 
  return componentState->tileBaseURL + "/" + path;
}
 
uint64_t
OGC3DTilesSystem::makeCacheKey(const OGC3DTiles::Coord& coord)
{
  assert(coord.level <= 0xFFFF && coord.x <= 0xFFFF && coord.y <= 0xFFFF && "Coord values out of the 16bit bounds");
  uint64_t hash = coord.level + (uint64_t(coord.x) << 16) + (uint64_t(coord.y) << 32);
 
  if (coord.z >= 0) {
    assert(coord.z <= 0xFFFF && "Coord.z value out of the 16bit bounds");
    hash += uint64_t(coord.z) << 48;
  }
  return hash;
}
 
bool
OGC3DTilesSystem::tileHasReadyContent(OGC3DTilesData* componentState, const OGC3DTilesTileset::Tileset* tileset, uint64_t tileId) const
{
  // Any pending dependencies?
  if (tileHasModelRequests(componentState, tileset, tileId) ||
    tileHasSubTilesetRequests(componentState, tileId)) {
    return false;
  }
 
  assert(componentState->states[tileset].tileCache.contains(tileId) && "Tile not in cache");
 
  const std::vector<LoadedModel>& models = componentState->states[tileset].tileCache[tileId];
  size_t numReadyModels = 0;
  for (const auto& lm : models) {
    if (!lm.isValid) {
      numReadyModels += 1;
      continue; // Node/tile is registered but has no content
    }
 
    if (modelIsReady(lm.modelHandle)) {
      numReadyModels += 1;
    }
    else {
      componentState->numberOfModelsBeingPrepared += 1;
    }
  }
 
   return models.size() == numReadyModels;
}
 
/*
* Return TRUE if a tile has ongoing model requests or pending requests (requests not started yet due to throttling).
*/
bool
OGC3DTilesSystem::tileHasModelRequests(const OGC3DTilesData* componentState, const OGC3DTilesTileset::Tileset* tileset, uint64_t tileId) const
{
  for (const auto& [URL, pair] : componentState->states.at(tileset).modelRequests) {
    const TileCandidate& tileCandidate = pair.first;
    if (tileCandidate.tileId == tileId) {
      return true;
    }
  }
 
  if (componentState->states.at(tileset).pendingModelRequests.contains(tileId)) {
    return true;
  }
 
  return false;
}
 
bool
OGC3DTilesSystem::tileHasSubTilesetRequests(const OGC3DTilesData* componentState, uint64_t tileId) const
{
  for (const auto& [URL, pair] : componentState->subTilesetRequests) {
    if (pair.first == tileId) {
      return true;
    }
  }
  return false;
}
 
bool
OGC3DTilesSystem::allChildrenAreReady(OGC3DTilesData* componentState, const OGC3DTilesTileset::Tileset* tileset, const Node* node) const
{
  size_t numReadyChildren = 0;
  for (auto const& [childTileId, child] : node->children) {
    if (child.tile.URLs.empty()) { // Child has no content. Go down a level?
      if (allChildrenAreReady(componentState, tileset, &child)) {
        numReadyChildren += 1;
      }
    }
    else {
      if (tileHasReadyContent(componentState, tileset, childTileId)) {
        numReadyChildren += 1;
      }
      else {
        return false;
      }
    }
  }
 
  return node->children.size() == numReadyChildren;
}
 
void
OGC3DTilesSystem::collectTileCandidates(OGC3DTilesData* componentState, const Node* node, std::unordered_map<uint64_t, TileCandidate>& target) const
{
#if 0 // Sanity check
  if (target.contains(node->tile.tileId)) {
    assert(false && "Node has already been visited. Internal error.");
  }
#endif
 
  if (!node->tile.URLs.empty()) {
    target[node->tile.tileId] = node->tile;
  }
 
  for (auto const& [childTileId, child] : node->children) {
    collectTileCandidates(componentState, &child, target);
  }
}
 
void
OGC3DTilesSystem::calculateTileVisibilities(OGC3DTilesData* componentState, const OGC3DTilesTileset::Tileset* tileset, const Node* node) const
{
  if (node->replaceRefine) {
    if (!componentState->waitForTileSiblings) {
      if (node->children.empty()) { // Always show leaf nodes (if ready)
        setTileVisibility(componentState, tileset, node->tile.tileId, true);
      }
      else if (allChildrenAreReady(componentState, tileset, node)) {
        setTileVisibility(componentState, tileset, node->tile.tileId, false);
      }
    }
    else {
      if (componentState->states[tileset].tileCache.contains(node->tile.tileId)) {
        bool showNode = true;
        if (!node->children.empty() &&
          tileHasReadyContent(componentState, tileset, node->tile.tileId) &&
          allChildrenAreReady(componentState, tileset, node)) {
          // All children are ready. Hide this node.
 
          showNode = false;
        }
        setTileVisibility(componentState, tileset, node->tile.tileId, showNode);
      }
    }
  }
 
  for (auto const& [childTileId, child] : node->children) {
    calculateTileVisibilities(componentState, tileset, &child); // Recursive
  }
}
 
OGC3DTilesSystem::Node
OGC3DTilesSystem::buildImplicitTree(OGC3DTilesData* componentState,
  const OGC3DTilesTileset::Tileset* tileset,
  const OGC3DTiles::Coord& coord,
  const glm::mat4& globalTransform) const
{
  Node node;
  node.valid = false;
  node.replaceRefine = tileset->root.refine == OGC3DTilesTileset::RefineType::REPLACE;
 
  componentState->statistics.traversedDepth = std::max(componentState->statistics.traversedDepth, coord.level);
 
  OGC3DTiles::BoundingVolume tileBoundingVolume =
    OGC3DTilesUtils::getBoundingVolumeFromCoord(coord, tileset->root.boundingVolume);
  Cogs::Geometry::DBoundingBox tileBBox =
    OGC3DTilesUtils::boundingVolumeConverter(tileBoundingVolume, tileset->root.transform);
  Cogs::Geometry::DBoundingBox transformedTileBBox(tileBBox);
 
  OGC3DTilesUtils::transformBBox(transformedTileBBox, globalTransform);
 
  if (!isInsideFrustum(transformedTileBBox)) {
    return node; // Don't dig deeper
  }
 
  OGC3DTilesSubtree::Subtree const* subtree =
    OGC3DTilesSystem::getSubtreeForTileCoord(componentState, tileset, coord);
  if (!subtree) {
    return node;
  }
 
  const double distance = OGC3DTilesUtils::distanceFromBBox(getCurrentCameraPosition(), transformedTileBBox);
 
  //
  // Shall we dig deeper or use content at this level?
  //
  const double geometricError = tileset->geometricError / std::pow(2, coord.level);
  const double factor = std::pow(componentState->detailFactor, 1.2) * geometricError;
  const bool hasContent = OGC3DTilesSubtree::hasContent(subtree, coord);
 
  if (distance < factor || !hasContent) {
    // Collect all child nodes to "coord" and evaluate each one using recursion
    std::vector<OGC3DTiles::Coord> children =
      getTileCoordChildren(componentState, tileset, coord);
 
    bool stop = false;
    if (componentState->dontRenderLeaves) {
      // If any of the children is a leaf node we'll have to stop as we
      // are instructed to never render leaf nodes.
      for (const OGC3DTiles::Coord& child : children) {
        if (getTileCoordChildren(componentState, tileset, child).empty()) {
          stop = true;
          break;
        }
      }
    }
 
    if (!stop) {
      for (const OGC3DTiles::Coord& childCoord : children) {
        assert(coord != childCoord && "Internal error");
        assert(childCoord.level != 0 && "Coord with level=0 cannot be a child");
 
        // *** Recursion ***
        const Node child = buildImplicitTree(componentState, tileset, childCoord, globalTransform);
        if (child.valid) {
          node.children[child.tile.tileId] = child;
        }
      }
    }
  }
  else {
    // Node is to far away. Don't dig any deeper.
  }
 
  //
  // Add contents/geometry for 'coord' if there is any
  //
  if (hasContent) {
    assert(tileset->root.contents.size() > 0 && "No content!");
    std::string path = tileset->root.contents[0].URI;
    path = path.replace(path.find("{level}"), 7, std::to_string(coord.level));
    path = path.replace(path.find("{x}"), 3, std::to_string(coord.x));
    path = path.replace(path.find("{y}"), 3, std::to_string(coord.y));
    if (coord.z >= 0) {
      path = path.replace(path.find("{z}"), 3, std::to_string(coord.z));
    }
 
    node.tile.URLs.emplace_back(OGC3DTilesSystem::compileURL(componentState->tileBaseURL, tileset->baseURL, path));
    node.tile.transform = tileset->root.transform;
  }
 
  node.tile.tileId = coord.toHash();
  node.tile.depth = coord.level;
  node.tile.bbox = tileBBox;
  node.valid = true;
  return node;
}
 
OGC3DTilesSystem::Node
OGC3DTilesSystem::buildExplicitTree(OGC3DTilesData* componentState,
  const OGC3DTilesTileset::Tileset* tileset,
  const OGC3DTilesTileset::Tile* tile,
  const std::string& tileIdStr,
  const glm::mat4& currentTransform,
  const glm::mat4& globalTransform,
  std::unordered_set<const OGC3DTilesTileset::Tileset*> & visitedTilesets) const
{
  Node node;
  node.valid = false;
  node.replaceRefine = tile->refine == OGC3DTilesTileset::RefineType::REPLACE;
  componentState->statistics.traversedDepth = std::max(componentState->statistics.traversedDepth, (int)tileIdStr.size());
 
  glm::mat4 transform = currentTransform;
  Cogs::Geometry::DBoundingBox bbox = OGC3DTilesUtils::boundingVolumeConverter(tile->boundingVolume, transform);
  Cogs::Geometry::DBoundingBox transformedBBox(bbox);
  OGC3DTilesUtils::transformBBox(transformedBBox, globalTransform);
 
  if (!isInsideFrustum(transformedBBox)) {
    return node; // Node is not visible. No need to continue.
  }
 
  const double distance = OGC3DTilesUtils::distanceFromBBox(getCurrentCameraPosition(), transformedBBox);
  const double factor = (node.tile.depth + 1) * std::pow(componentState->detailFactor, 2.0) * tile->geometricError;
  const bool hasContent = !tile->contents.empty();
 
  if (distance < factor || !hasContent) {
    bool stop = false;
    if (componentState->dontRenderLeaves) {
      // If any of the children is a leaf node we'll have to stop as we
      // are instructed to never render leaf nodes.
      for (size_t i=0; i < tile->children.size(); ++i) {
        const OGC3DTilesTileset::Tile* childTile = &tile->children.at(i);
        if (childTile->children.empty()) {
          stop = true;
          break;
        }
      }
    }
 
    if (!stop) {
      for (size_t i = 0; i < tile->children.size(); ++i) {
        const OGC3DTilesTileset::Tile* childTile = &tile->children.at(i);
        assert(!childTile->useImplicitTiling && "Internal error");
 
        // ** Recursion **
        Node childNode = buildExplicitTree(componentState, tileset, childTile, tileIdStr + std::to_string(i), transform, globalTransform, visitedTilesets);
 
        if (childNode.valid) {
          assert(node.children.find(childNode.tile.tileId) == node.children.end() && "Child node has already been added");
          node.children[childNode.tile.tileId] = childNode;
        }
      }
    }
  }
 
  //
  // Add any content available on the current level
  //
  node.tile.tileId = Cogs::hash(tileIdStr);
  node.tile.depth = (uint32_t)tileIdStr.length();
  node.tile.bbox = bbox;
  node.tile.transform = transform;
  node.tile.URLs.reserve(tile->contents.size());
  node.valid = true;
 
  for (const OGC3DTilesTileset::Content& c : tile->contents) {
    const std::string url = OGC3DTilesSystem::compileURL(componentState->tileBaseURL, tileset->baseURL, c.URI);
    // Sub-tileset?
    if (c.URI.find(".json") != std::string::npos || c.URI.find(".JSON") != std::string::npos) {
      const std::string tilesetURL = addOptionalURLParameters(componentState, url);
      if (componentState->states[tileset].subTilesets.contains(tilesetURL)) {
        visitedTilesets.insert(componentState->states[tileset].subTilesets[tilesetURL]);
        componentState->states[tileset].candidateForDelayedTraversal = true;
        componentState->statistics.numberOfVisitedSubTilesets += 1;
      }
      else {
        // We have encountered a new sub-tileset. We'll load and register it in ::processSubTilesetsRequests()
        requestSubTileset(componentState, tilesetURL, node.tile.tileId, tileset);
      }
    }
    else {
      node.tile.URLs.emplace_back(url);
    }
  }
 
  return node;
}
 
// Only relevant for EXPLICIT trees
void
OGC3DTilesSystem::requestSubTileset(OGC3DTilesData* componentState, const std::string& URL, uint64_t tileId, const OGC3DTilesTileset::Tileset* parentTileset) const
{
  if (componentState->subTilesetRequests.size() > MAX_NUM_ACTIVE_SUBTILESET_REQUESTS) {
    return;
  }
 
  if (componentState->loadedSubTilesets.contains(URL) ||
    componentState->subTilesetRequests.contains(URL)) {
    return;
  }
 
  componentState->subTilesetRequests[URL] = std::make_pair(tileId, parentTileset);
}
 
void
OGC3DTilesSystem::addModelToScene(const std::string& uniqueName, TileCandidate tile, ModelHandle handle, const OGC3DTilesData* componentState) const
{
  assert(!this->context->store->findEntity(uniqueName) && "Model already exists!");
 
  EntityPtr entity = this->context->store->createEntity(uniqueName, "ModelEntity");
  this->context->store->addChild(componentState->parentEntity, entity);
 
  ModelComponent* modelComponent = entity->getComponent<ModelComponent>();
 
  if (componentState->colorTileAccordingToTreeDepth) {
    modelComponent->inheritMaterial = true;
    modelComponent->materialInstance = debugTileTreeDepthColorMaterials[tile.depth % debugTileTreeDepthColorMaterials.size()];
  }
  else if (componentState->overrideMaterial) {
    modelComponent->inheritMaterial = true;
    modelComponent->materialInstance = componentState->overrideMaterial;
  }
 
  modelComponent->model = handle;
 
  TransformComponent* transformComponent = entity->getComponent<TransformComponent>();
  transformComponent->transform = tile.transform;
 
  transformComponent->transformFlags = 1; // use the matrix -- not position, rotation & scale
  transformComponent->setChanged();
}
 
void
OGC3DTilesSystem::addBBoxIndicatorToScene(OGC3DTilesData* componentState, const OGC3DTilesTileset::Tileset* tileset, uint64_t tileId, Cogs::Geometry::DBoundingBox box) const
{
  assert(componentState->states.contains(tileset) && "Internal error");
  if (!componentState->states[tileset].bboxIndicatorCache.contains(tileId)) {
    std::string title = "BBox ";
    title += tileset->root.useImplicitTiling ? OGC3DTiles::Coord::fromHash(tileId).toString() : std::to_string(tileId);
    title += " - ";
    title += std::to_string(uint64_t(tileset));
    EntityPtr bboxEntity = this->context->store->createEntity(title, "SubMeshPart");
    this->context->store->addChild(componentState->parentEntity, bboxEntity);
 
    componentState->states[tileset].bboxIndicatorCache[tileId] = bboxEntity;
 
    auto createBBoxTask = [ctx = this->context, bboxEntity, box]() {
      MeshComponent* meshComponent = bboxEntity->getComponent<MeshComponent>();
 
      MaterialInstanceHandle material = ctx->materialInstanceManager->createMaterialInstance(ctx->materialManager->getDefaultMaterial());
      material->setPermutation("Line");
      material->setBoolProperty(DefaultMaterial::EnableLighting, false);
      const float r = (rand() % 255) / 255.0f;
      material->setVec4Property(DefaultMaterial::DiffuseColor, BBOX_BASE_COLOR_FORMAT);
      material->options.depthBiasEnabled = true;
      material->options.depthBias.constant = -1.f;
      material->options.depthBias.slope = -1.f;
      material->options.depthBias.clamp = 100.f;
 
      // We'll translate the BBox to origo and let the OGC3DTilesEntity's transform handle the global offset.
      std::array<PositionVertex, 8> vertices = {
        PositionVertex{box.min},
        PositionVertex{glm::dvec3(box.min.x, box.max.y, box.min.z)},
        PositionVertex{glm::dvec3(box.max.x, box.max.y, box.min.z)},
        PositionVertex{glm::dvec3(box.max.x, box.min.y, box.min.z)},
        PositionVertex{box.max},
        PositionVertex{glm::dvec3(box.min.x, box.max.y, box.max.z)},
        PositionVertex{glm::dvec3(box.min.x, box.min.y, box.max.z)},
        PositionVertex{glm::dvec3(box.max.x, box.min.y, box.max.z)},
      };
 
      std::array<unsigned int, 16> lineStripIndices = {
        0, 1, 2, 3, 0,  // Bottom + Edge
        6, 7, 4, 5, 6,  // Top
        7, 3, // Edge
        2, 4, // Edge
        5, 1  // Edge
      };
 
      SubMeshRenderComponent* meshRenderComponent = bboxEntity->getComponent<SubMeshRenderComponent>();
      meshRenderComponent->setMaterial(material);
 
      MeshHandle meshHandle = ctx->meshManager->create();
      meshComponent->meshHandle = meshHandle;
 
      Cogs::Geometry::BoundingBox fbox;
      fbox += box.min;
      fbox += box.max;
      meshHandle->setBounds(fbox);
 
      Mesh* mesh = ctx->meshManager->get(meshHandle);
      assert(mesh && "Internal error");
      mesh->setVertexData(vertices.data(), vertices.size());
      mesh->addSubMesh(std::span(lineStripIndices), PrimitiveType::LineStrip);
 
      meshRenderComponent->setChanged();
      meshComponent->setChanged();
      mesh->setChanged();
      };
 
    this->context->taskManager->enqueue(TaskManager::GlobalQueue, createBBoxTask);
  }
}
 
void
OGC3DTilesSystem::removeBBoxIndicatorFromScene(OGC3DTilesData* componentState, const OGC3DTilesTileset::Tileset* tileset, uint64_t tileId) const
{
  auto it = componentState->states[tileset].bboxIndicatorCache.find(tileId);
  if (it != componentState->states[tileset].bboxIndicatorCache.end()) {
    EntityPtr entity = it->second;
    this->context->store->removeChild(componentState->parentEntity, entity.get());
    this->context->store->destroyEntity(entity->getId());
    componentState->states[tileset].bboxIndicatorCache.erase(tileId);
  }
  else {
    if (tileset->root.useImplicitTiling) {
      LOG_ERROR(logger, "Instructed to remove BBox '%s', but it does not exist.", OGC3DTiles::Coord::fromHash(tileId).toString().c_str());
    }
    else {
      LOG_ERROR(logger, "Instructed to remove BBox '%llu', but it does not exist.", tileId);
    }
  }
}
 
ComponentHandle
OGC3DTilesSystem::createComponent()
{
  ComponentHandle handle = ComponentSystemWithDataPool::createComponent();
  OGC3DTilesComponent* comp = static_cast<OGC3DTilesComponent*>(handle.resolve());
  OGC3DTilesDataHolder& h = this->getData(comp);
  h.data = std::make_unique<OGC3DTilesData>();
 
  OGC3DTilesData* data = h.data.get();
  data->uniqueComponentId = createUniqueComponentId();
 
  if (this->pool.size() >= 1 && this->bounds == nullptr) {
    this->bounds = new OGC3DTilesBounds(this);
    this->context->bounds->addBoundsExtension(this->bounds);
  }
 
  return handle;
}
 
void
OGC3DTilesSystem::destroyComponent(ComponentHandle componenthandle)
{
  OGC3DTilesComponent* comp = static_cast<OGC3DTilesComponent*>(componenthandle.resolve());
  LOG_DEBUG(logger, "Destroying OGC3DTilesComponent (baseURL=%s)", comp->baseURL.c_str());
 
  OGC3DTilesDataHolder& h = this->getData(comp);
  OGC3DTilesData* componentState = h.data.get();
 
  if (componentState->assetsFetchId != Cogs::Core::DataFetcherManager::NoFetchId) {
    Cogs::Core::DataFetcherManager::cancelAsyncFetch(this->context, componentState->assetsFetchId);
  }
 
  for (auto & [guid, fetchId] : componentState->tilesetFetchIds) {
    Cogs::Core::DataFetcherManager::cancelAsyncFetch(this->context, fetchId);
  }
 
  for (auto tileset : componentState->tilesets) {
    for (auto& [guid, fetchId] : componentState->states[tileset].subtreeFetchIds) {
      Cogs::Core::DataFetcherManager::cancelAsyncFetch(this->context, fetchId);
    }
 
    for (const auto& [tileId, loadedModels] : componentState->states[tileset].tileCache) {
      for (const LoadedModel& lm : loadedModels) {
        if (!lm.isValid) {
          continue; // Node/model is registered but has no content
        }
        EntityPtr entity = this->context->store->getEntity(lm.uniqueName);
        if (entity) {
          this->context->store->destroyEntity(entity->getId());
        }
        else {
          LOG_ERROR(logger, "destroyComponent(): Could not find entity '%s' (%s)", lm.URL.c_str(), lm.uniqueName.c_str());
        }
      }
    }
 
    // Clean subtreeCache
    for (auto& [id, subtreeMap] : componentState->states[tileset].subtreeCache) {
      for (auto& [key, val] : subtreeMap) {
        delete val;
      }
      subtreeMap.clear();
    }
 
    // Clean bboxIndicatorCache
    for (auto& b : componentState->states[tileset].bboxIndicatorCache) {
      context->store->destroyEntity(b.second->getId());
    }
 
    delete tileset;
  }
 
  componentState->tilesets.clear();
  componentState->states.clear();
 
  if (this->bounds != nullptr) {
    this->context->bounds->removeBoundsExtension(this->bounds);
  }
 
  ComponentSystemWithDataPool::destroyComponent(componenthandle);
}
 
glm::dvec3
OGC3DTilesSystem::getCurrentCameraPosition() const
{
  return this->context->cameraSystem->getMainCameraData().inverseViewMatrix * glm::dvec4(0, 0, 0, 1.0);
}
 
bool
OGC3DTilesSystem::isInsideFrustum(const Cogs::Geometry::DBoundingBox& box) const
{
  // FIXME: I suspect that the Cogs::Geometry::contains() function does
  // not handle BBox'es which completely occludes the viewport as "inside".
  // I.e. when both min and max is outside the frustrum but the "face" of the bbox
  // is still in view.
#if 0
  Cogs::Geometry::Frustum frustum = this->context->cameraSystem->getMainCameraData().frustum;
  Cogs::Geometry::BoundingBox fbox;
  fbox.min = box.min;
  fbox.max = box.max;
  int result = Cogs::Geometry::contains(frustum, fbox);
  return result == 2 || result == 1;  // Totally inside || partially inside
#else
  // FIXME: Are there times when the camera-system is not ready yet at startup?
  const CameraData& cameraData = this->context->cameraSystem->getMainCameraData();
  int result = OGC3DTilesUtils::bboxInsideViewFrustum(box, cameraData.rawViewProjection);
  return result != 0;  // Totally inside || partially inside
#endif
}
 
bool
OGC3DTilesSystem::modelIsEmpty(const ModelHandle handle)
{
  const size_t numParts = handle->parts.size();
  for (size_t i = 0; i < numParts; ++i) {
    const ModelPart& part = handle->parts[i];
    if (part.vertexCount != static_cast<uint32_t>(-1)) { // Part not initialized?
      return false;
    }
  }
  return true;
}
 
std::vector<OGC3DTiles::Coord>
OGC3DTilesSystem::getTileCoordChildren(OGC3DTilesData* componentState, const OGC3DTilesTileset::Tileset* tileset, const OGC3DTiles::Coord& parent) const
{
  assert(tileset->root.useImplicitTiling && "Only IMPLICIT trees uses subtrees");
  std::vector<OGC3DTiles::Coord> children;
 
  OGC3DTilesSubtree::Subtree const* subtree = getSubtreeForTileCoord(componentState, tileset, parent);
  if (!subtree) {
    LOG_ERROR(logger, "getTileCoordChildren(): No subtree found. Internal error");
    return children;
  }
 
  // Do we have to look up in this subtree's subtree?
  if (OGC3DTilesSubtree::isLeafNodeInSubtree(subtree, parent) || // Is a leaf-node
      ((parent.level + 1) >= tileset->root.implicitTiling.availableLevels)) { // We have no more levels
    std::vector<OGC3DTiles::Coord> subtreeCoords = OGC3DTilesSubtree::getLeafNodesSubtreeCoords(subtree, parent);
    children.reserve(subtreeCoords.size());
 
    for (auto const& subtreeCoord : subtreeCoords) {
      // FIXME: Should we check the BBox of the subtree against the view frustum before scheduling a request?
      if (subtreeCoord.level > tileset->root.implicitTiling.availableLevels) {
        LOG_WARNING(logger, "Requested subtree-level too deep: %d vs %d", subtreeCoord.level, tileset->root.implicitTiling.availableLevels);
        break;
      }
 
      OGC3DTilesSubtree::Subtree const* subSubtree = getSubtreeForTileCoord(componentState, tileset, subtreeCoord);
      if (subSubtree && (subtree->tileAvailability.availableCount > 0 || subtree->tileAvailability.allIsAvailable)) {
        children.emplace_back(subtreeCoord);
      }
    }
  }
  else {
    if (subtree->tileAvailability.availableCount == 0 && !subtree->tileAvailability.allIsAvailable) {
      // There is nothing to add
    }
    else if (subtree->tileAvailability.allIsAvailable) {
      // Add all possible children-coords for a node/coord depending on tree-type (Oct/Quad)
      children = OGC3DTilesSubtree::getAllChildren(subtree, parent);
    }
    else {
      // Use the tile-availability buffer bitmap to determine which children exists
      children = OGC3DTilesSubtree::getChildren(subtree, parent);
    }
  }
 
  return children;
}
 
OGC3DTilesSubtree::Subtree*
OGC3DTilesSystem::getSubtreeForTileCoord(OGC3DTilesData* componentState, const OGC3DTilesTileset::Tileset* tileset, const OGC3DTiles::Coord& coord) const
{
  assert(tileset->root.useImplicitTiling && "Only IMPLICIT trees uses subtrees");
 
  const int levelsPerSubtree = tileset->root.implicitTiling.subtreeLevels;
  OGC3DTiles::Coord subtreeCoord = OGC3DTilesSubtree::getSubtreesRootCoord(levelsPerSubtree, coord);
 
  if (subtreeCoord.level > tileset->root.implicitTiling.availableLevels) {
    LOG_ERROR(logger, "Subtree coord-depth > tree-depth (%d vs %d)", subtreeCoord.level, tileset->root.implicitTiling.availableLevels);
    return nullptr;
  }
 
  // Is subtree already in cache?
  const uint64_t key = OGC3DTilesSystem::makeCacheKey(subtreeCoord);
 
  if (!componentState->states[tileset].subtreeCache.contains(subtreeCoord.level) ||
    !componentState->states[tileset].subtreeCache[subtreeCoord.level].contains(key)) {
    requestSubtree(componentState, tileset, subtreeCoord);
    return nullptr;
  }
 
  return componentState->states[tileset].subtreeCache[subtreeCoord.level][key];
}
 
// Only relevant for EXPLICIT trees
void
OGC3DTilesSystem::processSubTilesetRequests(const OGC3DTilesComponent* component, OGC3DTilesData* componentState)
{
  // Pre-collect a list of URLs/keys so that we can modify the 'requestedSubtree' map as we go.
  std::vector<std::string> urls;
  urls.reserve(componentState->subTilesetRequests.size());
  for (const auto& [URL, tile] : componentState->subTilesetRequests) {
    const uint64_t tilesetGUID = Cogs::hash(URL);
    if (!componentState->tilesetFetchIds.contains(tilesetGUID)) {
      urls.emplace_back(URL);
    }
  }
 
  for (size_t i = 0; i < urls.size(); ++i) {
    const std::string url = addOptionalURLParameters(componentState, urls[i]);
    const OGC3DTilesTileset::Tileset* parentTileset = componentState->subTilesetRequests[url].second;
 
    extractAndStoreOptionalSessionKeys(componentState, url);
 
    const uint64_t tilesetGUID = Cogs::hash(url);
    componentState->tilesetFetchIds[tilesetGUID] = Cogs::Core::OGC3DTilesTileset::fetch(context, url,
      [thisp=this, component, url, parentTileset, tilesetGUID, uniqueComponentId=componentState->uniqueComponentId](OGC3DTilesTileset::Tileset* tileset) {
        if (OGC3DTilesSystem::componentIsStale(thisp->context, uniqueComponentId)) { // Has component been destructed in the meanwhile?
          return;
        }
 
        OGC3DTilesDataHolder& h = thisp->getData(component);
        OGC3DTilesData* componentState = h.data.get();
 
        if (tileset) {
          componentState->tilesets.push_back(tileset);
          componentState->states[tileset] = OGC3DTilesData::State();
          componentState->states[parentTileset].subTilesets[url] = tileset;
 
          // Now we need to set the baseURL for the new tileset so that its URLs will be relative to
          // the root-tileset's baseURL.
          size_t offset = componentState->baseURL.size() + 1;
          tileset->baseURL = url.substr(offset, url.find_last_of("/") - offset);
 
          if (tileset->root.useImplicitTiling) {
            tileset->root.implicitTiling.subTreeURLScheme = tileset->baseURL + "/" + tileset->root.implicitTiling.subTreeURLScheme;
          }
 
          // Transform the sub-tileset with the master-tileset's transform matrix.
          tileset->root.transform = tileset->root.transform * parentTileset->root.transform;
 
          // If the tileset is in sparse/implicit-mode, we'll always load and cache the root subtree-file.
          if (tileset->root.useImplicitTiling) {
            LOG_DEBUG(logger, "  Sub-tileset tree-structure is of type '%s'", tileset->root.implicitTiling.isOctTree ? "OCT" : "QUAD");
            OGC3DTiles::Coord rootCoord = OGC3DTiles::Coord{ 0, 0, 0, tileset->root.implicitTiling.isOctTree ? 0 : -1 };
            thisp->requestSubtree(componentState, tileset, rootCoord);
          }
        }
        else {
          LOG_ERROR(logger, "Could not parse incoming Sub-tileset from '%s'", url.c_str());
          assert(tileset && "Internal error. Failed loading and parsing incoming tileset");
          return;
        }
 
        componentState->subTilesetRequests.erase(url);
        componentState->tilesetFetchIds.erase(tilesetGUID);
        componentState->loadedSubTilesets.insert(url);
      });
  }
}
 
// Only relevant for IMPLICIT trees
void
OGC3DTilesSystem::processSubtreeRequests(const OGC3DTilesComponent* component, OGC3DTilesData* componentState, const OGC3DTilesTileset::Tileset* tileset)
{
  assert(tileset->root.useImplicitTiling && "Only IMPLICIT trees uses subtrees");
 
  // Pre-collect a list of URLs/keys so that we can modify the 'requestedSubtree' map as we go.
  std::vector<std::string> urls;
  urls.reserve(componentState->states[tileset].subtreeRequests.size());
  for (const auto& [subtreeURL, coord] : componentState->states[tileset].subtreeRequests) {
    const uint64_t subtreeGUID = Cogs::hash(subtreeURL);
    if (!componentState->states[tileset].subtreeFetchIds.contains(subtreeGUID)) {
      urls.emplace_back(subtreeURL);
    }
  }
 
  for (size_t i=0; i<urls.size(); ++i) {
    const std::string subtreeURL = urls[i];
    const OGC3DTiles::Coord subtreeCoord = componentState->states[tileset].subtreeRequests[subtreeURL];
 
    const uint64_t subtreeGUID = Cogs::hash(subtreeURL);
    componentState->states[tileset].subtreeFetchIds[subtreeGUID] = OGC3DTilesSubtree::fetchSubtree(this->context, subtreeURL, componentState->uniqueComponentId,
      [thisp=this, component, subtreeCoord, subtreeURL, tileset, uniqueComponentId = componentState->uniqueComponentId](OGC3DTilesSubtree::Subtree* subtree) {
        if (OGC3DTilesSystem::componentIsStale(thisp->context, uniqueComponentId)) { // Has component been destructed in the meanwhile?
          return;
        }
 
        OGC3DTilesDataHolder& h = thisp->getData(component);
        OGC3DTilesData* componentState = h.data.get();
 
        assert(componentState->states.contains(tileset) && "The tileset is not a part of the component state!");
 
        if (subtree != nullptr) {
          subtree->globalCoord = subtreeCoord;
          subtree->levelsPerSubtree = tileset->root.implicitTiling.subtreeLevels;
          const uint64_t key = OGC3DTilesSystem::makeCacheKey(subtreeCoord);
 
          assert(!componentState->states[tileset].subtreeCache[subtree->globalCoord.level].contains(key) && "Subtree is already loaded!");
          componentState->states[tileset].subtreeCache[subtree->globalCoord.level][key] = subtree;
        }
        else {
          LOG_ERROR(logger, "Failed to load subtree '%s'", subtreeCoord.toString().c_str());
        }
 
        // The registered requests in the component's state will be cleared in "cleanupPendingSubtreeRequests()" in the main
        // thread when the tree has been properly traversed.
 
        thisp->context->engine->setDirty();
      });
  }
}
 
void
OGC3DTilesSystem::requestSubtree(OGC3DTilesData* componentState, const OGC3DTilesTileset::Tileset* tileset, const OGC3DTiles::Coord& coord) const
{
  if (componentState->states[tileset].subtreeRequests.size() > MAX_NUM_ACTIVE_SUBTREES_REQUESTS) {
    return;
  }
 
  const std::string subtreeURL = OGC3DTilesSystem::buildSubtreeURL(componentState, tileset, coord);
  const std::string fullURL = this->addOptionalURLParameters(componentState, subtreeURL);
  const uint64_t key = OGC3DTilesSystem::makeCacheKey(coord);
 
  if (!componentState->states[tileset].subtreeCache[coord.level].contains(key) && // Not loaded or available?
    !componentState->states[tileset].subtreeRequests.contains(fullURL)) {         // Not already requested?
    componentState->states[tileset].subtreeRequests[fullURL] = coord;
  }
}