TilesetContentLoader.h

#pragma once
 
#include <Cesium3DTilesSelection/BoundingVolume.h>
#include <Cesium3DTilesSelection/Library.h>
#include <Cesium3DTilesSelection/SampleHeightResult.h>
#include <Cesium3DTilesSelection/TileContent.h>
#include <Cesium3DTilesSelection/TileLoadResult.h>
#include <Cesium3DTilesSelection/TilesetOptions.h>
#include <CesiumAsync/AsyncSystem.h>
#include <CesiumAsync/Future.h>
#include <CesiumAsync/IAssetAccessor.h>
#include <CesiumGeometry/Axis.h>
#include <CesiumGeospatial/Ellipsoid.h>
#include <CesiumGltf/Model.h>
#include <CesiumRasterOverlays/RasterOverlayDetails.h>
 
#include <spdlog/logger.h>
 
#include <functional>
#include <memory>
#include <optional>
#include <vector>
 
namespace CesiumGltf {
struct Schema;
};
 
namespace Cesium3DTilesSelection {
class Tile;
class ITilesetHeightSampler;
class TilesetContentManager;
class TilesetSharedAssetSystem;

struct CESIUM3DTILESSELECTION_API TileLoadInput {
  TileLoadInput(
      const Tile& tile,
      const TilesetContentOptions& contentOptions,
      const CesiumAsync::AsyncSystem& asyncSystem,
      const std::shared_ptr<CesiumAsync::IAssetAccessor>& pAssetAccessor,
      const std::shared_ptr<spdlog::logger>& pLogger,
      const std::vector<CesiumAsync::IAssetAccessor::THeader>& requestHeaders,
      const CesiumGeospatial::Ellipsoid& ellipsoid CESIUM_DEFAULT_ELLIPSOID);
  ~TileLoadInput() noexcept;

  TileLoadInput(const TileLoadInput& rhs) noexcept;

  TileLoadInput(TileLoadInput&& rhs) noexcept;

  const Tile& tile;

  const TilesetContentOptions& contentOptions;

  const CesiumAsync::AsyncSystem& asyncSystem;

  const std::shared_ptr<CesiumAsync::IAssetAccessor>& pAssetAccessor;

  const std::shared_ptr<spdlog::logger>& pLogger;

  const std::vector<CesiumAsync::IAssetAccessor::THeader>& requestHeaders;

  CesiumUtility::IntrusivePointer<TilesetSharedAssetSystem> pSharedAssetSystem;

  const CesiumGeospatial::Ellipsoid& ellipsoid;
};

struct CESIUM3DTILESSELECTION_API TileChildrenResult {
  std::vector<Tile> children;

  TileLoadResultState state;
};

class CESIUM3DTILESSELECTION_API TilesetContentLoader {
public:
  virtual ~TilesetContentLoader() = default;

  virtual CesiumAsync::Future<TileLoadResult>
  loadTileContent(const TileLoadInput& input) = 0;

  virtual TileChildrenResult createTileChildren(
      const Tile& tile,
      const CesiumGeospatial::Ellipsoid& ellipsoid
          CESIUM_DEFAULT_ELLIPSOID) = 0;

  virtual ITilesetHeightSampler* getHeightSampler() { return nullptr; }

  const TilesetContentManager* getOwner() const noexcept;

  TilesetContentManager* getOwner() noexcept;

  void setOwner(TilesetContentManager& owner) noexcept;

  virtual void setExternalSchema(CesiumGltf::Schema* schema);

  virtual CesiumUtility::IntrusivePointer<CesiumGltf::Schema>
  getExternalSchema();
 
protected:
  virtual void setOwnerOfNestedLoaders(TilesetContentManager& owner) noexcept;
 
private:
  TilesetContentManager* _pOwner = nullptr;
};
} // namespace Cesium3DTilesSelection