GltfModifier.h

#pragma once
 
#include <Cesium3DTilesSelection/GltfModifierState.h>
#include <Cesium3DTilesSelection/Tile.h>
#include <Cesium3DTilesSelection/TileLoadRequester.h>
#include <CesiumAsync/AsyncSystem.h>
#include <CesiumAsync/Future.h>
#include <CesiumGltf/Model.h>
 
#include <spdlog/fwd.h>
 
#include <memory>
#include <optional>
 
namespace CesiumAsync {
 
class IAssetAccessor;
 
} // namespace CesiumAsync
 
namespace Cesium3DTilesSelection {
 
class TilesetMetadata;
class TilesetContentManager;

struct GltfModifierInput {
  int64_t version;

  CesiumAsync::AsyncSystem asyncSystem;

  std::shared_ptr<CesiumAsync::IAssetAccessor> pAssetAccessor;

  std::shared_ptr<spdlog::logger> pLogger;

  const CesiumGltf::Model& previousModel;

  glm::dmat4 tileTransform;
};

struct GltfModifierOutput {
  CesiumGltf::Model modifiedModel;
};

class GltfModifier : private TileLoadRequester {
public:
  std::optional<int64_t> getCurrentVersion() const;

  bool isActive() const;

  void trigger();

  virtual CesiumAsync::Future<std::optional<GltfModifierOutput>>
  apply(GltfModifierInput&& input) = 0;

  bool needsWorkerThreadModification(const Tile& tile) const;

  bool needsMainThreadModification(const Tile& tile) const;
 
protected:
  GltfModifier();
  virtual ~GltfModifier();

  virtual CesiumAsync::Future<void> onRegister(
      const CesiumAsync::AsyncSystem& asyncSystem,
      const std::shared_ptr<CesiumAsync::IAssetAccessor>& pAssetAccessor,
      const std::shared_ptr<spdlog::logger>& pLogger,
      const TilesetMetadata& tilesetMetadata,
      const Tile& rootTile);
 
private:
  CesiumAsync::Future<void> onRegister(
      TilesetContentManager& contentManager,
      const TilesetMetadata& tilesetMetadata,
      const Tile& rootTile);

  void onUnregister(TilesetContentManager& contentManager);

  void onOldVersionContentLoadingComplete(const Tile& tile);

  void onWorkerThreadApplyComplete(const Tile& tile);
 
  // TileLoadRequester implementation
  double getWeight() const override;
  bool hasMoreTilesToLoadInWorkerThread() const override;
  const Tile* getNextTileToLoadInWorkerThread() override;
  bool hasMoreTilesToLoadInMainThread() const override;
  const Tile* getNextTileToLoadInMainThread() override;
 
  std::optional<int64_t> _currentVersion;
 
  const Tile* _pRootTile;
 
  // Ideally these would be weak pointers, but we don't currently have a good
  // way to do that.
  std::vector<Tile::ConstPointer> _workerThreadQueue;
  std::vector<Tile::ConstPointer> _mainThreadQueue;
 
  friend class TilesetContentManager;
  friend class MockTilesetContentManagerForGltfModifier;
};
 
} // namespace Cesium3DTilesSelection