Return the correct promise

Author: ggetz

packages/engine/Source/Core/CesiumTerrainProvider.js

@@ -901,6 +901,8 @@ CesiumTerrainProvider.prototype.requestTileGeometry = function (
   const layers = this._layers;
   let layerToUse;
   const layerCount = layers.length;
+  let unknownAvailability = false;
+  let availabilityPromise = Promise.resolve();
 
   if (layerCount === 1) {
     // Optimized path for single layers
@@ -916,36 +918,31 @@ CesiumTerrainProvider.prototype.requestTileGeometry = function (
         break;
       }
 
-      if (!defined(layer.availabilityLevels)) {
-        // This layer doesn't use cutout terrain, so we don't need to do the following check
-        continue;
-      }
-
-      const tile = getAvailabilityTile(layer, x, y, level);
-      if (
-        !defined(tile) ||
-        !layer.availability.isTileAvailable(tile.level, tile.x, tile.y) ||
-        layer.availabilityTilesLoaded.isTileAvailable(
-          tile.level,
-          tile.x,
-          tile.y
-        )
-      ) {
-        continue;
-      }
-
-      // There are some cases where availability tiles are not completely loaded at this point. Request them now.
-      return requestTileGeometry(
+      const availabilityUnloaded = checkLayer(
         this,
-        tile.x,
-        tile.y,
-        tile.level,
+        x,
+        y,
+        level,
         layer,
-        request
+        i === 0
       );
+      if (availabilityUnloaded.result) {
+        // We can't know yet since the availability is not yet loaded
+        unknownAvailability = true;
+        availabilityPromise = availabilityPromise.then(
+          () => availabilityUnloaded.promise
+        );
+      }
     }
   }
 
+  if (!defined(layerToUse) && unknownAvailability) {
+    // Try again when availability data is ready– Otherwise the tile will be marked as failed and never re-requested
+    return availabilityPromise.then(() =>
+      this.requestTileGeometry(x, y, level, request)
+    );
+  }
+
   return requestTileGeometry(this, x, y, level, layerToUse, request);
 };
 

packages/engine/Source/Core/TileAvailability.js

@@ -396,10 +396,10 @@ function findMaxLevelFromNode(stopNode, node, position) {
   // Find the deepest quadtree node containing this point.
   let found = false;
   while (!found) {
-    const nw = node.nw && rectangleContainsPosition(node.nw.extent, position);
-    const ne = node.ne && rectangleContainsPosition(node.ne.extent, position);
-    const sw = node.sw && rectangleContainsPosition(node.sw.extent, position);
-    const se = node.se && rectangleContainsPosition(node.se.extent, position);
+    const nw = node._nw && rectangleContainsPosition(node._nw.extent, position);
+    const ne = node._ne && rectangleContainsPosition(node._ne.extent, position);
+    const sw = node._sw && rectangleContainsPosition(node._sw.extent, position);
+    const se = node._se && rectangleContainsPosition(node._se.extent, position);
 
     // The common scenario is that the point is in only one quadrant and we can simply
     // iterate down the tree.  But if the point is on a boundary between tiles, it is
@@ -408,36 +408,36 @@ function findMaxLevelFromNode(stopNode, node, position) {
       if (nw) {
         maxLevel = Math.max(
           maxLevel,
-          findMaxLevelFromNode(node, node.nw, position)
+          findMaxLevelFromNode(node, node._nw, position)
         );
       }
       if (ne) {
         maxLevel = Math.max(
           maxLevel,
-          findMaxLevelFromNode(node, node.ne, position)
+          findMaxLevelFromNode(node, node._ne, position)
         );
       }
       if (sw) {
         maxLevel = Math.max(
           maxLevel,
-          findMaxLevelFromNode(node, node.sw, position)
+          findMaxLevelFromNode(node, node._sw, position)
         );
       }
       if (se) {
         maxLevel = Math.max(
           maxLevel,
-          findMaxLevelFromNode(node, node.se, position)
+          findMaxLevelFromNode(node, node._se, position)
         );
       }
       break;
     } else if (nw) {
-      node = node.nw;
+      node = node._nw;
     } else if (ne) {
-      node = node.ne;
+      node = node._ne;
     } else if (sw) {
-      node = node.sw;
+      node = node._sw;
     } else if (se) {
-      node = node.se;
+      node = node._se;
     } else {
       found = true;
     }
@@ -501,10 +501,10 @@ function updateCoverageWithNode(
   }
 
   // Update with child nodes.
-  updateCoverageWithNode(remainingToCoverByLevel, node.nw, rectanglesToCover);
-  updateCoverageWithNode(remainingToCoverByLevel, node.ne, rectanglesToCover);
-  updateCoverageWithNode(remainingToCoverByLevel, node.sw, rectanglesToCover);
-  updateCoverageWithNode(remainingToCoverByLevel, node.se, rectanglesToCover);
+  updateCoverageWithNode(remainingToCoverByLevel, node._nw, rectanglesToCover);
+  updateCoverageWithNode(remainingToCoverByLevel, node._ne, rectanglesToCover);
+  updateCoverageWithNode(remainingToCoverByLevel, node._sw, rectanglesToCover);
+  updateCoverageWithNode(remainingToCoverByLevel, node._se, rectanglesToCover);
 }
 
 function subtractRectangle(rectangleList, rectangleToSubtract) {