Tileset.h

#pragma once
 
#include <Cesium3DTilesSelection/Library.h>
#include <Cesium3DTilesSelection/LoadedTileEnumerator.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/TilesetViewGroup.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 TilesetViewGroup;
class TilesetFrameState;

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();

  std::optional<CesiumUtility::Credit> getUserCredit() const noexcept;

  const std::vector<CesiumUtility::Credit>& getTilesetCredits() const noexcept;

  void setShowCreditsOnScreen(bool showCreditsOnScreen) noexcept;

  const CesiumUtility::CreditSource& getCreditSource() const 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;
  }

  const Tile* getRootTile() const noexcept;

  RasterOverlayCollection& getOverlays() noexcept;

  const RasterOverlayCollection& getOverlays() const noexcept;

  TilesetSharedAssetSystem& getSharedAssetSystem() noexcept;

  const TilesetSharedAssetSystem& getSharedAssetSystem() const noexcept;

  [[deprecated("Instead of `tileset.updateViewOffline(...)`, call "
               "`tileset.updateViewGroupOffline(tileset.getDefaultViewGroup(), "
               "...)`.")]] const ViewUpdateResult&
  updateViewOffline(const std::vector<ViewState>& frustums);

  [[deprecated("Instead of `tileset.updateView(...)`, call "
               "`tileset.updateViewGroup(tileset.getDefaultViewGroup(), ...)` "
               "followed by `tileset.loadTiles()`.")]] const ViewUpdateResult&
  updateView(const std::vector<ViewState>& frustums, float deltaTime = 0.0f);

  int32_t getNumberOfTilesLoaded() const;

  float computeLoadProgress() noexcept;

  LoadedConstTileEnumerator loadedTiles() const;

  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);

  TilesetViewGroup& getDefaultViewGroup();

  const TilesetViewGroup& getDefaultViewGroup() const;

  const ViewUpdateResult& updateViewGroup(
      TilesetViewGroup& viewGroup,
      const std::vector<ViewState>& frustums,
      float deltaTime = 0.0f);

  const ViewUpdateResult& updateViewGroupOffline(
      TilesetViewGroup& viewGroup,
      const std::vector<ViewState>& frustums);

  void loadTiles();

  void registerLoadRequester(TileLoadRequester& requester);

  bool waitForAllLoadsToComplete(double maximumWaitTimeInMilliseconds);
 
  Tileset(const Tileset& rhs) = delete;
  Tileset& operator=(const Tileset& rhs) = delete;
 
private:
  struct TraversalDetails {
    bool allAreRenderable = true;

    bool anyWereRenderedLastFrame = false;

    uint32_t notYetRenderableCount = 0;
  };
 
  TraversalDetails _renderLeaf(
      const TilesetFrameState& frameState,
      Tile& tile,
      double tilePriority,
      double tileSse,
      ViewUpdateResult& result);
  TraversalDetails _renderInnerTile(
      const TilesetFrameState& frameState,
      Tile& tile,
      double tileSse,
      ViewUpdateResult& result);
  bool _kickDescendantsAndRenderTile(
      const TilesetFrameState& frameState,
      Tile& tile,
      ViewUpdateResult& result,
      TraversalDetails& traversalDetails,
      size_t firstRenderedDescendantIndex,
      const TilesetViewGroup::LoadQueueCheckpoint& loadQueueBeforeChildren,
      bool queuedForLoad,
      double tilePriority,
      double tileSse);
  TileOcclusionState _checkOcclusion(const Tile& tile);
 
  TraversalDetails _visitTile(
      const TilesetFrameState& frameState,
      uint32_t depth,
      bool meetsSse,
      bool ancestorMeetsSse,
      Tile& tile,
      double tilePriority,
      double tileSse,
      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 TilesetFrameState& frameState,
      bool cullWithChildrenBounds,
      CullResult& cullResult);
  void _fogCull(
      const TilesetFrameState& frameState,
      const std::vector<double>& distances,
      CullResult& cullResult);
  double _computeSse(
      const std::vector<ViewState>& frustums,
      const Tile& tile,
      const std::vector<double>& distances) const noexcept;
  bool _meetsSseThreshold(double sse, bool culled) const noexcept;
 
  TraversalDetails _visitTileIfNeeded(
      const TilesetFrameState& frameState,
      uint32_t depth,
      bool ancestorMeetsSse,
      Tile& tile,
      ViewUpdateResult& result);
  TraversalDetails _visitVisibleChildrenNearToFar(
      const TilesetFrameState& frameState,
      uint32_t depth,
      bool ancestorMeetsSse,
      Tile& tile,
      ViewUpdateResult& result);

  bool _loadAndRenderAdditiveRefinedTile(
      const TilesetFrameState& frameState,
      Tile& tile,
      ViewUpdateResult& result,
      double tilePriority,
      double tileSse,
      bool queuedForLoad);
 
  void _unloadCachedTiles(double timeBudget) noexcept;
 
  void _updateLodTransitions(
      const TilesetFrameState& frameState,
      float deltaTime,
      ViewUpdateResult& result) const noexcept;
 
  TilesetExternals _externals;
  CesiumAsync::AsyncSystem _asyncSystem;
 
  TilesetOptions _options;
 
  // 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;
 
  TilesetViewGroup _defaultViewGroup;
 
  void addTileToLoadQueue(
      const TilesetFrameState& frameState,
      Tile& tile,
      TileLoadPriorityGroup priorityGroup,
      double priority);
 
  static TraversalDetails createTraversalDetailsForSingleTile(
      const TilesetFrameState& frameState,
      const Tile& tile);
};
 
} // namespace Cesium3DTilesSelection