@cesium/engine 2.1.0 → 2.2.0

package/Source/Scene/ClassificationPrimitive.js

@@ -2,6 +2,7 @@ import ColorGeometryInstanceAttribute from "../Core/ColorGeometryInstanceAttribu
 import combine from "../Core/combine.js";
 import defaultValue from "../Core/defaultValue.js";
 import defined from "../Core/defined.js";
+import deprecationWarning from "../Core/deprecationWarning.js";
 import destroyObject from "../Core/destroyObject.js";
 import DeveloperError from "../Core/DeveloperError.js";
 import GeometryInstance from "../Core/GeometryInstance.js";
@@ -164,6 +165,7 @@ function ClassificationPrimitive(options) {
   this._ready = false;
 
   const classificationPrimitive = this;
+  // This is here for backwards compatibility. This promise wrapper can be removed once readyPromise is removed.
   this._readyPromise = new Promise((resolve, reject) => {
     classificationPrimitive._completeLoad = () => {
       if (this._ready) {
@@ -340,9 +342,14 @@ Object.defineProperties(ClassificationPrimitive.prototype, {
    * @memberof ClassificationPrimitive.prototype
    * @type {Promise<ClassificationPrimitive>}
    * @readonly
+   * @deprecated
    */
   readyPromise: {
     get: function () {
+      deprecationWarning(
+        "ClassificationPrimitive.readyPromise",
+        "ClassificationPrimitive.readyPromise was deprecated in CesiumJS 1.104. It will be removed in 1.107. Wait for ClassificationPrimitive.ready to return true instead."
+      );
       return this._readyPromise;
     },
   },

package/Source/Scene/Composite3DTileContent.js

@@ -1,5 +1,6 @@
 import defaultValue from "../Core/defaultValue.js";
 import defined from "../Core/defined.js";
+import deprecationWarning from "../Core/deprecationWarning.js";
 import destroyObject from "../Core/destroyObject.js";
 import getMagic from "../Core/getMagic.js";
 import RuntimeError from "../Core/RuntimeError.js";
@@ -17,23 +18,24 @@ import RuntimeError from "../Core/RuntimeError.js";
  *
  * @private
  */
-function Composite3DTileContent(
-  tileset,
-  tile,
-  resource,
-  arrayBuffer,
-  byteOffset,
-  factory
-) {
+function Composite3DTileContent(tileset, tile, resource, contents) {
   this._tileset = tileset;
   this._tile = tile;
   this._resource = resource;
-  this._contents = [];
+
+  if (!defined(contents)) {
+    contents = [];
+  }
+  this._contents = contents;
 
   this._metadata = undefined;
   this._group = undefined;
+  this._ready = false;
 
-  this._readyPromise = initialize(this, arrayBuffer, byteOffset, factory);
+  this._resolveContent = undefined;
+  this._readyPromise = new Promise((resolve) => {
+    this._resolveContent = resolve;
+  });
 }
 
 Object.defineProperties(Composite3DTileContent.prototype, {
@@ -130,8 +132,37 @@ Object.defineProperties(Composite3DTileContent.prototype, {
     },
   },
 
+  /**
+   * Returns true when the tile's content is ready to render; otherwise false
+   *
+   * @memberof Composite3DTileContent.prototype
+   *
+   * @type {boolean}
+   * @readonly
+   * @private
+   */
+  ready: {
+    get: function () {
+      return this._ready;
+    },
+  },
+
+  /**
+   * Gets the promise that will be resolved when the tile's content is ready to render.
+   *
+   * @memberof Composite3DTileContent.prototype
+   *
+   * @type {Promise<Composite3DTileContent>}
+   * @readonly
+   * @deprecated
+   * @private
+   */
   readyPromise: {
     get: function () {
+      deprecationWarning(
+        "Composite3DTileContent.readyPromise",
+        "Composite3DTileContent.readyPromise was deprecated in CesiumJS 1.104. It will be removed in 1.107. Wait for Composite3DTileContent.ready to return true instead."
+      );
       return this._readyPromise;
     },
   },
@@ -210,7 +241,14 @@ Object.defineProperties(Composite3DTileContent.prototype, {
 
 const sizeOfUint32 = Uint32Array.BYTES_PER_ELEMENT;
 
-function initialize(content, arrayBuffer, byteOffset, factory) {
+Composite3DTileContent.fromTileType = async function (
+  tileset,
+  tile,
+  resource,
+  arrayBuffer,
+  byteOffset,
+  factory
+) {
   byteOffset = defaultValue(byteOffset, 0);
 
   const uint8Array = new Uint8Array(arrayBuffer);
@@ -231,14 +269,11 @@ function initialize(content, arrayBuffer, byteOffset, factory) {
   const tilesLength = view.getUint32(byteOffset, true);
   byteOffset += sizeOfUint32;
 
-  const contentPromises = [];
-
   // For caching purposes, models within the composite tile must be
   // distinguished. To do this, add a query parameter ?compositeIndex=i.
   // Since composite tiles may contain other composite tiles, check for an
   // existing prefix and separate them with underscores. e.g.
   // ?compositeIndex=0_1_1
-  const resource = content._resource;
   let prefix = resource.queryParameters.compositeIndex;
   if (defined(prefix)) {
     // We'll be adding another value at the end, so add an underscore.
@@ -248,6 +283,8 @@ function initialize(content, arrayBuffer, byteOffset, factory) {
     prefix = "";
   }
 
+  const promises = [];
+  promises.length = tilesLength;
   for (let i = 0; i < tilesLength; ++i) {
     const tileType = getMagic(uint8Array, byteOffset);
 
@@ -265,15 +302,9 @@ function initialize(content, arrayBuffer, byteOffset, factory) {
     });
 
     if (defined(contentFactory)) {
-      const innerContent = contentFactory(
-        content._tileset,
-        content._tile,
-        childResource,
-        arrayBuffer,
-        byteOffset
+      promises[i] = Promise.resolve(
+        contentFactory(tileset, tile, childResource, arrayBuffer, byteOffset)
       );
-      content._contents.push(innerContent);
-      contentPromises.push(innerContent.readyPromise);
     } else {
       throw new RuntimeError(
         `Unknown tile content type, ${tileType}, inside Composite tile`
@@ -283,10 +314,15 @@ function initialize(content, arrayBuffer, byteOffset, factory) {
     byteOffset += tileByteLength;
   }
 
-  return Promise.all(contentPromises).then(function () {
-    return content;
-  });
-}
+  const innerContents = await Promise.all(promises);
+  const content = new Composite3DTileContent(
+    tileset,
+    tile,
+    resource,
+    innerContents
+  );
+  return content;
+};
 
 /**
  * Part of the {@link Cesium3DTileContent} interface.  <code>Composite3DTileContent</code>
@@ -326,8 +362,15 @@ Composite3DTileContent.prototype.applyStyle = function (style) {
 Composite3DTileContent.prototype.update = function (tileset, frameState) {
   const contents = this._contents;
   const length = contents.length;
+  let ready = true;
   for (let i = 0; i < length; ++i) {
     contents[i].update(tileset, frameState);
+    ready = ready && contents[i].ready;
+  }
+
+  if (!this._ready && ready) {
+    this._ready = true;
+    this._resolveContent(this);
   }
 };
 

package/Source/Scene/CreditDisplay.js

@@ -174,7 +174,7 @@ function addStyle(selector, styles) {
   return style;
 }
 
-function appendCss() {
+function appendCss(container) {
   let style = "";
   style += addStyle(".cesium-credit-lightbox-overlay", {
     display: "none",
@@ -270,10 +270,26 @@ function appendCss() {
     }
   );
 
-  const head = document.head;
+  function getShadowRoot(container) {
+    if (container.shadowRoot) {
+      return container.shadowRoot;
+    }
+    if (container.getRootNode) {
+      const root = container.getRootNode();
+      if (root instanceof ShadowRoot) {
+        return root;
+      }
+    }
+    return undefined;
+  }
+
+  const shadowRootOrDocumentHead = defaultValue(
+    getShadowRoot(container),
+    document.head
+  );
   const css = document.createElement("style");
   css.innerHTML = style;
-  head.insertBefore(css, head.firstChild);
+  shadowRootOrDocumentHead.appendChild(css);
 }
 
 /**
@@ -343,7 +359,7 @@ function CreditDisplay(container, delimiter, viewport) {
   expandLink.textContent = "Data attribution";
   container.appendChild(expandLink);
 
-  appendCss();
+  appendCss(container);
   const cesiumCredit = Credit.clone(CreditDisplay.cesiumCredit);
 
   this._delimiter = defaultValue(delimiter, " • ");

package/Source/Scene/DepthPlane.js

@@ -125,7 +125,7 @@ DepthPlane.prototype.update = function (frameState) {
 
   const context = frameState.context;
 
-  // Allow offsetting the ellipsoid radius to address rendering artefacts below ellipsoid zero elevation.
+  // Allow offsetting the ellipsoid radius to address rendering artifacts below ellipsoid zero elevation.
   const radii = frameState.mapProjection.ellipsoid.radii;
   const ellipsoid = new Ellipsoid(
     radii.x + this._ellipsoidOffset,

package/Source/Scene/Empty3DTileContent.js

@@ -1,3 +1,4 @@
+import deprecationWarning from "../Core/deprecationWarning.js";
 import destroyObject from "../Core/destroyObject.js";
 import DeveloperError from "../Core/DeveloperError.js";
 
@@ -64,9 +65,38 @@ Object.defineProperties(Empty3DTileContent.prototype, {
     },
   },
 
+  /**
+   * Returns true when the tile's content is ready to render; otherwise false
+   *
+   * @memberof Empty3DTileContent.prototype
+   *
+   * @type {boolean}
+   * @readonly
+   * @private
+   */
+  ready: {
+    get: function () {
+      return true;
+    },
+  },
+
+  /**
+   * Gets the promise that will be resolved when the tile's content is ready to render.
+   *
+   * @memberof Empty3DTileContent.prototype
+   *
+   * @type {Promise<Empty3DTileContent>}
+   * @readonly
+   * @deprecated
+   * @private
+   */
   readyPromise: {
     get: function () {
-      return undefined;
+      deprecationWarning(
+        "Empty3DTileContent.readyPromise",
+        "Empty3DTileContent.readyPromise was deprecated in CesiumJS 1.104. It will be removed in 1.107. Wait for Empty3DTileContent.ready to return true instead."
+      );
+      return Promise.resolve(this);
     },
   },
 

package/Source/Scene/Geometry3DTileContent.js

@@ -1,6 +1,7 @@
 import Cartesian3 from "../Core/Cartesian3.js";
 import defaultValue from "../Core/defaultValue.js";
 import defined from "../Core/defined.js";
+import deprecationWarning from "../Core/deprecationWarning.js";
 import destroyObject from "../Core/destroyObject.js";
 import DeveloperError from "../Core/DeveloperError.js";
 import getJsonFromTypedArray from "../Core/getJsonFromTypedArray.js";
@@ -42,7 +43,15 @@ function Geometry3DTileContent(
   this.featurePropertiesDirty = false;
   this._group = undefined;
 
-  this._readyPromise = initialize(this, arrayBuffer, byteOffset);
+  this._ready = false;
+
+  // This is for backwards compatibility. It can be removed once readyPromise is removed.
+  this._resolveContent = undefined;
+  this._readyPromise = new Promise((resolve) => {
+    this._resolveContent = resolve;
+  });
+
+  initialize(this, arrayBuffer, byteOffset);
 }
 
 Object.defineProperties(Geometry3DTileContent.prototype, {
@@ -96,8 +105,37 @@ Object.defineProperties(Geometry3DTileContent.prototype, {
     },
   },
 
+  /**
+   * Returns true when the tile's content is ready to render; otherwise false
+   *
+   * @memberof Geometry3DTileContent.prototype
+   *
+   * @type {boolean}
+   * @readonly
+   * @private
+   */
+  ready: {
+    get: function () {
+      return this._ready;
+    },
+  },
+
+  /**
+   * Gets the promise that will be resolved when the tile's content is ready to render.
+   *
+   * @memberof Geometry3DTileContent.prototype
+   *
+   * @type {Promise<Geometry3DTileContent>}
+   * @readonly
+   * @deprecated
+   * @private
+   */
   readyPromise: {
     get: function () {
+      deprecationWarning(
+        "Geometry3DTileContent.readyPromise",
+        "Geometry3DTileContent.readyPromise was deprecated in CesiumJS 1.104. It will be removed in 1.107. Wait for Geometry3DTileContent.ready to return true instead."
+      );
       return this._readyPromise;
     },
   },
@@ -224,7 +262,7 @@ function getBatchIds(featureTableJson, featureTableBinary) {
 
   if (atLeastOneDefined && atLeastOneUndefined) {
     throw new RuntimeError(
-      "If one group of batch ids is defined, then all batch ids must be defined."
+      "If one group of batch ids is defined, then all batch ids must be defined"
     );
   }
 
@@ -290,7 +328,8 @@ function initialize(content, arrayBuffer, byteOffset) {
   byteOffset += sizeOfUint32;
 
   if (byteLength === 0) {
-    content._readyPromise.resolve(content);
+    content._ready = true;
+    content._resolveContent(content);
     return;
   }
 
@@ -451,9 +490,7 @@ function initialize(content, arrayBuffer, byteOffset) {
       boundingVolume: content.tile.boundingVolume.boundingVolume,
     });
 
-    return content._geometries.readyPromise.then(function () {
-      return content;
-    });
+    return content;
   }
 
   return Promise.resolve(content);
@@ -509,8 +546,11 @@ Geometry3DTileContent.prototype.update = function (tileset, frameState) {
     this._geometries.debugWireframe = this._tileset.debugWireframe;
     this._geometries.update(frameState);
   }
-  if (defined(this._batchTable) && this._geometries._ready) {
+
+  if (defined(this._batchTable) && this._geometries.ready) {
     this._batchTable.update(tileset, frameState);
+    this._ready = true;
+    this._resolveContent(this);
   }
 };
 

package/Source/Scene/Globe.js

@@ -436,6 +436,7 @@ Object.defineProperties(Globe.prototype, {
         return true;
       }
       return (
+        // ready is deprecated. This is here for backwards compatibility
         this._surface.tileProvider.ready &&
         this._surface._tileLoadQueueHigh.length === 0 &&
         this._surface._tileLoadQueueMedium.length === 0 &&
@@ -984,7 +985,10 @@ Globe.prototype.beginFrame = function (frameState) {
   const terrainProvider = this.terrainProvider;
   const hasWaterMask =
     this.showWaterEffect &&
-    terrainProvider.ready &&
+    defined(terrainProvider) &&
+    terrainProvider.hasWaterMask &&
+    // ready is deprecated; This is here for backwards compatibility
+    terrainProvider._ready &&
     terrainProvider.hasWaterMask;
 
   if (hasWaterMask && this._oceanNormalMapResourceDirty) {

package/Source/Scene/GlobeSurfaceTile.js

@@ -345,7 +345,8 @@ GlobeSurfaceTile.prototype.processImagery = function (
 
     if (tileImagery.loadingImagery.state === ImageryState.PLACEHOLDER) {
       const imageryLayer = tileImagery.loadingImagery.imageryLayer;
-      if (imageryLayer.imageryProvider.ready) {
+      // ImageryProvider.ready is deprecated. This is here for backwards compatibility
+      if (imageryLayer.ready && imageryLayer.imageryProvider._ready) {
         // Remove the placeholder and add the actual skeletons (if any)
         // at the same position.  Then continue the loop at the same index.
         tileImagery.freeResources();

package/Source/Scene/GlobeSurfaceTileProvider.js

@@ -127,19 +127,19 @@ function GlobeSurfaceTileProvider(options) {
 
   this._errorEvent = new Event();
 
-  this._imageryLayers.layerAdded.addEventListener(
+  this._removeLayerAddedListener = this._imageryLayers.layerAdded.addEventListener(
     GlobeSurfaceTileProvider.prototype._onLayerAdded,
     this
   );
-  this._imageryLayers.layerRemoved.addEventListener(
+  this._removeLayerRemovedListener = this._imageryLayers.layerRemoved.addEventListener(
     GlobeSurfaceTileProvider.prototype._onLayerRemoved,
     this
   );
-  this._imageryLayers.layerMoved.addEventListener(
+  this._removeLayerMovedListener = this._imageryLayers.layerMoved.addEventListener(
     GlobeSurfaceTileProvider.prototype._onLayerMoved,
     this
   );
-  this._imageryLayers.layerShownOrHidden.addEventListener(
+  this._removeLayerShownListener = this._imageryLayers.layerShownOrHidden.addEventListener(
     GlobeSurfaceTileProvider.prototype._onLayerShownOrHidden,
     this
   );
@@ -233,20 +233,24 @@ Object.defineProperties(GlobeSurfaceTileProvider.prototype, {
    * Gets a value indicating whether or not the provider is ready for use.
    * @memberof GlobeSurfaceTileProvider.prototype
    * @type {boolean}
+   * @deprecated
    */
   ready: {
     get: function () {
       return (
-        this._terrainProvider.ready &&
+        defined(this._terrainProvider) &&
+        // TerrainProvider.ready is deprecated; This is here for backwards compatibility
+        this._terrainProvider._ready &&
         (this._imageryLayers.length === 0 ||
-          this._imageryLayers.get(0).imageryProvider.ready)
+          // ImageryProvider.ready is deprecated; This is here for backwards compatibility
+          (this._imageryLayers.get(0).ready &&
+            this._imageryLayers.get(0).imageryProvider._ready))
       );
     },
   },
 
   /**
-   * Gets the tiling scheme used by the provider.  This property should
-   * not be accessed before {@link GlobeSurfaceTileProvider#ready} returns true.
+   * Gets the tiling scheme used by the provider.
    * @memberof GlobeSurfaceTileProvider.prototype
    * @type {TilingScheme}
    */
@@ -294,12 +298,6 @@ Object.defineProperties(GlobeSurfaceTileProvider.prototype, {
         return;
       }
 
-      //>>includeStart('debug', pragmas.debug);
-      if (!defined(terrainProvider)) {
-        throw new DeveloperError("terrainProvider is required.");
-      }
-      //>>includeEnd('debug');
-
       this._terrainProvider = terrainProvider;
 
       if (defined(this._quadtree)) {
@@ -349,7 +347,9 @@ GlobeSurfaceTileProvider.prototype.update = function (frameState) {
 function updateCredits(surface, frameState) {
   const creditDisplay = frameState.creditDisplay;
   if (
-    surface._terrainProvider.ready &&
+    defined(surface._terrainProvider) &&
+    // ready is deprecated; This is here for backwards compatibility
+    surface._terrainProvider._ready &&
     defined(surface._terrainProvider.credit)
   ) {
     creditDisplay.addCredit(surface._terrainProvider.credit);
@@ -357,9 +357,14 @@ function updateCredits(surface, frameState) {
 
   const imageryLayers = surface._imageryLayers;
   for (let i = 0, len = imageryLayers.length; i < len; ++i) {
-    const imageryProvider = imageryLayers.get(i).imageryProvider;
-    if (imageryProvider.ready && defined(imageryProvider.credit)) {
-      creditDisplay.addCredit(imageryProvider.credit);
+    const layer = imageryLayers.get(i);
+    // ImageryProvider.ready is deprecated; This is here for backwards compatibility
+    if (
+      layer.ready &&
+      layer.imageryProvider._ready &&
+      defined(layer.imageryProvider.credit)
+    ) {
+      creditDisplay.addCredit(layer.imageryProvider.credit);
     }
   }
 }
@@ -562,8 +567,7 @@ GlobeSurfaceTileProvider.prototype.cancelReprojections = function () {
 };
 
 /**
- * Gets the maximum geometric error allowed in a tile at a given level, in meters.  This function should not be
- * called before {@link GlobeSurfaceTileProvider#ready} returns true.
+ * Gets the maximum geometric error allowed in a tile at a given level, in meters.
  *
  * @param {number} level The tile level for which to get the maximum geometric error.
  * @returns {number} The maximum geometric error in meters.
@@ -571,18 +575,19 @@ GlobeSurfaceTileProvider.prototype.cancelReprojections = function () {
 GlobeSurfaceTileProvider.prototype.getLevelMaximumGeometricError = function (
   level
 ) {
+  if (!defined(this._terrainProvider)) {
+    return 0;
+  }
+
   return this._terrainProvider.getLevelMaximumGeometricError(level);
 };
 
 /**
  * Loads, or continues loading, a given tile.  This function will continue to be called
- * until {@link QuadtreeTile#state} is no longer {@link QuadtreeTileLoadState#LOADING}.  This function should
- * not be called before {@link GlobeSurfaceTileProvider#ready} returns true.
+ * until {@link QuadtreeTile#state} is no longer {@link QuadtreeTileLoadState#LOADING}.
  *
  * @param {FrameState} frameState The frame state.
  * @param {QuadtreeTile} tile The tile to load.
- *
- * @exception {DeveloperError} <code>loadTile</code> must not be called before the tile provider is ready.
  */
 GlobeSurfaceTileProvider.prototype.loadTile = function (frameState, tile) {
   // We don't want to load imagery until we're certain that the terrain tiles are actually visible.
@@ -1384,6 +1389,14 @@ GlobeSurfaceTileProvider.prototype.isDestroyed = function () {
 GlobeSurfaceTileProvider.prototype.destroy = function () {
   this._tileProvider = this._tileProvider && this._tileProvider.destroy();
   this._clippingPlanes = this._clippingPlanes && this._clippingPlanes.destroy();
+  this._removeLayerAddedListener =
+    this._removeLayerAddedListener && this._removeLayerAddedListener();
+  this._removeLayerRemovedListener =
+    this._removeLayerRemovedListener && this._removeLayerRemovedListener();
+  this._removeLayerMovedListener =
+    this._removeLayerMovedListener && this._removeLayerMovedListener();
+  this._removeLayerShownListener =
+    this._removeLayerShownListener && this._removeLayerShownListener();
 
   return destroyObject(this);
 };
@@ -1436,13 +1449,16 @@ function getTileReadyCallback(tileImageriesToFree, layer, terrainProvider) {
 }
 
 GlobeSurfaceTileProvider.prototype._onLayerAdded = function (layer, index) {
+  if (this.isDestroyed()) {
+    return;
+  }
+
   if (layer.show) {
     const terrainProvider = this._terrainProvider;
 
     const that = this;
-    const imageryProvider = layer.imageryProvider;
     const tileImageryUpdatedEvent = this._imageryLayersUpdatedEvent;
-    imageryProvider._reload = function () {
+    const reloadFunction = function () {
       // Clear the layer's cache
       layer._imageryCache = {};
 
@@ -1504,6 +1520,11 @@ GlobeSurfaceTileProvider.prototype._onLayerAdded = function (layer, index) {
       });
     };
 
+    if (layer.ready) {
+      const imageryProvider = layer.imageryProvider;
+      imageryProvider._reload = reloadFunction;
+    }
+
     // create TileImageries for this layer for all previously loaded tiles
     this._quadtree.forEachLoadedTile(function (tile) {
       if (layer._createTileImagerySkeletons(tile, terrainProvider)) {
@@ -2124,7 +2145,9 @@ function addDrawCommandsForTile(tileProvider, tile, frameState) {
   const oceanNormalMap = tileProvider.oceanNormalMap;
   const showOceanWaves = showReflectiveOcean && defined(oceanNormalMap);
   const hasVertexNormals =
-    tileProvider.terrainProvider.ready &&
+    defined(tileProvider.terrainProvider) &&
+    // ready is deprecated; This is here for backwards compatibility
+    tileProvider.terrainProvider._ready &&
     tileProvider.terrainProvider.hasVertexNormals;
   const enableFog =
     frameState.fog.enabled && frameState.fog.renderable && !cameraUnderground;