Make sure availability tiles are loaded before deciding there is no terrain at that x, y, level

Author: ggetz

packages/engine/Source/Core/CesiumTerrainProvider.js

@@ -915,6 +915,34 @@ CesiumTerrainProvider.prototype.requestTileGeometry = function (
         layerToUse = layer;
         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(
+        this,
+        tile.x,
+        tile.y,
+        tile.level,
+        layer,
+        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) {