RasterOverlayTileProvider.h

#pragma once
 
#include "Library.h"
 
#include <CesiumAsync/IAssetAccessor.h>
#include <CesiumGeospatial/Projection.h>
#include <CesiumGltfReader/GltfReader.h>
#include <CesiumUtility/Assert.h>
#include <CesiumUtility/CreditSystem.h>
#include <CesiumUtility/ErrorList.h>
#include <CesiumUtility/IntrusivePointer.h>
#include <CesiumUtility/ReferenceCounted.h>
#include <CesiumUtility/Tracing.h>
 
#include <spdlog/fwd.h>
 
#include <optional>
 
namespace CesiumRasterOverlays {
 
class RasterOverlay;
class RasterOverlayTile;
class IPrepareRasterOverlayRendererResources;
 
struct CESIUMRASTEROVERLAYS_API LoadedRasterOverlayImage {
  CesiumUtility::IntrusivePointer<CesiumGltf::ImageAsset> pImage{nullptr};
 
  CesiumGeometry::Rectangle rectangle{};
 
  std::vector<CesiumUtility::Credit> credits{};
 
  CesiumUtility::ErrorList errorList{};
 
  bool moreDetailAvailable = false;
 
  int64_t getSizeBytes() const {
    int64_t accum = 0;
    accum += int64_t(sizeof(LoadedRasterOverlayImage));
    accum += int64_t(this->credits.capacity() * sizeof(CesiumUtility::Credit));
    if (this->pImage) {
      accum += this->pImage->getSizeBytes();
    }
    return accum;
  }
};
 
struct LoadTileImageFromUrlOptions {
  CesiumGeometry::Rectangle rectangle{};
 
  std::vector<CesiumUtility::Credit> credits{};
 
  bool moreDetailAvailable = true;
 
  bool allowEmptyImages = false;
};
 
class RasterOverlayTileProvider;
 
struct TileProviderAndTile {
  CesiumUtility::IntrusivePointer<RasterOverlayTileProvider> pTileProvider;
  CesiumUtility::IntrusivePointer<RasterOverlayTile> pTile;
 
  ~TileProviderAndTile() noexcept;
};
 
class CESIUMRASTEROVERLAYS_API RasterOverlayTileProvider
    : public CesiumUtility::ReferenceCountedNonThreadSafe<
          RasterOverlayTileProvider> {
public:
  RasterOverlayTileProvider(
      const CesiumUtility::IntrusivePointer<const RasterOverlay>& pOwner,
      const CesiumAsync::AsyncSystem& asyncSystem,
      const std::shared_ptr<CesiumAsync::IAssetAccessor>& pAssetAccessor,
      const CesiumGeospatial::Ellipsoid& ellipsoid
          CESIUM_DEFAULT_ELLIPSOID) noexcept;
 
  RasterOverlayTileProvider(
      const CesiumUtility::IntrusivePointer<const RasterOverlay>& pOwner,
      const CesiumAsync::AsyncSystem& asyncSystem,
      const std::shared_ptr<CesiumAsync::IAssetAccessor>& pAssetAccessor,
      std::optional<CesiumUtility::Credit> credit,
      const std::shared_ptr<IPrepareRasterOverlayRendererResources>&
          pPrepareRendererResources,
      const std::shared_ptr<spdlog::logger>& pLogger,
      const CesiumGeospatial::Projection& projection,
      const CesiumGeometry::Rectangle& coverageRectangle) noexcept;
 
  virtual ~RasterOverlayTileProvider() noexcept;
 
  bool isPlaceholder() const noexcept { return this->_pPlaceholder != nullptr; }
 
  RasterOverlay& getOwner() noexcept { return *this->_pOwner; }
 
  const RasterOverlay& getOwner() const noexcept { return *this->_pOwner; }
 
  const std::shared_ptr<CesiumAsync::IAssetAccessor>&
  getAssetAccessor() const noexcept {
    return this->_pAssetAccessor;
  }
 
  const CesiumAsync::AsyncSystem& getAsyncSystem() const noexcept {
    return this->_asyncSystem;
  }
 
  const std::shared_ptr<IPrepareRasterOverlayRendererResources>&
  getPrepareRendererResources() const noexcept {
    return this->_pPrepareRendererResources;
  }
 
  const std::shared_ptr<spdlog::logger>& getLogger() const noexcept {
    return this->_pLogger;
  }
 
  const CesiumGeospatial::Projection& getProjection() const noexcept {
    return this->_projection;
  }
 
  const CesiumGeometry::Rectangle& getCoverageRectangle() const noexcept {
    return this->_coverageRectangle;
  }
 
  CesiumUtility::IntrusivePointer<RasterOverlayTile> getTile(
      const CesiumGeometry::Rectangle& rectangle,
      const glm::dvec2& targetScreenPixels);
 
  int64_t getTileDataBytes() const noexcept { return this->_tileDataBytes; }
 
  uint32_t getNumberOfTilesLoading() const noexcept {
    CESIUM_ASSERT(this->_totalTilesCurrentlyLoading > -1);
    return static_cast<uint32_t>(this->_totalTilesCurrentlyLoading);
  }
 
  void removeTile(RasterOverlayTile* pTile) noexcept;
 
  const std::optional<CesiumUtility::Credit>& getCredit() const noexcept {
    return _credit;
  }
 
  CesiumAsync::Future<TileProviderAndTile> loadTile(RasterOverlayTile& tile);
 
  bool loadTileThrottled(RasterOverlayTile& tile);
 
protected:
  virtual CesiumAsync::Future<LoadedRasterOverlayImage>
  loadTileImage(RasterOverlayTile& overlayTile) = 0;
 
  CesiumAsync::Future<LoadedRasterOverlayImage> loadTileImageFromUrl(
      const std::string& url,
      const std::vector<CesiumAsync::IAssetAccessor::THeader>& headers = {},
      LoadTileImageFromUrlOptions&& options = {}) const;
 
private:
  CesiumAsync::Future<TileProviderAndTile>
  doLoad(RasterOverlayTile& tile, bool isThrottledLoad);
 
  void beginTileLoad(bool isThrottledLoad) noexcept;
 
  void finalizeTileLoad(bool isThrottledLoad) noexcept;
 
private:
  CesiumUtility::IntrusivePointer<RasterOverlay> _pOwner;
  CesiumAsync::AsyncSystem _asyncSystem;
  std::shared_ptr<CesiumAsync::IAssetAccessor> _pAssetAccessor;
  std::optional<CesiumUtility::Credit> _credit;
  std::shared_ptr<IPrepareRasterOverlayRendererResources>
      _pPrepareRendererResources;
  std::shared_ptr<spdlog::logger> _pLogger;
  CesiumGeospatial::Projection _projection;
  CesiumGeometry::Rectangle _coverageRectangle;
  CesiumUtility::IntrusivePointer<RasterOverlayTile> _pPlaceholder;
  int64_t _tileDataBytes;
  int32_t _totalTilesCurrentlyLoading;
  int32_t _throttledTilesCurrentlyLoading;
  CESIUM_TRACE_DECLARE_TRACK_SET(
      _loadingSlots,
      "Raster Overlay Tile Loading Slot")
};
} // namespace CesiumRasterOverlays