@cesium/engine 26.1.0 → 26.3.0

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;
   }
 

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;
   }
 

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/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/SimplePolylineGeometry.js

@@ -371,7 +371,7 @@ SimplePolylineGeometry.createGeometry = function (simplePolylineGeometry) {
         colorValues[offset++] = Color.floatToByte(lastColor.red);
         colorValues[offset++] = Color.floatToByte(lastColor.green);
         colorValues[offset++] = Color.floatToByte(lastColor.blue);
-        colorValues[offset++] = Color.floatToByte(lastColor.alpha);
+        colorValues[offset] = Color.floatToByte(lastColor.alpha);
       }
     }
   } else {

package/Source/Core/SnapService.js

@@ -0,0 +1,63 @@
+import DeveloperError from "./DeveloperError.js";
+
+/**
+ * The result of a successful {@link SnapService#snap}.
+ *
+ * Implementations may return additional properties beyond those listed here.
+ *
+ * @typedef {object} SnapService.Result
+ * @property {Cartesian3} [snapPoint] The snapped point. This is the point to consume.
+ * @property {Cartesian3} [hitPoint] The point where the cursor hit the geometry: the nearest edge point when within the snap aperture, otherwise the surface point under the cursor.
+ */
+
+/**
+ * Provides snap-to-geometry through an external service, which snaps against
+ * source geometry hosted remotely rather than geometry loaded in the scene.
+ * This type describes an interface and is not intended to be used.
+ *
+ * @experimental This feature is not final and is subject to change without Cesium's standard deprecation policy.
+ *
+ * @see IonSnapService
+ */
+class SnapService {
+  constructor() {
+    DeveloperError.throwInstantiationError();
+  }
+
+  /**
+   * Requests a snap against geometry known to the service.
+   *
+   * The camera and canvas dimensions describe the current view so the
+   * implementation can perform view-dependent snapping (nearest ordering,
+   * pixel apertures, surface tracking) correctly.
+   *
+   * Implementations may accept additional options beyond those listed here.
+   *
+   * @param {object} options Object with the following properties:
+   * @param {string} options.elementId An implementation-defined identifier of the geometry to snap to.
+   * @param {Cartesian3} options.testPoint The point to snap from, typically the picked cursor position.
+   * @param {Camera} options.camera The camera defining the current view.
+   * @param {number} options.canvasWidth The canvas width in CSS pixels.
+   * @param {number} options.canvasHeight The canvas height in CSS pixels.
+   * @param {Cartesian3} [options.closePoint=options.testPoint] A reference point near the target geometry that seeds the snap search.
+   * @param {number} [options.snapAperture=SnapService.DEFAULT_SNAP_APERTURE] The snap tolerance in CSS pixels.
+   * @returns {Promise<SnapService.Result|undefined>} The snap result, or <code>undefined</code> if no snap was possible.
+   */
+  async snap(options) {
+    DeveloperError.throwInstantiationError();
+  }
+}
+
+/**
+ * The default snap tolerance used by {@link SnapService#snap} when
+ * <code>options.snapAperture</code> is not provided, in CSS pixels.
+ * The value is implementation-defined.
+ *
+ * @experimental This feature is not final and is subject to change without Cesium's standard deprecation policy.
+ *
+ * @type {number}
+ * @constant
+ */
+SnapService.DEFAULT_SNAP_APERTURE = undefined;
+
+export default SnapService;

package/Source/Core/TerrainEncoding.js

@@ -422,7 +422,7 @@ TerrainEncoding.prototype.decodePosition = function (buffer, index, result) {
 /**
  * Decode a position from the vertex buffer and apply vertical exaggeration.
  *
- * @param {Float32Array} buffer
+ * @param {Float32Array|Float64Array} buffer
  * @param {number} index
  * @param {Cartesian3} [result]
  * @returns {Cartesian3} The exaggerated position.
@@ -587,7 +587,7 @@ TerrainEncoding.prototype.decodeNormal = function (buffer, index, result) {
   Check.typeOf.object("result", result);
   //>>includeEnd('debug');
 
-  const bufferIndex = (index = index * this.stride + this._offsetVertexNormal);
+  const bufferIndex = index * this.stride + this._offsetVertexNormal;
   return AttributeCompression.octDecodeFloat(buffer[bufferIndex], result);
 };