TileContent.h

#pragma once
 
#include <Cesium3DTilesSelection/Library.h>
#include <Cesium3DTilesSelection/TilesetMetadata.h>
#include <CesiumGeospatial/Projection.h>
#include <CesiumGltf/Model.h>
#include <CesiumRasterOverlays/RasterOverlayDetails.h>
#include <CesiumUtility/CreditSystem.h>
 
#include <memory>
#include <variant>
#include <vector>
 
namespace Cesium3DTilesSelection {
struct CESIUM3DTILESSELECTION_API TileUnknownContent {};

struct CESIUM3DTILESSELECTION_API TileEmptyContent {};

struct CESIUM3DTILESSELECTION_API TileExternalContent {
  TilesetMetadata metadata;
};

class CESIUM3DTILESSELECTION_API TileRenderContent {
public:
  TileRenderContent(CesiumGltf::Model&& model);

  const CesiumGltf::Model& getModel() const noexcept;

  CesiumGltf::Model& getModel() noexcept;

  void setModel(const CesiumGltf::Model& model);

  void setModel(CesiumGltf::Model&& model);

  const CesiumRasterOverlays::RasterOverlayDetails&
  getRasterOverlayDetails() const noexcept;

  CesiumRasterOverlays::RasterOverlayDetails&
  getRasterOverlayDetails() noexcept;

  void setRasterOverlayDetails(
      const CesiumRasterOverlays::RasterOverlayDetails& rasterOverlayDetails);

  void setRasterOverlayDetails(
      CesiumRasterOverlays::RasterOverlayDetails&& rasterOverlayDetails);

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

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

  void setCredits(std::vector<CesiumUtility::Credit>&& credits);

  void setCredits(const std::vector<CesiumUtility::Credit>& credits);

  void* getRenderResources() const noexcept;

  void setRenderResources(void* pRenderResources) noexcept;

  float getLodTransitionFadePercentage() const noexcept;

  void setLodTransitionFadePercentage(float percentage) noexcept;
 
private:
  CesiumGltf::Model _model;
  void* _pRenderResources;
  CesiumRasterOverlays::RasterOverlayDetails _rasterOverlayDetails;
  std::vector<CesiumUtility::Credit> _credits;
  float _lodTransitionFadePercentage;
};

class CESIUM3DTILESSELECTION_API TileContent {
  using TileContentKindImpl = std::variant<
      TileUnknownContent,
      TileEmptyContent,
      std::unique_ptr<TileExternalContent>,
      std::unique_ptr<TileRenderContent>>;
 
public:
  TileContent();

  TileContent(TileEmptyContent content);

  TileContent(std::unique_ptr<TileExternalContent>&& content);

  void setContentKind(TileUnknownContent content);

  void setContentKind(TileEmptyContent content);

  void setContentKind(std::unique_ptr<TileExternalContent>&& content);

  void setContentKind(std::unique_ptr<TileRenderContent>&& content);

  bool isUnknownContent() const noexcept;

  bool isEmptyContent() const noexcept;

  bool isExternalContent() const noexcept;

  bool isRenderContent() const noexcept;

  const TileRenderContent* getRenderContent() const noexcept;

  TileRenderContent* getRenderContent() noexcept;

  const TileExternalContent* getExternalContent() const noexcept;

  TileExternalContent* getExternalContent() noexcept;
 
private:
  TileContentKindImpl _contentKind;
};
} // namespace Cesium3DTilesSelection