@cesium/engine 2.0.0 → 2.2.0

package/Source/Scene/Vector3DTileBatch.js

@@ -4,23 +4,23 @@
  * @alias Vector3DTileBatch
  * @constructor
  *
- * @param {Object} options An object with the following properties:
- * @param {Number} options.offset The offset of the batch into the indices buffer.
- * @param {Number} options.count The number of indices in the batch.
+ * @param {object} options An object with the following properties:
+ * @param {number} options.offset The offset of the batch into the indices buffer.
+ * @param {number} options.count The number of indices in the batch.
  * @param {Color} options.color The color of the geometry in the batch.
- * @param {Number[]} options.batchIds An array where each element is the batch id of the geometry in the batch.
+ * @param {number[]} options.batchIds An array where each element is the batch id of the geometry in the batch.
  *
  * @private
  */
 function Vector3DTileBatch(options) {
   /**
    * The offset of the batch into the indices buffer.
-   * @type {Number}
+   * @type {number}
    */
   this.offset = options.offset;
   /**
    * The number of indices in the batch.
-   * @type {Number}
+   * @type {number}
    */
   this.count = options.count;
   /**
@@ -30,7 +30,7 @@ function Vector3DTileBatch(options) {
   this.color = options.color;
   /**
    * An array where each element is the batch id of the geometry in the batch.
-   * @type {Number[]}
+   * @type {number[]}
    */
   this.batchIds = options.batchIds;
 }

package/Source/Scene/Vector3DTileClampedPolylines.js

@@ -39,18 +39,18 @@ import Vector3DTilePolylines from "./Vector3DTilePolylines.js";
  * @alias Vector3DTileClampedPolylines
  * @constructor
  *
- * @param {Object} options An object with following properties:
+ * @param {object} options An object with following properties:
  * @param {Uint16Array} options.positions The positions of the polylines
  * @param {Uint32Array} options.counts The number or positions in the each polyline.
  * @param {Uint16Array} options.widths The width of each polyline.
- * @param {Number} options.minimumHeight The minimum height of the tile's region.
- * @param {Number} options.maximumHeight The maximum height of the tile's region.
+ * @param {number} options.minimumHeight The minimum height of the tile's region.
+ * @param {number} options.maximumHeight The maximum height of the tile's region.
  * @param {Rectangle} options.rectangle The rectangle containing the tile.
  * @param {Cartesian3} [options.center=Cartesian3.ZERO] The RTC center.
  * @param {Cesium3DTileBatchTable} options.batchTable The batch table for the tile containing the batched polylines.
  * @param {Uint16Array} options.batchIds The batch ids for each polyline.
  * @param {ClassificationType} options.classificationType The classification type.
- * @param {Boolean} options.keepDecodedPositions Whether to keep decoded positions in memory.
+ * @param {boolean} options.keepDecodedPositions Whether to keep decoded positions in memory.
  *
  * @private
  */
@@ -112,9 +112,8 @@ function Vector3DTileClampedPolylines(options) {
   this._geometryByteLength = 0;
 
   this._ready = false;
-  this._update = function (polylines, frameState) {};
-  this._readyPromise = initialize(this);
-  this._verticesPromise = undefined;
+  this._promise = undefined;
+  this._error = undefined;
 }
 
 Object.defineProperties(Vector3DTileClampedPolylines.prototype, {
@@ -123,7 +122,7 @@ Object.defineProperties(Vector3DTileClampedPolylines.prototype, {
    *
    * @memberof Vector3DTileClampedPolylines.prototype
    *
-   * @type {Number}
+   * @type {number}
    * @readonly
    */
   trianglesLength: {
@@ -137,7 +136,7 @@ Object.defineProperties(Vector3DTileClampedPolylines.prototype, {
    *
    * @memberof Vector3DTileClampedPolylines.prototype
    *
-   * @type {Number}
+   * @type {number}
    * @readonly
    */
   geometryByteLength: {
@@ -147,14 +146,14 @@ Object.defineProperties(Vector3DTileClampedPolylines.prototype, {
   },
 
   /**
-   * Gets a promise that resolves when the primitive is ready to render.
+   * Returns true when the primitive is ready to render.
    * @memberof Vector3DTileClampedPolylines.prototype
-   * @type {Promise}
+   * @type {boolean}
    * @readonly
    */
-  readyPromise: {
+  ready: {
     get: function () {
-      return this._readyPromise;
+      return this._ready;
     },
   },
 });
@@ -222,51 +221,55 @@ function createVertexArray(polylines, context) {
     return;
   }
 
-  if (!defined(polylines._verticesPromise)) {
-    let positions = polylines._positions;
-    let widths = polylines._widths;
-    let counts = polylines._counts;
-    let batchIds = polylines._transferrableBatchIds;
+  let positions = polylines._positions;
+  let widths = polylines._widths;
+  let counts = polylines._counts;
+  let batchIds = polylines._transferrableBatchIds;
 
-    let packedBuffer = polylines._packedBuffer;
+  let packedBuffer = polylines._packedBuffer;
 
-    if (!defined(packedBuffer)) {
-      // Copy because they may be the views on the same buffer.
-      positions = polylines._positions = positions.slice();
-      widths = polylines._widths = widths.slice();
-      counts = polylines._counts = counts.slice();
+  if (!defined(packedBuffer)) {
+    // Copy because they may be the views on the same buffer.
+    positions = polylines._positions = positions.slice();
+    widths = polylines._widths = widths.slice();
+    counts = polylines._counts = counts.slice();
 
-      batchIds = polylines._transferrableBatchIds = polylines._batchIds.slice();
+    batchIds = polylines._transferrableBatchIds = polylines._batchIds.slice();
 
-      packedBuffer = polylines._packedBuffer = packBuffer(polylines);
-    }
+    packedBuffer = polylines._packedBuffer = packBuffer(polylines);
+  }
 
-    const transferrableObjects = [
-      positions.buffer,
-      widths.buffer,
-      counts.buffer,
-      batchIds.buffer,
-      packedBuffer.buffer,
-    ];
-    const parameters = {
-      positions: positions.buffer,
-      widths: widths.buffer,
-      counts: counts.buffer,
-      batchIds: batchIds.buffer,
-      packedBuffer: packedBuffer.buffer,
-      keepDecodedPositions: polylines._keepDecodedPositions,
-    };
-
-    const verticesPromise = (polylines._verticesPromise = createVerticesTaskProcessor.scheduleTask(
-      parameters,
-      transferrableObjects
-    ));
-    if (!defined(verticesPromise)) {
-      // Postponed
-      return;
-    }
+  const transferrableObjects = [
+    positions.buffer,
+    widths.buffer,
+    counts.buffer,
+    batchIds.buffer,
+    packedBuffer.buffer,
+  ];
+  const parameters = {
+    positions: positions.buffer,
+    widths: widths.buffer,
+    counts: counts.buffer,
+    batchIds: batchIds.buffer,
+    packedBuffer: packedBuffer.buffer,
+    keepDecodedPositions: polylines._keepDecodedPositions,
+  };
+
+  const verticesPromise = createVerticesTaskProcessor.scheduleTask(
+    parameters,
+    transferrableObjects
+  );
+  if (!defined(verticesPromise)) {
+    // Postponed
+    return;
+  }
+
+  return verticesPromise
+    .then(function (result) {
+      if (polylines.isDestroyed()) {
+        return;
+      }
 
-    return verticesPromise.then(function (result) {
       if (polylines._keepDecodedPositions) {
         polylines._decodedPositions = new Float64Array(result.decodedPositions);
         polylines._decodedPositionOffsets = new Uint32Array(
@@ -300,13 +303,21 @@ function createVertexArray(polylines, context) {
           ? new Uint16Array(result.indices)
           : new Uint32Array(result.indices);
 
+      finishVertexArray(polylines, context);
       polylines._ready = true;
+    })
+    .catch((error) => {
+      if (polylines.isDestroyed()) {
+        return;
+      }
+
+      // Throw the error next frame
+      polylines._error = error;
     });
-  }
 }
 
 function finishVertexArray(polylines, context) {
-  if (polylines._ready && !defined(polylines._va)) {
+  if (!defined(polylines._va)) {
     const startEllipsoidNormals = polylines._startEllipsoidNormals;
     const endEllipsoidNormals = polylines._endEllipsoidNormals;
     const startPositionAndHeights = polylines._startPositionAndHeights;
@@ -610,7 +621,7 @@ function queueCommands(primitive, frameState) {
 /**
  * Get the polyline positions for the given feature.
  *
- * @param {Number} batchId The batch ID of the feature.
+ * @param {number} batchId The batch ID of the feature.
  */
 Vector3DTileClampedPolylines.prototype.getPositions = function (batchId) {
   return Vector3DTilePolylines.getPolylinePositions(this, batchId);
@@ -637,7 +648,7 @@ Vector3DTileClampedPolylines.prototype.createFeatures = function (
 /**
  * Colors the entire tile when enabled is true. The resulting color will be (polyline batch table color * color).
  *
- * @param {Boolean} enabled Whether to enable debug coloring.
+ * @param {boolean} enabled Whether to enable debug coloring.
  * @param {Color} color The debug color.
  */
 Vector3DTileClampedPolylines.prototype.applyDebugSettings = function (
@@ -692,43 +703,22 @@ Vector3DTileClampedPolylines.prototype.applyStyle = function (style, features) {
 };
 
 function initialize(polylines) {
-  return ApproximateTerrainHeights.initialize().then(function () {
-    updateMinimumMaximumHeights(
-      polylines,
-      polylines._rectangle,
-      polylines._ellipsoid
-    );
+  return ApproximateTerrainHeights.initialize()
+    .then(function () {
+      updateMinimumMaximumHeights(
+        polylines,
+        polylines._rectangle,
+        polylines._ellipsoid
+      );
+    })
+    .catch((error) => {
+      if (polylines.isDestroyed()) {
+        return;
+      }
 
-    return new Promise(function (resolve, reject) {
-      polylines._update = function (polylines, frameState) {
-        const context = frameState.context;
-        const promise = createVertexArray(polylines, context);
-        createUniformMap(polylines, context);
-        createShaders(polylines, context);
-        createRenderStates(polylines);
-
-        if (polylines._ready) {
-          const passes = frameState.passes;
-          if (passes.render || passes.pick) {
-            queueCommands(polylines, frameState);
-          }
-        }
-
-        if (!defined(promise)) {
-          return;
-        }
-
-        promise
-          .then(function () {
-            finishVertexArray(polylines, context);
-            resolve(polylines);
-          })
-          .catch(function (e) {
-            reject(e);
-          });
-      };
+      // Throw the error next frame
+      polylines._error = error;
     });
-  });
 }
 
 /**
@@ -737,7 +727,29 @@ function initialize(polylines) {
  * @param {FrameState} frameState The current frame state.
  */
 Vector3DTileClampedPolylines.prototype.update = function (frameState) {
-  this._update(this, frameState);
+  const context = frameState.context;
+  if (!this._ready) {
+    if (!defined(this._promise)) {
+      this._promise = initialize(this).then(createVertexArray(this, context));
+    }
+
+    if (defined(this._error)) {
+      const error = this._error;
+      this._error = undefined;
+      throw error;
+    }
+
+    return;
+  }
+
+  createUniformMap(this, context);
+  createShaders(this, context);
+  createRenderStates(this);
+
+  const passes = frameState.passes;
+  if (passes.render || passes.pick) {
+    queueCommands(this, frameState);
+  }
 };
 
 /**
@@ -747,7 +759,7 @@ Vector3DTileClampedPolylines.prototype.update = function (frameState) {
  * <code>isDestroyed</code> will result in a {@link DeveloperError} exception.
  * </p>
  *
- * @returns {Boolean} <code>true</code> if this object was destroyed; otherwise, <code>false</code>.
+ * @returns {boolean} <code>true</code> if this object was destroyed; otherwise, <code>false</code>.
  */
 Vector3DTileClampedPolylines.prototype.isDestroyed = function () {
   return false;

package/Source/Scene/Vector3DTileContent.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 Ellipsoid from "../Core/Ellipsoid.js";
@@ -51,6 +52,14 @@ function Vector3DTileContent(tileset, tile, resource, arrayBuffer, byteOffset) {
   this.featurePropertiesDirty = false;
   this._group = undefined;
 
+  this._ready = false;
+
+  // This is here for backwards compatibility and can be removed when readyPromise is removed.
+  this._resolveContent = undefined;
+  this._readyPromise = new Promise((resolve) => {
+    this._resolveContent = resolve;
+  });
+
   initialize(this, arrayBuffer, byteOffset);
 }
 
@@ -119,24 +128,38 @@ Object.defineProperties(Vector3DTileContent.prototype, {
     },
   },
 
+  /**
+   * Returns true when the tile's content is ready to render; otherwise false
+   *
+   * @memberof Vector3DTileContent.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 Vector3DTileContent.prototype
+   *
+   * @type {Promise<Vector3DTileContent>}
+   * @readonly
+   * @deprecated
+   * @private
+   */
   readyPromise: {
     get: function () {
-      const pointsPromise = defined(this._points)
-        ? this._points.readyPromise
-        : undefined;
-      const polygonPromise = defined(this._polygons)
-        ? this._polygons.readyPromise
-        : undefined;
-      const polylinePromise = defined(this._polylines)
-        ? this._polylines.readyPromise
-        : undefined;
-
-      const that = this;
-      return Promise.all([pointsPromise, polygonPromise, polylinePromise]).then(
-        function () {
-          return that;
-        }
+      deprecationWarning(
+        "Vector3DTileContent.readyPromise",
+        "Vector3DTileContent.readyPromise was deprecated in CesiumJS 1.104. It will be removed in 1.107. Wait for Vector3DTileContent.ready to return true instead."
       );
+      return this._readyPromise;
     },
   },
 
@@ -245,7 +268,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"
     );
   }
 
@@ -311,7 +334,9 @@ function initialize(content, arrayBuffer, byteOffset) {
   byteOffset += sizeOfUint32;
 
   if (byteLength === 0) {
-    return Promise.resolve(content);
+    content._ready = true;
+    content._resolveContent(content);
+    return;
   }
 
   const featureTableJSONByteLength = view.getUint32(byteOffset, true);
@@ -635,8 +660,6 @@ function initialize(content, arrayBuffer, byteOffset) {
       batchTable: batchTable,
     });
   }
-
-  return Promise.resolve(content);
 }
 
 function createFeatures(content) {
@@ -713,21 +736,23 @@ Vector3DTileContent.prototype.update = function (tileset, frameState) {
     this._polygons.classificationType = this._tileset.classificationType;
     this._polygons.debugWireframe = this._tileset.debugWireframe;
     this._polygons.update(frameState);
-    ready = ready && this._polygons._ready;
+    ready = ready && this._polygons.ready;
   }
   if (defined(this._polylines)) {
     this._polylines.update(frameState);
-    ready = ready && this._polylines._ready;
+    ready = ready && this._polylines.ready;
   }
   if (defined(this._points)) {
     this._points.update(frameState);
-    ready = ready && this._points._ready;
+    ready = ready && this._points.ready;
   }
   if (defined(this._batchTable) && ready) {
     if (!defined(this._features)) {
       createFeatures(this);
     }
     this._batchTable.update(tileset, frameState);
+    this._ready = true;
+    this._resolveContent(this);
   }
 };