@cesium/engine 3.0.2 → 5.0.0

package/Source/Core/sampleTerrainMostDetailed.js

@@ -12,6 +12,7 @@ const scratchCartesian2 = new Cartesian2();
  *
  * @param {TerrainProvider} terrainProvider The terrain provider from which to query heights.
  * @param {Cartographic[]} positions The positions to update with terrain heights.
+ * @param {boolean} [rejectOnTileFail=false] If true, for a failed terrain tile request the promise will be rejected. If false, returned heights will be undefined.
  * @returns {Promise<Cartographic[]>} A promise that resolves to the provided list of positions when terrain the query has completed.  This
  *                                     promise will reject if the terrain provider's `availability` property is undefined.
  *
@@ -25,8 +26,22 @@ const scratchCartesian2 = new Cartesian2();
  * const updatedPositions = await Cesium.sampleTerrainMostDetailed(terrainProvider, positions);
  * // positions[0].height and positions[1].height have been updated.
  * // updatedPositions is just a reference to positions.
+ *
+ * // To handle tile errors, pass true for the rejectOnTileFail parameter.
+ * try {
+ *    const updatedPositions = await Cesium.sampleTerrainMostDetailed(terrainProvider, positions, true);
+ * } catch (error) {
+ *   // A tile request error occurred.
+ * }
  */
-async function sampleTerrainMostDetailed(terrainProvider, positions) {
+async function sampleTerrainMostDetailed(
+  terrainProvider,
+  positions,
+  rejectOnTileFail
+) {
+  if (!defined(rejectOnTileFail)) {
+    rejectOnTileFail = false;
+  }
   //>>includeStart('debug', pragmas.debug);
   if (!defined(terrainProvider)) {
     throw new DeveloperError("terrainProvider is required.");
@@ -84,7 +99,12 @@ async function sampleTerrainMostDetailed(terrainProvider, positions) {
   await Promise.all(
     byLevel.map(function (positionsAtLevel, index) {
       if (defined(positionsAtLevel)) {
-        return sampleTerrain(terrainProvider, index, positionsAtLevel);
+        return sampleTerrain(
+          terrainProvider,
+          index,
+          positionsAtLevel,
+          rejectOnTileFail
+        );
       }
     })
   );
@@ -100,7 +120,11 @@ async function sampleTerrainMostDetailed(terrainProvider, positions) {
   }
 
   if (changedPositions.length > 0) {
-    await sampleTerrainMostDetailed(terrainProvider, changedPositions);
+    await sampleTerrainMostDetailed(
+      terrainProvider,
+      changedPositions,
+      rejectOnTileFail
+    );
   }
 
   return positions;

package/Source/Scene/ArcGisMapService.js

@@ -4,7 +4,7 @@ import Resource from "../Core/Resource.js";
 
 let defaultTokenCredit;
 const defaultAccessToken =
-  "AAPK8f33c81975d04fa5bc64d58baa922e4d8t7EX1YAV3MBqwKXAhJ1uohub5U5OCU0PyXE7kNEVf8hebc9ZA4kk17Y4FYDA_rV";
+  "AAPK4db83df15a06415e9b7d45d826eec992u0REAmuLmykhOFOk_4e61HgsO_e3C_qGUgiWNGElpjpiMfO9_Qg5ZRyy8POvB5EF";
 /**
  * Default options for accessing the ArcGIS image tile service.
  *
@@ -76,7 +76,6 @@ ArcGisMapService.getDefaultTokenCredit = function (providedKey) {
             You can sign up for a free ArcGIS Developer account at <a href="https://developers.arcgis.com/">https://developers.arcgis.com/</a>.</b>';
 
     defaultTokenCredit = new Credit(defaultTokenMessage, true);
-    defaultTokenCredit._isDefaultToken = true;
   }
 
   return defaultTokenCredit;

package/Source/Scene/Billboard.js

@@ -1166,6 +1166,13 @@ Billboard.prototype._loadImage = function () {
     that._image = undefined;
     that._imageIndexPromise = undefined;
     makeDirty(that, IMAGE_INDEX_INDEX);
+
+    const scene = that._billboardCollection._scene;
+    if (!defined(scene)) {
+      return;
+    }
+    // Request a new render in request render mode
+    scene.frameState.afterRender.push(() => true);
   }
 
   if (defined(image)) {

package/Source/Scene/Cesium3DTilePass.js

@@ -39,7 +39,7 @@ passOptions[Cesium3DTilePass.SHADOW] = Object.freeze({
 });
 
 passOptions[Cesium3DTilePass.PRELOAD] = Object.freeze({
-  pass: Cesium3DTilePass.SHADOW,
+  pass: Cesium3DTilePass.PRELOAD,
   isRender: false,
   requestTiles: true,
   ignoreCommands: true,

package/Source/Scene/Cesium3DTileset.js

@@ -67,7 +67,6 @@ import Cesium3DTilesetSkipTraversal from "./Cesium3DTilesetSkipTraversal.js";
  * @property {Axis} [modelForwardAxis=Axis.X] Which axis is considered forward when loading models for tile contents.
  * @property {ShadowMode} [shadows=ShadowMode.ENABLED] Determines whether the tileset casts or receives shadows from light sources.
  * @property {number} [maximumScreenSpaceError=16] The maximum screen space error used to drive level of detail refinement.
- * @property {number} [maximumMemoryUsage=512] The maximum amount of memory in MB that can be used by the tileset. Deprecated.
  * @property {number} [cacheBytes=536870912] The size (in bytes) to which the tile cache will be trimmed, if the cache contains tiles not needed for the current view.
  * @property {number} [maximumCacheOverflowBytes=536870912] The maximum additional memory (in bytes) to allow for cache headroom, if more than {@link Cesium3DTileset#cacheBytes} are needed for the current view.
  * @property {boolean} [cullWithChildrenBounds=true] Optimization option. Whether to cull tiles using the union of their children bounding volumes.
@@ -224,15 +223,7 @@ function Cesium3DTileset(options) {
   );
   this._memoryAdjustedScreenSpaceError = this._maximumScreenSpaceError;
 
-  let defaultCacheBytes = 512 * 1024 * 1024;
-  if (defined(options.maximumMemoryUsage)) {
-    deprecationWarning(
-      "Cesium3DTileset.maximumMemoryUsage",
-      "Cesium3DTileset.maximumMemoryUsage was deprecated in CesiumJS 1.107.  It will be removed in CesiumJS 1.110. Use Cesium3DTileset.cacheBytes instead."
-    );
-    defaultCacheBytes = options.maximumMemoryUsage * 1024 * 1024;
-  }
-  this._cacheBytes = defaultValue(options.cacheBytes, defaultCacheBytes);
+  this._cacheBytes = defaultValue(options.cacheBytes, 512 * 1024 * 1024);
   //>>includeStart('debug', pragmas.debug);
   Check.typeOf.number.greaterThanOrEquals("cacheBytes", this._cacheBytes, 0);
   //>>includeEnd('debug');
@@ -1376,57 +1367,6 @@ Object.defineProperties(Cesium3DTileset.prototype, {
     },
   },
 
-  /**
-   * The maximum amount of GPU memory (in MB) that may be used to cache tiles. This value is estimated from
-   * geometry, textures, and batch table textures of loaded tiles. For point clouds, this value also
-   * includes per-point metadata.
-   * <p>
-   * Tiles not in view are unloaded to enforce this.
-   * </p>
-   * <p>
-   * If decreasing this value results in unloading tiles, the tiles are unloaded the next frame.
-   * </p>
-   * <p>
-   * If tiles sized more than <code>maximumMemoryUsage</code> are needed
-   * to meet the desired screen space error, determined by {@link Cesium3DTileset#maximumScreenSpaceError},
-   * for the current view, then the memory usage of the tiles loaded will exceed
-   * <code>maximumMemoryUsage</code>.  For example, if the maximum is 256 MB, but
-   * 300 MB of tiles are needed to meet the screen space error, then 300 MB of tiles may be loaded.  When
-   * these tiles go out of view, they will be unloaded.
-   * </p>
-   *
-   * @memberof Cesium3DTileset.prototype
-   *
-   * @type {number}
-   * @default 512
-   *
-   * @exception {DeveloperError} <code>maximumMemoryUsage</code> must be greater than or equal to zero.
-   * @see Cesium3DTileset#totalMemoryUsageInBytes
-   *
-   * @deprecated
-   */
-  maximumMemoryUsage: {
-    get: function () {
-      deprecationWarning(
-        "Cesium3DTileset.maximumMemoryUsage",
-        "Cesium3DTileset.maximumMemoryUsage was deprecated in CesiumJS 1.107.  It will be removed in CesiumJS 1.110. Use Cesium3DTileset.cacheBytes instead."
-      );
-      return this._maximumMemoryUsage;
-    },
-    set: function (value) {
-      deprecationWarning(
-        "Cesium3DTileset.maximumMemoryUsage",
-        "Cesium3DTileset.maximumMemoryUsage was deprecated in CesiumJS 1.107.  It will be removed in CesiumJS 1.110. Use Cesium3DTileset.cacheBytes instead."
-      );
-      //>>includeStart('debug', pragmas.debug);
-      Check.typeOf.number.greaterThanOrEquals("value", value, 0);
-      //>>includeEnd('debug');
-
-      this._maximumMemoryUsage = value;
-      this._cacheBytes = value * 1024 * 1024;
-    },
-  },
-
   /**
    * The amount of GPU memory (in bytes) used to cache tiles. This memory usage is estimated from
    * geometry, textures, and batch table textures of loaded tiles. For point clouds, this value also
@@ -1880,6 +1820,7 @@ Object.defineProperties(Cesium3DTileset.prototype, {
     },
     set: function (value) {
       this._showCreditsOnScreen = value;
+      createCredits(this);
     },
   },
 
@@ -2068,24 +2009,7 @@ Cesium3DTileset.fromUrl = async function (url, options) {
   tileset._asset = asset;
   tileset._extras = tilesetJson.extras;
 
-  let credits = resource.credits;
-  if (!defined(credits)) {
-    credits = [];
-  }
-
-  const assetExtras = asset.extras;
-  if (
-    defined(assetExtras) &&
-    defined(assetExtras.cesium) &&
-    defined(assetExtras.cesium.credits)
-  ) {
-    const extraCredits = assetExtras.cesium.credits;
-    for (let i = 0; i < extraCredits.length; ++i) {
-      const credit = extraCredits[i];
-      credits.push(new Credit(credit.html, tileset._showCreditsOnScreen));
-    }
-  }
-  tileset._credits = credits;
+  createCredits(tileset);
 
   // Handle legacy gltfUpAxis option
   const gltfUpAxis = defined(tilesetJson.asset.gltfUpAxis)
@@ -3210,8 +3134,6 @@ function update(tileset, frameState, passStatistics, passOptions) {
     if (defined(credits) && statistics.selected !== 0) {
       for (let i = 0; i < credits.length; ++i) {
         const credit = credits[i];
-        credit.showOnScreen =
-          tileset._showCreditsOnScreen || credit._isDefaultToken;
         frameState.creditDisplay.addCreditToNextFrame(credit);
       }
     }
@@ -3220,6 +3142,41 @@ function update(tileset, frameState, passStatistics, passOptions) {
   return ready;
 }
 
+function createCredits(tileset) {
+  let credits = tileset._credits;
+  if (!defined(credits)) {
+    credits = [];
+  }
+  credits.length = 0;
+
+  if (defined(tileset.resource.credits)) {
+    tileset.resource.credits.forEach((credit) => {
+      credits.push(Credit.clone(credit));
+    });
+  }
+
+  const assetExtras = tileset.asset.extras;
+  if (
+    defined(assetExtras) &&
+    defined(assetExtras.cesium) &&
+    defined(assetExtras.cesium.credits)
+  ) {
+    const extraCredits = assetExtras.cesium.credits;
+    for (let i = 0; i < extraCredits.length; ++i) {
+      const credit = extraCredits[i];
+      credits.push(new Credit(credit.html));
+    }
+  }
+
+  credits.forEach(
+    (credit) =>
+      (credit.showOnScreen =
+        credit.showOnScreen || tileset._showCreditsOnScreen)
+  );
+
+  tileset._credits = credits;
+}
+
 /**
  * @private
  * @param {object} passOptions

package/Source/Scene/CreditDisplay.js

@@ -437,7 +437,7 @@ CreditDisplay.prototype.addCreditToNextFrame = function (credit) {
   Check.defined("credit", credit);
   //>>includeEnd('debug');
 
-  if (credit._isIon) {
+  if (credit.isIon()) {
     // If this is the an ion logo credit from the ion server
     // Just use the default credit (which is identical) to avoid blinking
     if (!defined(this._defaultCredit)) {
@@ -546,7 +546,7 @@ CreditDisplay.prototype.beginFrame = function () {
       : lightboxCredits;
 
     if (
-      staticCredit._isIon &&
+      staticCredit.isIon() &&
       Credit.equals(CreditDisplay.cesiumCredit, this._cesiumCredit)
     ) {
       // If this is an ion logo credit from the ion server,

package/Source/Scene/DracoLoader.js

@@ -1,5 +1,6 @@
 import defined from "../Core/defined.js";
 import FeatureDetection from "../Core/FeatureDetection.js";
+import RuntimeError from "../Core/RuntimeError.js";
 import TaskProcessor from "../Core/TaskProcessor.js";
 
 /**
@@ -16,6 +17,7 @@ DracoLoader._maxDecodingConcurrency = Math.max(
 // Exposed for testing purposes
 DracoLoader._decoderTaskProcessor = undefined;
 DracoLoader._taskProcessorReady = false;
+DracoLoader._error = undefined;
 DracoLoader._getDecoderTaskProcessor = function () {
   if (!defined(DracoLoader._decoderTaskProcessor)) {
     const processor = new TaskProcessor(
@@ -24,11 +26,19 @@ DracoLoader._getDecoderTaskProcessor = function () {
     );
     processor
       .initWebAssemblyModule({
-        modulePath: "ThirdParty/Workers/draco_decoder_nodejs.js",
         wasmBinaryFile: "ThirdParty/draco_decoder.wasm",
       })
-      .then(function () {
-        DracoLoader._taskProcessorReady = true;
+      .then(function (result) {
+        if (result) {
+          DracoLoader._taskProcessorReady = true;
+        } else {
+          DracoLoader._error = new RuntimeError(
+            "Draco decoder could not be initialized."
+          );
+        }
+      })
+      .catch((error) => {
+        DracoLoader._error = error;
       });
     DracoLoader._decoderTaskProcessor = processor;
   }
@@ -39,9 +49,15 @@ DracoLoader._getDecoderTaskProcessor = function () {
 /**
  * Decodes a compressed point cloud. Returns undefined if the task cannot be scheduled.
  * @private
+ *
+ * @exception {RuntimeError} Draco decoder could not be initialized.
  */
 DracoLoader.decodePointCloud = function (parameters) {
   const decoderTaskProcessor = DracoLoader._getDecoderTaskProcessor();
+  if (defined(DracoLoader._error)) {
+    throw DracoLoader._error;
+  }
+
   if (!DracoLoader._taskProcessorReady) {
     // The task processor is not ready to schedule tasks
     return;
@@ -62,9 +78,16 @@ DracoLoader.decodePointCloud = function (parameters) {
  *
  * @returns {Promise} A promise that resolves to the decoded indices and attributes.
  * @private
+ *
+ * @exception {RuntimeError} Draco decoder could not be initialized.
  */
 DracoLoader.decodeBufferView = function (options) {
   const decoderTaskProcessor = DracoLoader._getDecoderTaskProcessor();
+
+  if (defined(DracoLoader._error)) {
+    throw DracoLoader._error;
+  }
+
   if (!DracoLoader._taskProcessorReady) {
     // The task processor is not ready to schedule tasks
     return;

package/Source/Scene/I3SDataProvider.js

@@ -55,7 +55,6 @@ import destroyObject from "../Core/destroyObject.js";
 import HeightmapEncoding from "../Core/HeightmapEncoding.js";
 import Resource from "../Core/Resource.js";
 import RuntimeError from "../Core/RuntimeError.js";
-import TaskProcessor from "../Core/TaskProcessor.js";
 import WebMercatorProjection from "../Core/WebMercatorProjection.js";
 import I3SLayer from "./I3SLayer.js";
 import Lerc from "lerc";
@@ -492,32 +491,6 @@ I3SDataProvider.prototype._binarizeGltf = function (rawGltf) {
   return binaryGltfData;
 };
 
-/**
- * @private
- * @returns {Promise<TaskProcessor>}
- */
-I3SDataProvider.prototype.getDecoderTaskProcessor = function () {
-  if (defined(this._taskProcessorReadyPromise)) {
-    return this._taskProcessorReadyPromise;
-  }
-
-  if (!defined(this._decoderTaskProcessor)) {
-    const processor = new TaskProcessor("decodeI3S");
-    this._taskProcessorReadyPromise = processor
-      .initWebAssemblyModule({
-        modulePath: "ThirdParty/Workers/draco_decoder_nodejs.js",
-        wasmBinaryFile: "ThirdParty/draco_decoder.wasm",
-      })
-      .then(() => {
-        return processor;
-      });
-
-    this._decoderTaskProcessor = processor;
-  }
-
-  return this._taskProcessorReadyPromise;
-};
-
 const scratchCartesian2 = new Cartesian2();
 
 function getCoveredTiles(terrainProvider, extent) {

package/Source/Scene/I3SDecoder.js

@@ -0,0 +1,127 @@
+import Cartographic from "../Core/Cartographic.js";
+import Check from "../Core/Check.js";
+import defined from "../Core/defined.js";
+import Ellipsoid from "../Core/Ellipsoid.js";
+import FeatureDetection from "../Core/FeatureDetection.js";
+import CesiumMath from "../Core/Math.js";
+import Matrix3 from "../Core/Matrix3.js";
+import RuntimeError from "../Core/RuntimeError.js";
+import TaskProcessor from "../Core/TaskProcessor.js";
+
+/**
+ * Decode I3S using web workers.
+ *
+ * @private
+ */
+function I3SDecoder() {}
+
+// Maximum concurrency to use when decoding draco models
+I3SDecoder._maxDecodingConcurrency = Math.max(
+  FeatureDetection.hardwareConcurrency - 1,
+  1
+);
+
+I3SDecoder._decodeTaskProcessor = new TaskProcessor(
+  "decodeI3S",
+  I3SDecoder._maxDecodingConcurrency
+);
+
+I3SDecoder._promise = undefined;
+
+async function initializeDecoder() {
+  const result = await I3SDecoder._decodeTaskProcessor.initWebAssemblyModule({
+    wasmBinaryFile: "ThirdParty/draco_decoder.wasm",
+  });
+  if (result) {
+    return I3SDecoder._decodeTaskProcessor;
+  }
+
+  throw new RuntimeError("I3S decoder could not be initialized.");
+}
+
+/**
+ * Transcodes I3S to glTF in a web worker
+ * @param {String} url custom attributes source URL
+ * @param {Object} defaultGeometrySchema Schema to use during decoding
+ * @param {I3SGeometry} geometryData The draco encoded geometry data
+ * @param {Array} [featureData] The draco encoded feature data
+ * @returns Promise<undefined|object> Returns a promise which resolves to the glTF result, or undefined if the task cannot be scheduled this frame.
+ *
+ * @exception {RuntimeError} I3S decoder could not be initialized.
+ */
+I3SDecoder.decode = async function (
+  url,
+  defaultGeometrySchema,
+  geometryData,
+  featureData
+) {
+  //>>includeStart('debug', pragmas.debug);
+  Check.typeOf.string("url", url);
+  Check.defined("defaultGeometrySchema", defaultGeometrySchema);
+  Check.defined("geometryData", geometryData);
+  //>>includeEnd('debug');
+
+  if (!defined(I3SDecoder._promise)) {
+    I3SDecoder._promise = initializeDecoder();
+  }
+
+  return I3SDecoder._promise.then(function (taskProcessor) {
+    // Prepare the data to send to the worker
+    const parentData = geometryData._parent._data;
+    const parentRotationInverseMatrix =
+      geometryData._parent._inverseRotationMatrix;
+
+    let longitude = 0.0;
+    let latitude = 0.0;
+    let height = 0.0;
+
+    if (defined(parentData.obb)) {
+      longitude = parentData.obb.center[0];
+      latitude = parentData.obb.center[1];
+      height = parentData.obb.center[2];
+    } else if (defined(parentData.mbs)) {
+      longitude = parentData.mbs[0];
+      latitude = parentData.mbs[1];
+      height = parentData.mbs[2];
+    }
+
+    const axisFlipRotation = Matrix3.fromRotationX(-CesiumMath.PI_OVER_TWO);
+    const parentRotation = new Matrix3();
+
+    Matrix3.multiply(
+      axisFlipRotation,
+      parentRotationInverseMatrix,
+      parentRotation
+    );
+
+    const cartographicCenter = Cartographic.fromDegrees(
+      longitude,
+      latitude,
+      height
+    );
+
+    const cartesianCenter = Ellipsoid.WGS84.cartographicToCartesian(
+      cartographicCenter
+    );
+
+    const payload = {
+      binaryData: geometryData._data,
+      featureData:
+        defined(featureData) && defined(featureData[0])
+          ? featureData[0].data
+          : undefined,
+      schema: defaultGeometrySchema,
+      bufferInfo: geometryData._geometryBufferInfo,
+      ellipsoidRadiiSquare: Ellipsoid.WGS84.radiiSquared,
+      url: url,
+      geoidDataList: geometryData._dataProvider._geoidDataList,
+      cartographicCenter: cartographicCenter,
+      cartesianCenter: cartesianCenter,
+      parentRotation: parentRotation,
+    };
+
+    return taskProcessor.scheduleTask(payload);
+  });
+};
+
+export default I3SDecoder;