Tile.h

#pragma once
 
#include <Cesium3DTilesSelection/BoundingVolume.h>
#include <Cesium3DTilesSelection/Library.h>
#include <Cesium3DTilesSelection/RasterMappedTo3DTile.h>
#include <Cesium3DTilesSelection/TileContent.h>
#include <Cesium3DTilesSelection/TileID.h>
#include <Cesium3DTilesSelection/TileRefine.h>
#include <Cesium3DTilesSelection/TileSelectionState.h>
#include <CesiumUtility/DoublyLinkedList.h>
 
#include <glm/common.hpp>
 
#include <atomic>
#include <limits>
#include <memory>
#include <optional>
#include <span>
#include <string>
#include <vector>
 
#ifdef CESIUM_DEBUG_TILE_UNLOADING
#include <unordered_map>
#endif
 
namespace Cesium3DTilesSelection {
class TilesetContentLoader;
 
#ifdef CESIUM_DEBUG_TILE_UNLOADING
class TileDoNotUnloadSubtreeCountTracker {
private:
  struct Entry {
    std::string reason;
    bool increment;
    int32_t newCount;
  };
 
public:
  static void addEntry(
      const uint64_t id,
      bool increment,
      const std::string& reason,
      int32_t newCount);
 
private:
  static std::unordered_map<std::string, std::vector<Entry>> _entries;
};
#endif
 
enum class TileLoadState {
  Unloading = -2,
 
  FailedTemporarily = -1,
 
  Unloaded = 0,
 
  ContentLoading = 1,
 
  ContentLoaded = 2,
 
  Done = 3,
 
  Failed = 4,
};
 
class CESIUM3DTILESSELECTION_API Tile final {
public:
  explicit Tile(TilesetContentLoader* pLoader) noexcept;
 
  Tile(
      TilesetContentLoader* pLoader,
      std::unique_ptr<TileExternalContent>&& externalContent) noexcept;
 
  Tile(TilesetContentLoader* pLoader, TileEmptyContent emptyContent) noexcept;
 
  ~Tile() noexcept = default;
 
  Tile(const Tile& rhs) = delete;
 
  Tile(Tile&& rhs) noexcept;
 
  Tile& operator=(const Tile& rhs) = delete;
 
  Tile& operator=(Tile&& rhs) noexcept;
 
  Tile* getParent() noexcept { return this->_pParent; }
 
  const Tile* getParent() const noexcept { return this->_pParent; }
 
  std::span<Tile> getChildren() noexcept {
    return std::span<Tile>(this->_children);
  }
 
  std::span<const Tile> getChildren() const noexcept {
    return std::span<const Tile>(this->_children);
  }
 
  void clearChildren() noexcept;
 
  void createChildTiles(std::vector<Tile>&& children);
 
  const BoundingVolume& getBoundingVolume() const noexcept {
    return this->_boundingVolume;
  }
 
  void setBoundingVolume(const BoundingVolume& value) noexcept {
    this->_boundingVolume = value;
  }
 
  const std::optional<BoundingVolume>& getViewerRequestVolume() const noexcept {
    return this->_viewerRequestVolume;
  }
 
  void
  setViewerRequestVolume(const std::optional<BoundingVolume>& value) noexcept {
    this->_viewerRequestVolume = value;
  }
 
  double getGeometricError() const noexcept { return this->_geometricError; }
 
  void setGeometricError(double value) noexcept {
    this->_geometricError = value;
  }
 
  double getNonZeroGeometricError() const noexcept;
 
  bool getUnconditionallyRefine() const noexcept {
    return glm::isinf(this->_geometricError);
  }
 
  void setUnconditionallyRefine() noexcept {
    this->_geometricError = std::numeric_limits<double>::infinity();
  }
 
  TileRefine getRefine() const noexcept { return this->_refine; }
 
  void setRefine(TileRefine value) noexcept { this->_refine = value; }
 
  const glm::dmat4x4& getTransform() const noexcept { return this->_transform; }
 
  void setTransform(const glm::dmat4x4& value) noexcept {
    this->_transform = value;
  }
 
  const TileID& getTileID() const noexcept { return this->_id; }
 
  void setTileID(const TileID& id) noexcept { this->_id = id; }
 
  const std::optional<BoundingVolume>&
  getContentBoundingVolume() const noexcept {
    return this->_contentBoundingVolume;
  }
 
  void setContentBoundingVolume(
      const std::optional<BoundingVolume>& value) noexcept {
    this->_contentBoundingVolume = value;
  }
 
  TileSelectionState& getLastSelectionState() noexcept {
    return this->_lastSelectionState;
  }
 
  const TileSelectionState& getLastSelectionState() const noexcept {
    return this->_lastSelectionState;
  }
 
  void setLastSelectionState(const TileSelectionState& newState) noexcept {
    this->_lastSelectionState = newState;
  }
 
  int64_t computeByteSize() const noexcept;
 
  std::vector<RasterMappedTo3DTile>& getMappedRasterTiles() noexcept {
    return this->_rasterTiles;
  }
 
  const std::vector<RasterMappedTo3DTile>&
  getMappedRasterTiles() const noexcept {
    return this->_rasterTiles;
  }
 
  const TileContent& getContent() const noexcept { return _content; }
 
  TileContent& getContent() noexcept { return _content; }
 
  bool isRenderable() const noexcept;
 
  bool isRenderContent() const noexcept;
 
  bool isExternalContent() const noexcept;
 
  bool isEmptyContent() const noexcept;
 
  TilesetContentLoader* getLoader() const noexcept;
 
  TileLoadState getState() const noexcept;
 
  int32_t getDoNotUnloadSubtreeCount() const noexcept {
    return this->_doNotUnloadSubtreeCount;
  }
 
  void incrementDoNotUnloadSubtreeCount(const char* reason) noexcept;
 
  void decrementDoNotUnloadSubtreeCount(const char* reason) noexcept;
 
  void incrementDoNotUnloadSubtreeCountOnParent(const char* reason) noexcept;
 
  void decrementDoNotUnloadSubtreeCountOnParent(const char* reason) noexcept;
 
private:
  void incrementDoNotUnloadSubtreeCount(const std::string& reason) noexcept;
 
  void decrementDoNotUnloadSubtreeCount(const std::string& reason) noexcept;
 
  struct TileConstructorImpl {};
  template <
      typename... TileContentArgs,
      typename TileContentEnable = std::enable_if_t<
          std::is_constructible_v<TileContent, TileContentArgs&&...>,
          int>>
  Tile(
      TileConstructorImpl tag,
      TileLoadState loadState,
      TilesetContentLoader* pLoader,
      TileContentArgs&&... args);
 
  void setParent(Tile* pParent) noexcept;
 
  void setState(TileLoadState state) noexcept;
 
  bool getMightHaveLatentChildren() const noexcept;
 
  void setMightHaveLatentChildren(bool mightHaveLatentChildren) noexcept;
 
  // Position in bounding-volume hierarchy.
  Tile* _pParent;
  std::vector<Tile> _children;
 
  // Properties from tileset.json.
  // These are immutable after the tile leaves TileState::Unloaded.
  TileID _id;
  BoundingVolume _boundingVolume;
  std::optional<BoundingVolume> _viewerRequestVolume;
  std::optional<BoundingVolume> _contentBoundingVolume;
  double _geometricError;
  TileRefine _refine;
  glm::dmat4x4 _transform;
 
  // Selection state
  TileSelectionState _lastSelectionState;
 
  // tile content
  CesiumUtility::DoublyLinkedListPointers<Tile> _loadedTilesLinks;
  TileContent _content;
  TilesetContentLoader* _pLoader;
  TileLoadState _loadState;
  bool _mightHaveLatentChildren;
 
  // mapped raster overlay
  std::vector<RasterMappedTo3DTile> _rasterTiles;
 
  // Number of existing claims on this tile preventing it and its parent
  // external tileset (if any) from being unloaded from the tree.
  int32_t _doNotUnloadSubtreeCount = 0;
 
  friend class TilesetContentManager;
  friend class MockTilesetContentManagerTestFixture;
 
public:
  typedef CesiumUtility::DoublyLinkedList<Tile, &Tile::_loadedTilesLinks>
      LoadedLinkedList;
};
 
} // namespace Cesium3DTilesSelection