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/TilesetSelection.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;

  Tile* getRootTile() 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 updateTileContent(Tile& tile);

  void registerLoadRequester(TileLoadRequester& requester);

  bool waitForAllLoadsToComplete(double maximumWaitTimeInMilliseconds);
 
  Tileset(const Tileset& rhs) = delete;
  Tileset& operator=(const Tileset& rhs) = delete;
 
private:
  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, to avoid
  // per-frame allocation.
  std::vector<const TileOcclusionRendererProxy*> _childOcclusionProxies;
 
  CesiumUtility::IntrusivePointer<TilesetContentManager>
      _pTilesetContentManager;
 
  std::list<TilesetHeightRequest> _heightRequests;
 
  TilesetViewGroup _defaultViewGroup;
};
 
} // namespace Cesium3DTilesSelection