@cesium/engine 24.0.0 → 26.0.0

package/Source/Core/Cartesian2.js

@@ -651,7 +651,7 @@ class Cartesian2 {
    * @param {Cartesian2} cartesian
    * @param {number[]} array
    * @param {number} offset
-   * @private
+   * @ignore
    */
   static equalsArray(cartesian, array, offset) {
     return cartesian.x === array[offset] && cartesian.y === array[offset + 1];

package/Source/Core/Cartesian3.js

@@ -723,7 +723,7 @@ class Cartesian3 {
    * @param {Cartesian3} cartesian
    * @param {number[]} array
    * @param {number} offset
-   * @private
+   * @ignore
    */
   static equalsArray(cartesian, array, offset) {
     return (
@@ -876,8 +876,7 @@ class Cartesian3 {
 
     const radiiSquared = !defined(ellipsoid)
       ? Cartesian3._ellipsoidRadiiSquared
-      : // @ts-expect-error Requires type-checking on Ellipsoid.js.
-        ellipsoid.radiiSquared;
+      : ellipsoid.radiiSquared;
 
     const cosLatitude = Math.cos(latitude);
     scratchN.x = cosLatitude * Math.cos(longitude);

package/Source/Core/Cartesian4.js

@@ -727,7 +727,7 @@ class Cartesian4 {
    * @param {Cartesian4} cartesian
    * @param {number[]} array
    * @param {number} offset
-   * @private
+   * @ignore
    */
   static equalsArray(cartesian, array, offset) {
     return (

package/Source/Core/Cartographic.js

@@ -1,255 +1,301 @@
+// @ts-check
+
 import Cartesian3 from "./Cartesian3.js";
 import Check from "./Check.js";
 import defined from "./defined.js";
 import CesiumMath from "./Math.js";
 import scaleToGeodeticSurface from "./scaleToGeodeticSurface.js";
 
+/** @import Ellipsoid from "./Ellipsoid.js"; */
+
 /**
  * A position defined by longitude, latitude, and height.
- * @alias Cartographic
- * @constructor
- *
- * @param {number} [longitude=0.0] The longitude, in radians.
- * @param {number} [latitude=0.0] The latitude, in radians.
- * @param {number} [height=0.0] The height, in meters, above the ellipsoid.
  *
  * @see Ellipsoid
  */
-function Cartographic(longitude, latitude, height) {
+class Cartographic {
   /**
-   * The longitude, in radians.
-   * @type {number}
-   * @default 0.0
+   * @param {number} [longitude=0.0] The longitude, in radians.
+   * @param {number} [latitude=0.0] The latitude, in radians.
+   * @param {number} [height=0.0] The height, in meters, above the ellipsoid.
    */
-  this.longitude = longitude ?? 0.0;
+  constructor(longitude, latitude, height) {
+    /**
+     * The longitude, in radians.
+     * @type {number}
+     * @default 0.0
+     */
+    this.longitude = longitude ?? 0.0;
+
+    /**
+     * The latitude, in radians.
+     * @type {number}
+     * @default 0.0
+     */
+    this.latitude = latitude ?? 0.0;
+
+    /**
+     * The height, in meters, above the ellipsoid.
+     * @type {number}
+     * @default 0.0
+     */
+    this.height = height ?? 0.0;
+  }
 
   /**
-   * The latitude, in radians.
-   * @type {number}
-   * @default 0.0
+   * Creates a new Cartographic instance from longitude and latitude
+   * specified in radians.
+   *
+   * @param {number} longitude The longitude, in radians.
+   * @param {number} latitude The latitude, in radians.
+   * @param {number} [height=0.0] The height, in meters, above the ellipsoid.
+   * @param {Cartographic} [result] The object onto which to store the result.
+   * @returns {Cartographic} The modified result parameter or a new Cartographic instance if one was not provided.
    */
-  this.latitude = latitude ?? 0.0;
+  static fromRadians(longitude, latitude, height, result) {
+    //>>includeStart('debug', pragmas.debug);
+    Check.typeOf.number("longitude", longitude);
+    Check.typeOf.number("latitude", latitude);
+    //>>includeEnd('debug');
+
+    height = height ?? 0.0;
+
+    if (!defined(result)) {
+      return new Cartographic(longitude, latitude, height);
+    }
+
+    result.longitude = longitude;
+    result.latitude = latitude;
+    result.height = height;
+    return result;
+  }
 
   /**
-   * The height, in meters, above the ellipsoid.
-   * @type {number}
-   * @default 0.0
+   * Creates a new Cartographic instance from longitude and latitude
+   * specified in degrees.  The values in the resulting object will
+   * be in radians.
+   *
+   * @param {number} longitude The longitude, in degrees.
+   * @param {number} latitude The latitude, in degrees.
+   * @param {number} [height=0.0] The height, in meters, above the ellipsoid.
+   * @param {Cartographic} [result] The object onto which to store the result.
+   * @returns {Cartographic} The modified result parameter or a new Cartographic instance if one was not provided.
    */
-  this.height = height ?? 0.0;
-}
-
-/**
- * Creates a new Cartographic instance from longitude and latitude
- * specified in radians.
- *
- * @param {number} longitude The longitude, in radians.
- * @param {number} latitude The latitude, in radians.
- * @param {number} [height=0.0] The height, in meters, above the ellipsoid.
- * @param {Cartographic} [result] The object onto which to store the result.
- * @returns {Cartographic} The modified result parameter or a new Cartographic instance if one was not provided.
- */
-Cartographic.fromRadians = function (longitude, latitude, height, result) {
-  //>>includeStart('debug', pragmas.debug);
-  Check.typeOf.number("longitude", longitude);
-  Check.typeOf.number("latitude", latitude);
-  //>>includeEnd('debug');
+  static fromDegrees(longitude, latitude, height, result) {
+    //>>includeStart('debug', pragmas.debug);
+    Check.typeOf.number("longitude", longitude);
+    Check.typeOf.number("latitude", latitude);
+    //>>includeEnd('debug');
 
-  height = height ?? 0.0;
+    longitude = CesiumMath.toRadians(longitude);
+    latitude = CesiumMath.toRadians(latitude);
 
-  if (!defined(result)) {
-    return new Cartographic(longitude, latitude, height);
+    return Cartographic.fromRadians(longitude, latitude, height, result);
   }
 
-  result.longitude = longitude;
-  result.latitude = latitude;
-  result.height = height;
-  return result;
-};
+  /**
+   * Creates a new Cartographic instance from a Cartesian position. The values in the
+   * resulting object will be in radians.
+   *
+   * @param {Cartesian3} cartesian The Cartesian position to convert to cartographic representation.
+   * @param {Ellipsoid} [ellipsoid=Ellipsoid.default] The ellipsoid on which the position lies.
+   * @param {Cartographic} [result] The object onto which to store the result.
+   * @returns {Cartographic} The modified result parameter, new Cartographic instance if none was provided, or undefined if the cartesian is at the center of the ellipsoid.
+   */
+  static fromCartesian(cartesian, ellipsoid, result) {
+    const oneOverRadii = defined(ellipsoid)
+      ? ellipsoid.oneOverRadii
+      : Cartographic._ellipsoidOneOverRadii;
+    const oneOverRadiiSquared = defined(ellipsoid)
+      ? ellipsoid.oneOverRadiiSquared
+      : Cartographic._ellipsoidOneOverRadiiSquared;
+    const centerToleranceSquared = defined(ellipsoid)
+      ? ellipsoid._centerToleranceSquared
+      : Cartographic._ellipsoidCenterToleranceSquared;
 
-/**
- * Creates a new Cartographic instance from longitude and latitude
- * specified in degrees.  The values in the resulting object will
- * be in radians.
- *
- * @param {number} longitude The longitude, in degrees.
- * @param {number} latitude The latitude, in degrees.
- * @param {number} [height=0.0] The height, in meters, above the ellipsoid.
- * @param {Cartographic} [result] The object onto which to store the result.
- * @returns {Cartographic} The modified result parameter or a new Cartographic instance if one was not provided.
- */
-Cartographic.fromDegrees = function (longitude, latitude, height, result) {
-  //>>includeStart('debug', pragmas.debug);
-  Check.typeOf.number("longitude", longitude);
-  Check.typeOf.number("latitude", latitude);
-  //>>includeEnd('debug');
+    //`cartesian is required.` is thrown from scaleToGeodeticSurface
+    const p = scaleToGeodeticSurface(
+      cartesian,
+      oneOverRadii,
+      oneOverRadiiSquared,
+      centerToleranceSquared,
+      cartesianToCartographicP,
+    );
 
-  longitude = CesiumMath.toRadians(longitude);
-  latitude = CesiumMath.toRadians(latitude);
+    if (!defined(p)) {
+      return undefined;
+    }
 
-  return Cartographic.fromRadians(longitude, latitude, height, result);
-};
+    let n = Cartesian3.multiplyComponents(
+      p,
+      oneOverRadiiSquared,
+      cartesianToCartographicN,
+    );
+    n = Cartesian3.normalize(n, n);
 
-const cartesianToCartographicN = new Cartesian3();
-const cartesianToCartographicP = new Cartesian3();
-const cartesianToCartographicH = new Cartesian3();
+    const h = Cartesian3.subtract(cartesian, p, cartesianToCartographicH);
 
-// To avoid circular dependencies, these are set by Ellipsoid when Ellipsoid.default is set.
-Cartographic._ellipsoidOneOverRadii = new Cartesian3(
-  1.0 / 6378137.0,
-  1.0 / 6378137.0,
-  1.0 / 6356752.3142451793,
-);
-Cartographic._ellipsoidOneOverRadiiSquared = new Cartesian3(
-  1.0 / (6378137.0 * 6378137.0),
-  1.0 / (6378137.0 * 6378137.0),
-  1.0 / (6356752.3142451793 * 6356752.3142451793),
-);
-Cartographic._ellipsoidCenterToleranceSquared = CesiumMath.EPSILON1;
+    const longitude = Math.atan2(n.y, n.x);
+    const latitude = Math.asin(n.z);
+    const height =
+      CesiumMath.sign(Cartesian3.dot(h, cartesian)) * Cartesian3.magnitude(h);
 
-/**
- * Creates a new Cartographic instance from a Cartesian position. The values in the
- * resulting object will be in radians.
- *
- * @param {Cartesian3} cartesian The Cartesian position to convert to cartographic representation.
- * @param {Ellipsoid} [ellipsoid=Ellipsoid.default] The ellipsoid on which the position lies.
- * @param {Cartographic} [result] The object onto which to store the result.
- * @returns {Cartographic} The modified result parameter, new Cartographic instance if none was provided, or undefined if the cartesian is at the center of the ellipsoid.
- */
-Cartographic.fromCartesian = function (cartesian, ellipsoid, result) {
-  const oneOverRadii = defined(ellipsoid)
-    ? ellipsoid.oneOverRadii
-    : Cartographic._ellipsoidOneOverRadii;
-  const oneOverRadiiSquared = defined(ellipsoid)
-    ? ellipsoid.oneOverRadiiSquared
-    : Cartographic._ellipsoidOneOverRadiiSquared;
-  const centerToleranceSquared = defined(ellipsoid)
-    ? ellipsoid._centerToleranceSquared
-    : Cartographic._ellipsoidCenterToleranceSquared;
-
-  //`cartesian is required.` is thrown from scaleToGeodeticSurface
-  const p = scaleToGeodeticSurface(
-    cartesian,
-    oneOverRadii,
-    oneOverRadiiSquared,
-    centerToleranceSquared,
-    cartesianToCartographicP,
-  );
+    if (!defined(result)) {
+      return new Cartographic(longitude, latitude, height);
+    }
+    result.longitude = longitude;
+    result.latitude = latitude;
+    result.height = height;
+    return result;
+  }
+
+  /**
+   * Creates a new Cartesian3 instance from a Cartographic input. The values in the inputted
+   * object should be in radians.
+   *
+   * @param {Cartographic} cartographic Input to be converted into a Cartesian3 output.
+   * @param {Ellipsoid} [ellipsoid=Ellipsoid.default] The ellipsoid on which the position lies.
+   * @param {Cartesian3} [result] The object onto which to store the result.
+   * @returns {Cartesian3} The position
+   */
+  static toCartesian(cartographic, ellipsoid, result) {
+    //>>includeStart('debug', pragmas.debug);
+    Check.defined("cartographic", cartographic);
+    //>>includeEnd('debug');
+
+    return Cartesian3.fromRadians(
+      cartographic.longitude,
+      cartographic.latitude,
+      cartographic.height,
+      ellipsoid,
+      result,
+    );
+  }
 
-  if (!defined(p)) {
-    return undefined;
+  /**
+   * Duplicates a Cartographic instance.
+   *
+   * @param {Cartographic} cartographic The cartographic to duplicate.
+   * @param {Cartographic} [result] The object onto which to store the result.
+   * @returns {Cartographic} The modified result parameter or a new Cartographic instance if one was not provided. (Returns undefined if cartographic is undefined)
+   */
+  static clone(cartographic, result) {
+    if (!defined(cartographic)) {
+      return undefined;
+    }
+    if (!defined(result)) {
+      return new Cartographic(
+        cartographic.longitude,
+        cartographic.latitude,
+        cartographic.height,
+      );
+    }
+    result.longitude = cartographic.longitude;
+    result.latitude = cartographic.latitude;
+    result.height = cartographic.height;
+    return result;
   }
 
-  let n = Cartesian3.multiplyComponents(
-    p,
-    oneOverRadiiSquared,
-    cartesianToCartographicN,
-  );
-  n = Cartesian3.normalize(n, n);
+  /**
+   * Compares the provided cartographics componentwise and returns
+   * <code>true</code> if they are equal, <code>false</code> otherwise.
+   *
+   * @param {Cartographic} [left] The first cartographic.
+   * @param {Cartographic} [right] The second cartographic.
+   * @returns {boolean} <code>true</code> if left and right are equal, <code>false</code> otherwise.
+   */
+  static equals(left, right) {
+    return (
+      left === right ||
+      (defined(left) &&
+        defined(right) &&
+        left.longitude === right.longitude &&
+        left.latitude === right.latitude &&
+        left.height === right.height)
+    );
+  }
 
-  const h = Cartesian3.subtract(cartesian, p, cartesianToCartographicH);
+  /**
+   * Compares the provided cartographics componentwise and returns
+   * <code>true</code> if they are within the provided epsilon,
+   * <code>false</code> otherwise.
+   *
+   * @param {Cartographic} [left] The first cartographic.
+   * @param {Cartographic} [right] The second cartographic.
+   * @param {number} [epsilon=0] The epsilon to use for equality testing.
+   * @returns {boolean} <code>true</code> if left and right are within the provided epsilon, <code>false</code> otherwise.
+   */
+  static equalsEpsilon(left, right, epsilon) {
+    epsilon = epsilon ?? 0;
 
-  const longitude = Math.atan2(n.y, n.x);
-  const latitude = Math.asin(n.z);
-  const height =
-    CesiumMath.sign(Cartesian3.dot(h, cartesian)) * Cartesian3.magnitude(h);
+    return (
+      left === right ||
+      (defined(left) &&
+        defined(right) &&
+        Math.abs(left.longitude - right.longitude) <= epsilon &&
+        Math.abs(left.latitude - right.latitude) <= epsilon &&
+        Math.abs(left.height - right.height) <= epsilon)
+    );
+  }
 
-  if (!defined(result)) {
-    return new Cartographic(longitude, latitude, height);
+  /**
+   * Duplicates this instance.
+   *
+   * @param {Cartographic} [result] The object onto which to store the result.
+   * @returns {Cartographic} The modified result parameter or a new Cartographic instance if one was not provided.
+   */
+  clone(result) {
+    return Cartographic.clone(this, result);
   }
-  result.longitude = longitude;
-  result.latitude = latitude;
-  result.height = height;
-  return result;
-};
 
-/**
- * Creates a new Cartesian3 instance from a Cartographic input. The values in the inputted
- * object should be in radians.
- *
- * @param {Cartographic} cartographic Input to be converted into a Cartesian3 output.
- * @param {Ellipsoid} [ellipsoid=Ellipsoid.default] The ellipsoid on which the position lies.
- * @param {Cartesian3} [result] The object onto which to store the result.
- * @returns {Cartesian3} The position
- */
-Cartographic.toCartesian = function (cartographic, ellipsoid, result) {
-  //>>includeStart('debug', pragmas.debug);
-  Check.defined("cartographic", cartographic);
-  //>>includeEnd('debug');
-
-  return Cartesian3.fromRadians(
-    cartographic.longitude,
-    cartographic.latitude,
-    cartographic.height,
-    ellipsoid,
-    result,
-  );
-};
+  /**
+   * Compares the provided against this cartographic componentwise and returns
+   * <code>true</code> if they are equal, <code>false</code> otherwise.
+   *
+   * @param {Cartographic} [right] The second cartographic.
+   * @returns {boolean} <code>true</code> if left and right are equal, <code>false</code> otherwise.
+   */
+  equals(right) {
+    return Cartographic.equals(this, right);
+  }
 
-/**
- * Duplicates a Cartographic instance.
- *
- * @param {Cartographic} cartographic The cartographic to duplicate.
- * @param {Cartographic} [result] The object onto which to store the result.
- * @returns {Cartographic} The modified result parameter or a new Cartographic instance if one was not provided. (Returns undefined if cartographic is undefined)
- */
-Cartographic.clone = function (cartographic, result) {
-  if (!defined(cartographic)) {
-    return undefined;
+  /**
+   * Compares the provided against this cartographic componentwise and returns
+   * <code>true</code> if they are within the provided epsilon,
+   * <code>false</code> otherwise.
+   *
+   * @param {Cartographic} [right] The second cartographic.
+   * @param {number} [epsilon=0] The epsilon to use for equality testing.
+   * @returns {boolean} <code>true</code> if left and right are within the provided epsilon, <code>false</code> otherwise.
+   */
+  equalsEpsilon(right, epsilon) {
+    return Cartographic.equalsEpsilon(this, right, epsilon);
   }
-  if (!defined(result)) {
-    return new Cartographic(
-      cartographic.longitude,
-      cartographic.latitude,
-      cartographic.height,
-    );
+
+  /**
+   * Creates a string representing this cartographic in the format '(longitude, latitude, height)'.
+   *
+   * @returns {string} A string representing the provided cartographic in the format '(longitude, latitude, height)'.
+   */
+  toString() {
+    return `(${this.longitude}, ${this.latitude}, ${this.height})`;
   }
-  result.longitude = cartographic.longitude;
-  result.latitude = cartographic.latitude;
-  result.height = cartographic.height;
-  return result;
-};
 
-/**
- * Compares the provided cartographics componentwise and returns
- * <code>true</code> if they are equal, <code>false</code> otherwise.
- *
- * @param {Cartographic} [left] The first cartographic.
- * @param {Cartographic} [right] The second cartographic.
- * @returns {boolean} <code>true</code> if left and right are equal, <code>false</code> otherwise.
- */
-Cartographic.equals = function (left, right) {
-  return (
-    left === right ||
-    (defined(left) &&
-      defined(right) &&
-      left.longitude === right.longitude &&
-      left.latitude === right.latitude &&
-      left.height === right.height)
+  // To avoid circular dependencies, these are set by Ellipsoid when Ellipsoid.default is set.
+  static _ellipsoidOneOverRadii = new Cartesian3(
+    1.0 / 6378137.0,
+    1.0 / 6378137.0,
+    1.0 / 6356752.3142451793,
   );
-};
 
-/**
- * Compares the provided cartographics componentwise and returns
- * <code>true</code> if they are within the provided epsilon,
- * <code>false</code> otherwise.
- *
- * @param {Cartographic} [left] The first cartographic.
- * @param {Cartographic} [right] The second cartographic.
- * @param {number} [epsilon=0] The epsilon to use for equality testing.
- * @returns {boolean} <code>true</code> if left and right are within the provided epsilon, <code>false</code> otherwise.
- */
-Cartographic.equalsEpsilon = function (left, right, epsilon) {
-  epsilon = epsilon ?? 0;
-
-  return (
-    left === right ||
-    (defined(left) &&
-      defined(right) &&
-      Math.abs(left.longitude - right.longitude) <= epsilon &&
-      Math.abs(left.latitude - right.latitude) <= epsilon &&
-      Math.abs(left.height - right.height) <= epsilon)
+  static _ellipsoidOneOverRadiiSquared = new Cartesian3(
+    1.0 / (6378137.0 * 6378137.0),
+    1.0 / (6378137.0 * 6378137.0),
+    1.0 / (6356752.3142451793 * 6356752.3142451793),
   );
-};
+
+  static _ellipsoidCenterToleranceSquared = CesiumMath.EPSILON1;
+}
 
 /**
  * An immutable Cartographic instance initialized to (0.0, 0.0, 0.0).
@@ -259,46 +305,8 @@ Cartographic.equalsEpsilon = function (left, right, epsilon) {
  */
 Cartographic.ZERO = Object.freeze(new Cartographic(0.0, 0.0, 0.0));
 
-/**
- * Duplicates this instance.
- *
- * @param {Cartographic} [result] The object onto which to store the result.
- * @returns {Cartographic} The modified result parameter or a new Cartographic instance if one was not provided.
- */
-Cartographic.prototype.clone = function (result) {
-  return Cartographic.clone(this, result);
-};
-
-/**
- * Compares the provided against this cartographic componentwise and returns
- * <code>true</code> if they are equal, <code>false</code> otherwise.
- *
- * @param {Cartographic} [right] The second cartographic.
- * @returns {boolean} <code>true</code> if left and right are equal, <code>false</code> otherwise.
- */
-Cartographic.prototype.equals = function (right) {
-  return Cartographic.equals(this, right);
-};
-
-/**
- * Compares the provided against this cartographic componentwise and returns
- * <code>true</code> if they are within the provided epsilon,
- * <code>false</code> otherwise.
- *
- * @param {Cartographic} [right] The second cartographic.
- * @param {number} [epsilon=0] The epsilon to use for equality testing.
- * @returns {boolean} <code>true</code> if left and right are within the provided epsilon, <code>false</code> otherwise.
- */
-Cartographic.prototype.equalsEpsilon = function (right, epsilon) {
-  return Cartographic.equalsEpsilon(this, right, epsilon);
-};
+const cartesianToCartographicN = new Cartesian3();
+const cartesianToCartographicP = new Cartesian3();
+const cartesianToCartographicH = new Cartesian3();
 
-/**
- * Creates a string representing this cartographic in the format '(longitude, latitude, height)'.
- *
- * @returns {string} A string representing the provided cartographic in the format '(longitude, latitude, height)'.
- */
-Cartographic.prototype.toString = function () {
-  return `(${this.longitude}, ${this.latitude}, ${this.height})`;
-};
 export default Cartographic;

package/Source/Core/ClockRange.js

@@ -1,3 +1,5 @@
+// @ts-check
+
 /**
  * Constants used by {@link Clock#tick} to determine behavior
  * when {@link Clock#startTime} or {@link Clock#stopTime} is reached.
@@ -36,4 +38,7 @@ const ClockRange = {
    */
   LOOP_STOP: 2,
 };
-export default Object.freeze(ClockRange);
+
+Object.freeze(ClockRange);
+
+export default ClockRange;

package/Source/Core/ClockStep.js

@@ -1,3 +1,5 @@
+// @ts-check
+
 /**
  * Constants to determine how much time advances with each call
  * to {@link Clock#tick}.
@@ -35,4 +37,7 @@ const ClockStep = {
    */
   SYSTEM_CLOCK: 2,
 };
-export default Object.freeze(ClockStep);
+
+Object.freeze(ClockStep);
+
+export default ClockStep;