@cesium/engine 3.0.2 → 5.0.0

package/Source/Core/TaskProcessor.js

@@ -1,7 +1,6 @@
 import Uri from "urijs";
 import buildModuleUrl from "./buildModuleUrl.js";
 import defaultValue from "./defaultValue.js";
-import defer from "./defer.js";
 import defined from "./defined.js";
 import destroyObject from "./destroyObject.js";
 import DeveloperError from "./DeveloperError.js";
@@ -13,9 +12,7 @@ import RuntimeError from "./RuntimeError.js";
 
 function canTransferArrayBuffer() {
   if (!defined(TaskProcessor._canTransferArrayBuffer)) {
-    const worker = new Worker(
-      getWorkerUrl("Workers/transferTypedArrayTest.js")
-    );
+    const worker = createWorker("transferTypedArrayTest");
     worker.postMessage = defaultValue(
       worker.webkitPostMessage,
       worker.postMessage
@@ -38,23 +35,21 @@ function canTransferArrayBuffer() {
       return TaskProcessor._canTransferArrayBuffer;
     }
 
-    const deferred = defer();
-
-    worker.onmessage = function (event) {
-      const array = event.data.array;
-
-      // some versions of Firefox silently fail to transfer typed arrays.
-      // https://bugzilla.mozilla.org/show_bug.cgi?id=841904
-      // Check to make sure the value round-trips successfully.
-      const result = defined(array) && array[0] === value;
-      deferred.resolve(result);
+    TaskProcessor._canTransferArrayBuffer = new Promise((resolve) => {
+      worker.onmessage = function (event) {
+        const array = event.data.array;
 
-      worker.terminate();
+        // some versions of Firefox silently fail to transfer typed arrays.
+        // https://bugzilla.mozilla.org/show_bug.cgi?id=841904
+        // Check to make sure the value round-trips successfully.
+        const result = defined(array) && array[0] === value;
+        resolve(result);
 
-      TaskProcessor._canTransferArrayBuffer = result;
-    };
+        worker.terminate();
 
-    TaskProcessor._canTransferArrayBuffer = deferred.promise;
+        TaskProcessor._canTransferArrayBuffer = result;
+      };
+    });
   }
 
   return TaskProcessor._canTransferArrayBuffer;
@@ -62,101 +57,73 @@ function canTransferArrayBuffer() {
 
 const taskCompletedEvent = new Event();
 
-function completeTask(processor, data) {
-  --processor._activeTasks;
-
-  const id = data.id;
-  if (!defined(id)) {
-    // This is not one of ours.
-    return;
-  }
-
-  const deferreds = processor._deferreds;
-  const deferred = deferreds[id];
-
-  if (defined(data.error)) {
-    let error = data.error;
-    if (error.name === "RuntimeError") {
-      error = new RuntimeError(data.error.message);
-      error.stack = data.error.stack;
-    } else if (error.name === "DeveloperError") {
-      error = new DeveloperError(data.error.message);
-      error.stack = data.error.stack;
-    }
-    taskCompletedEvent.raiseEvent(error);
-    deferred.reject(error);
-  } else {
-    taskCompletedEvent.raiseEvent();
-    deferred.resolve(data.result);
+function urlFromScript(script) {
+  let blob;
+  try {
+    blob = new Blob([script], {
+      type: "application/javascript",
+    });
+  } catch (e) {
+    const BlobBuilder =
+      window.BlobBuilder ||
+      window.WebKitBlobBuilder ||
+      window.MozBlobBuilder ||
+      window.MSBlobBuilder;
+    const blobBuilder = new BlobBuilder();
+    blobBuilder.append(script);
+    blob = blobBuilder.getBlob("application/javascript");
   }
 
-  delete deferreds[id];
+  const URL = window.URL || window.webkitURL;
+  return URL.createObjectURL(blob);
 }
 
-function getWorkerUrl(moduleID) {
-  let url = buildModuleUrl(moduleID);
+function createWorker(url) {
+  const uri = new Uri(url);
+  const isUri = uri.scheme().length !== 0 && uri.fragment().length === 0;
 
+  const options = {};
+  let workerPath;
   if (isCrossOriginUrl(url)) {
-    //to load cross-origin, create a shim worker from a blob URL
+    // To load cross-origin, create a shim worker from a blob URL
     const script = `importScripts("${url}");`;
+    workerPath = urlFromScript(script);
+    return new Worker(workerPath, options);
+  }
 
-    let blob;
-    try {
-      blob = new Blob([script], {
-        type: "application/javascript",
-      });
-    } catch (e) {
-      const BlobBuilder =
-        window.BlobBuilder ||
-        window.WebKitBlobBuilder ||
-        window.MozBlobBuilder ||
-        window.MSBlobBuilder;
-      const blobBuilder = new BlobBuilder();
-      blobBuilder.append(script);
-      blob = blobBuilder.getBlob("application/javascript");
-    }
-
-    const URL = window.URL || window.webkitURL;
-    url = URL.createObjectURL(blob);
+  const moduleID = url.replace(/\.js$/, "");
+
+  /* global CESIUM_WORKERS */
+  if (!isUri && typeof CESIUM_WORKERS !== "undefined") {
+    // If the workers are embedded, create a shim worker from the embedded script data
+    const script = `
+      importScripts("${urlFromScript(CESIUM_WORKERS)}");
+      CesiumWorkers["${moduleID}"]();
+    `;
+    workerPath = urlFromScript(script);
+    return new Worker(workerPath, options);
   }
 
-  return url;
-}
+  workerPath = url;
 
-let bootstrapperUrlResult;
-function getBootstrapperUrl() {
-  if (!defined(bootstrapperUrlResult)) {
-    bootstrapperUrlResult = getWorkerUrl("Workers/cesiumWorkerBootstrapper.js");
+  if (!isUri) {
+    workerPath = buildModuleUrl(
+      `${TaskProcessor._workerModulePrefix + moduleID}.js`
+    );
   }
-  return bootstrapperUrlResult;
-}
-
-function createWorker(processor) {
-  const worker = new Worker(getBootstrapperUrl());
-  worker.postMessage = defaultValue(
-    worker.webkitPostMessage,
-    worker.postMessage
-  );
 
-  const bootstrapMessage = {
-    loaderConfig: {
-      paths: {
-        Workers: buildModuleUrl("Workers"),
-      },
-      baseUrl: buildModuleUrl.getCesiumBaseUrl().url,
-    },
-    workerModule: processor._workerPath,
-  };
+  if (!FeatureDetection.supportsEsmWebWorkers()) {
+    throw new RuntimeError(
+      "This browser is not supported. Please update your browser to continue."
+    );
+  }
 
-  worker.postMessage(bootstrapMessage);
-  worker.onmessage = function (event) {
-    completeTask(processor, event.data);
-  };
+  options.type = "module";
 
-  return worker;
+  return new Worker(workerPath, options);
 }
 
-function getWebAssemblyLoaderConfig(processor, wasmOptions) {
+async function getWebAssemblyLoaderConfig(processor, wasmOptions) {
   const config = {
     modulePath: undefined,
     wasmBinaryFile: undefined,
@@ -172,18 +139,17 @@ function getWebAssemblyLoaderConfig(processor, wasmOptions) {
     }
 
     config.modulePath = buildModuleUrl(wasmOptions.fallbackModulePath);
-    return Promise.resolve(config);
+    return config;
   }
 
-  config.modulePath = buildModuleUrl(wasmOptions.modulePath);
   config.wasmBinaryFile = buildModuleUrl(wasmOptions.wasmBinaryFile);
 
-  return Resource.fetchArrayBuffer({
+  const arrayBuffer = await Resource.fetchArrayBuffer({
     url: config.wasmBinaryFile,
-  }).then(function (arrayBuffer) {
-    config.wasmBinary = arrayBuffer;
-    return config;
   });
+
+  config.wasmBinary = arrayBuffer;
+  return config;
 }
 
 /**
@@ -201,21 +167,89 @@ function getWebAssemblyLoaderConfig(processor, wasmOptions) {
  *                                        work to be rescheduled in future frames.
  */
 function TaskProcessor(workerPath, maximumActiveTasks) {
-  const uri = new Uri(workerPath);
-  this._workerPath =
-    uri.scheme().length !== 0 && uri.fragment().length === 0
-      ? workerPath
-      : TaskProcessor._workerModulePrefix + workerPath;
+  this._workerPath = workerPath;
   this._maximumActiveTasks = defaultValue(
     maximumActiveTasks,
     Number.POSITIVE_INFINITY
   );
   this._activeTasks = 0;
-  this._deferreds = {};
   this._nextID = 0;
+  this._webAssemblyPromise = undefined;
 }
 
+const createOnmessageHandler = (worker, id, resolve, reject) => {
+  const listener = ({ data }) => {
+    if (data.id !== id) {
+      return;
+    }
+
+    if (defined(data.error)) {
+      let error = data.error;
+      if (error.name === "RuntimeError") {
+        error = new RuntimeError(data.error.message);
+        error.stack = data.error.stack;
+      } else if (error.name === "DeveloperError") {
+        error = new DeveloperError(data.error.message);
+        error.stack = data.error.stack;
+      } else if (error.name === "Error") {
+        error = new Error(data.error.message);
+        error.stack = data.error.stack;
+      }
+      taskCompletedEvent.raiseEvent(error);
+      reject(error);
+    } else {
+      taskCompletedEvent.raiseEvent();
+      resolve(data.result);
+    }
+
+    worker.removeEventListener("message", listener);
+  };
+
+  return listener;
+};
+
 const emptyTransferableObjectArray = [];
+async function runTask(processor, parameters, transferableObjects) {
+  const canTransfer = await Promise.resolve(canTransferArrayBuffer());
+  if (!defined(transferableObjects)) {
+    transferableObjects = emptyTransferableObjectArray;
+  } else if (!canTransfer) {
+    transferableObjects.length = 0;
+  }
+
+  const id = processor._nextID++;
+  const promise = new Promise((resolve, reject) => {
+    processor._worker.addEventListener(
+      "message",
+      createOnmessageHandler(processor._worker, id, resolve, reject)
+    );
+  });
+
+  processor._worker.postMessage(
+    {
+      id: id,
+      baseUrl: buildModuleUrl.getCesiumBaseUrl().url,
+      parameters: parameters,
+      canTransferArrayBuffer: canTransfer,
+    },
+    transferableObjects
+  );
+
+  return promise;
+}
+
+async function scheduleTask(processor, parameters, transferableObjects) {
+  ++processor._activeTasks;
+
+  try {
+    const result = await runTask(processor, parameters, transferableObjects);
+    --processor._activeTasks;
+    return result;
+  } catch (error) {
+    --processor._activeTasks;
+    throw error;
+  }
+}
 
 /**
  * Schedule a task to be processed by the web worker asynchronously.  If there are currently more
@@ -248,89 +282,72 @@ TaskProcessor.prototype.scheduleTask = function (
   transferableObjects
 ) {
   if (!defined(this._worker)) {
-    this._worker = createWorker(this);
+    this._worker = createWorker(this._workerPath);
   }
 
   if (this._activeTasks >= this._maximumActiveTasks) {
     return undefined;
   }
 
-  ++this._activeTasks;
-
-  const processor = this;
-  return Promise.resolve(canTransferArrayBuffer()).then(function (
-    canTransferArrayBuffer
-  ) {
-    if (!defined(transferableObjects)) {
-      transferableObjects = emptyTransferableObjectArray;
-    } else if (!canTransferArrayBuffer) {
-      transferableObjects.length = 0;
-    }
-
-    const id = processor._nextID++;
-    const deferred = defer();
-    processor._deferreds[id] = deferred;
-
-    processor._worker.postMessage(
-      {
-        id: id,
-        parameters: parameters,
-        canTransferArrayBuffer: canTransferArrayBuffer,
-      },
-      transferableObjects
-    );
-
-    return deferred.promise;
-  });
+  return scheduleTask(this, parameters, transferableObjects);
 };
 
 /**
  * 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 {object} [webAssemblyOptions] An object with the following properties:
  * @param {string} [webAssemblyOptions.modulePath] The path of the web assembly JavaScript wrapper module.
  * @param {string} [webAssemblyOptions.wasmBinaryFile] The path of the web assembly binary file.
  * @param {string} [webAssemblyOptions.fallbackModulePath] The path of the fallback JavaScript module to use if web assembly is not supported.
- * @returns {Promise<object>} A promise that resolves to the result when the web worker has loaded and compiled the web assembly module and is ready to process tasks.
+ * @returns {Promise<*>} A promise that resolves to the result when the web worker has loaded and compiled the web assembly module and is ready to process tasks.
+ *
+ * @exception {RuntimeError} This browser does not support Web Assembly, and no backup module was provided
  */
-TaskProcessor.prototype.initWebAssemblyModule = function (webAssemblyOptions) {
-  if (!defined(this._worker)) {
-    this._worker = createWorker(this);
+TaskProcessor.prototype.initWebAssemblyModule = async function (
+  webAssemblyOptions
+) {
+  if (defined(this._webAssemblyPromise)) {
+    return this._webAssemblyPromise;
   }
 
-  const deferred = defer();
-  const processor = this;
-  const worker = this._worker;
-  getWebAssemblyLoaderConfig(this, webAssemblyOptions).then(function (
-    wasmConfig
-  ) {
-    return Promise.resolve(canTransferArrayBuffer()).then(function (
-      canTransferArrayBuffer
-    ) {
-      let transferableObjects;
-      const binary = wasmConfig.wasmBinary;
-      if (defined(binary) && canTransferArrayBuffer) {
-        transferableObjects = [binary];
-      }
-
-      worker.onmessage = function (event) {
-        worker.onmessage = function (event) {
-          completeTask(processor, event.data);
-        };
+  const init = async () => {
+    const worker = (this._worker = createWorker(this._workerPath));
+    const wasmConfig = await getWebAssemblyLoaderConfig(
+      this,
+      webAssemblyOptions
+    );
+    const canTransfer = await Promise.resolve(canTransferArrayBuffer());
+    let transferableObjects;
+    const binary = wasmConfig.wasmBinary;
+    if (defined(binary) && canTransfer) {
+      transferableObjects = [binary];
+    }
 
-        deferred.resolve(event.data);
+    const promise = new Promise((resolve, reject) => {
+      worker.onmessage = function ({ data }) {
+        if (defined(data)) {
+          resolve(data.result);
+        } else {
+          reject(new RuntimeError("Could not configure wasm module"));
+        }
       };
-
-      worker.postMessage(
-        { webAssemblyConfig: wasmConfig },
-        transferableObjects
-      );
     });
-  });
 
-  return deferred.promise;
+    worker.postMessage(
+      {
+        canTransferArrayBuffer: canTransfer,
+        parameters: { webAssemblyConfig: wasmConfig },
+      },
+      transferableObjects
+    );
+
+    return promise;
+  };
+
+  this._webAssemblyPromise = init();
+  return this._webAssemblyPromise;
 };
 
 /**

package/Source/Core/Transforms.js

@@ -749,10 +749,10 @@ const rotation2Scratch = new Matrix3();
  *
  *
  * @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);

package/Source/Core/buildModuleUrl.js

@@ -21,7 +21,7 @@ function getBaseUrlFromCesiumScript() {
 let a;
 function tryMakeAbsolute(url) {
   if (typeof document === "undefined") {
-    //Node.js and Web Workers. In both cases, the URL will already be absolute.
+    // Node.js and Web Workers. In both cases, the URL will already be absolute.
     return url;
   }
 
@@ -29,10 +29,6 @@ function tryMakeAbsolute(url) {
     a = document.createElement("a");
   }
   a.href = url;
-
-  // IE only absolutizes href on get, not set
-  // eslint-disable-next-line no-self-assign
-  a.href = a.href;
   return a.href;
 }
 
@@ -45,17 +41,22 @@ function getCesiumBaseUrl() {
   let baseUrlString;
   if (typeof CESIUM_BASE_URL !== "undefined") {
     baseUrlString = CESIUM_BASE_URL;
+  } else if (defined(import.meta?.url)) {
+    // ESM
+    baseUrlString = getAbsoluteUri(".", import.meta.url);
   } else if (
     typeof define === "object" &&
     defined(define.amd) &&
     !define.amd.toUrlUndefined &&
     defined(require.toUrl)
   ) {
+    // RequireJS
     baseUrlString = getAbsoluteUri(
       "..",
       buildModuleUrl("Core/buildModuleUrl.js")
     );
   } else {
+    // IIFE
     baseUrlString = getBaseUrlFromCesiumScript();
   }
 

package/Source/Core/sampleTerrain.js

@@ -20,6 +20,7 @@ import defined from "./defined.js";
  * @param {TerrainProvider} terrainProvider The terrain provider from which to query heights.
  * @param {number} level The terrain level-of-detail from which to query terrain 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.
  *
  * @see sampleTerrainMostDetailed
@@ -34,26 +35,43 @@ import defined from "./defined.js";
  * 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.
+ * }
  */
-async function sampleTerrain(terrainProvider, level, positions) {
+async function sampleTerrain(
+  terrainProvider,
+  level,
+  positions,
+  rejectOnTileFail
+) {
+  if (!defined(rejectOnTileFail)) {
+    rejectOnTileFail = false;
+  }
   //>>includeStart('debug', pragmas.debug);
   Check.typeOf.object("terrainProvider", terrainProvider);
   Check.typeOf.number("level", level);
+  Check.typeOf.bool("rejectOnTileFail", rejectOnTileFail);
   Check.defined("positions", positions);
   //>>includeEnd('debug');
 
-  return doSampling(terrainProvider, level, positions);
+  return doSampling(terrainProvider, level, positions, rejectOnTileFail);
 }
 
 /**
  * @param {object[]} tileRequests The mutated list of requests, the first one will be attempted
  * @param {Array<Promise<void>>} results The list to put the result promises into
+ * @param {boolean} rejectOnTileFail If true, the promise will be rejected.  If false, returned heights will be undefined.
  * @returns {boolean} true if the request was made, and we are okay to attempt the next item immediately,
  *  or false if we were throttled and should wait awhile before retrying.
  *
  * @private
  */
-function attemptConsumeNextQueueItem(tileRequests, results) {
+function attemptConsumeNextQueueItem(tileRequests, results, rejectOnTileFail) {
   const tileRequest = tileRequests[0];
   const requestPromise = tileRequest.terrainProvider.requestTileGeometry(
     tileRequest.x,
@@ -66,9 +84,15 @@ function attemptConsumeNextQueueItem(tileRequests, results) {
     return false;
   }
 
-  const promise = requestPromise
-    .then(createInterpolateFunction(tileRequest))
-    .catch(createMarkFailedFunction(tileRequest));
+  let promise;
+
+  if (rejectOnTileFail) {
+    promise = requestPromise.then(createInterpolateFunction(tileRequest));
+  } else {
+    promise = requestPromise
+      .then(createInterpolateFunction(tileRequest))
+      .catch(createMarkFailedFunction(tileRequest));
+  }
 
   // remove the request we've just done from the queue
   //  and add its promise result to the result list
@@ -95,11 +119,12 @@ function delay(ms) {
  *  and a Promise of each result has been put into the results list
  * @param {object[]} tileRequests The list of requests desired to be made
  * @param {Array<Promise<void>>} results The list to put all the result promises into
+ * @param {boolean} rejectOnTileFail If true, the promise will be rejected.  If false, returned heights will be undefined.
  * @returns {Promise<void>} A promise which resolves once all requests have been started
  *
  * @private
  */
-function drainTileRequestQueue(tileRequests, results) {
+function drainTileRequestQueue(tileRequests, results, rejectOnTileFail) {
   // nothing left to do
   if (!tileRequests.length) {
     return Promise.resolve();
@@ -108,7 +133,11 @@ function drainTileRequestQueue(tileRequests, results) {
   // consume an item from the queue, which will
   //  mutate the request and result lists, and return true if we should
   //  immediately attempt to consume the next item as well
-  const success = attemptConsumeNextQueueItem(tileRequests, results);
+  const success = attemptConsumeNextQueueItem(
+    tileRequests,
+    results,
+    rejectOnTileFail
+  );
   if (success) {
     return drainTileRequestQueue(tileRequests, results);
   }
@@ -119,7 +148,7 @@ function drainTileRequestQueue(tileRequests, results) {
   });
 }
 
-function doSampling(terrainProvider, level, positions) {
+function doSampling(terrainProvider, level, positions, rejectOnTileFail) {
   const tilingScheme = terrainProvider.tilingScheme;
 
   let i;
@@ -155,7 +184,11 @@ function doSampling(terrainProvider, level, positions) {
 
   // create our list of result promises to be filled
   const tilePromises = [];
-  return drainTileRequestQueue(tileRequests, tilePromises).then(function () {
+  return drainTileRequestQueue(
+    tileRequests,
+    tilePromises,
+    rejectOnTileFail
+  ).then(function () {
     // now all the required requests have been started
     //  we just wait for them all to finish
     return Promise.all(tilePromises).then(function () {