@cesium/engine 2.1.0 → 2.3.0

package/Source/Scene/Vector3DTilePoints.js

@@ -52,15 +52,29 @@ function Vector3DTilePoints(options) {
   this._polylineCollection = new PolylineCollection();
   this._polylineCollection._useHighlightColor = true;
 
-  this._verticesPromise = undefined;
   this._packedBuffer = undefined;
 
   this._ready = false;
-  this._update = function (points, frameState) {};
-  this._readyPromise = initialize(this);
+  this._promise = undefined;
+  this._error = undefined;
 }
 
 Object.defineProperties(Vector3DTilePoints.prototype, {
+  /**
+   * Returns true if the points are ready to render
+   *
+   * @memberof Vector3DTilePoints.prototype
+   *
+   * @type {boolean}
+   * @readonly
+   * @private
+   */
+  ready: {
+    get: function () {
+      return this._ready;
+    },
+  },
+
   /**
    * Gets the number of points.
    *
@@ -68,6 +82,7 @@ Object.defineProperties(Vector3DTilePoints.prototype, {
    *
    * @type {number}
    * @readonly
+   * @private
    */
   pointsLength: {
     get: function () {
@@ -82,6 +97,7 @@ Object.defineProperties(Vector3DTilePoints.prototype, {
    *
    * @type {number}
    * @readonly
+   * @private
    */
   texturesByteLength: {
     get: function () {
@@ -91,18 +107,6 @@ Object.defineProperties(Vector3DTilePoints.prototype, {
       return billboardSize + labelSize;
     },
   },
-
-  /**
-   * Gets a promise that resolves when the primitive is ready to render.
-   * @memberof Vector3DTilePoints.prototype
-   * @type {Promise<void>}
-   * @readonly
-   */
-  readyPromise: {
-    get: function () {
-      return this._readyPromise;
-    },
-  },
 });
 
 function packBuffer(points, ellipsoid) {
@@ -132,35 +136,38 @@ const createVerticesTaskProcessor = new TaskProcessor(
 const scratchPosition = new Cartesian3();
 
 function createPoints(points, ellipsoid) {
-  let positions;
-  if (!defined(points._verticesPromise)) {
-    positions = points._positions;
-    let packedBuffer = points._packedBuffer;
+  let positions = points._positions;
+  let packedBuffer = points._packedBuffer;
 
-    if (!defined(packedBuffer)) {
-      // Copy because they may be the views on the same buffer.
-      positions = points._positions = positions.slice();
-      points._batchIds = points._batchIds.slice();
+  if (!defined(packedBuffer)) {
+    // Copy because they may be the views on the same buffer.
+    positions = points._positions = positions.slice();
+    points._batchIds = points._batchIds.slice();
 
-      packedBuffer = points._packedBuffer = packBuffer(points, ellipsoid);
-    }
+    packedBuffer = points._packedBuffer = packBuffer(points, ellipsoid);
+  }
 
-    const transferrableObjects = [positions.buffer, packedBuffer.buffer];
-    const parameters = {
-      positions: positions.buffer,
-      packedBuffer: packedBuffer.buffer,
-    };
-
-    const verticesPromise = (points._verticesPromise = createVerticesTaskProcessor.scheduleTask(
-      parameters,
-      transferrableObjects
-    ));
-    if (!defined(verticesPromise)) {
-      // Postponed
-      return;
-    }
+  const transferrableObjects = [positions.buffer, packedBuffer.buffer];
+  const parameters = {
+    positions: positions.buffer,
+    packedBuffer: packedBuffer.buffer,
+  };
+
+  const verticesPromise = createVerticesTaskProcessor.scheduleTask(
+    parameters,
+    transferrableObjects
+  );
+  if (!defined(verticesPromise)) {
+    // Postponed
+    return;
+  }
+
+  return verticesPromise
+    .then((result) => {
+      if (points.isDestroyed()) {
+        return;
+      }
 
-    return verticesPromise.then(function (result) {
       points._positions = new Float64Array(result.positions);
       const billboardCollection = points._billboardCollection;
       const labelCollection = points._labelCollection;
@@ -190,8 +197,15 @@ function createPoints(points, ellipsoid) {
       points._positions = undefined;
       points._packedBuffer = undefined;
       points._ready = true;
+    })
+    .catch((error) => {
+      if (points.isDestroyed()) {
+        return;
+      }
+
+      // Throw the error next frame
+      points._error = error;
     });
-  }
 }
 
 /**
@@ -380,11 +394,15 @@ Vector3DTilePoints.prototype.applyStyle = function (style, features) {
 
     if (defined(style.scaleByDistance)) {
       const scaleByDistanceCart4 = style.scaleByDistance.evaluate(feature);
-      scratchScaleByDistance.near = scaleByDistanceCart4.x;
-      scratchScaleByDistance.nearValue = scaleByDistanceCart4.y;
-      scratchScaleByDistance.far = scaleByDistanceCart4.z;
-      scratchScaleByDistance.farValue = scaleByDistanceCart4.w;
-      feature.scaleByDistance = scratchScaleByDistance;
+      if (defined(scaleByDistanceCart4)) {
+        scratchScaleByDistance.near = scaleByDistanceCart4.x;
+        scratchScaleByDistance.nearValue = scaleByDistanceCart4.y;
+        scratchScaleByDistance.far = scaleByDistanceCart4.z;
+        scratchScaleByDistance.farValue = scaleByDistanceCart4.w;
+        feature.scaleByDistance = scratchScaleByDistance;
+      } else {
+        feature.scaleByDistance = undefined;
+      }
     } else {
       feature.scaleByDistance = undefined;
     }
@@ -393,11 +411,15 @@ Vector3DTilePoints.prototype.applyStyle = function (style, features) {
       const translucencyByDistanceCart4 = style.translucencyByDistance.evaluate(
         feature
       );
-      scratchTranslucencyByDistance.near = translucencyByDistanceCart4.x;
-      scratchTranslucencyByDistance.nearValue = translucencyByDistanceCart4.y;
-      scratchTranslucencyByDistance.far = translucencyByDistanceCart4.z;
-      scratchTranslucencyByDistance.farValue = translucencyByDistanceCart4.w;
-      feature.translucencyByDistance = scratchTranslucencyByDistance;
+      if (defined(translucencyByDistanceCart4)) {
+        scratchTranslucencyByDistance.near = translucencyByDistanceCart4.x;
+        scratchTranslucencyByDistance.nearValue = translucencyByDistanceCart4.y;
+        scratchTranslucencyByDistance.far = translucencyByDistanceCart4.z;
+        scratchTranslucencyByDistance.farValue = translucencyByDistanceCart4.w;
+        feature.translucencyByDistance = scratchTranslucencyByDistance;
+      } else {
+        feature.translucencyByDistance = undefined;
+      }
     } else {
       feature.translucencyByDistance = undefined;
     }
@@ -406,9 +428,13 @@ Vector3DTilePoints.prototype.applyStyle = function (style, features) {
       const distanceDisplayConditionCart2 = style.distanceDisplayCondition.evaluate(
         feature
       );
-      scratchDistanceDisplayCondition.near = distanceDisplayConditionCart2.x;
-      scratchDistanceDisplayCondition.far = distanceDisplayConditionCart2.y;
-      feature.distanceDisplayCondition = scratchDistanceDisplayCondition;
+      if (defined(distanceDisplayConditionCart2)) {
+        scratchDistanceDisplayCondition.near = distanceDisplayConditionCart2.x;
+        scratchDistanceDisplayCondition.far = distanceDisplayConditionCart2.y;
+        feature.distanceDisplayCondition = scratchDistanceDisplayCondition;
+      } else {
+        feature.distanceDisplayCondition = undefined;
+      }
     } else {
       feature.distanceDisplayCondition = undefined;
     }
@@ -460,37 +486,27 @@ Vector3DTilePoints.prototype.applyStyle = function (style, features) {
   }
 };
 
-function initialize(points) {
-  return new Promise(function (resolve, reject) {
-    points._update = function (points, frameState) {
-      const promise = createPoints(points, frameState.mapProjection.ellipsoid);
-
-      if (points._ready) {
-        points._polylineCollection.update(frameState);
-        points._billboardCollection.update(frameState);
-        points._labelCollection.update(frameState);
-      }
-
-      if (!defined(promise)) {
-        return;
-      }
-
-      promise
-        .then(function () {
-          resolve();
-        })
-        .catch(function (e) {
-          reject(e);
-        });
-    };
-  });
-}
-
 /**
  * @private
  */
 Vector3DTilePoints.prototype.update = function (frameState) {
-  this._update(this, frameState);
+  if (!this._ready) {
+    if (!defined(this._promise)) {
+      this._promise = createPoints(this, frameState.mapProjection.ellipsoid);
+    }
+
+    if (defined(this._error)) {
+      const error = this._error;
+      this._error = undefined;
+      throw error;
+    }
+
+    return;
+  }
+
+  this._polylineCollection.update(frameState);
+  this._billboardCollection.update(frameState);
+  this._labelCollection.update(frameState);
 };
 
 /**

package/Source/Scene/Vector3DTilePolygons.js

@@ -40,8 +40,7 @@ import Vector3DTilePrimitive from "./Vector3DTilePrimitive.js";
  * @private
  */
 function Vector3DTilePolygons(options) {
-  // All of the private properties will be released except _readyPromise
-  // and _primitive after the Vector3DTilePrimitive is created.
+  // All of the private properties will be released except _primitive after the Vector3DTilePrimitive is created.
   this._batchTable = options.batchTable;
 
   this._batchIds = options.batchIds;
@@ -75,10 +74,8 @@ function Vector3DTilePolygons(options) {
   this._batchedIndices = undefined;
 
   this._ready = false;
-  this._update = function (polygons, frameState) {};
-  this._readyPromise = initialize(this);
-  this._verticesPromise = undefined;
-
+  this._promise = undefined;
+  this._error = undefined;
   this._primitive = undefined;
 
   /**
@@ -111,6 +108,7 @@ Object.defineProperties(Vector3DTilePolygons.prototype, {
    *
    * @type {number}
    * @readonly
+   * @private
    */
   trianglesLength: {
     get: function () {
@@ -128,6 +126,7 @@ Object.defineProperties(Vector3DTilePolygons.prototype, {
    *
    * @type {number}
    * @readonly
+   * @private
    */
   geometryByteLength: {
     get: function () {
@@ -139,14 +138,15 @@ Object.defineProperties(Vector3DTilePolygons.prototype, {
   },
 
   /**
-   * Gets a promise that resolves when the primitive is ready to render.
+   * Returns true when the primitive is ready to render.
    * @memberof Vector3DTilePolygons.prototype
-   * @type {Promise<void>}
+   * @type {boolean}
    * @readonly
+   * @private
    */
-  readyPromise: {
+  ready: {
     get: function () {
-      return this._readyPromise;
+      return this._ready;
     },
   },
 });
@@ -224,85 +224,89 @@ function createPrimitive(polygons) {
     return;
   }
 
-  if (!defined(polygons._verticesPromise)) {
-    let positions = polygons._positions;
-    let counts = polygons._counts;
-    let indexCounts = polygons._indexCounts;
-    let indices = polygons._indices;
-
-    let batchIds = polygons._transferrableBatchIds;
-    let batchTableColors = polygons._batchTableColors;
-
-    let packedBuffer = polygons._packedBuffer;
-
-    if (!defined(batchTableColors)) {
-      // Copy because they may be the views on the same buffer.
-      positions = polygons._positions = polygons._positions.slice();
-      counts = polygons._counts = polygons._counts.slice();
-      indexCounts = polygons._indexCounts = polygons._indexCounts.slice();
-      indices = polygons._indices = polygons._indices.slice();
-
-      polygons._center = polygons._ellipsoid.cartographicToCartesian(
-        Rectangle.center(polygons._rectangle)
-      );
-
-      batchIds = polygons._transferrableBatchIds = new Uint32Array(
-        polygons._batchIds
-      );
-      batchTableColors = polygons._batchTableColors = new Uint32Array(
-        batchIds.length
-      );
-      const batchTable = polygons._batchTable;
-
-      const length = batchTableColors.length;
-      for (let i = 0; i < length; ++i) {
-        const color = batchTable.getColor(i, scratchColor);
-        batchTableColors[i] = color.toRgba();
-      }
-
-      packedBuffer = polygons._packedBuffer = packBuffer(polygons);
+  let positions = polygons._positions;
+  let counts = polygons._counts;
+  let indexCounts = polygons._indexCounts;
+  let indices = polygons._indices;
+
+  let batchIds = polygons._transferrableBatchIds;
+  let batchTableColors = polygons._batchTableColors;
+
+  let packedBuffer = polygons._packedBuffer;
+
+  if (!defined(batchTableColors)) {
+    // Copy because they may be the views on the same buffer.
+    positions = polygons._positions = polygons._positions.slice();
+    counts = polygons._counts = polygons._counts.slice();
+    indexCounts = polygons._indexCounts = polygons._indexCounts.slice();
+    indices = polygons._indices = polygons._indices.slice();
+
+    polygons._center = polygons._ellipsoid.cartographicToCartesian(
+      Rectangle.center(polygons._rectangle)
+    );
+
+    batchIds = polygons._transferrableBatchIds = new Uint32Array(
+      polygons._batchIds
+    );
+    batchTableColors = polygons._batchTableColors = new Uint32Array(
+      batchIds.length
+    );
+    const batchTable = polygons._batchTable;
+
+    const length = batchTableColors.length;
+    for (let i = 0; i < length; ++i) {
+      const color = batchTable.getColor(i, scratchColor);
+      batchTableColors[i] = color.toRgba();
     }
 
-    const transferrableObjects = [
-      positions.buffer,
-      counts.buffer,
-      indexCounts.buffer,
-      indices.buffer,
-      batchIds.buffer,
-      batchTableColors.buffer,
-      packedBuffer.buffer,
-    ];
-    const parameters = {
-      packedBuffer: packedBuffer.buffer,
-      positions: positions.buffer,
-      counts: counts.buffer,
-      indexCounts: indexCounts.buffer,
-      indices: indices.buffer,
-      batchIds: batchIds.buffer,
-      batchTableColors: batchTableColors.buffer,
-    };
-
-    let minimumHeights = polygons._polygonMinimumHeights;
-    let maximumHeights = polygons._polygonMaximumHeights;
-    if (defined(minimumHeights) && defined(maximumHeights)) {
-      minimumHeights = minimumHeights.slice();
-      maximumHeights = maximumHeights.slice();
-
-      transferrableObjects.push(minimumHeights.buffer, maximumHeights.buffer);
-      parameters.minimumHeights = minimumHeights;
-      parameters.maximumHeights = maximumHeights;
-    }
+    packedBuffer = polygons._packedBuffer = packBuffer(polygons);
+  }
 
-    const verticesPromise = (polygons._verticesPromise = createVerticesTaskProcessor.scheduleTask(
-      parameters,
-      transferrableObjects
-    ));
-    if (!defined(verticesPromise)) {
-      // Postponed
-      return;
-    }
+  const transferrableObjects = [
+    positions.buffer,
+    counts.buffer,
+    indexCounts.buffer,
+    indices.buffer,
+    batchIds.buffer,
+    batchTableColors.buffer,
+    packedBuffer.buffer,
+  ];
+  const parameters = {
+    packedBuffer: packedBuffer.buffer,
+    positions: positions.buffer,
+    counts: counts.buffer,
+    indexCounts: indexCounts.buffer,
+    indices: indices.buffer,
+    batchIds: batchIds.buffer,
+    batchTableColors: batchTableColors.buffer,
+  };
+
+  let minimumHeights = polygons._polygonMinimumHeights;
+  let maximumHeights = polygons._polygonMaximumHeights;
+  if (defined(minimumHeights) && defined(maximumHeights)) {
+    minimumHeights = minimumHeights.slice();
+    maximumHeights = maximumHeights.slice();
+
+    transferrableObjects.push(minimumHeights.buffer, maximumHeights.buffer);
+    parameters.minimumHeights = minimumHeights;
+    parameters.maximumHeights = maximumHeights;
+  }
+
+  const verticesPromise = createVerticesTaskProcessor.scheduleTask(
+    parameters,
+    transferrableObjects
+  );
+  if (!defined(verticesPromise)) {
+    // Postponed
+    return;
+  }
+
+  return verticesPromise
+    .then((result) => {
+      if (polygons.isDestroyed()) {
+        return;
+      }
 
-    return verticesPromise.then(function (result) {
       polygons._positions = undefined;
       polygons._counts = undefined;
       polygons._polygonMinimumHeights = undefined;
@@ -323,13 +327,22 @@ function createPrimitive(polygons) {
       polygons._batchedPositions = new Float32Array(result.positions);
       polygons._vertexBatchIds = new Uint16Array(result.batchIds);
 
+      finishPrimitive(polygons);
+
       polygons._ready = true;
+    })
+    .catch((error) => {
+      if (polygons.isDestroyed()) {
+        return;
+      }
+
+      // Throw the error next frame
+      polygons._error = error;
     });
-  }
 }
 
 function finishPrimitive(polygons) {
-  if (polygons._ready && !defined(polygons._primitive)) {
+  if (!defined(polygons._primitive)) {
     polygons._primitive = new Vector3DTilePrimitive({
       batchTable: polygons._batchTable,
       positions: polygons._batchedPositions,
@@ -366,7 +379,6 @@ function finishPrimitive(polygons) {
     polygons._boundingVolume = undefined;
     polygons._boundingVolumes = undefined;
     polygons._batchedIndices = undefined;
-    polygons._verticesPromise = undefined;
   }
 }
 
@@ -411,41 +423,30 @@ Vector3DTilePolygons.prototype.updateCommands = function (batchId, color) {
   this._primitive.updateCommands(batchId, color);
 };
 
-function initialize(polygons) {
-  return new Promise(function (resolve, reject) {
-    polygons._update = function (polygons, frameState) {
-      const promise = createPrimitive(polygons);
-
-      if (polygons._ready) {
-        polygons._primitive.debugWireframe = polygons.debugWireframe;
-        polygons._primitive.forceRebatch = polygons.forceRebatch;
-        polygons._primitive.classificationType = polygons.classificationType;
-        polygons._primitive.update(frameState);
-      }
-
-      if (!defined(promise)) {
-        return;
-      }
-
-      promise
-        .then(function () {
-          finishPrimitive(polygons);
-          resolve(polygons);
-        })
-        .catch(function (e) {
-          reject(e);
-        });
-    };
-  });
-}
-
 /**
  * Updates the batches and queues the commands for rendering.
  *
  * @param {FrameState} frameState The current frame state.
  */
 Vector3DTilePolygons.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);
 };
 
 /**