@cesium/engine 9.2.0 → 10.1.0

package/Build/Workers/{chunk-GX5LMUGZ.js → chunk-PYHLO636.js}

@@ -1,7 +1,7 @@
 /**
  * @license
  * Cesium - https://github.com/CesiumGS/cesium
- * Version 1.118
+ * Version 1.119
  *
  * Copyright 2011-2022 Cesium Contributors
  *
@@ -25,17 +25,17 @@
 
 import {
   Math_default
-} from "./chunk-ETC45PHH.js";
+} from "./chunk-MSKXMXJI.js";
 import {
   defaultValue_default
-} from "./chunk-EODIOQ35.js";
+} from "./chunk-VE7BFUIX.js";
 import {
   Check_default,
   DeveloperError_default
-} from "./chunk-DIVFF6DK.js";
+} from "./chunk-S3PI2KFM.js";
 import {
   defined_default
-} from "./chunk-IF2OX6R4.js";
+} from "./chunk-AA4GZKOT.js";
 
 // packages/engine/Source/Core/Cartesian3.js
 function Cartesian3(x, y, z) {
@@ -396,7 +396,7 @@ Cartesian3.fromDegrees = function(longitude, latitude, height, ellipsoid, result
 };
 var scratchN = new Cartesian3();
 var scratchK = new Cartesian3();
-var wgs84RadiiSquared = new Cartesian3(
+Cartesian3._ellipsoidRadiiSquared = new Cartesian3(
   6378137 * 6378137,
   6378137 * 6378137,
   6356752314245179e-9 * 6356752314245179e-9
@@ -405,7 +405,7 @@ Cartesian3.fromRadians = function(longitude, latitude, height, ellipsoid, result
   Check_default.typeOf.number("longitude", longitude);
   Check_default.typeOf.number("latitude", latitude);
   height = defaultValue_default(height, 0);
-  const radiiSquared = defined_default(ellipsoid) ? ellipsoid.radiiSquared : wgs84RadiiSquared;
+  const radiiSquared = !defined_default(ellipsoid) ? Cartesian3._ellipsoidRadiiSquared : ellipsoid.radiiSquared;
   const cosLatitude = Math.cos(latitude);
   scratchN.x = cosLatitude * Math.cos(longitude);
   scratchN.y = cosLatitude * Math.sin(longitude);
@@ -667,21 +667,21 @@ Cartographic.fromDegrees = function(longitude, latitude, height, result) {
 var cartesianToCartographicN = new Cartesian3_default();
 var cartesianToCartographicP = new Cartesian3_default();
 var cartesianToCartographicH = new Cartesian3_default();
-var wgs84OneOverRadii = new Cartesian3_default(
+Cartographic._ellipsoidOneOverRadii = new Cartesian3_default(
   1 / 6378137,
   1 / 6378137,
   1 / 6356752314245179e-9
 );
-var wgs84OneOverRadiiSquared = new Cartesian3_default(
+Cartographic._ellipsoidOneOverRadiiSquared = new Cartesian3_default(
   1 / (6378137 * 6378137),
   1 / (6378137 * 6378137),
   1 / (6356752314245179e-9 * 6356752314245179e-9)
 );
-var wgs84CenterToleranceSquared = Math_default.EPSILON1;
+Cartographic._ellipsoidCenterToleranceSquared = Math_default.EPSILON1;
 Cartographic.fromCartesian = function(cartesian, ellipsoid, result) {
-  const oneOverRadii = defined_default(ellipsoid) ? ellipsoid.oneOverRadii : wgs84OneOverRadii;
-  const oneOverRadiiSquared = defined_default(ellipsoid) ? ellipsoid.oneOverRadiiSquared : wgs84OneOverRadiiSquared;
-  const centerToleranceSquared = defined_default(ellipsoid) ? ellipsoid._centerToleranceSquared : wgs84CenterToleranceSquared;
+  const oneOverRadii = defined_default(ellipsoid) ? ellipsoid.oneOverRadii : Cartographic._ellipsoidOneOverRadii;
+  const oneOverRadiiSquared = defined_default(ellipsoid) ? ellipsoid.oneOverRadiiSquared : Cartographic._ellipsoidOneOverRadiiSquared;
+  const centerToleranceSquared = defined_default(ellipsoid) ? ellipsoid._centerToleranceSquared : Cartographic._ellipsoidCenterToleranceSquared;
   const p = scaleToGeodeticSurface_default(
     cartesian,
     oneOverRadii,
@@ -1216,6 +1216,35 @@ Ellipsoid.MOON = Object.freeze(
     Math_default.LUNAR_RADIUS
   )
 );
+Ellipsoid._default = Ellipsoid.WGS84;
+Object.defineProperties(Ellipsoid, {
+  /**
+   * The default ellipsoid used when not otherwise specified.
+   * @memberof Ellipsoid
+   * @type {Ellipsoid}
+   * @example
+   * Cesium.Ellipsoid.default = Cesium.Ellipsoid.MOON;
+   *
+   * // Apollo 11 landing site
+   * const position = Cesium.Cartesian3.fromRadians(
+   *   0.67416,
+   *   23.47315,
+   * );
+   */
+  default: {
+    get: function() {
+      return Ellipsoid._default;
+    },
+    set: function(value) {
+      Check_default.typeOf.object("value", value);
+      Ellipsoid._default = value;
+      Cartesian3_default._ellipsoidRadiiSquared = value.radiiSquared;
+      Cartographic_default._ellipsoidOneOverRadii = value.oneOverRadii;
+      Cartographic_default._ellipsoidOneOverRadiiSquared = value.oneOverRadiiSquared;
+      Cartographic_default._ellipsoidCenterToleranceSquared = value._centerToleranceSquared;
+    }
+  }
+});
 Ellipsoid.prototype.clone = function(result) {
   return Ellipsoid.clone(this, result);
 };

package/Build/Workers/chunk-Q55ECN3Y.js

@@ -0,0 +1,37 @@
+/**
+ * @license
+ * Cesium - https://github.com/CesiumGS/cesium
+ * Version 1.119
+ *
+ * Copyright 2011-2022 Cesium Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * Columbus View (Pat. Pend.)
+ *
+ * Portions licensed separately.
+ * See https://github.com/CesiumGS/cesium/blob/main/LICENSE.md for full licensing details.
+ */
+
+
+// packages/engine/Source/Core/GeometryOffsetAttribute.js
+var GeometryOffsetAttribute = {
+  NONE: 0,
+  TOP: 1,
+  ALL: 2
+};
+var GeometryOffsetAttribute_default = Object.freeze(GeometryOffsetAttribute);
+
+export {
+  GeometryOffsetAttribute_default
+};

package/Build/Workers/chunk-QD4KM3GO.js

@@ -0,0 +1,138 @@
+/**
+ * @license
+ * Cesium - https://github.com/CesiumGS/cesium
+ * Version 1.119
+ *
+ * Copyright 2011-2022 Cesium Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * Columbus View (Pat. Pend.)
+ *
+ * Portions licensed separately.
+ * See https://github.com/CesiumGS/cesium/blob/main/LICENSE.md for full licensing details.
+ */
+
+import {
+  Math_default
+} from "./chunk-MSKXMXJI.js";
+import {
+  WebGLConstants_default
+} from "./chunk-OOK53QUQ.js";
+import {
+  DeveloperError_default
+} from "./chunk-S3PI2KFM.js";
+import {
+  defined_default
+} from "./chunk-AA4GZKOT.js";
+
+// packages/engine/Source/Core/IndexDatatype.js
+var IndexDatatype = {
+  /**
+   * 8-bit unsigned byte corresponding to <code>UNSIGNED_BYTE</code> and the type
+   * of an element in <code>Uint8Array</code>.
+   *
+   * @type {number}
+   * @constant
+   */
+  UNSIGNED_BYTE: WebGLConstants_default.UNSIGNED_BYTE,
+  /**
+   * 16-bit unsigned short corresponding to <code>UNSIGNED_SHORT</code> and the type
+   * of an element in <code>Uint16Array</code>.
+   *
+   * @type {number}
+   * @constant
+   */
+  UNSIGNED_SHORT: WebGLConstants_default.UNSIGNED_SHORT,
+  /**
+   * 32-bit unsigned int corresponding to <code>UNSIGNED_INT</code> and the type
+   * of an element in <code>Uint32Array</code>.
+   *
+   * @type {number}
+   * @constant
+   */
+  UNSIGNED_INT: WebGLConstants_default.UNSIGNED_INT
+};
+IndexDatatype.getSizeInBytes = function(indexDatatype) {
+  switch (indexDatatype) {
+    case IndexDatatype.UNSIGNED_BYTE:
+      return Uint8Array.BYTES_PER_ELEMENT;
+    case IndexDatatype.UNSIGNED_SHORT:
+      return Uint16Array.BYTES_PER_ELEMENT;
+    case IndexDatatype.UNSIGNED_INT:
+      return Uint32Array.BYTES_PER_ELEMENT;
+  }
+  throw new DeveloperError_default(
+    "indexDatatype is required and must be a valid IndexDatatype constant."
+  );
+};
+IndexDatatype.fromSizeInBytes = function(sizeInBytes) {
+  switch (sizeInBytes) {
+    case 2:
+      return IndexDatatype.UNSIGNED_SHORT;
+    case 4:
+      return IndexDatatype.UNSIGNED_INT;
+    case 1:
+      return IndexDatatype.UNSIGNED_BYTE;
+    default:
+      throw new DeveloperError_default(
+        "Size in bytes cannot be mapped to an IndexDatatype"
+      );
+  }
+};
+IndexDatatype.validate = function(indexDatatype) {
+  return defined_default(indexDatatype) && (indexDatatype === IndexDatatype.UNSIGNED_BYTE || indexDatatype === IndexDatatype.UNSIGNED_SHORT || indexDatatype === IndexDatatype.UNSIGNED_INT);
+};
+IndexDatatype.createTypedArray = function(numberOfVertices, indicesLengthOrArray) {
+  if (!defined_default(numberOfVertices)) {
+    throw new DeveloperError_default("numberOfVertices is required.");
+  }
+  if (numberOfVertices >= Math_default.SIXTY_FOUR_KILOBYTES) {
+    return new Uint32Array(indicesLengthOrArray);
+  }
+  return new Uint16Array(indicesLengthOrArray);
+};
+IndexDatatype.createTypedArrayFromArrayBuffer = function(numberOfVertices, sourceArray, byteOffset, length) {
+  if (!defined_default(numberOfVertices)) {
+    throw new DeveloperError_default("numberOfVertices is required.");
+  }
+  if (!defined_default(sourceArray)) {
+    throw new DeveloperError_default("sourceArray is required.");
+  }
+  if (!defined_default(byteOffset)) {
+    throw new DeveloperError_default("byteOffset is required.");
+  }
+  if (numberOfVertices >= Math_default.SIXTY_FOUR_KILOBYTES) {
+    return new Uint32Array(sourceArray, byteOffset, length);
+  }
+  return new Uint16Array(sourceArray, byteOffset, length);
+};
+IndexDatatype.fromTypedArray = function(array) {
+  if (array instanceof Uint8Array) {
+    return IndexDatatype.UNSIGNED_BYTE;
+  }
+  if (array instanceof Uint16Array) {
+    return IndexDatatype.UNSIGNED_SHORT;
+  }
+  if (array instanceof Uint32Array) {
+    return IndexDatatype.UNSIGNED_INT;
+  }
+  throw new DeveloperError_default(
+    "array must be a Uint8Array, Uint16Array, or Uint32Array."
+  );
+};
+var IndexDatatype_default = Object.freeze(IndexDatatype);
+
+export {
+  IndexDatatype_default
+};

package/Build/Workers/chunk-QMLTCCYG.js

@@ -0,0 +1,55 @@
+/**
+ * @license
+ * Cesium - https://github.com/CesiumGS/cesium
+ * Version 1.119
+ *
+ * Copyright 2011-2022 Cesium Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * Columbus View (Pat. Pend.)
+ *
+ * Portions licensed separately.
+ * See https://github.com/CesiumGS/cesium/blob/main/LICENSE.md for full licensing details.
+ */
+
+
+// packages/engine/Source/Core/ArcType.js
+var ArcType = {
+  /**
+   * Straight line that does not conform to the surface of the ellipsoid.
+   *
+   * @type {number}
+   * @constant
+   */
+  NONE: 0,
+  /**
+   * Follow geodesic path.
+   *
+   * @type {number}
+   * @constant
+   */
+  GEODESIC: 1,
+  /**
+   * Follow rhumb or loxodrome path.
+   *
+   * @type {number}
+   * @constant
+   */
+  RHUMB: 2
+};
+var ArcType_default = Object.freeze(ArcType);
+
+export {
+  ArcType_default
+};

package/Build/Workers/chunk-QX5XS4LC.js

@@ -0,0 +1,101 @@
+/**
+ * @license
+ * Cesium - https://github.com/CesiumGS/cesium
+ * Version 1.119
+ *
+ * Copyright 2011-2022 Cesium Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * Columbus View (Pat. Pend.)
+ *
+ * Portions licensed separately.
+ * See https://github.com/CesiumGS/cesium/blob/main/LICENSE.md for full licensing details.
+ */
+
+import {
+  defined_default
+} from "./chunk-AA4GZKOT.js";
+
+// packages/engine/Source/Core/formatError.js
+function formatError(object) {
+  let result;
+  const name = object.name;
+  const message = object.message;
+  if (defined_default(name) && defined_default(message)) {
+    result = `${name}: ${message}`;
+  } else {
+    result = object.toString();
+  }
+  const stack = object.stack;
+  if (defined_default(stack)) {
+    result += `
+${stack}`;
+  }
+  return result;
+}
+var formatError_default = formatError;
+
+// packages/engine/Source/Workers/createTaskProcessorWorker.js
+function createTaskProcessorWorker(workerFunction) {
+  async function onMessageHandler({ data }) {
+    const transferableObjects = [];
+    const responseMessage = {
+      id: data.id,
+      result: void 0,
+      error: void 0
+    };
+    self.CESIUM_BASE_URL = data.baseUrl;
+    try {
+      const result = await workerFunction(data.parameters, transferableObjects);
+      responseMessage.result = result;
+    } catch (error) {
+      if (error instanceof Error) {
+        responseMessage.error = {
+          name: error.name,
+          message: error.message,
+          stack: error.stack
+        };
+      } else {
+        responseMessage.error = error;
+      }
+    }
+    if (!data.canTransferArrayBuffer) {
+      transferableObjects.length = 0;
+    }
+    try {
+      postMessage(responseMessage, transferableObjects);
+    } catch (error) {
+      responseMessage.result = void 0;
+      responseMessage.error = `postMessage failed with error: ${formatError_default(
+        error
+      )}
+  with responseMessage: ${JSON.stringify(responseMessage)}`;
+      postMessage(responseMessage);
+    }
+  }
+  function onMessageErrorHandler(event) {
+    postMessage({
+      id: event.data?.id,
+      error: `postMessage failed with error: ${JSON.stringify(event)}`
+    });
+  }
+  self.onmessage = onMessageHandler;
+  self.onmessageerror = onMessageErrorHandler;
+  return self;
+}
+var createTaskProcessorWorker_default = createTaskProcessorWorker;
+
+export {
+  createTaskProcessorWorker_default
+};

package/Build/Workers/{chunk-UKJCFXVV.js → chunk-QYQIVZBU.js}

@@ -1,7 +1,7 @@
 /**
  * @license
  * Cesium - https://github.com/CesiumGS/cesium
- * Version 1.118
+ * Version 1.120
  *
  * Copyright 2011-2022 Cesium Contributors
  *
@@ -27,19 +27,19 @@ import {
   Cartesian3_default,
   Cartographic_default,
   Ellipsoid_default
-} from "./chunk-GX5LMUGZ.js";
+} from "./chunk-T6LPN7RI.js";
 import {
   Math_default
-} from "./chunk-ETC45PHH.js";
+} from "./chunk-R4OIEIPE.js";
 import {
   defaultValue_default
-} from "./chunk-EODIOQ35.js";
+} from "./chunk-BAVI3ZS2.js";
 import {
   DeveloperError_default
-} from "./chunk-DIVFF6DK.js";
+} from "./chunk-TGY6H6N6.js";
 import {
   defined_default
-} from "./chunk-IF2OX6R4.js";
+} from "./chunk-N4QEHO3U.js";
 
 // packages/engine/Source/Core/WebMercatorProjection.js
 function WebMercatorProjection(ellipsoid) {