RasterOverlay.h

#pragma once
 
#include <CesiumAsync/AsyncSystem.h>
#include <CesiumAsync/IAssetAccessor.h>
#include <CesiumGeospatial/Ellipsoid.h>
#include <CesiumGltf/Ktx2TranscodeTargets.h>
#include <CesiumRasterOverlays/Library.h>
#include <CesiumRasterOverlays/RasterOverlayLoadFailureDetails.h>
#include <CesiumUtility/IntrusivePointer.h>
#include <CesiumUtility/ReferenceCounted.h>
 
#include <nonstd/expected.hpp>
#include <spdlog/fwd.h>
 
#include <any>
#include <cstddef>
#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 = static_cast<int64_t>(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;

  CesiumGeospatial::Ellipsoid ellipsoid = CesiumGeospatial::Ellipsoid::WGS84;
};

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