@cesium/engine 3.0.2 → 5.0.0

package/Source/{WorkersES6 → Workers}/decodeI3S.js

@@ -1,4 +1,3 @@
-/* global require */
 import createTaskProcessorWorker from "./createTaskProcessorWorker.js";
 import defined from "../Core/defined.js";
 import WebMercatorProjection from "../Core/WebMercatorProjection.js";
@@ -7,6 +6,7 @@ import Cartographic from "../Core/Cartographic.js";
 import Cartesian3 from "../Core/Cartesian3.js";
 import Matrix3 from "../Core/Matrix3.js";
 import CesiumMath from "../Core/Math.js";
+import dracoModule from "draco3d/draco_decoder_nodejs.js";
 
 let draco;
 
@@ -171,7 +171,6 @@ function transformToLocal(
       const rotatedNormal = {};
       Matrix3.multiplyByVector(parentRotation, normal, rotatedNormal);
 
-      // TODO: check if normals are Z-UP or Y-UP and flip y and z
       normals[indexOffset] = rotatedNormal.x;
       normals[indexOffset1] = rotatedNormal.y;
       normals[indexOffset2] = rotatedNormal.z;
@@ -890,17 +889,11 @@ function decodeBinaryGeometry(data, schema, bufferInfo, featureData) {
       // Use default geometry schema
       for (let i = 0; i < ordering.length; i++) {
         const decoder = binaryAttributeDecoders[ordering[i]];
-        if (!defined(decoder)) {
-          console.log(ordering[i]);
-        }
         offset = decoder(decodedGeometry, data, offset);
       }
 
       for (let j = 0; j < featureAttributeOrder.length; j++) {
         const curDecoder = binaryAttributeDecoders[featureAttributeOrder[j]];
-        if (!defined(curDecoder)) {
-          console.log(featureAttributeOrder[j]);
-        }
         offset = curDecoder(decodedGeometry, data, offset);
       }
     }
@@ -914,7 +907,7 @@ function decodeBinaryGeometry(data, schema, bufferInfo, featureData) {
   return decodedGeometry;
 }
 
-function decodeI3S(parameters) {
+function decodeAndCreateGltf(parameters) {
   // Decode the data into geometry
   const geometryData = decode(
     parameters.binaryData,
@@ -1012,33 +1005,26 @@ function decodeI3S(parameters) {
   return results;
 }
 
-function initWorker(dracoModule) {
-  draco = dracoModule;
-  self.onmessage = createTaskProcessorWorker(decodeI3S);
-  self.postMessage(true);
-}
+async function initWorker(parameters, transferableObjects) {
+  // Require and compile WebAssembly module, or use fallback if not supported
+  const wasmConfig = parameters.webAssemblyConfig;
+  if (defined(wasmConfig) && defined(wasmConfig.wasmBinaryFile)) {
+    draco = await dracoModule(wasmConfig);
+  } else {
+    draco = await dracoModule();
+  }
 
-function decodeI3SStart(event) {
-  const data = event.data;
+  return true;
+}
 
+function decodeI3S(parameters, transferableObjects) {
   // Expect the first message to be to load a web assembly module
-  const wasmConfig = data.webAssemblyConfig;
+  const wasmConfig = parameters.webAssemblyConfig;
   if (defined(wasmConfig)) {
-    // Require and compile WebAssembly module, or use fallback if not supported
-    return require([wasmConfig.modulePath], function (dracoModule) {
-      if (defined(wasmConfig.wasmBinaryFile)) {
-        if (!defined(dracoModule)) {
-          dracoModule = self.DracoDecoderModule;
-        }
-
-        dracoModule(wasmConfig).then(function (compiledModule) {
-          initWorker(compiledModule);
-        });
-      } else {
-        initWorker(dracoModule());
-      }
-    });
+    return initWorker(parameters, transferableObjects);
   }
+
+  return decodeAndCreateGltf(parameters, transferableObjects);
 }
 
-export default decodeI3SStart;
+export default createTaskProcessorWorker(decodeI3S);

package/Source/{WorkersES6 → Workers}/transcodeKTX2.js

@@ -1,4 +1,4 @@
-/* global require */
+import defaultValue from "../Core/defaultValue.js";
 import defined from "../Core/defined.js";
 import Check from "../Core/Check.js";
 import PixelFormat from "../Core/PixelFormat.js";
@@ -7,6 +7,7 @@ import VulkanConstants from "../Core//VulkanConstants.js";
 import PixelDatatype from "../Renderer/PixelDatatype.js";
 import createTaskProcessorWorker from "./createTaskProcessorWorker.js";
 import { read } from "ktx-parse";
+import basis from "../ThirdParty/Workers/basis_transcoder.js";
 
 const faceOrder = [
   "positiveX",
@@ -281,36 +282,28 @@ function transcodeCompressed(
   return result;
 }
 
-function initWorker(compiledModule) {
-  transcoderModule = compiledModule;
+async function initWorker(parameters, transferableObjects) {
+  // Require and compile WebAssembly module, or use fallback if not supported
+  const wasmConfig = parameters.webAssemblyConfig;
+  const basisTranscoder = defaultValue(basis, self.BASIS);
+  if (defined(wasmConfig.wasmBinaryFile)) {
+    transcoderModule = await basisTranscoder(wasmConfig);
+  } else {
+    transcoderModule = await basisTranscoder();
+  }
+
   transcoderModule.initializeBasis();
 
-  self.onmessage = createTaskProcessorWorker(transcode);
-  self.postMessage(true);
+  return true;
 }
 
-function transcodeKTX2(event) {
-  const data = event.data;
-
+function transcodeKTX2(parameters, transferableObjects) {
   // Expect the first message to be to load a web assembly module
-  const wasmConfig = data.webAssemblyConfig;
+  const wasmConfig = parameters.webAssemblyConfig;
   if (defined(wasmConfig)) {
-    // Require and compile WebAssembly module, or use fallback if not supported
-    return require([wasmConfig.modulePath], function (mscBasisTranscoder) {
-      if (defined(wasmConfig.wasmBinaryFile)) {
-        if (!defined(mscBasisTranscoder)) {
-          mscBasisTranscoder = self.MSC_TRANSCODER;
-        }
-
-        mscBasisTranscoder(wasmConfig).then(function (compiledModule) {
-          initWorker(compiledModule);
-        });
-      } else {
-        return mscBasisTranscoder().then(function (transcoder) {
-          initWorker(transcoder);
-        });
-      }
-    });
+    return initWorker(parameters, transferableObjects);
   }
+
+  return transcode(parameters, transferableObjects);
 }
-export default transcodeKTX2;
+export default createTaskProcessorWorker(transcodeKTX2);

package/Source/Workers/transferTypedArrayTest.js

@@ -1,9 +1,3 @@
-// make sure self is defined so that the Dojo build can evaluate this file without crashing.
-if (typeof self === "undefined") {
-  //eslint-disable-next-line no-implicit-globals, no-global-assign
-  self = {};
-}
-
 self.onmessage = function (event) {
   const array = event.data.array;
   const postMessage = self.webkitPostMessage || self.postMessage;

package/index.d.ts

@@ -6405,6 +6405,11 @@ export namespace FeatureDetection {
      * @returns true if the browser supports a WebGL2 rendering context, false if not.
      */
     function supportsWebgl2(scene: Scene): boolean;
+    /**
+     * Detects whether the current browser supports ECMAScript modules in web workers.
+     * @returns true if the browser supports ECMAScript modules in web workers.
+     */
+    function supportsEsmWebWorkers(): boolean;
 }
 
 /**
@@ -12869,6 +12874,15 @@ export class PolygonGeometry {
      * @param [result] - The object into which to store the result.
      */
     static unpack(array: number[], startingIndex?: number, result?: PolygonGeometry): void;
+    /**
+     * Computes a rectangle which encloses the polygon defined by the list of positions, including cases over the international date line and the poles.
+     * @param positions - A linear ring defining the outer boundary of the polygon.
+     * @param [ellipsoid = Ellipsoid.WGS84] - The ellipsoid to be used as a reference.
+     * @param [arcType = ArcType.GEODESIC] - The type of line the polygon edges must follow. Valid options are {@link ArcType.GEODESIC} and {@link ArcType.RHUMB}.
+     * @param [result] - An object in which to store the result.
+     * @returns The result rectangle
+     */
+    static computeRectangleFromPositions(positions: Cartesian3[], ellipsoid?: Ellipsoid, arcType?: ArcType, result?: Rectangle): Rectangle;
     /**
      * Returns the bounding rectangle given the provided options
      * @param options - Object with the following properties:
@@ -16081,6 +16095,15 @@ export class SteppedSpline {
     evaluate(time: number, result?: Cartesian3 | Quaternion): number | Cartesian3 | Quaternion;
 }
 
+/**
+ * Represents a point in stereographic coordinates, which can be obtained by projecting a cartesian coordinate from one pole onto a tangent plane at the other pole.
+ * The stereographic projection faithfully represents the relative directions of all great circles passing through its center point.
+ * To faithfully represents angles everywhere, this is a conformal projection, which means points are projected onto an arbrary sphere.
+ * @param [position] - The steroegraphic coordinates.
+ * @param [tangentPlane] - The tangent plane onto which the point was projected.
+ */
+export function Stereographic(position?: Cartesian2, tangentPlane?: EllipseGeometry): void;
+
 /**
  * A wrapper around a web worker that allows scheduling tasks for a given worker,
  * returning results asynchronously via a promise.
@@ -16120,7 +16143,7 @@ export class TaskProcessor {
     scheduleTask(parameters: any, transferableObjects?: object[]): Promise<object> | undefined;
     /**
      * Posts a message to a web worker with configuration to initialize loading
-     * and compiling a web assembly module asychronously, as well as an optional
+     * and compiling a web assembly module asynchronously, as well as an optional
      * fallback JavaScript module to use if Web Assembly is not supported.
      * @param [webAssemblyOptions] - An object with the following properties:
      * @param [webAssemblyOptions.modulePath] - The path of the web assembly JavaScript wrapper module.
@@ -16132,7 +16155,7 @@ export class TaskProcessor {
         modulePath?: string;
         wasmBinaryFile?: string;
         fallbackModulePath?: string;
-    }): Promise<object>;
+    }): Promise<any>;
     /**
      * Returns true if this object was destroyed; otherwise, false.
      * <br /><br />
@@ -17183,10 +17206,10 @@ export namespace Transforms {
      * at a given time.  This function may return undefined if the data necessary to
      * do the transformation is not yet loaded.
      * @example
-     * // Transform a point from the ICRF axes to the Fixed axes.
+     * // Transform a point from the Fixed axes to the ICRF axes.
      * const now = Cesium.JulianDate.now();
      * const pointInFixed = Cesium.Cartesian3.fromDegrees(0.0, 0.0);
-     * const fixedToIcrf = Cesium.Transforms.computeIcrfToFixedMatrix(now);
+     * const fixedToIcrf = Cesium.Transforms.computeFixedToIcrfMatrix(now);
      * let pointInInertial = new Cesium.Cartesian3();
      * if (Cesium.defined(fixedToIcrf)) {
      *     pointInInertial = Cesium.Matrix3.multiplyByVector(fixedToIcrf, pointInFixed, pointInInertial);
@@ -18341,12 +18364,20 @@ export function queryToObject(queryString: string): any;
  * const updatedPositions = await Cesium.sampleTerrain(terrainProvider, 11, 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.sampleTerrain(terrainProvider, 11, positions, true);
+ * } catch (error) {
+ *   // A tile request error occurred.
+ * }
  * @param terrainProvider - The terrain provider from which to query heights.
  * @param level - The terrain level-of-detail from which to query terrain heights.
  * @param positions - The positions to update with terrain heights.
+ * @param [rejectOnTileFail = false] - If true, for a failed terrain tile request the promise will be rejected. If false, returned heights will be undefined.
  * @returns A promise that resolves to the provided list of positions when terrain the query has completed.
  */
-export function sampleTerrain(terrainProvider: TerrainProvider, level: number, positions: Cartographic[]): Promise<Cartographic[]>;
+export function sampleTerrain(terrainProvider: TerrainProvider, level: number, positions: Cartographic[], rejectOnTileFail?: boolean): Promise<Cartographic[]>;
 
 /**
  * Initiates a sampleTerrain() request at the maximum available tile level for a terrain dataset.
@@ -18360,12 +18391,20 @@ export function sampleTerrain(terrainProvider: TerrainProvider, level: number, p
  * 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.
+ * }
  * @param terrainProvider - The terrain provider from which to query heights.
  * @param positions - The positions to update with terrain heights.
+ * @param [rejectOnTileFail = false] - If true, for a failed terrain tile request the promise will be rejected. If false, returned heights will be undefined.
  * @returns 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.
  */
-export function sampleTerrainMostDetailed(terrainProvider: TerrainProvider, positions: Cartographic[]): Promise<Cartographic[]>;
+export function sampleTerrainMostDetailed(terrainProvider: TerrainProvider, positions: Cartographic[], rejectOnTileFail?: boolean): Promise<Cartographic[]>;
 
 /**
  * Subdivides an array into a number of smaller, equal sized arrays.
@@ -28592,7 +28631,6 @@ export namespace Cesium3DTileset {
      * @property [modelForwardAxis = Axis.X] - Which axis is considered forward when loading models for tile contents.
      * @property [shadows = ShadowMode.ENABLED] - Determines whether the tileset casts or receives shadows from light sources.
      * @property [maximumScreenSpaceError = 16] - The maximum screen space error used to drive level of detail refinement.
-     * @property [maximumMemoryUsage = 512] - The maximum amount of memory in MB that can be used by the tileset. Deprecated.
      * @property [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 [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 [cullWithChildrenBounds = true] - Optimization option. Whether to cull tiles using the union of their children bounding volumes.
@@ -28654,7 +28692,6 @@ export namespace Cesium3DTileset {
         modelForwardAxis?: Axis;
         shadows?: ShadowMode;
         maximumScreenSpaceError?: number;
-        maximumMemoryUsage?: number;
         cacheBytes?: number;
         maximumCacheOverflowBytes?: number;
         cullWithChildrenBounds?: boolean;
@@ -29253,26 +29290,6 @@ export class Cesium3DTileset {
      * </p>
      */
     maximumScreenSpaceError: number;
-    /**
-     * 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>
-     */
-    maximumMemoryUsage: number;
     /**
      * 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
@@ -36819,6 +36836,7 @@ export namespace OpenStreetMapImageryProvider {
      * Initialization options for the OpenStreetMapImageryProvider constructor
      * @property [url = 'https://tile.openstreetmap.org'] - The OpenStreetMap server url.
      * @property [fileExtension = 'png'] - The file extension for images on the server.
+     * @property [retinaTiles = false] - When true, request tiles at the 2x resolution for retina displays.
      * @property [rectangle = Rectangle.MAX_VALUE] - The rectangle of the layer.
      * @property [minimumLevel = 0] - The minimum level-of-detail supported by the imagery provider.
      * @property [maximumLevel] - The maximum level-of-detail supported by the imagery provider, or undefined if there is no limit.
@@ -36828,6 +36846,7 @@ export namespace OpenStreetMapImageryProvider {
     type ConstructorOptions = {
         url?: string;
         fileExtension?: string;
+        retinaTiles?: boolean;
         rectangle?: Rectangle;
         minimumLevel?: number;
         maximumLevel?: number;
@@ -38578,16 +38597,16 @@ export namespace PostProcessStageLibrary {
      * </p>
      * @example
      * // multiple silhouette effects
-     * const yellowEdge = Cesium.PostProcessLibrary.createEdgeDetectionStage();
+     * const yellowEdge = Cesium.PostProcessStageLibrary.createEdgeDetectionStage();
      * yellowEdge.uniforms.color = Cesium.Color.YELLOW;
      * yellowEdge.selected = [feature0];
      *
-     * const greenEdge = Cesium.PostProcessLibrary.createEdgeDetectionStage();
+     * const greenEdge = Cesium.PostProcessStageLibrary.createEdgeDetectionStage();
      * greenEdge.uniforms.color = Cesium.Color.LIME;
      * greenEdge.selected = [feature1];
      *
      * // draw edges around feature0 and feature1
-     * postProcessStages.add(Cesium.PostProcessLibrary.createSilhouetteStage([yellowEdge, greenEdge]);
+     * postProcessStages.add(Cesium.PostProcessStageLibrary.createSilhouetteStage([yellowEdge, greenEdge]);
      * @returns A post-process stage that applies an edge detection effect.
      */
     function createEdgeDetectionStage(): PostProcessStage;
@@ -39012,6 +39031,19 @@ export class PrimitiveCollection {
      * Gets the number of primitives in the collection.
      */
     readonly length: number;
+    /**
+     * An event that is raised when a primitive is added to the collection.
+     * Event handlers are passed the primitive that was added.
+     */
+    readonly primitiveAdded: Event;
+    /**
+     * An event that is raised when a primitive is removed from the collection.
+     * Event handlers are passed the primitive that was removed.
+     * <p>
+     * Note: Depending on the destroyPrimitives constructor option, the primitive may already be destroyed.
+     * </p>
+     */
+    readonly primitiveRemoved: Event;
     /**
      * Adds a primitive to the collection.
      * @example
@@ -40102,8 +40134,9 @@ export namespace SingleTileImageryProvider {
 }
 
 /**
- * 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}.
  * @param options - Object describing initialization options
  */
 export class SingleTileImageryProvider {
@@ -40171,8 +40204,9 @@ export class SingleTileImageryProvider {
      * const provider = await SingleTileImageryProvider.fromUrl("https://yoururl.com/image.png");
      * @param url - The url for the tile
      * @param [options] - Object describing initialization options.
+     * @returns The resolved SingleTileImageryProvider.
      */
-    static fromUrl(url: Resource | string, options?: SingleTileImageryProvider.fromUrlOptions): void;
+    static fromUrl(url: Resource | string, options?: SingleTileImageryProvider.fromUrlOptions): Promise<SingleTileImageryProvider>;
     /**
      * Gets the credits to be displayed when a given tile is displayed.
      * @param x - The tile X coordinate.
@@ -42361,7 +42395,7 @@ export function createWorldImageryAsync(options?: {
  * @param [options.scene3DOnly = false] - When <code>true</code>, each geometry instance will only be rendered in 3D to save GPU memory.
  * @param [options.orderIndependentTranslucency = true] - If true and the configuration supports it, use order independent translucency.
  * @param [options.mapProjection = new GeographicProjection()] - The map projection to use in 2D and Columbus View modes.
- * @param [options.globe = new Globe(mapProjection.ellipsoid)] - The globe to use in the scene.  If set to <code>false</code>, no globe will be added.
+ * @param [options.globe = new Globe(mapProjection.ellipsoid)] - The globe to use in the scene.  If set to <code>false</code>, no globe will be added and the sky atmosphere will be hidden by default.
  * @param [options.useDefaultRenderLoop = true] - True if this widget should control the render loop, false otherwise.
  * @param [options.useBrowserRecommendedResolution = true] - If true, render at the browser's recommended resolution and ignore <code>window.devicePixelRatio</code>.
  * @param [options.targetFrameRate] - The target frame rate when using the default render loop.