ActivatedRasterOverlay.h

#pragma once
 
#include <CesiumAsync/Future.h>
#include <CesiumAsync/Promise.h>
#include <CesiumAsync/SharedFuture.h>
#include <CesiumGeometry/Rectangle.h>
#include <CesiumGeospatial/Ellipsoid.h>
#include <CesiumRasterOverlays/Library.h>
#include <CesiumUtility/IntrusivePointer.h>
#include <CesiumUtility/ReferenceCounted.h>
 
#include <glm/vec2.hpp>
 
namespace CesiumRasterOverlays {
 
class RasterOverlay;
class RasterOverlayExternals;
class RasterOverlayTile;
class RasterOverlayTileProvider;
class ActivatedRasterOverlay;
struct RasterOverlayTileLoadResult;
 
} // namespace CesiumRasterOverlays
 
namespace CesiumRasterOverlays {

struct RasterOverlayTileLoadResult {
  CesiumUtility::IntrusivePointer<ActivatedRasterOverlay> pActivated;
  CesiumUtility::IntrusivePointer<RasterOverlayTile> pTile;

  RasterOverlayTileLoadResult(
      const CesiumUtility::IntrusivePointer<ActivatedRasterOverlay>&
          pActivated_,
      const CesiumUtility::IntrusivePointer<RasterOverlayTile>&
          pTile_) noexcept;
 
  ~RasterOverlayTileLoadResult() noexcept;

  RasterOverlayTileLoadResult(const RasterOverlayTileLoadResult&) noexcept;

  RasterOverlayTileLoadResult&
  operator=(const RasterOverlayTileLoadResult&) noexcept;

  RasterOverlayTileLoadResult(RasterOverlayTileLoadResult&&) noexcept;

  RasterOverlayTileLoadResult&
  operator=(RasterOverlayTileLoadResult&&) noexcept;
};

class CESIUMRASTEROVERLAYS_API ActivatedRasterOverlay
    : public CesiumUtility::ReferenceCountedNonThreadSafe<
          ActivatedRasterOverlay> {
public:
  ActivatedRasterOverlay(
      const RasterOverlayExternals& externals,
      const CesiumUtility::IntrusivePointer<const RasterOverlay>& pOverlay,
      const CesiumGeospatial::Ellipsoid& ellipsoid
          CESIUM_DEFAULT_ELLIPSOID) noexcept;

  ~ActivatedRasterOverlay() noexcept;

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

  const CesiumRasterOverlays::RasterOverlay& getOverlay() const noexcept;

  const CesiumRasterOverlays::RasterOverlayTileProvider*
  getTileProvider() const noexcept;

  CesiumRasterOverlays::RasterOverlayTileProvider* getTileProvider() noexcept;

  void setTileProvider(
      const CesiumUtility::IntrusivePointer<RasterOverlayTileProvider>&
          pTileProvider);

  const CesiumRasterOverlays::RasterOverlayTileProvider*
  getPlaceholderTileProvider() const noexcept;

  CesiumRasterOverlays::RasterOverlayTileProvider*
  getPlaceholderTileProvider() noexcept;

  const CesiumRasterOverlays::RasterOverlayTile*
  getPlaceholderTile() const noexcept;

  CesiumRasterOverlays::RasterOverlayTile* getPlaceholderTile() noexcept;

  CesiumUtility::IntrusivePointer<CesiumRasterOverlays::RasterOverlayTile>
  getTile(
      const CesiumGeometry::Rectangle& rectangle,
      const glm::dvec2& targetScreenPixels);

  int64_t getTileDataBytes() const noexcept;

  uint32_t getNumberOfTilesLoading() const noexcept;

  void removeTile(RasterOverlayTile* pTile) noexcept;

  CesiumAsync::Future<RasterOverlayTileLoadResult>
  loadTile(RasterOverlayTile& tile);

  bool loadTileThrottled(RasterOverlayTile& tile);

  void tick();
 
private:
  CesiumAsync::Future<RasterOverlayTileLoadResult>
  doLoad(RasterOverlayTile& tile, bool isThrottledLoad);

  void beginTileLoad(bool isThrottledLoad) noexcept;

  void finalizeTileLoad(bool isThrottledLoad) noexcept;
 
  CesiumUtility::IntrusivePointer<const CesiumRasterOverlays::RasterOverlay>
      _pOverlay;
  CesiumUtility::IntrusivePointer<
      CesiumRasterOverlays::RasterOverlayTileProvider>
      _pPlaceholderTileProvider;
  CesiumUtility::IntrusivePointer<CesiumRasterOverlays::RasterOverlayTile>
      _pPlaceholderTile;
  CesiumUtility::IntrusivePointer<
      CesiumRasterOverlays::RasterOverlayTileProvider>
      _pTileProvider;
 
  int64_t _tileDataBytes;
  int32_t _totalTilesCurrentlyLoading;
  int32_t _throttledTilesCurrentlyLoading;
 
  CesiumAsync::Promise<void> _readyPromise;
  CesiumAsync::SharedFuture<void> _readyEvent;
};
 
} // namespace CesiumRasterOverlays