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 <CesiumUtility/IntrusivePointer.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;
class GltfModifier;
 
#ifdef CESIUM_DEBUG_TILE_UNLOADING
class TileReferenceCountTracker {
private:
  struct Entry {
    std::string reason;
    bool increment;
    int32_t newCount;
  };
 
public:
  static void addEntry(
      const uint64_t id,
      bool increment,
      const char* 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:
  using Pointer = CesiumUtility::IntrusivePointer<Tile>;

  using ConstPointer = CesiumUtility::IntrusivePointer<const Tile>;

  explicit Tile(
      TilesetContentLoader* pLoader,
      const TileID& tileID = {}) noexcept;

  Tile(
      TilesetContentLoader* pLoader,
      const TileID& tileID,
      std::unique_ptr<TileExternalContent>&& externalContent) noexcept;

  Tile(
      TilesetContentLoader* pLoader,
      const TileID& tileID,
      TileEmptyContent emptyContent) noexcept;

  ~Tile() noexcept;

  Tile(const Tile& rhs) = delete;

  Tile(Tile&& rhs) noexcept;

  Tile& operator=(const Tile& rhs) = delete;

  Tile& operator=(Tile&& rhs) noexcept = delete;

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

  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;

  bool needsWorkerThreadLoading(const GltfModifier* pModifier) const noexcept;

  bool needsMainThreadLoading(const GltfModifier* pModifier) const noexcept;

  void addReference(const char* reason = nullptr) const noexcept;

  void releaseReference(const char* reason = nullptr) const noexcept;

  int32_t getReferenceCount() const noexcept;

  bool hasReferencingContent() const noexcept;
 
private:
  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,
      const TileID& tileID,
      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;
 
  // tile content
  CesiumUtility::DoublyLinkedListPointers<Tile> _unusedTilesLinks;
  TileContent _content;
  TilesetContentLoader* _pLoader;
  TileLoadState _loadState;
  bool _mightHaveLatentChildren;
 
  // mapped raster overlay
  std::vector<RasterMappedTo3DTile> _rasterTiles;
 
  mutable int32_t _referenceCount;
 
  friend class TilesetContentManager;
  friend class MockTilesetContentManagerTestFixture;
 
public:
  typedef CesiumUtility::DoublyLinkedList<Tile, &Tile::_unusedTilesLinks>
      UnusedLinkedList;
};
 
} // namespace Cesium3DTilesSelection