Tileset.h

#pragma once
 
#include <Cesium3DTilesSelection/Library.h>
#include <Cesium3DTilesSelection/RasterOverlayCollection.h>
#include <Cesium3DTilesSelection/SampleHeightResult.h>
#include <Cesium3DTilesSelection/Tile.h>
#include <Cesium3DTilesSelection/TilesetContentLoader.h>
#include <Cesium3DTilesSelection/TilesetContentLoaderFactory.h>
#include <Cesium3DTilesSelection/TilesetExternals.h>
#include <Cesium3DTilesSelection/TilesetLoadFailureDetails.h>
#include <Cesium3DTilesSelection/TilesetOptions.h>
#include <Cesium3DTilesSelection/ViewState.h>
#include <Cesium3DTilesSelection/ViewUpdateResult.h>
#include <CesiumAsync/AsyncSystem.h>
#include <CesiumUtility/IntrusivePointer.h>
 
#include <rapidjson/fwd.h>
 
#include <list>
#include <memory>
#include <string>
#include <vector>
 
namespace Cesium3DTilesSelection {
 
class TilesetContentManager;
class TilesetMetadata;
class TilesetHeightQuery;
struct TilesetHeightRequest;
class TilesetSharedAssetSystem;
 
class CESIUM3DTILESSELECTION_API Tileset final {
public:
  Tileset(
      const TilesetExternals& externals,
      std::unique_ptr<TilesetContentLoader>&& pCustomLoader,
      std::unique_ptr<Tile>&& pRootTile,
      const TilesetOptions& options = TilesetOptions());
 
  Tileset(
      const TilesetExternals& externals,
      const std::string& url,
      const TilesetOptions& options = TilesetOptions());
 
  Tileset(
      const TilesetExternals& externals,
      int64_t ionAssetID,
      const std::string& ionAccessToken,
      const TilesetOptions& options = TilesetOptions(),
      const std::string& ionAssetEndpointUrl = "https://api.cesium.com/");
 
  Tileset(
      const TilesetExternals& externals,
      TilesetContentLoaderFactory&& loaderFactory,
      const TilesetOptions& options = TilesetOptions());
 
  ~Tileset() noexcept;
 
  CesiumAsync::SharedFuture<void>& getAsyncDestructionCompleteEvent();
 
  CesiumAsync::SharedFuture<void>& getRootTileAvailableEvent();
 
  const std::vector<CesiumUtility::Credit>& getTilesetCredits() const noexcept;
 
  void setShowCreditsOnScreen(bool showCreditsOnScreen) noexcept;
 
  TilesetExternals& getExternals() noexcept { return this->_externals; }
 
  const TilesetExternals& getExternals() const noexcept {
    return this->_externals;
  }
 
  CesiumAsync::AsyncSystem& getAsyncSystem() noexcept {
    return this->_asyncSystem;
  }
 
  const CesiumAsync::AsyncSystem& getAsyncSystem() const noexcept {
    return this->_asyncSystem;
  }
 
  const TilesetOptions& getOptions() const noexcept { return this->_options; }
 
  TilesetOptions& getOptions() noexcept { return this->_options; }
 
  const CesiumGeospatial::Ellipsoid& getEllipsoid() const {
    return this->_options.ellipsoid;
  }
 
  CesiumGeospatial::Ellipsoid& getEllipsoid() noexcept {
    return this->_options.ellipsoid;
  }
 
  Tile* getRootTile() noexcept;
 
  const Tile* getRootTile() const noexcept;
 
  RasterOverlayCollection& getOverlays() noexcept;
 
  const RasterOverlayCollection& getOverlays() const noexcept;
 
  TilesetSharedAssetSystem& getSharedAssetSystem() noexcept;
 
  const TilesetSharedAssetSystem& getSharedAssetSystem() const noexcept;
 
  const ViewUpdateResult&
  updateViewOffline(const std::vector<ViewState>& frustums);
 
  const ViewUpdateResult&
  updateView(const std::vector<ViewState>& frustums, float deltaTime = 0.0f);
 
  int32_t getNumberOfTilesLoaded() const;
 
  float computeLoadProgress() noexcept;
 
  void forEachLoadedTile(const std::function<void(Tile& tile)>& callback);
 
  void forEachLoadedTile(
      const std::function<void(const Tile& tile)>& callback) const;
 
  int64_t getTotalDataBytes() const noexcept;
 
  const TilesetMetadata* getMetadata(const Tile* pTile = nullptr) const;
 
  CesiumAsync::Future<const TilesetMetadata*> loadMetadata();
 
  CesiumAsync::Future<SampleHeightResult> sampleHeightMostDetailed(
      const std::vector<CesiumGeospatial::Cartographic>& positions);
 
  Tileset(const Tileset& rhs) = delete;
  Tileset& operator=(const Tileset& rhs) = delete;
 
private:
  struct TraversalDetails {
    bool allAreRenderable = true;
 
    bool anyWereRenderedLastFrame = false;
 
    uint32_t notYetRenderableCount = 0;
  };
 
  struct FrameState {
    const std::vector<ViewState>& frustums;
    std::vector<double> fogDensities;
    int32_t lastFrameNumber;
    int32_t currentFrameNumber;
  };
 
  TraversalDetails _renderLeaf(
      const FrameState& frameState,
      Tile& tile,
      double tilePriority,
      ViewUpdateResult& result);
  TraversalDetails _renderInnerTile(
      const FrameState& frameState,
      Tile& tile,
      ViewUpdateResult& result);
  bool _kickDescendantsAndRenderTile(
      const FrameState& frameState,
      Tile& tile,
      ViewUpdateResult& result,
      TraversalDetails& traversalDetails,
      size_t firstRenderedDescendantIndex,
      size_t workerThreadLoadQueueIndex,
      size_t mainThreadLoadQueueIndex,
      bool queuedForLoad,
      double tilePriority);
  TileOcclusionState
  _checkOcclusion(const Tile& tile, const FrameState& frameState);
 
  TraversalDetails _visitTile(
      const FrameState& frameState,
      uint32_t depth,
      bool meetsSse,
      bool ancestorMeetsSse,
      Tile& tile,
      double tilePriority,
      ViewUpdateResult& result);
 
  struct CullResult {
    // whether we should visit this tile
    bool shouldVisit = true;
    // whether this tile was culled (Note: we might still want to visit it)
    bool culled = false;
  };
 
  // TODO: abstract these into a composable culling interface.
  void _frustumCull(
      const Tile& tile,
      const FrameState& frameState,
      bool cullWithChildrenBounds,
      CullResult& cullResult);
  void _fogCull(
      const FrameState& frameState,
      const std::vector<double>& distances,
      CullResult& cullResult);
  bool _meetsSse(
      const std::vector<ViewState>& frustums,
      const Tile& tile,
      const std::vector<double>& distances,
      bool culled) const noexcept;
 
  TraversalDetails _visitTileIfNeeded(
      const FrameState& frameState,
      uint32_t depth,
      bool ancestorMeetsSse,
      Tile& tile,
      ViewUpdateResult& result);
  TraversalDetails _visitVisibleChildrenNearToFar(
      const FrameState& frameState,
      uint32_t depth,
      bool ancestorMeetsSse,
      Tile& tile,
      ViewUpdateResult& result);
 
  bool _loadAndRenderAdditiveRefinedTile(
      Tile& tile,
      ViewUpdateResult& result,
      double tilePriority,
      bool queuedForLoad);
 
  void _processWorkerThreadLoadQueue();
  void _processMainThreadLoadQueue();
 
  void _clearChildrenRecursively(Tile* pTile) noexcept;
  void _unloadCachedTiles(double timeBudget) noexcept;
  void _markTileVisited(Tile& tile) noexcept;
 
  void _updateLodTransitions(
      const FrameState& frameState,
      float deltaTime,
      ViewUpdateResult& result) const noexcept;
 
  TilesetExternals _externals;
  CesiumAsync::AsyncSystem _asyncSystem;
 
  TilesetOptions _options;
 
  int32_t _previousFrameNumber;
  ViewUpdateResult _updateResult;
 
  enum class TileLoadPriorityGroup {
    Preload = 0,
 
    Normal = 1,
 
    Urgent = 2
  };
 
  struct TileLoadTask {
    Tile* pTile;
 
    TileLoadPriorityGroup group;
 
    double priority;
 
    bool operator<(const TileLoadTask& rhs) const noexcept {
      if (this->group == rhs.group)
        return this->priority < rhs.priority;
      else
        return this->group > rhs.group;
    }
  };
 
  std::vector<TileLoadTask> _mainThreadLoadQueue;
  std::vector<TileLoadTask> _workerThreadLoadQueue;
  std::vector<Tile*> _heightQueryLoadQueue;
 
  Tile::LoadedLinkedList _loadedTiles;
 
  // Holds computed distances, to avoid allocating them on the heap during tile
  // selection.
  std::vector<double> _distances;
 
  // Holds the occlusion proxies of the children of a tile. Store them in this
  // scratch variable so that it can allocate only when growing bigger.
  std::vector<const TileOcclusionRendererProxy*> _childOcclusionProxies;
 
  CesiumUtility::IntrusivePointer<TilesetContentManager>
      _pTilesetContentManager;
 
  std::list<TilesetHeightRequest> _heightRequests;
 
  void addTileToLoadQueue(
      Tile& tile,
      TileLoadPriorityGroup priorityGroup,
      double priority);
 
  static TraversalDetails createTraversalDetailsForSingleTile(
      const FrameState& frameState,
      const Tile& tile,
      const TileSelectionState& lastFrameSelectionState);
};
 
} // namespace Cesium3DTilesSelection