RasterOverlay.h

#pragma once
 
#include "Library.h"
#include "RasterOverlayLoadFailureDetails.h"
 
#include <CesiumAsync/AsyncSystem.h>
#include <CesiumAsync/IAssetAccessor.h>
#include <CesiumGeospatial/Ellipsoid.h>
#include <CesiumGltf/Ktx2TranscodeTargets.h>
#include <CesiumUtility/IntrusivePointer.h>
#include <CesiumUtility/ReferenceCounted.h>
 
#include <nonstd/expected.hpp>
#include <spdlog/fwd.h>
 
#include <any>
#include <functional>
#include <memory>
#include <optional>
#include <string>
 
namespace CesiumUtility {
struct Credit;
class CreditSystem;
} // namespace CesiumUtility
 
namespace CesiumRasterOverlays {
 
class IPrepareRasterOverlayRendererResources;
class RasterOverlayTileProvider;
 
struct CESIUMRASTEROVERLAYS_API RasterOverlayOptions {
  int32_t maximumSimultaneousTileLoads = 20;
 
  int64_t subTileCacheBytes = 16 * 1024 * 1024;
 
  int32_t maximumTextureSize = 2048;
 
  double maximumScreenSpaceError = 2.0;
 
  CesiumGltf::Ktx2TranscodeTargets ktx2TranscodeTargets;
 
  std::function<void(const RasterOverlayLoadFailureDetails&)> loadErrorCallback;
 
  bool showCreditsOnScreen = false;
 
  std::any rendererOptions;
 
  std::optional<CesiumGeospatial::Ellipsoid> ellipsoid = std::nullopt;
};
 
class RasterOverlay
    : public CesiumUtility::ReferenceCountedNonThreadSafe<RasterOverlay> {
public:
  RasterOverlay(
      const std::string& name,
      const RasterOverlayOptions& overlayOptions = RasterOverlayOptions());
  virtual ~RasterOverlay() noexcept;
 
  CesiumAsync::SharedFuture<void>&
  getAsyncDestructionCompleteEvent(const CesiumAsync::AsyncSystem& asyncSystem);
 
  const std::string& getName() const noexcept { return this->_name; }
 
  RasterOverlayOptions& getOptions() noexcept { return this->_options; }
 
  const RasterOverlayOptions& getOptions() const noexcept {
    return this->_options;
  }
 
  const std::vector<CesiumUtility::Credit>& getCredits() const noexcept {
    return this->_credits;
  }
 
  std::vector<CesiumUtility::Credit>& getCredits() noexcept {
    return this->_credits;
  }
 
  CesiumUtility::IntrusivePointer<RasterOverlayTileProvider> createPlaceholder(
      const CesiumAsync::AsyncSystem& asyncSystem,
      const std::shared_ptr<CesiumAsync::IAssetAccessor>& pAssetAccessor,
      const CesiumGeospatial::Ellipsoid& ellipsoid
          CESIUM_DEFAULT_ELLIPSOID) const;
 
  using CreateTileProviderResult = nonstd::expected<
      CesiumUtility::IntrusivePointer<RasterOverlayTileProvider>,
      RasterOverlayLoadFailureDetails>;
 
  virtual CesiumAsync::Future<CreateTileProviderResult> createTileProvider(
      const CesiumAsync::AsyncSystem& asyncSystem,
      const std::shared_ptr<CesiumAsync::IAssetAccessor>& pAssetAccessor,
      const std::shared_ptr<CesiumUtility::CreditSystem>& pCreditSystem,
      const std::shared_ptr<IPrepareRasterOverlayRendererResources>&
          pPrepareRendererResources,
      const std::shared_ptr<spdlog::logger>& pLogger,
      CesiumUtility::IntrusivePointer<const RasterOverlay> pOwner) const = 0;
 
private:
  struct DestructionCompleteDetails {
    CesiumAsync::AsyncSystem asyncSystem;
    CesiumAsync::Promise<void> promise;
    CesiumAsync::SharedFuture<void> future;
  };
 
  std::string _name;
  RasterOverlayOptions _options;
  std::vector<CesiumUtility::Credit> _credits;
  std::optional<DestructionCompleteDetails> _destructionCompleteDetails;
};
 
} // namespace CesiumRasterOverlays