@cesium/engine 2.1.0 → 2.3.0

package/Source/Core/sampleTerrainMostDetailed.js

@@ -17,18 +17,16 @@ const scratchCartesian2 = new Cartesian2();
  *
  * @example
  * // Query the terrain height of two Cartographic positions
- * const terrainProvider = Cesium.createWorldTerrain();
+ * const terrainProvider = await Cesium.createWorldTerrainAsync();
  * const positions = [
  *     Cesium.Cartographic.fromDegrees(86.925145, 27.988257),
  *     Cesium.Cartographic.fromDegrees(87.0, 28.0)
  * ];
- * const promise = Cesium.sampleTerrainMostDetailed(terrainProvider, positions);
- * Promise.resolve(promise).then(function(updatedPositions) {
- *     // positions[0].height and positions[1].height have been updated.
- *     // updatedPositions is just a reference to positions.
- * });
+ * const updatedPositions = await Cesium.sampleTerrainMostDetailed(terrainProvider, positions);
+ * // positions[0].height and positions[1].height have been updated.
+ * // updatedPositions is just a reference to positions.
  */
-function sampleTerrainMostDetailed(terrainProvider, positions) {
+async function sampleTerrainMostDetailed(terrainProvider, positions) {
   //>>includeStart('debug', pragmas.debug);
   if (!defined(terrainProvider)) {
     throw new DeveloperError("terrainProvider is required.");
@@ -38,80 +36,76 @@ function sampleTerrainMostDetailed(terrainProvider, positions) {
   }
   //>>includeEnd('debug');
 
-  return terrainProvider.readyPromise.then(function () {
-    const byLevel = [];
-    const maxLevels = [];
+  const byLevel = [];
+  const maxLevels = [];
 
-    const availability = terrainProvider.availability;
+  // readyPromise has been deprecated; This is here for backwards compatibility
+  await terrainProvider._readyPromise;
 
-    //>>includeStart('debug', pragmas.debug);
-    if (!defined(availability)) {
-      throw new DeveloperError(
-        "sampleTerrainMostDetailed requires a terrain provider that has tile availability."
+  const availability = terrainProvider.availability;
+
+  //>>includeStart('debug', pragmas.debug);
+  if (!defined(availability)) {
+    throw new DeveloperError(
+      "sampleTerrainMostDetailed requires a terrain provider that has tile availability."
+    );
+  }
+  //>>includeEnd('debug');
+
+  const promises = [];
+  for (let i = 0; i < positions.length; ++i) {
+    const position = positions[i];
+    const maxLevel = availability.computeMaximumLevelAtPosition(position);
+    maxLevels[i] = maxLevel;
+    if (maxLevel === 0) {
+      // This is a special case where we have a parent terrain and we are requesting
+      // heights from an area that isn't covered by the top level terrain at all.
+      // This will essentially trigger the loading of the parent terrains root tile
+      terrainProvider.tilingScheme.positionToTileXY(
+        position,
+        1,
+        scratchCartesian2
+      );
+      const promise = terrainProvider.loadTileDataAvailability(
+        scratchCartesian2.x,
+        scratchCartesian2.y,
+        1
       );
+      if (defined(promise)) {
+        promises.push(promise);
+      }
     }
-    //>>includeEnd('debug');
 
-    const promises = [];
-    for (let i = 0; i < positions.length; ++i) {
-      const position = positions[i];
-      const maxLevel = availability.computeMaximumLevelAtPosition(position);
-      maxLevels[i] = maxLevel;
-      if (maxLevel === 0) {
-        // This is a special case where we have a parent terrain and we are requesting
-        // heights from an area that isn't covered by the top level terrain at all.
-        // This will essentially trigger the loading of the parent terrains root tile
-        terrainProvider.tilingScheme.positionToTileXY(
-          position,
-          1,
-          scratchCartesian2
-        );
-        const promise = terrainProvider.loadTileDataAvailability(
-          scratchCartesian2.x,
-          scratchCartesian2.y,
-          1
-        );
-        if (defined(promise)) {
-          promises.push(promise);
-        }
-      }
+    let atLevel = byLevel[maxLevel];
+    if (!defined(atLevel)) {
+      byLevel[maxLevel] = atLevel = [];
+    }
+    atLevel.push(position);
+  }
 
-      let atLevel = byLevel[maxLevel];
-      if (!defined(atLevel)) {
-        byLevel[maxLevel] = atLevel = [];
+  await Promise.all(promises);
+  await Promise.all(
+    byLevel.map(function (positionsAtLevel, index) {
+      if (defined(positionsAtLevel)) {
+        return sampleTerrain(terrainProvider, index, positionsAtLevel);
       }
-      atLevel.push(position);
-    }
+    })
+  );
+  const changedPositions = [];
+  for (let i = 0; i < positions.length; ++i) {
+    const position = positions[i];
+    const maxLevel = availability.computeMaximumLevelAtPosition(position);
 
-    return Promise.all(promises)
-      .then(function () {
-        return Promise.all(
-          byLevel.map(function (positionsAtLevel, index) {
-            if (defined(positionsAtLevel)) {
-              return sampleTerrain(terrainProvider, index, positionsAtLevel);
-            }
-          })
-        );
-      })
-      .then(function () {
-        const changedPositions = [];
-        for (let i = 0; i < positions.length; ++i) {
-          const position = positions[i];
-          const maxLevel = availability.computeMaximumLevelAtPosition(position);
+    if (maxLevel !== maxLevels[i]) {
+      // Now that we loaded the max availability, a higher level has become available
+      changedPositions.push(position);
+    }
+  }
 
-          if (maxLevel !== maxLevels[i]) {
-            // Now that we loaded the max availability, a higher level has become available
-            changedPositions.push(position);
-          }
-        }
+  if (changedPositions.length > 0) {
+    await sampleTerrainMostDetailed(terrainProvider, changedPositions);
+  }
 
-        if (changedPositions.length > 0) {
-          return sampleTerrainMostDetailed(terrainProvider, changedPositions);
-        }
-      })
-      .then(function () {
-        return positions;
-      });
-  });
+  return positions;
 }
 export default sampleTerrainMostDetailed;

package/Source/DataSources/Cesium3DTilesetVisualizer.js

@@ -65,7 +65,7 @@ Cesium3DTilesetVisualizer.prototype.update = function (time) {
     const tilesetGraphics = entity._tileset;
 
     let resource;
-    let tilesetData = tilesetHash[entity.id];
+    const tilesetData = tilesetHash[entity.id];
     const show =
       entity.isShowing &&
       entity.isAvailable(time) &&
@@ -86,28 +86,21 @@ Cesium3DTilesetVisualizer.prototype.update = function (time) {
       continue;
     }
 
-    let tileset = defined(tilesetData)
+    const tileset = defined(tilesetData)
       ? tilesetData.tilesetPrimitive
       : undefined;
-    if (!defined(tileset) || resource.url !== tilesetData.url) {
+    if (!defined(tilesetData) || resource.url !== tilesetData.url) {
       if (defined(tileset)) {
         primitives.removeAndDestroy(tileset);
-        delete tilesetHash[entity.id];
       }
-      tileset = new Cesium3DTileset({
-        url: resource,
-      });
-      tileset.id = entity;
-      primitives.add(tileset);
-
-      tilesetData = {
-        tilesetPrimitive: tileset,
-        url: resource.url,
-        loadFail: false,
-      };
-      tilesetHash[entity.id] = tilesetData;
-
-      checkLoad(tileset, entity, tilesetHash);
+
+      delete tilesetHash[entity.id];
+
+      createTileset(resource, tilesetHash, entity, primitives);
+    }
+
+    if (!defined(tileset)) {
+      continue;
     }
 
     tileset.show = true;
@@ -180,12 +173,12 @@ Cesium3DTilesetVisualizer.prototype.getBoundingSphere = function (
   }
 
   const primitive = tilesetData.tilesetPrimitive;
-  if (!defined(primitive) || !primitive.show) {
-    return BoundingSphereState.FAILED;
+  if (!defined(primitive)) {
+    return BoundingSphereState.PENDING;
   }
 
-  if (!primitive.ready) {
-    return BoundingSphereState.PENDING;
+  if (!primitive.show) {
+    return BoundingSphereState.FAILED;
   }
 
   BoundingSphere.clone(primitive.boundingSphere, result);
@@ -235,15 +228,33 @@ Cesium3DTilesetVisualizer.prototype._onCollectionChanged = function (
 function removeTileset(visualizer, entity, tilesetHash, primitives) {
   const tilesetData = tilesetHash[entity.id];
   if (defined(tilesetData)) {
-    primitives.removeAndDestroy(tilesetData.tilesetPrimitive);
+    if (defined(tilesetData.tilesetPrimitive)) {
+      primitives.removeAndDestroy(tilesetData.tilesetPrimitive);
+    }
     delete tilesetHash[entity.id];
   }
 }
 
-function checkLoad(primitive, entity, tilesetHash) {
-  primitive.readyPromise.catch(function (error) {
+async function createTileset(resource, tilesetHash, entity, primitives) {
+  tilesetHash[entity.id] = {
+    url: resource.url,
+    loadFail: false,
+  };
+
+  try {
+    const tileset = await Cesium3DTileset.fromUrl(resource);
+    tileset.id = entity;
+    primitives.add(tileset);
+
+    if (!defined(tilesetHash[entity.id])) {
+      return;
+    }
+
+    tilesetHash[entity.id].tilesetPrimitive = tileset;
+  } catch (error) {
     console.error(error);
     tilesetHash[entity.id].loadFail = true;
-  });
+  }
 }
+
 export default Cesium3DTilesetVisualizer;

package/Source/DataSources/DataSourceDisplay.js

@@ -313,7 +313,7 @@ DataSourceDisplay.prototype._postRender = function () {
 
     const credit = dataSource.credit;
     if (defined(credit)) {
-      frameState.creditDisplay.addCredit(credit);
+      frameState.creditDisplay.addCreditToNextFrame(credit);
     }
 
     // Credits from the resource that the user can't remove
@@ -321,7 +321,7 @@ DataSourceDisplay.prototype._postRender = function () {
     if (defined(credits)) {
       const creditCount = credits.length;
       for (let c = 0; c < creditCount; c++) {
-        frameState.creditDisplay.addCredit(credits[c]);
+        frameState.creditDisplay.addCreditToNextFrame(credits[c]);
       }
     }
   }

package/Source/DataSources/Entity.js

@@ -597,7 +597,12 @@ Entity.prototype.merge = function (source) {
     //While source is required by the API to be an Entity, we internally call this method from the
     //constructor with an options object to configure initial custom properties.
     //So we need to ignore reserved-non-property.
-    if (name === "parent" || name === "name" || name === "availability") {
+    if (
+      name === "parent" ||
+      name === "name" ||
+      name === "availability" ||
+      name === "children"
+    ) {
       continue;
     }
 

package/Source/DataSources/EntityCluster.js

@@ -76,14 +76,6 @@ function EntityCluster(options) {
   this.show = defaultValue(options.show, true);
 }
 
-function getX(point) {
-  return point.coord.x;
-}
-
-function getY(point) {
-  return point.coord.y;
-}
-
 function expandBoundingBox(bbox, pixelRange) {
   bbox.x -= pixelRange;
   bbox.y -= pixelRange;
@@ -335,153 +327,159 @@ function createDeclutterCallback(entityCluster) {
     let collection;
     let collectionIndex;
 
-    const index = new KDBush(points, getX, getY, 64, Int32Array);
+    if (points.length > 0) {
+      const index = new KDBush(points.length, 64, Uint32Array);
+      for (let p = 0; p < points.length; ++p) {
+        index.add(points[p].coord.x, points[p].coord.y);
+      }
+      index.finish();
 
-    if (currentHeight < previousHeight) {
-      length = clusters.length;
-      for (i = 0; i < length; ++i) {
-        const cluster = clusters[i];
+      if (currentHeight < previousHeight) {
+        length = clusters.length;
+        for (i = 0; i < length; ++i) {
+          const cluster = clusters[i];
 
-        if (!occluder.isPointVisible(cluster.position)) {
-          continue;
+          if (!occluder.isPointVisible(cluster.position)) {
+            continue;
+          }
+
+          const coord = Billboard._computeScreenSpacePosition(
+            Matrix4.IDENTITY,
+            cluster.position,
+            Cartesian3.ZERO,
+            Cartesian2.ZERO,
+            scene
+          );
+          if (!defined(coord)) {
+            continue;
+          }
+
+          const factor = 1.0 - currentHeight / previousHeight;
+          let width = (cluster.width = cluster.width * factor);
+          let height = (cluster.height = cluster.height * factor);
+
+          width = Math.max(width, cluster.minimumWidth);
+          height = Math.max(height, cluster.minimumHeight);
+
+          const minX = coord.x - width * 0.5;
+          const minY = coord.y - height * 0.5;
+          const maxX = coord.x + width;
+          const maxY = coord.y + height;
+
+          neighbors = index.range(minX, minY, maxX, maxY);
+          neighborLength = neighbors.length;
+          numPoints = 0;
+          ids = [];
+
+          for (j = 0; j < neighborLength; ++j) {
+            neighborIndex = neighbors[j];
+            neighborPoint = points[neighborIndex];
+            if (!neighborPoint.clustered) {
+              ++numPoints;
+
+              collection = neighborPoint.collection;
+              collectionIndex = neighborPoint.index;
+              ids.push(collection.get(collectionIndex).id);
+            }
+          }
+
+          if (numPoints >= minimumClusterSize) {
+            addCluster(cluster.position, numPoints, ids, entityCluster);
+            newClusters.push(cluster);
+
+            for (j = 0; j < neighborLength; ++j) {
+              points[neighbors[j]].clustered = true;
+            }
+          }
         }
+      }
 
-        const coord = Billboard._computeScreenSpacePosition(
-          Matrix4.IDENTITY,
-          cluster.position,
-          Cartesian3.ZERO,
-          Cartesian2.ZERO,
-          scene
-        );
-        if (!defined(coord)) {
+      length = points.length;
+      for (i = 0; i < length; ++i) {
+        const point = points[i];
+        if (point.clustered) {
           continue;
         }
 
-        const factor = 1.0 - currentHeight / previousHeight;
-        let width = (cluster.width = cluster.width * factor);
-        let height = (cluster.height = cluster.height * factor);
+        point.clustered = true;
 
-        width = Math.max(width, cluster.minimumWidth);
-        height = Math.max(height, cluster.minimumHeight);
+        collection = point.collection;
+        collectionIndex = point.index;
 
-        const minX = coord.x - width * 0.5;
-        const minY = coord.y - height * 0.5;
-        const maxX = coord.x + width;
-        const maxY = coord.y + height;
+        const item = collection.get(collectionIndex);
+        bbox = getBoundingBox(
+          item,
+          point.coord,
+          pixelRange,
+          entityCluster,
+          pointBoundinRectangleScratch
+        );
+        const totalBBox = BoundingRectangle.clone(
+          bbox,
+          totalBoundingRectangleScratch
+        );
 
-        neighbors = index.range(minX, minY, maxX, maxY);
+        neighbors = index.range(
+          bbox.x,
+          bbox.y,
+          bbox.x + bbox.width,
+          bbox.y + bbox.height
+        );
         neighborLength = neighbors.length;
-        numPoints = 0;
-        ids = [];
+
+        const clusterPosition = Cartesian3.clone(item.position);
+        numPoints = 1;
+        ids = [item.id];
 
         for (j = 0; j < neighborLength; ++j) {
           neighborIndex = neighbors[j];
           neighborPoint = points[neighborIndex];
           if (!neighborPoint.clustered) {
+            const neighborItem = neighborPoint.collection.get(
+              neighborPoint.index
+            );
+            const neighborBBox = getBoundingBox(
+              neighborItem,
+              neighborPoint.coord,
+              pixelRange,
+              entityCluster,
+              neighborBoundingRectangleScratch
+            );
+
+            Cartesian3.add(
+              neighborItem.position,
+              clusterPosition,
+              clusterPosition
+            );
+
+            BoundingRectangle.union(totalBBox, neighborBBox, totalBBox);
             ++numPoints;
 
-            collection = neighborPoint.collection;
-            collectionIndex = neighborPoint.index;
-            ids.push(collection.get(collectionIndex).id);
+            ids.push(neighborItem.id);
           }
         }
 
         if (numPoints >= minimumClusterSize) {
-          addCluster(cluster.position, numPoints, ids, entityCluster);
-          newClusters.push(cluster);
-
-          for (j = 0; j < neighborLength; ++j) {
-            points[neighbors[j]].clustered = true;
-          }
-        }
-      }
-    }
-
-    length = points.length;
-    for (i = 0; i < length; ++i) {
-      const point = points[i];
-      if (point.clustered) {
-        continue;
-      }
-
-      point.clustered = true;
-
-      collection = point.collection;
-      collectionIndex = point.index;
-
-      const item = collection.get(collectionIndex);
-      bbox = getBoundingBox(
-        item,
-        point.coord,
-        pixelRange,
-        entityCluster,
-        pointBoundinRectangleScratch
-      );
-      const totalBBox = BoundingRectangle.clone(
-        bbox,
-        totalBoundingRectangleScratch
-      );
-
-      neighbors = index.range(
-        bbox.x,
-        bbox.y,
-        bbox.x + bbox.width,
-        bbox.y + bbox.height
-      );
-      neighborLength = neighbors.length;
-
-      const clusterPosition = Cartesian3.clone(item.position);
-      numPoints = 1;
-      ids = [item.id];
-
-      for (j = 0; j < neighborLength; ++j) {
-        neighborIndex = neighbors[j];
-        neighborPoint = points[neighborIndex];
-        if (!neighborPoint.clustered) {
-          const neighborItem = neighborPoint.collection.get(
-            neighborPoint.index
-          );
-          const neighborBBox = getBoundingBox(
-            neighborItem,
-            neighborPoint.coord,
-            pixelRange,
-            entityCluster,
-            neighborBoundingRectangleScratch
-          );
-
-          Cartesian3.add(
-            neighborItem.position,
+          const position = Cartesian3.multiplyByScalar(
             clusterPosition,
+            1.0 / numPoints,
             clusterPosition
           );
+          addCluster(position, numPoints, ids, entityCluster);
+          newClusters.push({
+            position: position,
+            width: totalBBox.width,
+            height: totalBBox.height,
+            minimumWidth: bbox.width,
+            minimumHeight: bbox.height,
+          });
 
-          BoundingRectangle.union(totalBBox, neighborBBox, totalBBox);
-          ++numPoints;
-
-          ids.push(neighborItem.id);
-        }
-      }
-
-      if (numPoints >= minimumClusterSize) {
-        const position = Cartesian3.multiplyByScalar(
-          clusterPosition,
-          1.0 / numPoints,
-          clusterPosition
-        );
-        addCluster(position, numPoints, ids, entityCluster);
-        newClusters.push({
-          position: position,
-          width: totalBBox.width,
-          height: totalBBox.height,
-          minimumWidth: bbox.width,
-          minimumHeight: bbox.height,
-        });
-
-        for (j = 0; j < neighborLength; ++j) {
-          points[neighbors[j]].clustered = true;
+          for (j = 0; j < neighborLength; ++j) {
+            points[neighbors[j]].clustered = true;
+          }
+        } else {
+          addNonClusteredItem(item, entityCluster);
         }
-      } else {
-        addNonClusteredItem(item, entityCluster);
       }
     }