OGC3DTilesSystem.h

#pragma once
 
#include "../OGC3DTiles.h"
#include "../Components/OGC3DTilesComponent.h"
 
#include "Context.h"
#include "Systems/ComponentSystem.h"
#include "Scene/GetBounds.h"
#include "Services/TaskManager.h"
#include "Resources/DataFetcherManager.h"
 
#include "Foundation/Geometry/Glm.hpp"
#include "Foundation/Geometry/BoundingBox.hpp"
#include "Foundation/Platform/Threads.h"
 
#include <chrono>
#include <string>
#include <set>
#include <unordered_map>
#include <unordered_set>
#include <map>
 
namespace Cogs {
  namespace Core {
    namespace OGC3DTilesTileset {
      struct Tile;
      struct Tileset;
    };
 
    namespace OGC3DTilesSubtree {
      struct Subtree;
    }
 
    struct OGC3DTilesData; // Full definition below
    struct OGC3DTilesDataHolder;
    class OGC3DTilesBounds;
 
    class OGC3DTilesSystem : public ComponentSystemWithDataPool<OGC3DTilesComponent, OGC3DTilesDataHolder>
    {
      using base_type = Cogs::Core::ComponentSystem<OGC3DTilesComponent>;
    public:
 
      OGC3DTilesSystem(Cogs::Memory::Allocator* allocator, Cogs::ComponentIndex capacity);
      ~OGC3DTilesSystem() override;
 
      static bool componentIsStale(Context* context, uint32_t id);
 
      void initialize(Context* context) override;
      void update(Context* context) override;
      ComponentHandle createComponent() override;
      void destroyComponent(ComponentHandle component) override;
 
      struct TileCandidate {
        uint64_t tileId;
        std::vector<std::string> URLs;
        glm::mat4 transform;
        Cogs::Geometry::DBoundingBox bbox;
        uint32_t depth = 0;
      };
 
      struct LoadedModel {
        std::string URL;
        double timestampLastUsed = 0.0;
        ModelHandle modelHandle;
        bool isValid = false;
        std::string uniqueName;
        uint32_t frameNumberAtArrival = 0; // The current frame-number when model was received from server
      };
 
    private:
      void initializeTileset(OGC3DTilesComponent* component, OGC3DTilesData* componentState);
      void traverseTileset(const OGC3DTilesComponent * component, OGC3DTilesData* componentState, const OGC3DTilesTileset::Tileset* tileset, float gracePeriodBeforeTileRemoval);
 
      uint64_t fetchAndInitializeTileset(const uint64_t tilesetGUID, const std::string& tilesetURL, OGC3DTilesComponent* component, uint32_t uniqueComponentId);
      Cogs::Core::DataFetcherManager::FetchId fetchAndInitializeAsset(OGC3DTilesComponent* component, uint32_t uniqueComponentId);
 
      struct Node {
        bool valid = false;
        bool replaceRefine = false;
        TileCandidate tile;
#if defined(__linux__)
        // NOTE: The Linux compiler does not allow usage of "unordered_map" with the same 'value' as the
        // container struct itself (ie. an unordered_map with value of type 'Node').
        std::map<uint64_t, Node> children;
#else
        std::unordered_map<uint64_t, Node> children;
#endif
      };
 
      Node 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 buildImplicitTree(OGC3DTilesData* componentState,
        const OGC3DTilesTileset::Tileset* tileset,
        const OGC3DTiles::Coord& coord,
        const glm::mat4& globalTransform) const;
 
      void collectTileCandidates(OGC3DTilesData* componentState, const Node* node, std::unordered_map<uint64_t, TileCandidate>& target) const;
      void calculateTileVisibilities(OGC3DTilesData* componentState, const OGC3DTilesTileset::Tileset* tileset, const Node* node) const;
 
      bool allChildrenAreReady(OGC3DTilesData* componentState, const OGC3DTilesTileset::Tileset* tileset, const Node* node) const;
      bool tileHasReadyContent(OGC3DTilesData* componentState, const OGC3DTilesTileset::Tileset* tileset, uint64_t tileId) const;
      bool tileHasModelRequests(const OGC3DTilesData* componentState, const OGC3DTilesTileset::Tileset* tileset, uint64_t tileId) const;
      bool tileHasSubTilesetRequests(const OGC3DTilesData* componentState, uint64_t tileId) const;
      void setTileVisibility(const OGC3DTilesData* componentState, const OGC3DTilesTileset::Tileset* tileset, uint64_t tileId, bool onoff) const;
      void setVisibilityForAllTiles(const OGC3DTilesData* componentState, bool onoff) const;
      bool modelIsReady(const ModelHandle& modelhandle) const;
 
      size_t pruneTileCache(OGC3DTilesData* componentState, const OGC3DTilesTileset::Tileset* tileset, float gracePeriodBeforeTileRemoval) const;
      void removeTileFromScene(OGC3DTilesData* componentState, const OGC3DTilesTileset::Tileset* tileset, uint64_t tileId) const;
      void requestSubTileset(OGC3DTilesData* componentState, const std::string& fullURL, uint64_t tileId, const OGC3DTilesTileset::Tileset* parentTileset) const;
      void requestSubtree(OGC3DTilesData* componentState, const OGC3DTilesTileset::Tileset* tileset, const OGC3DTiles::Coord& coord) const;
 
      bool requestModel(OGC3DTilesData* componentState, const OGC3DTilesTileset::Tileset* tileset, const TileCandidate & tile, const std::string URL) const;
      void loadMissingModels(OGC3DTilesData* componentState, const OGC3DTilesTileset::Tileset* tileset, const std::unordered_map<uint64_t, TileCandidate>& toBeLoaded) const;
      void addModelToScene(const std::string& uniqueName, TileCandidate tile, ModelHandle handle, const OGC3DTilesData* componentState) const;
 
      void addBBoxIndicatorToScene(OGC3DTilesData* componentState, const OGC3DTilesTileset::Tileset* tileset, uint64_t tileId, Cogs::Geometry::DBoundingBox box) const;
      void removeBBoxIndicatorFromScene(OGC3DTilesData* componentState, const OGC3DTilesTileset::Tileset* tileset, uint64_t tileId) const;
      void cancelStaleModelRequests(OGC3DTilesData* componentState, const OGC3DTilesTileset::Tileset* tileset, const Node& node) const;
 
      void processModelRequests(OGC3DTilesData* componentState, const OGC3DTilesTileset::Tileset* tileset, uint32_t frameNumber) const;
      void processSubtreeRequests(const OGC3DTilesComponent* component, OGC3DTilesData* componentState, const OGC3DTilesTileset::Tileset* tileset);
      void processSubTilesetRequests(const OGC3DTilesComponent* component, OGC3DTilesData* componentState);
 
      bool hasPendingRequests(const OGC3DTilesData* componentState) const;
      void cleanupPendingSubtreeRequests(OGC3DTilesData* componentState, const OGC3DTilesTileset::Tileset* tileset) const;
 
      bool isInsideFrustum(const Cogs::Geometry::DBoundingBox& box) const;
      glm::dvec3 getCurrentCameraPosition() const;
 
      static uint64_t makeCacheKey(const OGC3DTiles::Coord& coord);
      static std::string buildSubtreeURL(const OGC3DTilesData* componentState, const OGC3DTilesTileset::Tileset* tileset, const OGC3DTiles::Coord& coord);
      OGC3DTilesSubtree::Subtree* getSubtreeForTileCoord(OGC3DTilesData* componentState, const OGC3DTilesTileset::Tileset* tileset, const OGC3DTiles::Coord& coord) const;
      std::vector<OGC3DTiles::Coord> getTileCoordChildren(OGC3DTilesData* componentState, const OGC3DTilesTileset::Tileset* tileset, const OGC3DTiles::Coord& parent) const;
 
      static bool modelIsEmpty(const ModelHandle handle);
      std::string addOptionalURLParameters(const OGC3DTilesData* componentState, const std::string& url) const;
      bool extractAndStoreOptionalSessionKeys(OGC3DTilesData* componentState, const std::string& url) const;
 
      void applyMaterialToAllModels(const OGC3DTilesData* componentState, MaterialInstanceHandle materialHandle);
      void applyMaterialToModel(const OGC3DTilesSystem::LoadedModel & model, MaterialInstanceHandle materialHandle);
 
      static void printDebugStats(const OGC3DTilesData* componentState);
      static std::string compileURL(const std::string& baseURL, const std::string& tilesetPath, const std::string& modelPath);
 
      OGC3DTilesBounds* bounds = nullptr;
      std::string accessToken = "";
 
      double timestampOfLastCameraMovement = 0.0;
      glm::mat4 lastCameraViewProjection = glm::mat4(-1);
    };
 
    //
    // Current state for a OGC3DTilesComponent
    //
    struct OGC3DTilesData {
      struct State {
        std::unordered_map<uint64_t, std::vector<OGC3DTilesSystem::LoadedModel>> tileCache; // map[tileId] = vector<LoadedTile>
        std::unordered_set<uint64_t> pendingModelRequests; // set[tileId]
        std::unordered_map<uint64_t, EntityPtr> bboxIndicatorCache; // map[tileId] = AxisBoxEntity
        std::unordered_map<uint32_t, std::unordered_map<uint64_t, OGC3DTilesSubtree::Subtree*>> subtreeCache; // map[subtreeLevel][cachekey] = Subtree
        std::unordered_map<std::string, OGC3DTilesTileset::Tileset*> subTilesets; // map[URL] = TilesetPtr
        std::unordered_map<std::string, std::pair<OGC3DTilesSystem::TileCandidate, ModelHandle>> modelRequests; // map[URL] = {tile, ModelHandle}
        std::unordered_map<std::string, OGC3DTiles::Coord> subtreeRequests; // map[URL] = coord
        std::unordered_map<uint64_t, Cogs::Core::DataFetcherManager::FetchId> subtreeFetchIds; // map[GUID] = FetchId
        double timestampOfLastTraversal = 0.0;
        bool candidateForDelayedTraversal = false; // If true, the tileset might need a traversal after the grace-period as it could be outside the view-frustum.
      };
      std::unordered_map<const OGC3DTilesTileset::Tileset*, State> states;
 
      std::unordered_map<std::string, std::pair<uint64_t, const OGC3DTilesTileset::Tileset*>> subTilesetRequests; // map[URL] = pair<tileId, ParentTilesetPtr>
      std::vector<const OGC3DTilesTileset::Tileset*> tilesets; // Loaded tilesets. The first tileset is always the main tileset.
      std::set<std::string> loadedSubTilesets; // set[URL]. A set of URLs for loaded sub-tilesets.
 
      Entity* parentEntity = nullptr;
      uint32_t uniqueComponentId = 0;
      glm::dmat4 originalRootTransform;
      std::string baseURL = "";
      std::string additionalURLParameters = "";
      std::string tileBaseURL = "";
      std::string optionalAccessKey = ""; // NOTE: All optional access-keys must be in the form "key=value", not just value.
      std::string optionalSessionKey = "";
      float detailFactor = 1.0;
      MaterialInstanceHandle overrideMaterial;
      bool requiresTraversal = false;
 
      unsigned int numberOfModelsBeingPrepared = 0; // Num models not ready yet in this frame
      bool showTileBBoxes = false;
      bool neverDiscardRootTiles = true;
      bool waitForTileSiblings = true;
      bool enableCaching = false;
      bool colorTileAccordingToTreeDepth = false;
      bool dontRenderLeaves = false;
 
      Cogs::Core::DataFetcherManager::FetchId assetsFetchId = Cogs::Core::DataFetcherManager::NoFetchId;
      std::unordered_map<uint64_t, Cogs::Core::DataFetcherManager::FetchId> tilesetFetchIds; // map[GUID] = FetchId
 
      struct Statistics {
        int traversedDepth = 0;
        int numberOfCancelledRequests = 0;
        int numberOfPendingRequests = 0;
        int numberOfVisitedSubTilesets = 0;
      };
      Statistics statistics;
    };
 
    struct OGC3DTilesDataHolder {
      std::unique_ptr<OGC3DTilesData> data;
    };
  }
}