@hztxi/cesium-engine 25.0.6 → 26.2.1

package/Source/Core/LagrangePolynomialApproximation.js

@@ -1,3 +1,5 @@
+// @ts-check
+
 import defined from "./defined.js";
 
 /**
@@ -5,67 +7,68 @@ import defined from "./defined.js";
  *
  * @namespace LagrangePolynomialApproximation
  */
-const LagrangePolynomialApproximation = {
-  type: "Lagrange",
-};
-
-/**
- * Given the desired degree, returns the number of data points required for interpolation.
- *
- * @param {number} degree The desired degree of interpolation.
- * @returns {number} The number of required data points needed for the desired degree of interpolation.
- */
-LagrangePolynomialApproximation.getRequiredDataPoints = function (degree) {
-  return Math.max(degree + 1.0, 2);
-};
+class LagrangePolynomialApproximation {
+  /**
+   * Gets the name of this interpolation algorithm.
+   * @type {string}
+   */
+  static get type() {
+    return "Lagrange";
+  }
 
-/**
- * Interpolates values using Lagrange Polynomial Approximation.
- *
- * @param {number} x The independent variable for which the dependent variables will be interpolated.
- * @param {number[]} xTable The array of independent variables to use to interpolate.  The values
- * in this array must be in increasing order and the same value must not occur twice in the array.
- * @param {number[]} yTable The array of dependent variables to use to interpolate.  For a set of three
- * dependent values (p,q,w) at time 1 and time 2 this should be as follows: {p1, q1, w1, p2, q2, w2}.
- * @param {number} yStride The number of dependent variable values in yTable corresponding to
- * each independent variable value in xTable.
- * @param {number[]} [result] An existing array into which to store the result.
- * @returns {number[]} The array of interpolated values, or the result parameter if one was provided.
- */
-LagrangePolynomialApproximation.interpolateOrderZero = function (
-  x,
-  xTable,
-  yTable,
-  yStride,
-  result,
-) {
-  if (!defined(result)) {
-    result = new Array(yStride);
+  /**
+   * Given the desired degree, returns the number of data points required for interpolation.
+   *
+   * @param {number} degree The desired degree of interpolation.
+   * @returns {number} The number of required data points needed for the desired degree of interpolation.
+   */
+  static getRequiredDataPoints(degree) {
+    return Math.max(degree + 1.0, 2);
   }
 
-  let i;
-  let j;
-  const length = xTable.length;
+  /**
+   * Interpolates values using Lagrange Polynomial Approximation.
+   *
+   * @param {number} x The independent variable for which the dependent variables will be interpolated.
+   * @param {number[]} xTable The array of independent variables to use to interpolate.  The values
+   * in this array must be in increasing order and the same value must not occur twice in the array.
+   * @param {number[]} yTable The array of dependent variables to use to interpolate.  For a set of three
+   * dependent values (p,q,w) at time 1 and time 2 this should be as follows: {p1, q1, w1, p2, q2, w2}.
+   * @param {number} yStride The number of dependent variable values in yTable corresponding to
+   * each independent variable value in xTable.
+   * @param {number[]} [result] An existing array into which to store the result.
+   * @returns {number[]} The array of interpolated values, or the result parameter if one was provided.
+   */
+  static interpolateOrderZero(x, xTable, yTable, yStride, result) {
+    if (!defined(result)) {
+      result = new Array(yStride);
+    }
+
+    let i;
+    let j;
+    const length = xTable.length;
 
-  for (i = 0; i < yStride; i++) {
-    result[i] = 0;
-  }
+    for (i = 0; i < yStride; i++) {
+      result[i] = 0;
+    }
 
-  for (i = 0; i < length; i++) {
-    let coefficient = 1;
+    for (i = 0; i < length; i++) {
+      let coefficient = 1;
 
-    for (j = 0; j < length; j++) {
-      if (j !== i) {
-        const diffX = xTable[i] - xTable[j];
-        coefficient *= (x - xTable[j]) / diffX;
+      for (j = 0; j < length; j++) {
+        if (j !== i) {
+          const diffX = xTable[i] - xTable[j];
+          coefficient *= (x - xTable[j]) / diffX;
+        }
       }
-    }
 
-    for (j = 0; j < yStride; j++) {
-      result[j] += coefficient * yTable[i * yStride + j];
+      for (j = 0; j < yStride; j++) {
+        result[j] += coefficient * yTable[i * yStride + j];
+      }
     }
+
+    return result;
   }
+}
 
-  return result;
-};
 export default LagrangePolynomialApproximation;

package/Source/Core/LinearApproximation.js

@@ -1,3 +1,5 @@
+// @ts-check
+
 import defined from "./defined.js";
 import DeveloperError from "./DeveloperError.js";
 
@@ -6,78 +8,79 @@ import DeveloperError from "./DeveloperError.js";
  *
  * @namespace LinearApproximation
  */
-const LinearApproximation = {
-  type: "Linear",
-};
-
-/**
- * Given the desired degree, returns the number of data points required for interpolation.
- * Since linear interpolation can only generate a first degree polynomial, this function
- * always returns 2.
- * @param {number} degree The desired degree of interpolation.
- * @returns {number} This function always returns 2.
- *
- */
-LinearApproximation.getRequiredDataPoints = function (degree) {
-  return 2;
-};
-
-/**
- * Interpolates values using linear approximation.
- *
- * @param {number} x The independent variable for which the dependent variables will be interpolated.
- * @param {number[]} xTable The array of independent variables to use to interpolate.  The values
- * in this array must be in increasing order and the same value must not occur twice in the array.
- * @param {number[]} yTable The array of dependent variables to use to interpolate.  For a set of three
- * dependent values (p,q,w) at time 1 and time 2 this should be as follows: {p1, q1, w1, p2, q2, w2}.
- * @param {number} yStride The number of dependent variable values in yTable corresponding to
- * each independent variable value in xTable.
- * @param {number[]} [result] An existing array into which to store the result.
- * @returns {number[]} The array of interpolated values, or the result parameter if one was provided.
- */
-LinearApproximation.interpolateOrderZero = function (
-  x,
-  xTable,
-  yTable,
-  yStride,
-  result,
-) {
-  //>>includeStart('debug', pragmas.debug);
-  if (xTable.length !== 2) {
-    throw new DeveloperError(
-      "The xTable provided to the linear interpolator must have exactly two elements.",
-    );
-  } else if (yStride <= 0) {
-    throw new DeveloperError(
-      "There must be at least 1 dependent variable for each independent variable.",
-    );
+class LinearApproximation {
+  /**
+   * Gets the name of this interpolation algorithm.
+   * @type {string}
+   */
+  static get type() {
+    return "Linear";
   }
-  //>>includeEnd('debug');
 
-  if (!defined(result)) {
-    result = new Array(yStride);
+  /**
+   * Given the desired degree, returns the number of data points required for interpolation.
+   * Since linear interpolation can only generate a first degree polynomial, this function
+   * always returns 2.
+   * @param {number} degree The desired degree of interpolation.
+   * @returns {number} This function always returns 2.
+   *
+   */
+  static getRequiredDataPoints(degree) {
+    return 2;
   }
 
-  let i;
-  let y0;
-  let y1;
-  const x0 = xTable[0];
-  const x1 = xTable[1];
+  /**
+   * Interpolates values using linear approximation.
+   *
+   * @param {number} x The independent variable for which the dependent variables will be interpolated.
+   * @param {number[]} xTable The array of independent variables to use to interpolate.  The values
+   * in this array must be in increasing order and the same value must not occur twice in the array.
+   * @param {number[]} yTable The array of dependent variables to use to interpolate.  For a set of three
+   * dependent values (p,q,w) at time 1 and time 2 this should be as follows: {p1, q1, w1, p2, q2, w2}.
+   * @param {number} yStride The number of dependent variable values in yTable corresponding to
+   * each independent variable value in xTable.
+   * @param {number[]} [result] An existing array into which to store the result.
+   * @returns {number[]} The array of interpolated values, or the result parameter if one was provided.
+   */
+  static interpolateOrderZero(x, xTable, yTable, yStride, result) {
+    //>>includeStart('debug', pragmas.debug);
+    if (xTable.length !== 2) {
+      throw new DeveloperError(
+        "The xTable provided to the linear interpolator must have exactly two elements.",
+      );
+    } else if (yStride <= 0) {
+      throw new DeveloperError(
+        "There must be at least 1 dependent variable for each independent variable.",
+      );
+    }
+    //>>includeEnd('debug');
 
-  //>>includeStart('debug', pragmas.debug);
-  if (x0 === x1) {
-    throw new DeveloperError(
-      "Divide by zero error: xTable[0] and xTable[1] are equal",
-    );
-  }
-  //>>includeEnd('debug');
+    if (!defined(result)) {
+      result = new Array(yStride);
+    }
+
+    let i;
+    let y0;
+    let y1;
+    const x0 = xTable[0];
+    const x1 = xTable[1];
+
+    //>>includeStart('debug', pragmas.debug);
+    if (x0 === x1) {
+      throw new DeveloperError(
+        "Divide by zero error: xTable[0] and xTable[1] are equal",
+      );
+    }
+    //>>includeEnd('debug');
+
+    for (i = 0; i < yStride; i++) {
+      y0 = yTable[i];
+      y1 = yTable[i + yStride];
+      result[i] = ((y1 - y0) * x + x1 * y0 - x0 * y1) / (x1 - x0);
+    }
 
-  for (i = 0; i < yStride; i++) {
-    y0 = yTable[i];
-    y1 = yTable[i + yStride];
-    result[i] = ((y1 - y0) * x + x1 * y0 - x0 * y1) / (x1 - x0);
+    return result;
   }
+}
 
-  return result;
-};
 export default LinearApproximation;

package/Source/Core/MapProjection.js

@@ -21,6 +21,7 @@ class MapProjection {
    *
    * @type {Ellipsoid}
    * @readonly
+   * @constant
    */
   ellipsoid;
 

package/Source/Core/Math.js

@@ -339,6 +339,64 @@ CesiumMath.lerp = function (p, q, time) {
   return (1.0 - time) * p + time * q;
 };
 
+/** @typedef {Object} SmoothDampResult
+ * @property {number} value The new value after applying the smooth damp.
+ * @property {number} velocity The updated current velocity.
+ */
+
+/**
+ * Gradually changes a value towards a target value over time. The smoothing function uses a spring-damping algorithm based on Game Programming Gems 4 Chapter 1.10.
+ * @param {number} p The current value.
+ * @param {number} q The target value.
+ * @param {number} velocity The current velocity.
+ * @param {number} [deltaTime=0.0] The time since the last call to this function. Value must be greater than or equal to 0.0.
+ * @param {number} [maximumSpeed=Number.POSITIVE_INFINITY] Optionally allows clamping to the specified maximum speed.
+ * @param {number} [smoothTime=0.0001] Approximately the time it will take to reach the target. A smaller value will reach the target faster. This value must be greater than or equal to 0.0001.
+ * @param {SmoothDampResult} [result] An object to store the result. If not provided, a new object will be created and returned.
+ * @returns {SmoothDampResult} An object containing the new value and the updated current velocity.
+ */
+CesiumMath.smoothDamp = function (
+  p,
+  q,
+  velocity,
+  deltaTime = 0.0,
+  maximumSpeed = Number.POSITIVE_INFINITY,
+  smoothTime = 0.0001,
+  result = {},
+) {
+  //>>includeStart('debug', pragmas.debug);
+  Check.typeOf.number("p", p);
+  Check.typeOf.number("q", q);
+  Check.typeOf.number("velocity", velocity);
+  Check.typeOf.number.greaterThanOrEquals("deltaTime", deltaTime, 0.0);
+  Check.typeOf.number.greaterThanOrEquals("maximumSpeed", maximumSpeed, 0.0);
+  Check.typeOf.number.greaterThanOrEquals("smoothTime", smoothTime, 0.0001);
+  Check.typeOf.object("result", result);
+  //>>includeEnd('debug');
+
+  // As a fallback, prevent crashes even if smoothTime is too small
+  smoothTime = Math.max(0.0001, smoothTime);
+  const omega = 2.0 / smoothTime;
+
+  const x = omega * deltaTime;
+  const exp = 1.0 / (1.0 + x + 0.48 * x * x + 0.235 * x * x * x);
+
+  const maxChange = maximumSpeed * smoothTime;
+  let change = p - q;
+  change = CesiumMath.clamp(change, -maxChange, maxChange);
+
+  const target = p - change;
+
+  const temp = (velocity + omega * change) * deltaTime;
+
+  velocity = (velocity - omega * temp) * exp;
+
+  result.value = target + (change + temp) * exp;
+  result.velocity = velocity;
+
+  return result;
+};
+
 /**
  * pi
  *
@@ -1122,4 +1180,5 @@ CesiumMath.fastApproximateAtan2 = function (x, y) {
   t = y < 0.0 ? -t : t;
   return t;
 };
+
 export default CesiumMath;

package/Source/Core/Matrix2.js

@@ -55,7 +55,7 @@ class Matrix2 {
     array[startingIndex++] = value[0];
     array[startingIndex++] = value[1];
     array[startingIndex++] = value[2];
-    array[startingIndex++] = value[3];
+    array[startingIndex] = value[3];
 
     return array;
   }
@@ -82,7 +82,7 @@ class Matrix2 {
     result[0] = array[startingIndex++];
     result[1] = array[startingIndex++];
     result[2] = array[startingIndex++];
-    result[3] = array[startingIndex++];
+    result[3] = array[startingIndex];
     return result;
   }
 
@@ -914,7 +914,7 @@ class Matrix2 {
    * @param {Matrix2} matrix
    * @param {number[]} array
    * @param {number} offset
-   * @private
+   * @ignore
    */
   static equalsArray(matrix, array, offset) {
     return (

package/Source/Core/Matrix3.js

@@ -95,7 +95,7 @@ class Matrix3 {
     array[startingIndex++] = value[5];
     array[startingIndex++] = value[6];
     array[startingIndex++] = value[7];
-    array[startingIndex++] = value[8];
+    array[startingIndex] = value[8];
 
     return array;
   }
@@ -127,7 +127,7 @@ class Matrix3 {
     result[5] = array[startingIndex++];
     result[6] = array[startingIndex++];
     result[7] = array[startingIndex++];
-    result[8] = array[startingIndex++];
+    result[8] = array[startingIndex];
     return result;
   }
 
@@ -1618,7 +1618,7 @@ class Matrix3 {
    * @param {Matrix3} matrix
    * @param {number[]} array
    * @param {number} offset
-   * @private
+   * @ignore
    */
   static equalsArray(matrix, array, offset) {
     return (

package/Source/Core/Matrix4.js

@@ -2978,7 +2978,7 @@ class Matrix4 {
    * @param {Matrix4} matrix
    * @param {number[]} array
    * @param {number} offset
-   * @private
+   * @ignore
    */
   static equalsArray(matrix, array, offset) {
     return (

package/Source/Core/OrthographicFrustum.js

@@ -185,7 +185,7 @@ Object.defineProperties(OrthographicFrustum.prototype, {
     },
   },
   /**
-   * Gets the orthographic projection matrix computed from the view frustum.
+   * Gets the underlying {@link OrthographicOffCenterFrustum}
    * @memberof OrthographicFrustum.prototype
    * @type {OrthographicOffCenterFrustum}
    * @readonly

package/Source/Core/PerspectiveFrustum.js

@@ -282,7 +282,7 @@ Object.defineProperties(PerspectiveFrustum.prototype, {
   },
 
   /**
-   * Gets the orthographic projection matrix computed from the view frustum.
+   * Gets the underlying {@link PerspectiveOffCenterFrustum}.
    * @memberof PerspectiveFrustum.prototype
    * @type {PerspectiveOffCenterFrustum}
    * @readonly

package/Source/Core/PolygonGeometry.js

@@ -858,7 +858,7 @@ PolygonGeometry.pack = function (value, array, startingIndex) {
   } else {
     array[startingIndex++] = -1.0;
   }
-  array[startingIndex++] = value.packedLength;
+  array[startingIndex] = value.packedLength;
   return array;
 };
 
@@ -928,7 +928,7 @@ PolygonGeometry.unpack = function (array, startingIndex, result) {
   } else {
     startingIndex++;
   }
-  const packedLength = array[startingIndex++];
+  const packedLength = array[startingIndex];
 
   if (!defined(result)) {
     result = new PolygonGeometry(dummyOptions);

package/Source/Core/PolygonGeometryLibrary.js

@@ -694,7 +694,7 @@ function wirePolygon(
   for (const index of polygonsToWire) {
     polygonIndex = wirePolygon(
       polygons,
-      ++polygonIndex,
+      polygonIndex + 1,
       positions,
       edgesOnPlane,
       0,

package/Source/Core/PolygonOutlineGeometry.js

@@ -116,7 +116,7 @@ function createGeometryFromPositions(
     indices[index++] = i + 1;
   }
   indices[index++] = length - 1;
-  indices[index++] = 0;
+  indices[index] = 0;
 
   return new GeometryInstance({
     geometry: new Geometry({

package/Source/Core/PolylineGeometry.js

@@ -316,7 +316,7 @@ PolylineGeometry.createGeometry = function (polylineGeometry) {
     let removedArrayIndex = 0;
     let nextRemovedIndex = removedIndices[0];
     colors = colors.filter(function (color, index) {
-      let remove = false;
+      let remove;
       if (colorsPerVertex) {
         remove =
           index === nextRemovedIndex || (index === 0 && nextRemovedIndex === 1);

package/Source/Core/PolylinePipeline.js

@@ -21,9 +21,16 @@ PolylinePipeline.numberOfPoints = function (p0, p1, minDistance) {
 };
 
 PolylinePipeline.numberOfPointsRhumbLine = function (p0, p1, granularity) {
+  // Wrap the longitude delta to (-pi, pi]: EllipsoidRhumbLine always
+  // interpolates along the shortest rhumb path. A segment crossing the
+  // +/-180 meridian has a raw delta of nearly 2*pi but spans only a tiny arc;
+  // counting subdivisions from the raw delta over-tessellates that segment by
+  // up to ~360x, which skews index-based parameterizations (the polyline `st`
+  // attribute used by line materials): animations appear to stall at the
+  // antimeridian.
+  const deltaLongitude = CesiumMath.negativePiToPi(p0.longitude - p1.longitude);
   const radiansDistanceSquared =
-    Math.pow(p0.longitude - p1.longitude, 2) +
-    Math.pow(p0.latitude - p1.latitude, 2);
+    Math.pow(deltaLongitude, 2) + Math.pow(p0.latitude - p1.latitude, 2);
 
   return Math.max(
     1,

package/Source/Core/PolylineVolumeGeometryLibrary.js

@@ -198,7 +198,7 @@ function convertShapeTo3DDuplicate(shape2D, boundingRectangle) {
   point = shape2D[0];
   shape[index++] = point.x - xOffset;
   shape[index++] = 0.0;
-  shape[index++] = point.y - yOffset;
+  shape[index] = point.y - yOffset;
 
   return shape;
 }

package/Source/Core/Rectangle.js

@@ -711,13 +711,19 @@ class Rectangle {
       rectangleWest += CesiumMath.TWO_PI;
     }
 
-    const west = CesiumMath.negativePiToPi(
+    let west = CesiumMath.negativePiToPi(
       Math.max(rectangleWest, otherRectangleWest),
     );
     const east = CesiumMath.negativePiToPi(
       Math.min(rectangleEast, otherRectangleEast),
     );
 
+    // +pi and -pi are the same longitude; use -pi here so a real intersection
+    // touching the antimeridian isn't mistaken for empty by the check below.
+    if (west === CesiumMath.PI && east < CesiumMath.PI) {
+      west = -CesiumMath.PI;
+    }
+
     if (
       (rectangle.west < rectangle.east ||
         otherRectangle.west < otherRectangle.east) &&

package/Source/Core/RectangleOutlineGeometry.js

@@ -141,7 +141,7 @@ function constructRectangle(geometry, computedOptions) {
     indices[index++] = i + 1;
   }
   indices[index++] = positions.length / 3 - 1;
-  indices[index++] = 0;
+  indices[index] = 0;
 
   const geo = new Geometry({
     attributes: new GeometryAttributes(),

package/Source/Core/Resource.js

@@ -173,7 +173,7 @@ function defaultClone(value, defaultValue) {
  *
  * @returns {Resource} If resource is a String, a Resource constructed with the url and options. Otherwise the resource parameter is returned.
  *
- * @private
+ * @ignore
  */
 Resource.createIfNeeded = function (resource) {
   if (resource instanceof Resource) {