@cesium/engine 3.0.1 → 4.0.0

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;

package/Source/Scene/I3SNode.js

@@ -3,7 +3,6 @@ import defaultValue from "../Core/defaultValue.js";
 import defined from "../Core/defined.js";
 import Ellipsoid from "../Core/Ellipsoid.js";
 import HeadingPitchRoll from "../Core/HeadingPitchRoll.js";
-import CesiumMath from "../Core/Math.js";
 import Matrix3 from "../Core/Matrix3.js";
 import Matrix4 from "../Core/Matrix4.js";
 import Resource from "../Core/Resource.js";
@@ -11,6 +10,7 @@ import Quaternion from "../Core/Quaternion.js";
 import Transforms from "../Core/Transforms.js";
 import Cesium3DTile from "./Cesium3DTile.js";
 import I3SDataProvider from "./I3SDataProvider.js";
+import I3SDecoder from "./I3SDecoder.js";
 import I3SFeature from "./I3SFeature.js";
 import I3SField from "./I3SField.js";
 import I3SGeometry from "./I3SGeometry.js";
@@ -608,71 +608,6 @@ I3SNode.prototype._create3DTileDefinition = function () {
   return inPlaceTileDefinition;
 };
 
-/**
- * @private
- */
-I3SNode.prototype._createI3SDecoderTask = async function (
-  decodeI3STaskProcessor,
-  data
-) {
-  // Prepare the data to send to the worker
-  const parentData = data.geometryData._parent._data;
-  const parentRotationInverseMatrix =
-    data.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: data.geometryData._data,
-    featureData:
-      defined(data.featureData) && defined(data.featureData[0])
-        ? data.featureData[0].data
-        : undefined,
-    schema: data.defaultGeometrySchema,
-    bufferInfo: data.geometryData._geometryBufferInfo,
-    ellipsoidRadiiSquare: Ellipsoid.WGS84.radiiSquared,
-    url: data.url,
-    geoidDataList: data.geometryData._dataProvider._geoidDataList,
-    cartographicCenter: cartographicCenter,
-    cartesianCenter: cartesianCenter,
-    parentRotation: parentRotation,
-  };
-
-  const transferrableObjects = [];
-  return decodeI3STaskProcessor.scheduleTask(payload, transferrableObjects);
-};
-
 /**
  * @private
  */
@@ -702,59 +637,46 @@ I3SNode.prototype._createContentURL = async function () {
     },
   };
 
-  const decodeI3STaskProcessor = await this._dataProvider.getDecoderTaskProcessor();
-
   // Load the geometry data
   const dataPromises = [this._loadGeometryData()];
   if (this._dataProvider.legacyVersion16) {
     dataPromises.push(this._loadFeatureData());
   }
 
-  const that = this;
-  return Promise.all(dataPromises).then(function () {
-    // Binary glTF
-    let generateGltfPromise = Promise.resolve();
-    if (defined(that._geometryData) && that._geometryData.length > 0) {
-      const parameters = {
-        geometryData: that._geometryData[0],
-        featureData: that._featureData,
-        defaultGeometrySchema: that._layer._data.store.defaultGeometrySchema,
-        url: that._geometryData[0].resource.url,
-        tile: that._tile,
-      };
-
-      const promise = that._createI3SDecoderTask(
-        decodeI3STaskProcessor,
-        parameters
-      );
-      if (!defined(promise)) {
-        // Postponed
-        return;
-      }
-
-      generateGltfPromise = promise.then(function (result) {
-        rawGltf = parameters.geometryData._generateGltf(
-          result.meshData.nodesInScene,
-          result.meshData.nodes,
-          result.meshData.meshes,
-          result.meshData.buffers,
-          result.meshData.bufferViews,
-          result.meshData.accessors
-        );
-
-        that._geometryData[0]._customAttributes =
-          result.meshData._customAttributes;
-      });
+  await Promise.all(dataPromises);
+  // Binary glTF
+  if (defined(this._geometryData) && this._geometryData.length > 0) {
+    const url = this._geometryData[0].resource.url;
+    const geometrySchema = this._layer._data.store.defaultGeometrySchema;
+    const geometryData = this._geometryData[0];
+    const result = await I3SDecoder.decode(
+      url,
+      geometrySchema,
+      geometryData,
+      this._featureData[0]
+    );
+    if (!defined(result)) {
+      // Postponed
+      return;
     }
 
-    return generateGltfPromise.then(function () {
-      const binaryGltfData = that._dataProvider._binarizeGltf(rawGltf);
-      const glbDataBlob = new Blob([binaryGltfData], {
-        type: "application/binary",
-      });
-      return URL.createObjectURL(glbDataBlob);
-    });
+    rawGltf = geometryData._generateGltf(
+      result.meshData.nodesInScene,
+      result.meshData.nodes,
+      result.meshData.meshes,
+      result.meshData.buffers,
+      result.meshData.bufferViews,
+      result.meshData.accessors
+    );
+
+    this._geometryData[0]._customAttributes = result.meshData._customAttributes;
+  }
+
+  const binaryGltfData = this._dataProvider._binarizeGltf(rawGltf);
+  const glbDataBlob = new Blob([binaryGltfData], {
+    type: "application/binary",
   });
+  return URL.createObjectURL(glbDataBlob);
 };
 
 // Reimplement Cesium3DTile.prototype.requestContent so that

package/Source/Scene/ImageryLayer.js

@@ -140,8 +140,8 @@ import TileImagery from "./TileImagery.js";
  *
  * @example
  * // Add an OpenStreetMaps layer
- * const imageryLayer = new Cesium.ImageryLayer(OpenStreetMapImageryProvider({
- *   url: "https://a.tile.openstreetmap.org/"
+ * const imageryLayer = new Cesium.ImageryLayer(new Cesium.OpenStreetMapImageryProvider({
+ *   url: "https://tile.openstreetmap.org/"
  * })),
  * scene.imageryLayers.add(imageryLayer);
  *

package/Source/Scene/Implicit3DTileContent.js

@@ -536,8 +536,21 @@ function deriveChildTile(
   // user specified such as extras or extensions.
   const deep = true;
   const rootHeader = clone(implicitTileset.tileHeader, deep);
+  // The bounding volume was computed above since it may come from metadata
+  // in the subtree file.
   delete rootHeader.boundingVolume;
+  // Copying the transform to all the transcoded tiles would cause the transform
+  // to be applied multiple times. Removing it from the header avoids this issue.
   delete rootHeader.transform;
+  // The implicit tiling spec does not specify what should happen if explicit
+  // tile metadata is added to the placeholder tile. Since implicit tile
+  // metadata comes from the subtree file, ignore the explicit version.
+  //
+  // Also, when a property with the semantic TILE_BOUNDING_VOLUME is added to
+  // the placeholder tile to set a tight bounding volume (See Cesium3DTile.js)
+  // propagating it to transcoded tiles causes transcoded tiles to use the
+  // wrong bounding volume, this can lead to loading far too many tiles.
+  delete rootHeader.metadata;
   const combinedTileJson = combine(tileJson, rootHeader, deep);
 
   const childTile = makeTile(

package/Source/Scene/ImplicitTileset.js

@@ -60,6 +60,11 @@ function ImplicitTileset(baseResource, tileJson, metadataSchema) {
    */
   this.metadataSchema = metadataSchema;
 
+  // Due to using explicit tile metadata to store a tight bounding box
+  // in some cases (see https://github.com/CesiumGS/cesium/pull/11365)
+  // it's important that this bounding volume is computed from the tile JSON
+  // (which is the original, possibly loose bounding volume) rather than
+  // tile.boundingVolume which is the tighter one.
   const boundingVolume = tileJson.boundingVolume;
   if (
     !defined(boundingVolume.box) &&

package/Source/Scene/Model/I3dmLoader.js

@@ -423,7 +423,11 @@ function createInstances(loader, components, frameState) {
   // For I3DMs that do not define an RTC center, we manually compute a BoundingSphere and store
   // positions relative to the center, to be uploaded to the GPU. This avoids jittering at higher
   // precisions.
-  if (!defined(rtcCenter)) {
+  // Also manually compute if RTC center equals Cartesian3.ZERO
+  if (
+    !defined(rtcCenter) ||
+    Cartesian3.equals(Cartesian3.unpack(rtcCenter), Cartesian3.ZERO)
+  ) {
     const positionBoundingSphere = BoundingSphere.fromPoints(instancePositions);
 
     for (i = 0; i < instancePositions.length; i++) {

package/Source/Scene/Model/Model.js

@@ -1838,7 +1838,10 @@ Model.prototype.update = function (frameState) {
 };
 
 function processLoader(model, frameState) {
-  if (!model._resourcesLoaded || !model._texturesLoaded) {
+  if (
+    !model._resourcesLoaded ||
+    (model._loader.incrementallyLoadTextures && !model._texturesLoaded)
+  ) {
     // Ensures frames continue to render in requestRender mode while resources are processing
     frameState.afterRender.push(() => true);
     return model._loader.process(frameState);

package/Source/Scene/OpenStreetMapImageryProvider.js

@@ -16,8 +16,9 @@ const defaultCredit = new Credit(
  *
  * Initialization options for the OpenStreetMapImageryProvider constructor
  *
- * @property {string} [url='https://a.tile.openstreetmap.org'] The OpenStreetMap server url.
+ * @property {string} [url='https://tile.openstreetmap.org'] The OpenStreetMap server url.
  * @property {string} [fileExtension='png'] The file extension for images on the server.
+ * @property {boolean} [retinaTiles=false] When true, request tiles at the 2x resolution for retina displays.
  * @property {Rectangle} [rectangle=Rectangle.MAX_VALUE] The rectangle of the layer.
  * @property {number} [minimumLevel=0] The minimum level-of-detail supported by the imagery provider.
  * @property {number} [maximumLevel] The maximum level-of-detail supported by the imagery provider, or undefined if there is no limit.
@@ -49,7 +50,7 @@ const defaultCredit = new Credit(
  *
  * @example
  * const osm = new Cesium.OpenStreetMapImageryProvider({
- *     url : 'https://a.tile.openstreetmap.org/'
+ *     url : 'https://tile.openstreetmap.org/'
  * });
  *
  * @see {@link http://wiki.openstreetmap.org/wiki/Main_Page|OpenStreetMap Wiki}
@@ -59,10 +60,12 @@ function OpenStreetMapImageryProvider(options) {
   options = defaultValue(options, defaultValue.EMPTY_OBJECT);
 
   const resource = Resource.createIfNeeded(
-    defaultValue(options.url, "https://a.tile.openstreetmap.org/")
+    defaultValue(options.url, "https://tile.openstreetmap.org/")
   );
   resource.appendForwardSlash();
-  resource.url += `{z}/{x}/{y}.${defaultValue(options.fileExtension, "png")}`;
+  resource.url += `{z}/{x}/{y}${
+    options.retinaTiles ? "@2x" : ""
+  }.${defaultValue(options.fileExtension, "png")}`;
 
   const tilingScheme = new WebMercatorTilingScheme({
     ellipsoid: options.ellipsoid,

package/Source/Scene/SingleTileImageryProvider.js

@@ -24,8 +24,9 @@ import ImageryProvider from "./ImageryProvider.js";
  */
 
 /**
- * Provides a single, top-level imagery tile.  The single image is assumed to use a
- * {@link GeographicTilingScheme}.
+ * Provides a single, top-level imagery tile.  The single image is assumed to be in
+ * the Geographic projection (i.e. WGS84 / EPSG:4326),
+ * and will be rendered using a {@link GeographicTilingScheme}.
  *
  * @alias SingleTileImageryProvider
  * @constructor
@@ -295,6 +296,7 @@ async function doRequest(resource, provider, previousError) {
  * Creates a provider for a single, top-level imagery tile.  The single image is assumed to use a
  * @param {Resource|String} url The url for the tile
  * @param {SingleTileImageryProvider.fromUrlOptions} [options] Object describing initialization options.
+ * @returns {Promise.<SingleTileImageryProvider>} The resolved SingleTileImageryProvider.
  *
  * @example
  * const provider = await SingleTileImageryProvider.fromUrl("https://yoururl.com/image.png");