@cesium/engine 2.1.0 → 2.3.0

package/Source/Scene/Vector3DTileClampedPolylines.js

@@ -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, {
@@ -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;
@@ -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);
+  }
 };
 
 /**

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);
   }
 };
 

package/Source/Scene/Vector3DTileGeometry.js

@@ -71,8 +71,8 @@ function Vector3DTileGeometry(options) {
   this._packedBuffer = undefined;
 
   this._ready = false;
-  this._update = function (geometries, frameState) {};
-  this._readyPromise = initialize(this);
+  this._promise = undefined;
+  this._error = undefined;
 
   this._verticesPromise = undefined;
 
@@ -108,6 +108,7 @@ Object.defineProperties(Vector3DTileGeometry.prototype, {
    *
    * @type {number}
    * @readonly
+   * @private
    */
   trianglesLength: {
     get: function () {
@@ -125,6 +126,7 @@ Object.defineProperties(Vector3DTileGeometry.prototype, {
    *
    * @type {number}
    * @readonly
+   * @private
    */
   geometryByteLength: {
     get: function () {
@@ -136,14 +138,15 @@ Object.defineProperties(Vector3DTileGeometry.prototype, {
   },
 
   /**
-   * Gets a promise that resolves when the primitive is ready to render.
+   * Return true when the primitive is ready to render.
    * @memberof Vector3DTileGeometry.prototype
-   * @type {Promise<void>}
+   * @type {boolean}
    * @readonly
+   * @private
    */
-  readyPromise: {
+  ready: {
     get: function () {
-      return this._readyPromise;
+      return this._ready;
     },
   },
 });
@@ -308,31 +311,45 @@ function createPrimitive(geometries) {
       return;
     }
 
-    return verticesPromise.then(function (result) {
-      const packedBuffer = new Float64Array(result.packedBuffer);
-      const indicesBytesPerElement = unpackBuffer(geometries, packedBuffer);
+    return verticesPromise
+      .then(function (result) {
+        if (geometries.isDestroyed()) {
+          return;
+        }
 
-      if (indicesBytesPerElement === 2) {
-        geometries._indices = new Uint16Array(result.indices);
-      } else {
-        geometries._indices = new Uint32Array(result.indices);
-      }
+        const packedBuffer = new Float64Array(result.packedBuffer);
+        const indicesBytesPerElement = unpackBuffer(geometries, packedBuffer);
 
-      geometries._indexOffsets = new Uint32Array(result.indexOffsets);
-      geometries._indexCounts = new Uint32Array(result.indexCounts);
+        if (indicesBytesPerElement === 2) {
+          geometries._indices = new Uint16Array(result.indices);
+        } else {
+          geometries._indices = new Uint32Array(result.indices);
+        }
 
-      geometries._positions = new Float32Array(result.positions);
-      geometries._vertexBatchIds = new Uint16Array(result.vertexBatchIds);
+        geometries._indexOffsets = new Uint32Array(result.indexOffsets);
+        geometries._indexCounts = new Uint32Array(result.indexCounts);
 
-      geometries._batchIds = new Uint16Array(result.batchIds);
+        geometries._positions = new Float32Array(result.positions);
+        geometries._vertexBatchIds = new Uint16Array(result.vertexBatchIds);
 
-      geometries._ready = true;
-    });
+        geometries._batchIds = new Uint16Array(result.batchIds);
+
+        finishPrimitive(geometries);
+
+        geometries._ready = true;
+      })
+      .catch((error) => {
+        if (geometries.isDestroyed()) {
+          return;
+        }
+
+        geometries._error = error;
+      });
   }
 }
 
 function finishPrimitive(geometries) {
-  if (geometries._ready && !defined(geometries._primitive)) {
+  if (!defined(geometries._primitive)) {
     geometries._primitive = new Vector3DTilePrimitive({
       batchTable: geometries._batchTable,
       positions: geometries._positions,
@@ -421,42 +438,30 @@ Vector3DTileGeometry.prototype.updateCommands = function (batchId, color) {
   this._primitive.updateCommands(batchId, color);
 };
 
-function initialize(geometries) {
-  return new Promise(function (resolve, reject) {
-    geometries._update = function (geometries, frameState) {
-      const promise = createPrimitive(geometries);
-
-      if (geometries._ready) {
-        geometries._primitive.debugWireframe = geometries.debugWireframe;
-        geometries._primitive.forceRebatch = geometries.forceRebatch;
-        geometries._primitive.classificationType =
-          geometries.classificationType;
-        geometries._primitive.update(frameState);
-      }
-
-      if (!defined(promise)) {
-        return;
-      }
-
-      promise
-        .then(function () {
-          finishPrimitive(geometries);
-          resolve(geometries);
-        })
-        .catch(function (e) {
-          reject(e);
-        });
-    };
-  });
-}
-
 /**
  * Updates the batches and queues the commands for rendering.
  *
  * @param {FrameState} frameState The current frame state.
  */
 Vector3DTileGeometry.prototype.update = function (frameState) {
-  this._update(this, frameState);
+  if (!this._ready) {
+    if (!defined(this._promise)) {
+      this._promise = createPrimitive(this);
+    }
+
+    if (defined(this._error)) {
+      const error = this._error;
+      this._error = undefined;
+      throw error;
+    }
+
+    return;
+  }
+
+  this._primitive.debugWireframe = this.debugWireframe;
+  this._primitive.forceRebatch = this.forceRebatch;
+  this._primitive.classificationType = this.classificationType;
+  this._primitive.update(frameState);
 };
 
 /**