RasterOverlayTileProvider.h

#pragma once
 
#include <CesiumAsync/IAssetAccessor.h>
#include <CesiumGeospatial/Projection.h>
#include <CesiumGltfReader/GltfReader.h>
#include <CesiumRasterOverlays/Library.h>
#include <CesiumRasterOverlays/RasterOverlayExternals.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 CesiumImage {
struct ImageAsset;
}
 
namespace CesiumUtility {
class CreditReferencer;
}
 
namespace CesiumRasterOverlays {
 
class RasterOverlay;
class RasterOverlayTile;
class IPrepareRasterOverlayRendererResources;
struct CreateRasterOverlayTileProviderParameters;

struct CESIUMRASTEROVERLAYS_API LoadedRasterOverlayImage {
  CesiumUtility::IntrusivePointer<CesiumImage::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;

class CESIUMRASTEROVERLAYS_API RasterOverlayTileProvider
    : public CesiumUtility::ReferenceCountedNonThreadSafe<
          RasterOverlayTileProvider> {
public:
  RasterOverlayTileProvider(
      const CesiumUtility::IntrusivePointer<const RasterOverlay>& pCreator,
      const CreateRasterOverlayTileProviderParameters& parameters,
      const CesiumGeospatial::Projection& projection,
      const CesiumGeometry::Rectangle& coverageRectangle) noexcept;

  virtual ~RasterOverlayTileProvider() noexcept;

  CesiumAsync::SharedFuture<void>& getAsyncDestructionCompleteEvent();

  RasterOverlay& getOwner() noexcept;

  const RasterOverlay& getOwner() const noexcept;

  const RasterOverlayExternals& getExternals() const noexcept;

  const std::shared_ptr<CesiumAsync::IAssetAccessor>&
  getAssetAccessor() const noexcept;

  const std::shared_ptr<CesiumUtility::CreditSystem>&
  getCreditSystem() const noexcept;

  const CesiumAsync::AsyncSystem& getAsyncSystem() const noexcept;

  const std::shared_ptr<IPrepareRasterOverlayRendererResources>&
  getPrepareRendererResources() const noexcept;

  const std::shared_ptr<spdlog::logger>& getLogger() const noexcept;

  const CesiumGeospatial::Projection& getProjection() const noexcept;

  const CesiumGeometry::Rectangle& getCoverageRectangle() const noexcept;

  const CesiumUtility::CreditSource& getCreditSource() const noexcept;

  std::vector<CesiumUtility::Credit>& getCredits() noexcept;

  const std::vector<CesiumUtility::Credit>& getCredits() const noexcept;

  virtual CesiumAsync::Future<LoadedRasterOverlayImage>
  loadTileImage(const RasterOverlayTile& overlayTile) = 0;

  virtual void
  addCredits(CesiumUtility::CreditReferencer& creditReferencer) noexcept;

  virtual void tick() {}
 
protected:
  CesiumAsync::Future<LoadedRasterOverlayImage> loadTileImageFromUrl(
      const std::string& url,
      const std::vector<CesiumAsync::IAssetAccessor::THeader>& headers = {},
      LoadTileImageFromUrlOptions&& options = {}) const;
 
private:
  struct DestructionCompleteDetails {
    CesiumAsync::Promise<void> promise;
    CesiumAsync::SharedFuture<void> future;
  };
 
  CesiumUtility::IntrusivePointer<RasterOverlay> _pOwner;
  RasterOverlayExternals _externals;
  std::vector<CesiumUtility::Credit> _credits;
  CesiumGeospatial::Projection _projection;
  CesiumGeometry::Rectangle _coverageRectangle;
  std::optional<DestructionCompleteDetails> _destructionCompleteDetails;
  std::shared_ptr<CesiumUtility::CreditSource> _pCreditSource;
};
} // namespace CesiumRasterOverlays