Implement Staged Tile Loading Pipeline

.github/workflows/build.yml

@@ -1,5 +1,5 @@
 name: cesium-native
-on: [push, pull_request]
+on: [push]
 jobs:
   QuickChecks:
     name: "Quick Checks"

Cesium3DTilesContent/include/Cesium3DTilesContent/SubtreeAvailability.h

@@ -85,14 +85,18 @@ class SubtreeAvailability {
    * @return A future that resolves to a `SubtreeAvailability` instance for the
    * subtree file, or std::nullopt if something goes wrong.
    */
-  static CesiumAsync::Future<std::optional<SubtreeAvailability>> loadSubtree(
+
+  using LoadResult =
+      std::pair<std::optional<SubtreeAvailability>, CesiumAsync::RequestData>;
+
+  static CesiumAsync::Future<LoadResult> loadSubtree(
       ImplicitTileSubdivisionScheme subdivisionScheme,
       uint32_t levelsInSubtree,
       const CesiumAsync::AsyncSystem& asyncSystem,
-      const std::shared_ptr<CesiumAsync::IAssetAccessor>& pAssetAccessor,
       const std::shared_ptr<spdlog::logger>& pLogger,
-      const std::string& subtreeUrl,
-      const std::vector<CesiumAsync::IAssetAccessor::THeader>& requestHeaders);
+      const std::string& baseUrl,
+      const CesiumAsync::IAssetResponse* baseResponse,
+      const CesiumAsync::UrlResponseDataMap& additionalResponse);
 
   /**
    * @brief An AvailibilityView that indicates that either all tiles are

Cesium3DTilesContent/src/SubtreeAvailability.cpp

@@ -137,44 +137,56 @@ std::optional<SubtreeAvailability::AvailabilityView> parseAvailabilityView(
       std::move(subtree));
 }
 
-/*static*/ CesiumAsync::Future<std::optional<SubtreeAvailability>>
+/*static*/ CesiumAsync::Future<SubtreeAvailability::LoadResult>
 SubtreeAvailability::loadSubtree(
     ImplicitTileSubdivisionScheme subdivisionScheme,
     uint32_t levelsInSubtree,
     const CesiumAsync::AsyncSystem& asyncSystem,
-    const std::shared_ptr<CesiumAsync::IAssetAccessor>& pAssetAccessor,
     const std::shared_ptr<spdlog::logger>& pLogger,
-    const std::string& subtreeUrl,
-    const std::vector<CesiumAsync::IAssetAccessor::THeader>& requestHeaders) {
+    const std::string& baseUrl,
+    const CesiumAsync::IAssetResponse* baseResponse,
+    const CesiumAsync::UrlResponseDataMap& additionalResponse) {
   auto pReader = std::make_shared<SubtreeFileReader>();
-  return pReader->load(asyncSystem, pAssetAccessor, subtreeUrl, requestHeaders)
+  return pReader->load(asyncSystem, baseUrl, baseResponse, additionalResponse)
       .thenInMainThread(
-          [pLogger, subtreeUrl, subdivisionScheme, levelsInSubtree, pReader](
+          [pLogger, baseUrl, subdivisionScheme, levelsInSubtree, pReader](
               ReadJsonResult<Subtree>&& subtree)
-              -> std::optional<SubtreeAvailability> {
+              -> SubtreeAvailability::LoadResult {
             if (!subtree.errors.empty()) {
               SPDLOG_LOGGER_ERROR(
                   pLogger,
                   "Errors while loading subtree from {}:\n- {}",
-                  subtreeUrl,
+                  baseUrl,
                   CesiumUtility::joinToString(subtree.errors, "\n- "));
             }
             if (!subtree.warnings.empty()) {
               SPDLOG_LOGGER_WARN(
                   pLogger,
                   "Warnings while loading subtree from {}:\n- {}",
-                  subtreeUrl,
+                  baseUrl,
                   CesiumUtility::joinToString(subtree.warnings, "\n- "));
             }
+            if (!subtree.urlNeeded.empty()) {
+              return SubtreeAvailability::LoadResult{
+                  std::nullopt,
+                  CesiumAsync::RequestData{subtree.urlNeeded, {}}};
+            }
 
             if (!subtree.value) {
-              return std::nullopt;
+              return SubtreeAvailability::LoadResult{
+                  std::nullopt,
+                  CesiumAsync::RequestData{}};
             }
 
-            return SubtreeAvailability::fromSubtree(
-                subdivisionScheme,
-                levelsInSubtree,
-                std::move(*subtree.value));
+            std::optional<SubtreeAvailability> returnedSubtree =
+                SubtreeAvailability::fromSubtree(
+                    subdivisionScheme,
+                    levelsInSubtree,
+                    std::move(*subtree.value));
+
+            return SubtreeAvailability::LoadResult{
+                std::move(returnedSubtree),
+                CesiumAsync::RequestData{}};
           });
 }
 

Cesium3DTilesContent/test/TestSubtreeAvailability.cpp

@@ -289,16 +289,30 @@ std::optional<SubtreeAvailability> mockLoadSubtreeJson(
   auto pMockTaskProcessor = std::make_shared<ThreadTaskProcessor>();
   CesiumAsync::AsyncSystem asyncSystem{pMockTaskProcessor};
 
+  auto testEntry = pMockAssetAccessor->mockCompletedRequests.find("test");
+  assert(testEntry != pMockAssetAccessor->mockCompletedRequests.end());
+  const CesiumAsync::IAssetResponse* testResponse =
+      testEntry->second->response();
+  assert(testResponse);
+
+  CesiumAsync::UrlResponseDataMap additionalResponses;
+  auto bufferEntry = pMockAssetAccessor->mockCompletedRequests.find("buffer");
+  additionalResponses.emplace(
+      bufferEntry->first,
+      CesiumAsync::ResponseData{
+          bufferEntry->second.get(),
+          bufferEntry->second->response()});
+
   auto subtreeFuture = SubtreeAvailability::loadSubtree(
       ImplicitTileSubdivisionScheme::Quadtree,
       levelsInSubtree,
       asyncSystem,
-      pMockAssetAccessor,
       spdlog::default_logger(),
       "test",
-      {});
+      testResponse,
+      additionalResponses);
 
-  return waitForFuture(asyncSystem, std::move(subtreeFuture));
+  return waitForFuture(asyncSystem, std::move(subtreeFuture)).first;
 }
 } // namespace
 
@@ -557,10 +571,6 @@ TEST_CASE("Test parsing subtree format") {
         "test",
         CesiumAsync::HttpHeaders{},
         std::move(pMockResponse));
-    std::map<std::string, std::shared_ptr<SimpleAssetRequest>> mapUrlToRequest{
-        {"test", std::move(pMockRequest)}};
-    auto pMockAssetAccessor =
-        std::make_shared<SimpleAssetAccessor>(std::move(mapUrlToRequest));
 
     // mock async system
     auto pMockTaskProcessor = std::make_shared<SimpleTaskProcessor>();
@@ -570,13 +580,14 @@ TEST_CASE("Test parsing subtree format") {
         ImplicitTileSubdivisionScheme::Quadtree,
         maxSubtreeLevels,
         asyncSystem,
-        pMockAssetAccessor,
         spdlog::default_logger(),
         "test",
-        {});
+        pMockRequest->response(),
+        CesiumAsync::UrlResponseDataMap{});
 
     asyncSystem.dispatchMainThreadTasks();
-    auto parsedSubtree = subtreeFuture.wait();
+    SubtreeAvailability::LoadResult loadResult = subtreeFuture.wait();
+    std::optional<SubtreeAvailability>& parsedSubtree = loadResult.first;
     REQUIRE(parsedSubtree != std::nullopt);
 
     for (const auto& tileID : availableTileIDs) {
@@ -595,7 +606,6 @@ TEST_CASE("Test parsing subtree format") {
       CHECK(parsedSubtree->isSubtreeAvailable(
           libmorton::morton2D_64_encode(subtreeID.x, subtreeID.y)));
     }
-
     for (const auto& subtreeID : unavailableSubtreeIDs) {
       CHECK(!parsedSubtree->isSubtreeAvailable(
           libmorton::morton2D_64_encode(subtreeID.x, subtreeID.y)));

Cesium3DTilesReader/include/Cesium3DTilesReader/SubtreeFileReader.h

@@ -57,47 +57,38 @@ class CESIUM3DTILESREADER_API SubtreeFileReader {
   CesiumAsync::Future<CesiumJsonReader::ReadJsonResult<Cesium3DTiles::Subtree>>
   load(
       const CesiumAsync::AsyncSystem& asyncSystem,
-      const std::shared_ptr<CesiumAsync::IAssetAccessor>& pAssetAccessor,
-      const std::string& url,
-      const std::vector<CesiumAsync::IAssetAccessor::THeader>& headers = {})
+      const std::string& baseUrl,
+      const CesiumAsync::IAssetResponse* baseResponse,
+      const CesiumAsync::UrlResponseDataMap& additionalResponses)
       const noexcept;
 
   CesiumAsync::Future<CesiumJsonReader::ReadJsonResult<Cesium3DTiles::Subtree>>
   load(
       const CesiumAsync::AsyncSystem& asyncSystem,
-      const std::shared_ptr<CesiumAsync::IAssetAccessor>& pAssetAccessor,
-      const std::shared_ptr<CesiumAsync::IAssetRequest>& pRequest)
-      const noexcept;
-
-  CesiumAsync::Future<CesiumJsonReader::ReadJsonResult<Cesium3DTiles::Subtree>>
-  load(
-      const CesiumAsync::AsyncSystem& asyncSystem,
-      const std::shared_ptr<CesiumAsync::IAssetAccessor>& pAssetAccessor,
-      const std::string& url,
-      const std::vector<CesiumAsync::IAssetAccessor::THeader>& requestHeaders,
+      const std::string& baseUrl,
+      const CesiumAsync::UrlResponseDataMap& additionalResponses,
       const gsl::span<const std::byte>& data) const noexcept;
 
 private:
   CesiumAsync::Future<CesiumJsonReader::ReadJsonResult<Cesium3DTiles::Subtree>>
   loadBinary(
       const CesiumAsync::AsyncSystem& asyncSystem,
-      const std::shared_ptr<CesiumAsync::IAssetAccessor>& pAssetAccessor,
-      const std::string& url,
-      const std::vector<CesiumAsync::IAssetAccessor::THeader>& requestHeaders,
-      const gsl::span<const std::byte>& data) const noexcept;
+      const std::string& baseUrl,
+      const gsl::span<const std::byte>& data,
+      const CesiumAsync::UrlResponseDataMap& additionalResponses)
+      const noexcept;
   CesiumAsync::Future<CesiumJsonReader::ReadJsonResult<Cesium3DTiles::Subtree>>
   loadJson(
       const CesiumAsync::AsyncSystem& asyncSystem,
-      const std::shared_ptr<CesiumAsync::IAssetAccessor>& pAssetAccessor,
-      const std::string& url,
-      const std::vector<CesiumAsync::IAssetAccessor::THeader>& requestHeaders,
-      const gsl::span<const std::byte>& data) const noexcept;
+      const std::string& baseUrl,
+      const gsl::span<const std::byte>& data,
+      const CesiumAsync::UrlResponseDataMap& additionalResponses)
+      const noexcept;
   CesiumAsync::Future<CesiumJsonReader::ReadJsonResult<Cesium3DTiles::Subtree>>
   postprocess(
       const CesiumAsync::AsyncSystem& asyncSystem,
-      const std::shared_ptr<CesiumAsync::IAssetAccessor>& pAssetAccessor,
-      const std::string& url,
-      const std::vector<CesiumAsync::IAssetAccessor::THeader>& requestHeaders,
+      const std::string& baseUrl,
+      const CesiumAsync::UrlResponseDataMap& additionalResponses,
       CesiumJsonReader::ReadJsonResult<Cesium3DTiles::Subtree>&& loaded)
       const noexcept;