@cesium/engine 13.1.0 → 14.0.0

package/Source/Scene/VoxelPrimitive.js

@@ -25,6 +25,7 @@ import CustomShader from "./Model/CustomShader.js";
 import Cartographic from "../Core/Cartographic.js";
 import Ellipsoid from "../Core/Ellipsoid.js";
 import VerticalExaggeration from "../Core/VerticalExaggeration.js";
+import Cesium3DTilesetStatistics from "./Cesium3DTilesetStatistics.js";
 
 /**
  * A primitive that renders voxel data from a {@link VoxelProvider}.
@@ -70,6 +71,12 @@ function VoxelPrimitive(options) {
    */
   this._traversal = undefined;
 
+  /**
+   * @type {Cesium3DTilesetStatistics}
+   * @private
+   */
+  this._statistics = new Cesium3DTilesetStatistics();
+
   /**
    * This member is not created until the provider is ready.
    *
@@ -450,6 +457,123 @@ function VoxelPrimitive(options) {
     }
   }
 
+  /**
+   * The event fired to indicate that a tile's content was loaded.
+   * <p>
+   * This event is fired during the tileset traversal while the frame is being rendered
+   * so that updates to the tile take effect in the same frame.  Do not create or modify
+   * Cesium entities or primitives during the event listener.
+   * </p>
+   *
+   * @type {Event}
+   *
+   * @example
+   * voxelPrimitive.tileLoad.addEventListener(function() {
+   *     console.log('A tile was loaded.');
+   * });
+   */
+  this.tileLoad = new Event();
+
+  /**
+   * This event fires once for each visible tile in a frame.
+   * <p>
+   * This event is fired during the traversal while the frame is being rendered.
+   *
+   * @type {Event}
+   *
+   * @example
+   * voxelPrimitive.tileVisible.addEventListener(function() {
+   *     console.log('A tile is visible.');
+   * });
+   *
+   */
+  this.tileVisible = new Event();
+
+  /**
+   * The event fired to indicate that a tile's content failed to load.
+   *
+   * @type {Event}
+   *
+   * @example
+   * voxelPrimitive.tileFailed.addEventListener(function() {
+   *     console.log('An error occurred loading tile.');
+   * });
+   */
+  this.tileFailed = new Event();
+
+  /**
+   * The event fired to indicate that a tile's content was unloaded.
+   *
+   * @type {Event}
+   *
+   * @example
+   * voxelPrimitive.tileUnload.addEventListener(function() {
+   *     console.log('A tile was unloaded from the cache.');
+   * });
+   *
+   */
+  this.tileUnload = new Event();
+
+  /**
+   * The event fired to indicate progress of loading new tiles. This event is fired when a new tile
+   * is requested, when a requested tile is finished downloading, and when a downloaded tile has been
+   * processed and is ready to render.
+   * <p>
+   * The number of pending tile requests, <code>numberOfPendingRequests</code>, and number of tiles
+   * processing, <code>numberOfTilesProcessing</code> are passed to the event listener.
+   * </p>
+   * <p>
+   * This event is fired at the end of the frame after the scene is rendered.
+   * </p>
+   *
+   * @type {Event}
+   *
+   * @example
+   * voxelPrimitive.loadProgress.addEventListener(function(numberOfPendingRequests, numberOfTilesProcessing) {
+   *     if ((numberOfPendingRequests === 0) && (numberOfTilesProcessing === 0)) {
+   *         console.log('Finished loading');
+   *         return;
+   *     }
+   *
+   *     console.log(`Loading: requests: ${numberOfPendingRequests}, processing: ${numberOfTilesProcessing}`);
+   * });
+   */
+  this.loadProgress = new Event();
+
+  /**
+   * The event fired to indicate that all tiles that meet the screen space error this frame are loaded. The voxel
+   * primitive is completely loaded for this view.
+   * <p>
+   * This event is fired at the end of the frame after the scene is rendered.
+   * </p>
+   *
+   * @type {Event}
+   *
+   * @example
+   * voxelPrimitive.allTilesLoaded.addEventListener(function() {
+   *     console.log('All tiles are loaded');
+   * });
+   */
+  this.allTilesLoaded = new Event();
+
+  /**
+   * The event fired to indicate that all tiles that meet the screen space error this frame are loaded. This event
+   * is fired once when all tiles in the initial view are loaded.
+   * <p>
+   * This event is fired at the end of the frame after the scene is rendered.
+   * </p>
+   *
+   * @type {Event}
+   *
+   * @example
+   * voxelPrimitive.initialTilesLoaded.addEventListener(function() {
+   *     console.log('Initial tiles are loaded');
+   * });
+   *
+   * @see Cesium3DTileset#allTilesLoaded
+   */
+  this.initialTilesLoaded = new Event();
+
   // If the provider fails to initialize the primitive will fail too.
   const provider = this._provider;
   initialize(this, provider);

package/Source/Scene/VoxelProvider.js

@@ -186,6 +186,16 @@ Object.defineProperties(VoxelProvider.prototype, {
     get: DeveloperError.throwInstantiationError,
   },
 
+  /**
+   * The number of levels of detail containing available tiles in the tileset.
+   *
+   * @type {number|undefined}
+   * @readonly
+   */
+  availableLevels: {
+    get: DeveloperError.throwInstantiationError,
+  },
+
   /**
    * Gets the number of keyframes in the dataset.
    * This should not be called before {@link VoxelProvider#ready} returns true.

package/Source/Scene/VoxelTraversal.js

@@ -143,6 +143,12 @@ function VoxelTraversal(
    */
   this._binaryTreeKeyframeWeighting = new Array(keyframeCount);
 
+  /**
+   * @type {boolean}
+   * @private
+   */
+  this._initialTilesLoaded = false;
+
   const binaryTreeKeyframeWeighting = this._binaryTreeKeyframeWeighting;
   binaryTreeKeyframeWeighting[0] = 0;
   binaryTreeKeyframeWeighting[keyframeCount - 1] = 0;
@@ -316,13 +322,17 @@ VoxelTraversal.prototype.update = function (
   const timestamp1 = getTimestamp();
   generateOctree(this, sampleCount, levelBlendFactor);
   const timestamp2 = getTimestamp();
-
-  if (this._debugPrint) {
+  const checkEventListeners =
+    primitive.loadProgress.numberOfListeners > 0 ||
+    primitive.allTilesLoaded.numberOfListeners > 0 ||
+    primitive.initialTilesLoaded.numberOfListeners > 0;
+  if (this._debugPrint || checkEventListeners) {
     const loadAndUnloadTimeMs = timestamp1 - timestamp0;
     const generateOctreeTimeMs = timestamp2 - timestamp1;
     const totalTimeMs = timestamp2 - timestamp0;
-    printDebugInformation(
+    postPassesUpdate(
       this,
+      frameState,
       loadAndUnloadTimeMs,
       generateOctreeTimeMs,
       totalTimeMs,
@@ -418,6 +428,21 @@ function requestData(that, keyframeNode) {
   }
 
   const provider = that._primitive._provider;
+  const { keyframe, spatialNode } = keyframeNode;
+  if (
+    defined(provider.availableLevels) &&
+    spatialNode.level >= provider.availableLevels
+  ) {
+    return;
+  }
+
+  const requestOptions = {
+    tileLevel: spatialNode.level,
+    tileX: spatialNode.x,
+    tileY: spatialNode.y,
+    tileZ: spatialNode.z,
+    keyframe: keyframe,
+  };
 
   function postRequestSuccess(result) {
     that._simultaneousRequestCount--;
@@ -443,27 +468,25 @@ function requestData(that, keyframeNode) {
           keyframeNode.metadata[i] = data;
           // State is received only when all metadata requests have been received
           keyframeNode.state = KeyframeNode.LoadState.RECEIVED;
+          that._primitive.tileLoad.raiseEvent();
         } else {
           keyframeNode.state = KeyframeNode.LoadState.FAILED;
           break;
         }
       }
     }
+    if (keyframeNode.state === KeyframeNode.LoadState.FAILED) {
+      that._primitive.tileFailed.raiseEvent();
+    }
   }
 
   function postRequestFailure() {
     that._simultaneousRequestCount--;
     keyframeNode.state = KeyframeNode.LoadState.FAILED;
+    that._primitive.tileFailed.raiseEvent();
   }
 
-  const { keyframe, spatialNode } = keyframeNode;
-  const promise = provider.requestData({
-    tileLevel: spatialNode.level,
-    tileX: spatialNode.x,
-    tileY: spatialNode.y,
-    tileZ: spatialNode.z,
-    keyframe: keyframe,
-  });
+  const promise = provider.requestData(requestOptions);
 
   if (defined(promise)) {
     that._simultaneousRequestCount++;
@@ -471,6 +494,7 @@ function requestData(that, keyframeNode) {
     promise.then(postRequestSuccess).catch(postRequestFailure);
   } else {
     keyframeNode.state = KeyframeNode.LoadState.FAILED;
+    that._primitive.tileFailed.raiseEvent();
   }
 }
 
@@ -645,6 +669,7 @@ function loadAndUnload(that, frameState) {
         destroyedCount++;
 
         const discardNode = keyframeNodesInMegatexture[addNodeIndex];
+        that._primitive.tileUnload.raiseEvent();
         discardNode.spatialNode.destroyKeyframeNode(
           discardNode,
           that.megatextures,
@@ -703,8 +728,9 @@ function keyframePriority(previousKeyframe, keyframe, nextKeyframe, traversal) {
  *
  * @private
  */
-function printDebugInformation(
+function postPassesUpdate(
   that,
+  frameState,
   loadAndUnloadTimeMs,
   generateOctreeTimeMs,
   totalTimeMs,
@@ -758,6 +784,55 @@ function printDebugInformation(
   }
   traverseRecursive(rootNode);
 
+  const numberOfPendingRequests =
+    loadStateByCount[KeyframeNode.LoadState.RECEIVING];
+  const numberOfTilesProcessing =
+    loadStateByCount[KeyframeNode.LoadState.RECEIVED];
+
+  const progressChanged =
+    numberOfPendingRequests !==
+      that._primitive._statistics.numberOfPendingRequests ||
+    numberOfTilesProcessing !==
+      that._primitive._statistics.numberOfTilesProcessing;
+
+  if (progressChanged) {
+    frameState.afterRender.push(function () {
+      that._primitive.loadProgress.raiseEvent(
+        numberOfPendingRequests,
+        numberOfTilesProcessing,
+      );
+
+      return true;
+    });
+  }
+
+  that._primitive._statistics.numberOfPendingRequests = numberOfPendingRequests;
+  that._primitive._statistics.numberOfTilesProcessing = numberOfTilesProcessing;
+
+  const tilesLoaded =
+    numberOfPendingRequests === 0 && numberOfTilesProcessing === 0;
+
+  // Events are raised (added to the afterRender queue) here since promises
+  // may resolve outside of the update loop that then raise events, e.g.,
+  // model's readyEvent
+  if (progressChanged && tilesLoaded) {
+    frameState.afterRender.push(function () {
+      that._primitive.allTilesLoaded.raiseEvent();
+      return true;
+    });
+    if (!that._initialTilesLoaded) {
+      that._initialTilesLoaded = true;
+      frameState.afterRender.push(function () {
+        that._primitive.initialTilesLoaded.raiseEvent();
+        return true;
+      });
+    }
+  }
+
+  if (!that._debugPrint) {
+    return;
+  }
+
   const loadedKeyframeStatistics = `KEYFRAMES: ${
     loadStatesByKeyframe[KeyframeNode.LoadState.LOADED]
   }`;
@@ -892,6 +967,7 @@ function generateOctree(that, sampleCount, levelBlendFactor) {
     } else {
       // Store the leaf node information instead
       // Recursion stops here because there are no renderable children
+      that._primitive.tileVisible.raiseEvent();
       if (useLeafNodes) {
         const baseIdx = leafNodeCount * 5;
         const keyframeNode = node.renderableKeyframeNodePrevious;

package/Source/Scene/WebMapTileServiceImageryProvider.js

@@ -57,7 +57,7 @@ const defaultParameters = Object.freeze({
  * @example
  * // Example 1. USGS shaded relief tiles (KVP)
  * const shadedRelief1 = new Cesium.WebMapTileServiceImageryProvider({
- *     url : 'http://basemap.nationalmap.gov/arcgis/rest/services/USGSShadedReliefOnly/MapServer/WMTS',
+ *     url : 'https://basemap.nationalmap.gov/arcgis/rest/services/USGSShadedReliefOnly/MapServer/WMTS',
  *     layer : 'USGSShadedReliefOnly',
  *     style : 'default',
  *     format : 'image/jpeg',
@@ -71,7 +71,7 @@ const defaultParameters = Object.freeze({
  * @example
  * // Example 2. USGS shaded relief tiles (RESTful)
  * const shadedRelief2 = new Cesium.WebMapTileServiceImageryProvider({
- *     url : 'http://basemap.nationalmap.gov/arcgis/rest/services/USGSShadedReliefOnly/MapServer/WMTS/tile/1.0.0/USGSShadedReliefOnly/{Style}/{TileMatrixSet}/{TileMatrix}/{TileRow}/{TileCol}.jpg',
+ *     url : 'https://basemap.nationalmap.gov/arcgis/rest/services/USGSShadedReliefOnly/MapServer/WMTS/tile/1.0.0/USGSShadedReliefOnly/{Style}/{TileMatrixSet}/{TileMatrix}/{TileRow}/{TileCol}.jpg',
  *     layer : 'USGSShadedReliefOnly',
  *     style : 'default',
  *     format : 'image/jpeg',

package/Source/Scene/createGooglePhotorealistic3DTileset.js

@@ -1,11 +1,11 @@
 import Cesium3DTileset from "./Cesium3DTileset.js";
+import Check from "../Core/Check.js";
 import defaultValue from "../Core/defaultValue.js";
 import defined from "../Core/defined.js";
 import IonResource from "../Core/IonResource.js";
 import GoogleMaps from "../Core/GoogleMaps.js";
 import Resource from "../Core/Resource.js";
 import oneTimeWarning from "../Core/oneTimeWarning.js";
-import deprecationWarning from "../Core/deprecationWarning.js";
 
 /**
  * Creates a {@link Cesium3DTileset} instance for the Google Photorealistic 3D
@@ -73,13 +73,10 @@ async function createGooglePhotorealistic3DTileset(apiOptions, tilesetOptions) {
   );
 
   apiOptions = defaultValue(apiOptions, defaultValue.EMPTY_OBJECT);
-  if (typeof apiOptions === "string") {
-    deprecationWarning(
-      "createGooglePhotorealistic3DTileset(key)",
-      "createGooglePhotorealistic3DTileset(key) has been deprecated.   It is replaced by createGooglePhotorealistic3DTileset({key}).  It will be removed in Cesium 1.126.",
-    );
-    apiOptions = { key: apiOptions };
-  }
+  //>>includeStart('debug', pragmas.debug);
+  Check.typeOf.object("apiOptions", apiOptions);
+  //>>includeEnd('debug');
+
   if (!apiOptions.onlyUsingWithGoogleGeocoder) {
     oneTimeWarning(
       "google-tiles-with-google-geocoder",

package/Source/Shaders/PolylineCommon.glsl

@@ -160,7 +160,7 @@ vec4 getPolylineWindowCoordinatesEC(vec4 positionEC, vec4 prevEC, vec4 nextEC, f
         vec2 u = -thisSegmentForwardWC;
         vec2 v = leftWC;
         float sinAngle = abs(u.x * v.y - u.y * v.x);
-        expandWidth = clamp(expandWidth / sinAngle, 0.0, width * 2.0);
+        expandWidth = clamp(expandWidth / sinAngle, 0.0, width * 0.5);
     }
 
     vec2 offset = leftWC * expandDirection * expandWidth * czm_pixelRatio;

package/Source/Shaders/PolylineCommon.js

@@ -161,7 +161,7 @@ vec4 getPolylineWindowCoordinatesEC(vec4 positionEC, vec4 prevEC, vec4 nextEC, f
         vec2 u = -thisSegmentForwardWC;\n\
         vec2 v = leftWC;\n\
         float sinAngle = abs(u.x * v.y - u.y * v.x);\n\
-        expandWidth = clamp(expandWidth / sinAngle, 0.0, width * 2.0);\n\
+        expandWidth = clamp(expandWidth / sinAngle, 0.0, width * 0.5);\n\
     }\n\
 \n\
     vec2 offset = leftWC * expandDirection * expandWidth * czm_pixelRatio;\n\

package/Source/Widget/CesiumWidget.js

@@ -1134,8 +1134,6 @@ CesiumWidget.prototype._updateCanAnimate = function (isUpdated) {
   this._clock.canAnimate = isUpdated;
 };
 
-const boundingSphereScratch = new BoundingSphere();
-
 /**
  * @private
  */
@@ -1148,15 +1146,15 @@ CesiumWidget.prototype._onTick = function (clock) {
   }
 
   const entityView = this._entityView;
-  if (defined(entityView)) {
+  if (defined(entityView) && defined(entityView.boundingSphere)) {
     const trackedEntity = this._trackedEntity;
     const trackedState = this._dataSourceDisplay.getBoundingSphere(
       trackedEntity,
-      true,
-      boundingSphereScratch,
+      false,
+      entityView.boundingSphere,
     );
     if (trackedState === BoundingSphereState.DONE) {
-      entityView.update(time, boundingSphereScratch);
+      entityView.update(time, entityView.boundingSphere);
     }
   }
 };
@@ -1414,6 +1412,8 @@ CesiumWidget.prototype._postRender = function () {
   updateTrackedEntity(this);
 };
 
+const zoomTargetBoundingSphereScratch = new BoundingSphere();
+
 function updateZoomTarget(widget) {
   const target = widget._zoomTarget;
   if (!defined(target) || widget.scene.mode === SceneMode.MORPHING) {
@@ -1511,13 +1511,15 @@ function updateZoomTarget(widget) {
     const state = widget._dataSourceDisplay.getBoundingSphere(
       entities[i],
       false,
-      boundingSphereScratch,
+      zoomTargetBoundingSphereScratch,
     );
 
     if (state === BoundingSphereState.PENDING) {
       return;
     } else if (state !== BoundingSphereState.FAILED) {
-      boundingSpheres.push(BoundingSphere.clone(boundingSphereScratch));
+      boundingSpheres.push(
+        BoundingSphere.clone(zoomTargetBoundingSphereScratch),
+      );
     }
   }
 
@@ -1552,6 +1554,8 @@ function updateZoomTarget(widget) {
   }
 }
 
+const trackedEntityBoundingSphereScratch = new BoundingSphere();
+
 function updateTrackedEntity(widget) {
   if (!widget._needTrackedEntityUpdate) {
     return;
@@ -1577,7 +1581,7 @@ function updateTrackedEntity(widget) {
   const state = widget._dataSourceDisplay.getBoundingSphere(
     trackedEntity,
     false,
-    boundingSphereScratch,
+    trackedEntityBoundingSphereScratch,
   );
   if (state === BoundingSphereState.PENDING) {
     return;
@@ -1599,7 +1603,9 @@ function updateTrackedEntity(widget) {
   }
 
   const bs =
-    state !== BoundingSphereState.FAILED ? boundingSphereScratch : undefined;
+    state !== BoundingSphereState.FAILED
+      ? trackedEntityBoundingSphereScratch
+      : undefined;
   widget._entityView = new EntityView(trackedEntity, scene, scene.ellipsoid);
   widget._entityView.update(currentTime, bs);
   widget._needTrackedEntityUpdate = false;

package/Source/Workers/decodeDraco.js

@@ -295,11 +295,11 @@ function decodePointCloud(parameters) {
 function decodePrimitive(parameters) {
   const dracoDecoder = new draco.Decoder();
 
-  // Skip all parameter types except generic
-  const attributesToSkip = ["POSITION", "NORMAL", "COLOR", "TEX_COORD"];
   if (parameters.dequantizeInShader) {
-    for (let i = 0; i < attributesToSkip.length; ++i) {
-      dracoDecoder.SkipAttributeTransform(draco[attributesToSkip[i]]);
+    for (let i = 0; i < parameters.attributesToSkipTransform.length; ++i) {
+      dracoDecoder.SkipAttributeTransform(
+        draco[parameters.attributesToSkipTransform[i]],
+      );
     }
   }