Cache images across glTFs to avoid duplication

Cesium3DTilesSelection/include/Cesium3DTilesSelection/Tileset.h

@@ -177,6 +177,14 @@ class CESIUM3DTILESSELECTION_API Tileset final {
   /** @copydoc Tileset::getOverlays() */
   const RasterOverlayCollection& getOverlays() const noexcept;
 
+  /**
+   * @brief Returns the {@link SharedAssetDepot} of this tileset.
+   */
+  CesiumGltf::SharedAssetDepot& getSharedAssetDepot() noexcept;
+
+  /** @copydoc Tileset::getSharedAssetDepot() */
+  const CesiumGltf::SharedAssetDepot& getSharedAssetDepot() const noexcept;
+
   /**
    * @brief Updates this view but waits for all tiles that meet sse to finish
    * loading and ready to be rendered before returning the function. This method

Cesium3DTilesSelection/src/Tile.cpp

@@ -175,7 +175,7 @@ int64_t Tile::computeByteSize() const noexcept {
 
       // sizeBytes is set in TilesetContentManager::ContentKindSetter, if not
       // sooner (e.g., by the renderer implementation).
-      bytes += image.cesium.sizeBytes;
+      bytes += image.cesium->sizeBytes;
     }
   }
 

Cesium3DTilesSelection/src/TileContentLoadInfo.cpp

@@ -9,6 +9,8 @@ TileContentLoadInfo::TileContentLoadInfo(
     const std::shared_ptr<IPrepareRendererResources>&
         pPrepareRendererResources_,
     const std::shared_ptr<spdlog::logger>& pLogger_,
+    const std::optional<std::shared_ptr<CesiumGltf::SharedAssetDepot>>
+        maybeAssetDepot_,
     const TilesetContentOptions& contentOptions_,
     const Tile& tile)
     : asyncSystem(asyncSystem_),
@@ -18,6 +20,7 @@ TileContentLoadInfo::TileContentLoadInfo(
       tileID(tile.getTileID()),
       tileBoundingVolume(tile.getBoundingVolume()),
       tileContentBoundingVolume(tile.getContentBoundingVolume()),
+      maybeAssetDepot{maybeAssetDepot_},
       tileRefine(tile.getRefine()),
       tileGeometricError(tile.getGeometricError()),
       tileTransform(tile.getTransform()),

Cesium3DTilesSelection/src/TileContentLoadInfo.h

@@ -24,6 +24,8 @@ struct TileContentLoadInfo {
       const std::shared_ptr<IPrepareRendererResources>&
           pPrepareRendererResources,
       const std::shared_ptr<spdlog::logger>& pLogger,
+      const std::optional<std::shared_ptr<CesiumGltf::SharedAssetDepot>>
+          maybeAssetDepot,
       const TilesetContentOptions& contentOptions,
       const Tile& tile);
 
@@ -40,6 +42,7 @@ struct TileContentLoadInfo {
   BoundingVolume tileBoundingVolume;
 
   std::optional<BoundingVolume> tileContentBoundingVolume;
+  std::optional<std::shared_ptr<CesiumGltf::SharedAssetDepot>> maybeAssetDepot;
 
   TileRefine tileRefine;
 

Cesium3DTilesSelection/src/Tileset.cpp

@@ -134,6 +134,15 @@ const RasterOverlayCollection& Tileset::getOverlays() const noexcept {
   return this->_pTilesetContentManager->getRasterOverlayCollection();
 }
 
+CesiumGltf::SharedAssetDepot& Tileset::getSharedAssetDepot() noexcept {
+  return *this->_pTilesetContentManager->getSharedAssetDepot();
+}
+
+const CesiumGltf::SharedAssetDepot&
+Tileset::getSharedAssetDepot() const noexcept {
+  return *this->_pTilesetContentManager->getSharedAssetDepot();
+}
+
 static bool
 operator<(const FogDensityAtHeight& fogDensity, double height) noexcept {
   return fogDensity.cameraHeight < height;

Cesium3DTilesSelection/src/TilesetContentManager.cpp

@@ -53,8 +53,13 @@ struct ContentKindSetter {
       // size now. We'll be adding this number to our total memory usage soon,
       // and remove it when the tile is later unloaded, and we must use
       // the same size in each case.
-      if (image.cesium.sizeBytes < 0) {
-        image.cesium.sizeBytes = int64_t(image.cesium.pixelData.size());
+
+      // TODO: this number will be wrong once we deduplicate images! it'll log
+      // the image's size for each time it's used, instead of only once as it
+      // should. if you are reading this comment in a code review, i forgot to
+      // fix this and you should remind me.
+      if (image.cesium->sizeBytes < 0) {
+        image.cesium->sizeBytes = int64_t(image.cesium->pixelData.size());
       }
     }
 
@@ -562,6 +567,9 @@ postProcessContentInWorkerThread(
       tileLoadInfo.contentOptions.ktx2TranscodeTargets;
   gltfOptions.applyTextureTransform =
       tileLoadInfo.contentOptions.applyTextureTransform;
+  if (tileLoadInfo.maybeAssetDepot.has_value()) {
+    gltfOptions.sharedAssets = *tileLoadInfo.maybeAssetDepot;
+  }
 
   auto asyncSystem = tileLoadInfo.asyncSystem;
   auto pAssetAccessor = tileLoadInfo.pAssetAccessor;
@@ -655,6 +663,7 @@ TilesetContentManager::TilesetContentManager(
       _tileLoadsInProgress{0},
       _loadedTilesCount{0},
       _tilesDataUsed{0},
+      _assetDepot(std::make_shared<CesiumGltf::SharedAssetDepot>()),
       _destructionCompletePromise{externals.asyncSystem.createPromise<void>()},
       _destructionCompleteFuture{
           this->_destructionCompletePromise.getFuture().share()},
@@ -684,6 +693,7 @@ TilesetContentManager::TilesetContentManager(
       _tileLoadsInProgress{0},
       _loadedTilesCount{0},
       _tilesDataUsed{0},
+      _assetDepot(std::make_shared<CesiumGltf::SharedAssetDepot>()),
       _destructionCompletePromise{externals.asyncSystem.createPromise<void>()},
       _destructionCompleteFuture{
           this->_destructionCompletePromise.getFuture().share()},
@@ -835,6 +845,7 @@ TilesetContentManager::TilesetContentManager(
       _tileLoadsInProgress{0},
       _loadedTilesCount{0},
       _tilesDataUsed{0},
+      _assetDepot(std::make_shared<CesiumGltf::SharedAssetDepot>()),
       _destructionCompletePromise{externals.asyncSystem.createPromise<void>()},
       _destructionCompleteFuture{
           this->_destructionCompletePromise.getFuture().share()},
@@ -980,6 +991,7 @@ void TilesetContentManager::loadTileContent(
       this->_externals.pAssetAccessor,
       this->_externals.pPrepareRendererResources,
       this->_externals.pLogger,
+      std::optional(this->_assetDepot),
       tilesetOptions.contentOptions,
       tile};
 
@@ -1209,6 +1221,11 @@ TilesetContentManager::getTilesetCredits() const noexcept {
   return this->_tilesetCredits;
 }
 
+const std::shared_ptr<CesiumGltf::SharedAssetDepot>&
+TilesetContentManager::getSharedAssetDepot() const noexcept {
+  return this->_assetDepot;
+}
+
 int32_t TilesetContentManager::getNumberOfTilesLoading() const noexcept {
   return this->_tileLoadsInProgress;
 }

Cesium3DTilesSelection/src/TilesetContentManager.h

@@ -11,6 +11,7 @@
 #include <Cesium3DTilesSelection/TilesetLoadFailureDetails.h>
 #include <Cesium3DTilesSelection/TilesetOptions.h>
 #include <CesiumAsync/IAssetAccessor.h>
+#include <CesiumGltf/SharedAssetDepot.h>
 #include <CesiumUtility/CreditSystem.h>
 #include <CesiumUtility/ReferenceCounted.h>
 
@@ -94,6 +95,9 @@ class TilesetContentManager
 
   const std::vector<CesiumUtility::Credit>& getTilesetCredits() const noexcept;
 
+  const std::shared_ptr<CesiumGltf::SharedAssetDepot>&
+  getSharedAssetDepot() const noexcept;
+
   int32_t getNumberOfTilesLoading() const noexcept;
 
   int32_t getNumberOfTilesLoaded() const noexcept;
@@ -146,6 +150,9 @@ class TilesetContentManager
   int32_t _loadedTilesCount;
   int64_t _tilesDataUsed;
 
+  // Stores assets that might be shared between tiles.
+  std::shared_ptr<CesiumGltf::SharedAssetDepot> _assetDepot;
+
   CesiumAsync::Promise<void> _destructionCompletePromise;
   CesiumAsync::SharedFuture<void> _destructionCompleteFuture;
 

Cesium3DTilesSelection/src/TilesetJsonLoader.cpp

@@ -1005,4 +1005,5 @@ void TilesetJsonLoader::addChildLoader(
     std::unique_ptr<TilesetContentLoader> pLoader) {
   this->_children.emplace_back(std::move(pLoader));
 }
+
 } // namespace Cesium3DTilesSelection

Cesium3DTilesSelection/src/TilesetJsonLoader.h

@@ -6,6 +6,7 @@
 #include <Cesium3DTilesSelection/TilesetExternals.h>
 #include <CesiumAsync/Future.h>
 #include <CesiumAsync/IAssetAccessor.h>
+#include <CesiumGltf/SharedAssetDepot.h>
 
 #include <rapidjson/fwd.h>
 
@@ -55,6 +56,7 @@ class TilesetJsonLoader : public TilesetContentLoader {
 private:
   std::string _baseUrl;
   CesiumGeospatial::Ellipsoid _ellipsoid;
+  std::optional<std::shared_ptr<CesiumGltf::SharedAssetDepot>> _maybeAssetDepot;
 
   /**
    * @brief The axis that was declared as the "up-axis" for glTF content.

Cesium3DTilesSelection/test/TestTilesetContentManager.cpp

@@ -1,5 +1,7 @@
 #include "SimplePrepareRendererResource.h"
+#include "TestTilesetJsonLoader.h"
 #include "TilesetContentManager.h"
+#include "TilesetJsonLoader.h"
 
 #include <Cesium3DTilesContent/registerAllTileContentTypes.h>
 #include <Cesium3DTilesSelection/RasterOverlayCollection.h>
@@ -1626,4 +1628,65 @@ TEST_CASE("Test the tileset content manager's post processing for gltf") {
 
     pManager->unloadTileContent(tile);
   }
+
+  SECTION("Resolve external images, with deduplication") {
+    std::filesystem::path dirPath(testDataPath / "SharedImages");
+
+    // mock the requests for all files
+    for (const auto& entry : std::filesystem::directory_iterator(dirPath)) {
+      pMockedAssetAccessor->mockCompletedRequests.insert(
+          {entry.path().filename().string(), createMockRequest(entry.path())});
+    }
+
+    std::filesystem::path tilesetPath(dirPath / "tileset.json");
+    auto pExternals = createMockJsonTilesetExternals(
+        tilesetPath.string(),
+        pMockedAssetAccessor);
+
+    auto pJsonLoaderFuture =
+        TilesetJsonLoader::createLoader(pExternals, tilesetPath.string(), {});
+
+    externals.asyncSystem.dispatchMainThreadTasks();
+
+    auto loaderResult = pJsonLoaderFuture.wait();
+
+    REQUIRE(loaderResult.pRootTile);
+    REQUIRE(loaderResult.pRootTile->getChildren().size() == 1);
+
+    auto& rootTile = *loaderResult.pRootTile;
+    auto& containerTile = rootTile.getChildren()[0];
+
+    REQUIRE(containerTile.getChildren().size() == 100);
+
+    // create manager
+    Tile::LoadedLinkedList loadedTiles;
+    IntrusivePointer<TilesetContentManager> pManager =
+        new TilesetContentManager{
+            externals,
+            {},
+            RasterOverlayCollection{loadedTiles, externals},
+            {},
+            std::move(loaderResult.pLoader),
+            std::move(loaderResult.pRootTile)};
+
+    for (auto& child : containerTile.getChildren()) {
+      pManager->loadTileContent(child, {});
+      externals.asyncSystem.dispatchMainThreadTasks();
+      pManager->waitUntilIdle();
+
+      CHECK(child.getState() == TileLoadState::ContentLoaded);
+      CHECK(child.isRenderContent());
+
+      const auto& renderContent = child.getContent().getRenderContent();
+      const auto& images = renderContent->getModel().images;
+      CHECK(images.size() == 1);
+    }
+
+    CHECK(pManager->getSharedAssetDepot()->getImagesCount() == 2);
+
+    // unload the tile content
+    for (auto& child : containerTile.getChildren()) {
+      pManager->unloadTileContent(child);
+    }
+  }
 }