@cesium/engine 23.0.1 → 25.0.0

package/Source/Core/PixelFormat.js

@@ -600,4 +600,6 @@ PixelFormat.toInternalFormat = function (pixelFormat, pixelDatatype, context) {
   return pixelFormat;
 };
 
-export default Object.freeze(PixelFormat);
+Object.freeze(PixelFormat);
+
+export default PixelFormat;

package/Source/Core/PrimitiveType.js

@@ -1,3 +1,5 @@
+// @ts-check
+
 import WebGLConstants from "./WebGLConstants.js";
 
 /**
@@ -69,7 +71,9 @@ const PrimitiveType = {
 
 /**
  * @private
+ * @param {PrimitiveType} primitiveType
  */
+// @ts-expect-error https://github.com/CesiumGS/cesium/issues/13420
 PrimitiveType.isLines = function (primitiveType) {
   return (
     primitiveType === PrimitiveType.LINES ||
@@ -80,7 +84,9 @@ PrimitiveType.isLines = function (primitiveType) {
 
 /**
  * @private
+ * @param {PrimitiveType} primitiveType
  */
+// @ts-expect-error https://github.com/CesiumGS/cesium/issues/13420
 PrimitiveType.isTriangles = function (primitiveType) {
   return (
     primitiveType === PrimitiveType.TRIANGLES ||
@@ -91,7 +97,9 @@ PrimitiveType.isTriangles = function (primitiveType) {
 
 /**
  * @private
+ * @param {PrimitiveType} primitiveType
  */
+// @ts-expect-error https://github.com/CesiumGS/cesium/issues/13420
 PrimitiveType.validate = function (primitiveType) {
   return (
     primitiveType === PrimitiveType.POINTS ||
@@ -104,4 +112,6 @@ PrimitiveType.validate = function (primitiveType) {
   );
 };
 
-export default Object.freeze(PrimitiveType);
+Object.freeze(PrimitiveType);
+
+export default PrimitiveType;

package/Source/Core/Ray.js

@@ -4,76 +4,78 @@ import defined from "./defined.js";
 
 /**
  * Represents a ray that extends infinitely from the provided origin in the provided direction.
- * @alias Ray
- * @constructor
- *
- * @param {Cartesian3} [origin=Cartesian3.ZERO] The origin of the ray.
- * @param {Cartesian3} [direction=Cartesian3.ZERO] The direction of the ray.
  */
-function Ray(origin, direction) {
-  direction = Cartesian3.clone(direction ?? Cartesian3.ZERO);
-  if (!Cartesian3.equals(direction, Cartesian3.ZERO)) {
-    Cartesian3.normalize(direction, direction);
+class Ray {
+  /**
+   * @param {Cartesian3} [origin=Cartesian3.ZERO] The origin of the ray.
+   * @param {Cartesian3} [direction=Cartesian3.ZERO] The direction of the ray.
+   */
+  constructor(origin, direction) {
+    direction = Cartesian3.clone(direction ?? Cartesian3.ZERO);
+    if (!Cartesian3.equals(direction, Cartesian3.ZERO)) {
+      Cartesian3.normalize(direction, direction);
+    }
+
+    /**
+     * The origin of the ray.
+     * @type {Cartesian3}
+     * @default {@link Cartesian3.ZERO}
+     */
+    this.origin = Cartesian3.clone(origin ?? Cartesian3.ZERO);
+
+    /**
+     * The direction of the ray.
+     * @type {Cartesian3}
+     */
+    this.direction = direction;
   }
 
   /**
-   * The origin of the ray.
-   * @type {Cartesian3}
-   * @default {@link Cartesian3.ZERO}
+   * Duplicates a Ray instance.
+   *
+   * @param {Ray} ray The ray to duplicate.
+   * @param {Ray} [result] The object onto which to store the result.
+   * @returns {Ray} The modified result parameter or a new Ray instance if one was not provided. (Returns undefined if ray is undefined)
    */
-  this.origin = Cartesian3.clone(origin ?? Cartesian3.ZERO);
+  static clone(ray, result) {
+    if (!defined(ray)) {
+      return undefined;
+    }
+    if (!defined(result)) {
+      return new Ray(ray.origin, ray.direction);
+    }
+    result.origin = Cartesian3.clone(ray.origin);
+    result.direction = Cartesian3.clone(ray.direction);
+    return result;
+  }
 
   /**
-   * The direction of the ray.
-   * @type {Cartesian3}
+   * Computes the point along the ray given by r(t) = o + t*d,
+   * where o is the origin of the ray and d is the direction.
+   *
+   * @param {Ray} ray The ray.
+   * @param {number} t A scalar value.
+   * @param {Cartesian3} [result] The object in which the result will be stored.
+   * @returns {Cartesian3} The modified result parameter, or a new instance if none was provided.
+   *
+   * @example
+   * //Get the first intersection point of a ray and an ellipsoid.
+   * const intersection = Cesium.IntersectionTests.rayEllipsoid(ray, ellipsoid);
+   * const point = Cesium.Ray.getPoint(ray, intersection.start);
    */
-  this.direction = direction;
-}
-
-/**
- * Duplicates a Ray instance.
- *
- * @param {Ray} ray The ray to duplicate.
- * @param {Ray} [result] The object onto which to store the result.
- * @returns {Ray} The modified result parameter or a new Ray instance if one was not provided. (Returns undefined if ray is undefined)
- */
-Ray.clone = function (ray, result) {
-  if (!defined(ray)) {
-    return undefined;
-  }
-  if (!defined(result)) {
-    return new Ray(ray.origin, ray.direction);
-  }
-  result.origin = Cartesian3.clone(ray.origin);
-  result.direction = Cartesian3.clone(ray.direction);
-  return result;
-};
+  static getPoint(ray, t, result) {
+    //>>includeStart('debug', pragmas.debug);
+    Check.typeOf.object("ray", ray);
+    Check.typeOf.number("t", t);
+    //>>includeEnd('debug');
 
-/**
- * Computes the point along the ray given by r(t) = o + t*d,
- * where o is the origin of the ray and d is the direction.
- *
- * @param {Ray} ray The ray.
- * @param {number} t A scalar value.
- * @param {Cartesian3} [result] The object in which the result will be stored.
- * @returns {Cartesian3} The modified result parameter, or a new instance if none was provided.
- *
- * @example
- * //Get the first intersection point of a ray and an ellipsoid.
- * const intersection = Cesium.IntersectionTests.rayEllipsoid(ray, ellipsoid);
- * const point = Cesium.Ray.getPoint(ray, intersection.start);
- */
-Ray.getPoint = function (ray, t, result) {
-  //>>includeStart('debug', pragmas.debug);
-  Check.typeOf.object("ray", ray);
-  Check.typeOf.number("t", t);
-  //>>includeEnd('debug');
+    if (!defined(result)) {
+      result = new Cartesian3();
+    }
 
-  if (!defined(result)) {
-    result = new Cartesian3();
+    result = Cartesian3.multiplyByScalar(ray.direction, t, result);
+    return Cartesian3.add(ray.origin, result, result);
   }
+}
 
-  result = Cartesian3.multiplyByScalar(ray.direction, t, result);
-  return Cartesian3.add(ray.origin, result, result);
-};
 export default Ray;