Cache images across glTFs to avoid duplication

Source/CesiumRuntime/Private/Cesium3DTileset.cpp

@@ -19,6 +19,7 @@
 #include "CesiumGeospatial/GlobeTransforms.h"
 #include "CesiumGltf/ImageCesium.h"
 #include "CesiumGltf/Ktx2TranscodeTargets.h"
+#include "CesiumGltf/SharedAssetDepot.h"
 #include "CesiumGltfComponent.h"
 #include "CesiumGltfPointsSceneProxyUpdater.h"
 #include "CesiumGltfPrimitiveComponent.h"
@@ -729,16 +730,22 @@ class UnrealResourcePreparer
 
     const CesiumGeospatial::Ellipsoid& ellipsoid = tileLoadResult.ellipsoid;
 
-    TUniquePtr<UCesiumGltfComponent::HalfConstructed> pHalf =
-        UCesiumGltfComponent::CreateOffGameThread(
+    CesiumAsync::Future<TUniquePtr<UCesiumGltfComponent::HalfConstructed>>
+        pHalfFuture = UCesiumGltfComponent::CreateOffGameThread(
+            asyncSystem,
             transform,
             options,
             ellipsoid);
 
-    return asyncSystem.createResolvedFuture(
-        Cesium3DTilesSelection::TileLoadResultAndRenderResources{
-            std::move(tileLoadResult),
-            pHalf.Release()});
+    return MoveTemp(pHalfFuture)
+        .thenImmediately(
+            [tileLoadResult](
+                TUniquePtr<UCesiumGltfComponent::HalfConstructed>&& pHalf)
+                -> Cesium3DTilesSelection::TileLoadResultAndRenderResources {
+              return Cesium3DTilesSelection::TileLoadResultAndRenderResources{
+                  std::move(tileLoadResult),
+                  pHalf.Release()};
+            });
   }
 
   virtual void* prepareInMainThread(
@@ -807,7 +814,7 @@ class UnrealResourcePreparer
       }
     }
 
-    auto texture = CesiumTextureUtility::loadTextureAnyThreadPart(
+    auto texture = CesiumTextureUtility::loadTextureAnyThreadPartSync(
         image,
         TextureAddress::TA_Clamp,
         TextureAddress::TA_Clamp,
@@ -816,8 +823,7 @@ class UnrealResourcePreparer
         pOptions->group,
         // TODO: sRGB should probably be configurable on the raster overlay.
         true,
-        std::nullopt,
-        nullptr);
+        std::nullopt);
     return texture.Release();
   }
 
@@ -1863,6 +1869,35 @@ void ACesium3DTileset::updateLastViewUpdateResultState(
     const Cesium3DTilesSelection::ViewUpdateResult& result) {
   TRACE_CPUPROFILER_EVENT_SCOPE(Cesium::updateLastViewUpdateResultState)
 
+  if (this->DrawTileInfo) {
+    const UWorld* World = GetWorld();
+    check(World);
+
+    const TSoftObjectPtr<ACesiumGeoreference> Georeference = GetGeoreference();
+    check(Georeference);
+
+    for (auto& tile : result.tilesToRenderThisFrame) {
+
+      CesiumGeometry::OrientedBoundingBox obb =
+          Cesium3DTilesSelection::getOrientedBoundingBoxFromBoundingVolume(
+              tile->getBoundingVolume(),
+              Georeference->GetEllipsoid()->GetNativeEllipsoid());
+
+      FVector unrealCenter =
+          Georeference->TransformEarthCenteredEarthFixedPositionToUnreal(
+              VecMath::createVector(obb.getCenter()));
+
+      FString text = FString::Printf(
+          TEXT("ID %s (%p)"),
+          Cesium3DTilesSelection::TileIdUtilities::createTileIdString(
+              tile->getTileID())
+              .c_str(),
+          tile);
+
+      DrawDebugString(World, unrealCenter, text, nullptr, FColor::Red, 0, true);
+    }
+  }
+
   if (!this->LogSelectionStats) {
     return;
   }

Source/CesiumRuntime/Private/CesiumEncodedFeaturesMetadata.cpp

@@ -143,7 +143,7 @@ std::optional<EncodedFeatureIdSet> encodeFeatureIdTexture(
     // Copy the image, so that we can keep a copy of it in the glTF.
     CesiumGltf::ImageCesium imageCopy(*pFeatureIdImage);
     encodedFeatureIdTexture.pTexture =
-        MakeShared<LoadedTextureResult>(std::move(*loadTextureAnyThreadPart(
+        MakeShared<LoadedTextureResult>(std::move(*loadTextureAnyThreadPartSync(
             imageCopy,
             addressX,
             addressY,
@@ -152,8 +152,7 @@ std::optional<EncodedFeatureIdSet> encodeFeatureIdTexture(
             TEXTUREGROUP_8BitData,
             false,
             // TODO: currently this is always the case, but doesn't have to be
-            EPixelFormat::PF_R8G8B8A8_UINT,
-            nullptr)));
+            EPixelFormat::PF_R8G8B8A8_UINT)));
     featureIdTextureMap.Emplace(
         pFeatureIdImage,
         encodedFeatureIdTexture.pTexture);
@@ -567,16 +566,16 @@ EncodedPropertyTable encodePropertyTableAnyThreadPart(
             encodedFormat.bytesPerChannel * encodedFormat.channels);
       }
 
-      encodedProperty.pTexture = loadTextureAnyThreadPart(
-          image,
+      CesiumGltf::ImageCesium imageCopy(image);
+      encodedProperty.pTexture = loadTextureAnyThreadPartSync(
+          imageCopy,
           TextureAddress::TA_Clamp,
           TextureAddress::TA_Clamp,
           TextureFilter::TF_Nearest,
           false,
           TEXTUREGROUP_8BitData,
           false,
-          encodedFormat.format,
-          nullptr);
+          encodedFormat.format);
     }
 
     if (pDescription->PropertyDetails.bHasOffset) {
@@ -693,8 +692,8 @@ EncodedPropertyTexture encodePropertyTextureAnyThreadPart(
 
         // Copy the image, so that we can keep a copy of it in the glTF.
         CesiumGltf::ImageCesium imageCopy(*pImage);
-        encodedProperty.pTexture =
-            MakeShared<LoadedTextureResult>(std::move(*loadTextureAnyThreadPart(
+        encodedProperty.pTexture = MakeShared<LoadedTextureResult>(
+            std::move(*loadTextureAnyThreadPartSync(
                 imageCopy,
                 addressX,
                 addressY,
@@ -705,8 +704,7 @@ EncodedPropertyTexture encodePropertyTextureAnyThreadPart(
                 false,
                 // This assumes that the texture's image only contains one byte
                 // per channel.
-                EPixelFormat::PF_R8G8B8A8_UINT,
-                nullptr)));
+                EPixelFormat::PF_R8G8B8A8_UINT)));
         propertyTexturePropertyMap.Emplace(pImage, encodedProperty.pTexture);
       }
     };

Source/CesiumRuntime/Private/CesiumEncodedMetadataUtility.cpp

@@ -276,16 +276,16 @@ EncodedMetadataFeatureTable encodeMetadataFeatureTableAnyThreadPart(
       }
     }
 
-    encodedProperty.pTexture = loadTextureAnyThreadPart(
-        image,
+    CesiumGltf::ImageCesium imageCopy(image);
+    encodedProperty.pTexture = loadTextureAnyThreadPartSync(
+        imageCopy,
         TextureAddress::TA_Clamp,
         TextureAddress::TA_Clamp,
         TextureFilter::TF_Nearest,
         false,
         TEXTUREGROUP_8BitData,
         false,
-        encodedFormat.format,
-        nullptr);
+        encodedFormat.format);
   }
 
   return encodedFeatureTable;
@@ -411,8 +411,8 @@ EncodedFeatureTexture encodeFeatureTextureAnyThreadPart(
       encodedFeatureTextureProperty.pTexture = pMappedUnrealImageIt->Pin();
     } else {
       CesiumGltf::ImageCesium imageCopy(*pImage);
-      encodedFeatureTextureProperty.pTexture =
-          MakeShared<LoadedTextureResult>(std::move(*loadTextureAnyThreadPart(
+      encodedFeatureTextureProperty.pTexture = MakeShared<LoadedTextureResult>(
+          std::move(*loadTextureAnyThreadPartSync(
               imageCopy,
               TextureAddress::TA_Clamp,
               TextureAddress::TA_Clamp,
@@ -424,8 +424,7 @@ EncodedFeatureTexture encodeFeatureTextureAnyThreadPart(
               // R8G8B8A8 form, but this does not necessarily need to be the
               // case in the future.
               isNormalized ? EPixelFormat::PF_R8G8B8A8
-                           : EPixelFormat::PF_R8G8B8A8_UINT,
-              nullptr)));
+                           : EPixelFormat::PF_R8G8B8A8_UINT)));
       featureTexturePropertyMap.Emplace(
           pImage,
           encodedFeatureTextureProperty.pTexture);
@@ -518,7 +517,7 @@ EncodedMetadataPrimitive encodeMetadataPrimitiveAnyThreadPart(
         } else {
           CesiumGltf::ImageCesium imageCopy(*pFeatureIdImage);
           encodedFeatureIdTexture.pTexture = MakeShared<LoadedTextureResult>(
-              std::move(*loadTextureAnyThreadPart(
+              std::move(*loadTextureAnyThreadPartSync(
                   imageCopy,
                   TextureAddress::TA_Clamp,
                   TextureAddress::TA_Clamp,
@@ -528,8 +527,7 @@ EncodedMetadataPrimitive encodeMetadataPrimitiveAnyThreadPart(
                   false,
                   // TODO: currently this is always the case, but doesn't have
                   // to be
-                  EPixelFormat::PF_R8G8B8A8_UINT,
-                  nullptr)));
+                  EPixelFormat::PF_R8G8B8A8_UINT)));
           featureIdTextureMap.Emplace(
               pFeatureIdImage,
               encodedFeatureIdTexture.pTexture);