Reapply modification to all loaded tiles.

Author: kring

Cesium3DTilesSelection/include/Cesium3DTilesSelection/GltfModifier.h

@@ -124,6 +124,35 @@ class GltfModifier {
       const TilesetMetadata& tilesetMetadata,
       const Tile& rootTile);
 
+  /**
+   * @brief Called by {@link Tileset} when the given tile leaves the
+   * {@link TileLoadState::ContentLoading} state but it was loaded with an
+   * older {@link GltfModifier} version. The tile will be queued for a call
+   * to {@link GltfModifier::apply} in a worker thread.
+   *
+   * This method is called from the main thread.
+   *
+   * @private
+   *
+   * @param tile The tile that has just left the
+   * {@link TileLoadState::ContentLoading} state.
+   */
+  void onOldVersionContentLoadingComplete(const Tile& tile);
+
+  /**
+   * @brief Called by {@link Tileset} when the {@link GltfModifier::apply}
+   * method has finished running on a previously-loaded tile. The tile will be
+   * queued to finish its loading in the main thread.
+   *
+   * This method is called from the main thread.
+   *
+   * @private
+   *
+   * @param tile The tile that has just been processed by the
+   * {@link GltfModifier::apply} method.
+   */
+  void onWorkerThreadApplyComplete(const Tile& tile);
+
 protected:
   GltfModifier();
   virtual ~GltfModifier();

Cesium3DTilesSelection/src/GltfModifier.cpp

@@ -17,14 +17,10 @@ class GltfModifier::NewVersionLoadRequester : public TileLoadRequester {
 
   void notifyOfTrigger();
 
-private:
-  void addTilesToQueues();
-
-  GltfModifier* _pModifier;
-  const Tile* _pRootTile;
-  std::vector<Tile::ConstPointer> _workerThreadQueue;
-  std::vector<Tile::ConstPointer> _mainThreadQueue;
-  bool _running;
+  GltfModifier* pModifier;
+  const Tile* pRootTile;
+  std::vector<Tile::ConstPointer> workerThreadQueue;
+  std::vector<Tile::ConstPointer> mainThreadQueue;
 };
 
 GltfModifier::GltfModifier()
@@ -48,6 +44,7 @@ CesiumAsync::Future<void> GltfModifier::onRegister(
     TilesetContentManager& contentManager,
     const TilesetMetadata& tilesetMetadata,
     const Tile& rootTile) {
+  this->_pNewVersionLoadRequester->pRootTile = &rootTile;
   contentManager.registerTileRequester(*this->_pNewVersionLoadRequester);
 
   const TilesetExternals& externals = contentManager.getExternals();
@@ -68,111 +65,68 @@ CesiumAsync::Future<void> GltfModifier::onRegister(
   return asyncSystem.createResolvedFuture();
 }
 
-GltfModifier::NewVersionLoadRequester::NewVersionLoadRequester(
-    GltfModifier* pModifier)
-    : _pModifier(pModifier),
-      _pRootTile(nullptr),
-      _workerThreadQueue(),
-      _mainThreadQueue(),
-      _running(false) {}
+void GltfModifier::onOldVersionContentLoadingComplete(const Tile& tile) {
+  CESIUM_ASSERT(
+      tile.getState() == TileLoadState::ContentLoaded ||
+      tile.getState() == TileLoadState::Failed ||
+      tile.getState() == TileLoadState::FailedTemporarily);
+  if (tile.getState() == TileLoadState::ContentLoaded) {
+    // Tile just transitioned from ContentLoading -> ContentLoaded, but it did
+    // so based on the load version. Add it to the worker thread queue in order
+    // to re-run the GltfModifier on it.
+    this->_pNewVersionLoadRequester->workerThreadQueue.emplace_back(&tile);
+  }
+}
 
-void GltfModifier::NewVersionLoadRequester::notifyOfTrigger() {
-  this->_running = true;
-  this->addTilesToQueues();
+void GltfModifier::onWorkerThreadApplyComplete(const Tile& tile) {
+  // GltfModifier::apply just finished, so now we need to do the main-thread
+  // processing of the new version.
+  this->_pNewVersionLoadRequester->mainThreadQueue.emplace_back(&tile);
 }
 
-void GltfModifier::NewVersionLoadRequester::addTilesToQueues() {
-  CESIUM_ASSERT(this->_pRootTile != nullptr);
-  LoadedConstTileEnumerator enumerator(this->_pRootTile);
+GltfModifier::NewVersionLoadRequester::NewVersionLoadRequester(
+    GltfModifier* pModifier_)
+    : pModifier(pModifier_),
+      pRootTile(nullptr),
+      workerThreadQueue(),
+      mainThreadQueue() {}
+
+void GltfModifier::NewVersionLoadRequester::notifyOfTrigger() {
+  // Add all already-loaded tiles to this requester worker thread load queue.
+  // Tiles that are in ContentLoading will be added to this queue when they
+  // finish.
+  LoadedConstTileEnumerator enumerator(this->pRootTile);
   for (const Tile& tile : enumerator) {
     TileLoadState state = tile.getState();
-
-    // Tiles that are already being loaded will need to finish loading, _then_
-    // we'll have to apply the modification. Always add them to the queue.
-    if (state == TileLoadState::ContentLoading) {
-      this->_workerThreadQueue.emplace_back(&tile);
-    }
-
-    // Tiles that are already loaded only need to be added to the queue if they
-    // have a glTF and it is the wrong version.
-    if (state != TileLoadState::ContentLoaded && state != TileLoadState::Done)
-      continue;
-
-    const TileRenderContent* pRenderContent =
-        tile.getContent().getRenderContent();
-    if (!pRenderContent)
-      continue;
-
-    if (pRenderContent->getModel().version ==
-        this->_pModifier->getCurrentVersion()) {
-      CESIUM_ASSERT(!pRenderContent->getModifiedModel());
-      continue;
-    }
-
-    if (pRenderContent->getModifiedModel() &&
-        pRenderContent->getModifiedModel()->version ==
-            this->_pModifier->getCurrentVersion()) {
-      // Worker thread GltfModifier::apply done, need to do main thread loading.
-      this->_mainThreadQueue.emplace_back(&tile);
-    } else {
-      this->_workerThreadQueue.emplace_back(&tile);
+    if (state == TileLoadState::ContentLoaded || state == TileLoadState::Done) {
+      this->workerThreadQueue.emplace_back(&tile);
     }
   }
 }
 
 bool GltfModifier::NewVersionLoadRequester::hasMoreTilesToLoadInWorkerThread()
     const {
-  return !this->_workerThreadQueue.empty();
+  return !this->workerThreadQueue.empty();
 }
 
 const Tile*
 GltfModifier::NewVersionLoadRequester::getNextTileToLoadInWorkerThread() {
-  if (!this->_running) {
-    CESIUM_ASSERT(this->_workerThreadQueue.empty());
-    return nullptr;
-  }
-
-  CESIUM_ASSERT(!this->_workerThreadQueue.empty());
-  const Tile* pResult = this->_workerThreadQueue.back().get();
-  this->_workerThreadQueue.pop_back();
-
-  if (this->_workerThreadQueue.empty()) {
-    this->addTilesToQueues();
-
-    // If both queues are still empty, we're done.
-    if (this->_workerThreadQueue.empty() && this->_mainThreadQueue.empty()) {
-      this->_running = false;
-    }
-  }
-
+  CESIUM_ASSERT(!this->workerThreadQueue.empty());
+  const Tile* pResult = this->workerThreadQueue.back().get();
+  this->workerThreadQueue.pop_back();
   return pResult;
 }
 
 bool GltfModifier::NewVersionLoadRequester::hasMoreTilesToLoadInMainThread()
     const {
-  return !this->_mainThreadQueue.empty();
+  return !this->mainThreadQueue.empty();
 }
 
 const Tile*
 GltfModifier::NewVersionLoadRequester::getNextTileToLoadInMainThread() {
-  if (!this->_running) {
-    CESIUM_ASSERT(this->_mainThreadQueue.empty());
-    return nullptr;
-  }
-
-  CESIUM_ASSERT(!this->_mainThreadQueue.empty());
-  const Tile* pResult = this->_mainThreadQueue.back().get();
-  this->_mainThreadQueue.pop_back();
-
-  if (this->_mainThreadQueue.empty()) {
-    this->addTilesToQueues();
-
-    // If both queues are still empty, we're done.
-    if (this->_workerThreadQueue.empty() && this->_mainThreadQueue.empty()) {
-      this->_running = false;
-    }
-  }
-
+  CESIUM_ASSERT(!this->mainThreadQueue.empty());
+  const Tile* pResult = this->mainThreadQueue.back().get();
+  this->mainThreadQueue.pop_back();
   return pResult;
 }
 

Cesium3DTilesSelection/src/Tile.cpp

@@ -214,20 +214,20 @@ int64_t Tile::computeByteSize() const noexcept {
   return bytes;
 }
 
-bool Tile::isRenderable(std::optional<int> modelVersion) const noexcept {
+bool Tile::isRenderable(std::optional<int> /* modelVersion */) const noexcept {
   if (getState() == TileLoadState::Failed) {
     // Explicitly treat failed tiles as "renderable" - we just treat them like
     // empty tiles.
     return true;
   }
 
   if (getState() == TileLoadState::Done) {
-    auto* renderContent = getContent().getRenderContent();
-    if (renderContent && modelVersion &&
-        // compares optional values if both have one:
-        modelVersion != renderContent->getModel().version) {
-      return false;
-    }
+    // auto* renderContent = getContent().getRenderContent();
+    // if (renderContent && modelVersion &&
+    //     // compares optional values if both have one:
+    //     modelVersion != renderContent->getModel().version) {
+    //   return false;
+    // }
     // An unconditionally-refined tile is never renderable... UNLESS it has no
     // children, in which case waiting longer will be futile.
     if (!getUnconditionallyRefine() || this->_children.empty()) {

Cesium3DTilesSelection/src/TilesetContentManager.cpp

@@ -1103,18 +1103,16 @@ TilesetContentManager::~TilesetContentManager() noexcept {
   this->_destructionCompletePromise.resolve();
 }
 
-namespace {
-
-void reapplyGltfModifier(
-    TilesetContentManager& contentManager,
+void TilesetContentManager::reapplyGltfModifier(
     Tile& tile,
     const TilesetOptions& tilesetOptions,
-    TileRenderContent* pRenderContent) {
+    TileRenderContent* pRenderContent) noexcept {
+  this->notifyTileStartLoading(&tile);
   pRenderContent->setGltfModifierState(GltfModifier::State::WorkerRunning);
 
   const CesiumGltf::Model& previousModel = pRenderContent->getModel();
 
-  const TilesetExternals& externals = contentManager.getExternals();
+  const TilesetExternals& externals = this->getExternals();
 
   // It is safe to capture the TilesetExternals and Model by reference because
   // the TilesetContentManager guarantees both will continue to exist and are
@@ -1178,29 +1176,30 @@ void reapplyGltfModifier(
             tileTransform,
             rendererOptions);
       })
-      .thenInMainThread([pTile = Tile::Pointer(&tile)](
+      .thenInMainThread([this, pTile = Tile::Pointer(&tile)](
                             TileLoadResultAndRenderResources&& pair) {
         pTile->getContent().getRenderContent()->setGltfModifierState(
             GltfModifier::State::WorkerDone);
+        this->notifyTileDoneLoading(pTile.get());
         pTile->getContent()
             .getRenderContent()
             ->setModifiedModelAndRenderResources(
                 std::move(std::get<CesiumGltf::Model>(pair.result.contentKind)),
                 pair.pRenderResources);
+        this->_externals.pGltfModifier->onWorkerThreadApplyComplete(*pTile);
       })
       .catchInMainThread(
-          [pTile = Tile::Pointer(&tile), &externals](std::exception&& e) {
+          [this, pTile = Tile::Pointer(&tile), &externals](std::exception&& e) {
             pTile->getContent().getRenderContent()->setGltfModifierState(
                 GltfModifier::State::WorkerDone);
+            this->notifyTileDoneLoading(pTile.get());
             SPDLOG_LOGGER_ERROR(
                 externals.pLogger,
                 "An unexpected error occurred when reapplying GltfModifier: {}",
                 e.what());
           });
 }
 
-} // namespace
-
 void TilesetContentManager::loadTileContent(
     Tile& tile,
     const TilesetOptions& tilesetOptions) {
@@ -1217,7 +1216,7 @@ void TilesetContentManager::loadTileContent(
         pRenderContent->getGltfModifierState() == GltfModifier::State::Idle &&
         pRenderContent->getModel().version !=
             _externals.pGltfModifier->getCurrentVersion()) {
-      reapplyGltfModifier(*this, tile, tilesetOptions, pRenderContent);
+      this->reapplyGltfModifier(tile, tilesetOptions, pRenderContent);
       return;
     }
     // else: we may be in the case related to raster tiles, see just below
@@ -1357,6 +1356,18 @@ void TilesetContentManager::loadTileContent(
       .thenInMainThread([pTile, thiz](TileLoadResultAndRenderResources&& pair) {
         setTileContent(*pTile, std::move(pair.result), pair.pRenderResources);
         thiz->notifyTileDoneLoading(pTile.get());
+
+        if (thiz->_externals.pGltfModifier) {
+          const TileRenderContent* pRenderContent =
+              pTile->getContent().getRenderContent();
+          CESIUM_ASSERT(!pRenderContent || !pRenderContent->getModifiedModel());
+          if (pRenderContent &&
+              pRenderContent->getModel().version !=
+                  thiz->_externals.pGltfModifier->getCurrentVersion()) {
+            thiz->_externals.pGltfModifier->onOldVersionContentLoadingComplete(
+                *pTile);
+          }
+        }
       })
       .catchInMainThread([pLogger = this->_externals.pLogger, pTile, thiz](
                              std::exception&& e) {

Cesium3DTilesSelection/src/TilesetContentManager.h

@@ -204,6 +204,11 @@ class TilesetContentManager
 
   void notifyTileUnloading(const Tile* pTile) noexcept;
 
+  void reapplyGltfModifier(
+      Tile& tile,
+      const TilesetOptions& tilesetOptions,
+      TileRenderContent* pRenderContent) noexcept;
+
   template <class TilesetContentLoaderType>
   void propagateTilesetContentLoaderResult(
       TilesetLoadType type,