@cesium/engine 10.1.0 → 11.1.0

package/Source/Core/Quaternion.js

@@ -136,7 +136,7 @@ Quaternion.fromRotationMatrix = function (matrix, result) {
       matrix[Matrix3.getElementIndex(i, i)] -
         matrix[Matrix3.getElementIndex(j, j)] -
         matrix[Matrix3.getElementIndex(k, k)] +
-        1.0
+        1.0,
     );
 
     const quat = fromRotationMatrixQuat;
@@ -192,22 +192,22 @@ Quaternion.fromHeadingPitchRoll = function (headingPitchRoll, result) {
   scratchRollQuaternion = Quaternion.fromAxisAngle(
     Cartesian3.UNIT_X,
     headingPitchRoll.roll,
-    scratchHPRQuaternion
+    scratchHPRQuaternion,
   );
   scratchPitchQuaternion = Quaternion.fromAxisAngle(
     Cartesian3.UNIT_Y,
     -headingPitchRoll.pitch,
-    result
+    result,
   );
   result = Quaternion.multiply(
     scratchPitchQuaternion,
     scratchRollQuaternion,
-    scratchPitchQuaternion
+    scratchPitchQuaternion,
   );
   scratchHeadingQuaternion = Quaternion.fromAxisAngle(
     Cartesian3.UNIT_Z,
     -headingPitchRoll.heading,
-    scratchHPRQuaternion
+    scratchHPRQuaternion,
   );
   return Quaternion.multiply(scratchHeadingQuaternion, result, result);
 };
@@ -292,16 +292,16 @@ Quaternion.convertPackedArrayForInterpolation = function (
   packedArray,
   startingIndex,
   lastIndex,
-  result
+  result,
 ) {
   Quaternion.unpack(
     packedArray,
     lastIndex * 4,
-    sampledQuaternionQuaternion0Conjugate
+    sampledQuaternionQuaternion0Conjugate,
   );
   Quaternion.conjugate(
     sampledQuaternionQuaternion0Conjugate,
-    sampledQuaternionQuaternion0Conjugate
+    sampledQuaternionQuaternion0Conjugate,
   );
 
   for (let i = 0, len = lastIndex - startingIndex + 1; i < len; i++) {
@@ -309,25 +309,25 @@ Quaternion.convertPackedArrayForInterpolation = function (
     Quaternion.unpack(
       packedArray,
       (startingIndex + i) * 4,
-      sampledQuaternionTempQuaternion
+      sampledQuaternionTempQuaternion,
     );
 
     Quaternion.multiply(
       sampledQuaternionTempQuaternion,
       sampledQuaternionQuaternion0Conjugate,
-      sampledQuaternionTempQuaternion
+      sampledQuaternionTempQuaternion,
     );
 
     if (sampledQuaternionTempQuaternion.w < 0) {
       Quaternion.negate(
         sampledQuaternionTempQuaternion,
-        sampledQuaternionTempQuaternion
+        sampledQuaternionTempQuaternion,
       );
     }
 
     Quaternion.computeAxis(
       sampledQuaternionTempQuaternion,
-      sampledQuaternionAxis
+      sampledQuaternionAxis,
     );
     const angle = Quaternion.computeAngle(sampledQuaternionTempQuaternion);
     if (!defined(result)) {
@@ -354,7 +354,7 @@ Quaternion.unpackInterpolationResult = function (
   sourceArray,
   firstIndex,
   lastIndex,
-  result
+  result,
 ) {
   if (!defined(result)) {
     result = new Quaternion();
@@ -370,14 +370,14 @@ Quaternion.unpackInterpolationResult = function (
     Quaternion.fromAxisAngle(
       sampledQuaternionRotation,
       magnitude,
-      sampledQuaternionTempQuaternion
+      sampledQuaternionTempQuaternion,
     );
   }
 
   return Quaternion.multiply(
     sampledQuaternionTempQuaternion,
     sampledQuaternionQuaternion0,
-    result
+    result,
   );
 };
 
@@ -398,7 +398,7 @@ Quaternion.clone = function (quaternion, result) {
       quaternion.x,
       quaternion.y,
       quaternion.z,
-      quaternion.w
+      quaternion.w,
     );
   }
 
@@ -776,12 +776,12 @@ Quaternion.slerp = function (start, end, t, result) {
   slerpScaledP = Quaternion.multiplyByScalar(
     start,
     Math.sin((1 - t) * theta),
-    slerpScaledP
+    slerpScaledP,
   );
   slerpScaledR = Quaternion.multiplyByScalar(
     r,
     Math.sin(t * theta),
-    slerpScaledR
+    slerpScaledR,
   );
   result = Quaternion.add(slerpScaledP, slerpScaledR, result);
   return Quaternion.multiplyByScalar(result, 1.0 / Math.sin(theta), result);
@@ -1006,7 +1006,7 @@ Quaternion.fastSlerp = function (start, end, t, result) {
   const temp = Quaternion.multiplyByScalar(
     start,
     cD,
-    fastSlerpScratchQuaternion
+    fastSlerpScratchQuaternion,
   );
   Quaternion.multiplyByScalar(end, cT, result);
   return Quaternion.add(temp, result, result);

package/Source/Core/QuaternionSpline.js

@@ -15,7 +15,7 @@ function createEvaluateFunction(spline) {
     }
     const i = (spline._lastTimeIndex = spline.findTimeInterval(
       time,
-      spline._lastTimeIndex
+      spline._lastTimeIndex,
     ));
     const u = (time - times[i]) / (times[i + 1] - times[i]);
 
@@ -61,7 +61,7 @@ function QuaternionSpline(options) {
   }
   if (points.length < 2) {
     throw new DeveloperError(
-      "points.length must be greater than or equal to 2."
+      "points.length must be greater than or equal to 2.",
     );
   }
   if (times.length !== points.length) {

package/Source/Core/Rectangle.js

@@ -7,6 +7,7 @@ import Ellipsoid from "./Ellipsoid.js";
 import CesiumMath from "./Math.js";
 import Transforms from "./Transforms.js";
 import Matrix4 from "./Matrix4.js";
+import deprecationWarning from "./deprecationWarning.js";
 
 /**
  * A two dimensional region specified as longitude and latitude coordinates.
@@ -382,18 +383,18 @@ Rectangle.fromBoundingSphere = function (boundingSphere, ellipsoid, result) {
   const fromENU = Transforms.eastNorthUpToFixedFrame(
     center,
     ellipsoid,
-    fromBoundingSphereMatrixScratch
+    fromBoundingSphereMatrixScratch,
   );
   const east = Matrix4.multiplyByPointAsVector(
     fromENU,
     Cartesian3.UNIT_X,
-    fromBoundingSphereEastScratch
+    fromBoundingSphereEastScratch,
   );
   Cartesian3.normalize(east, east);
   const north = Matrix4.multiplyByPointAsVector(
     fromENU,
     Cartesian3.UNIT_Y,
-    fromBoundingSphereNorthScratch
+    fromBoundingSphereNorthScratch,
   );
   Cartesian3.normalize(north, north);
 
@@ -443,7 +444,7 @@ Rectangle.clone = function (rectangle, result) {
       rectangle.west,
       rectangle.south,
       rectangle.east,
-      rectangle.north
+      rectangle.north,
     );
   }
 
@@ -541,8 +542,28 @@ Rectangle.prototype.equalsEpsilon = function (other, epsilon) {
  * @exception {DeveloperError} <code>south</code> must be in the interval [<code>-Pi/2</code>, <code>Pi/2</code>].
  * @exception {DeveloperError} <code>east</code> must be in the interval [<code>-Pi</code>, <code>Pi</code>].
  * @exception {DeveloperError} <code>west</code> must be in the interval [<code>-Pi</code>, <code>Pi</code>].
+ * @deprecated This function is deprecated and will be removed in Cesium 1.124. See <a href="https://github.com/CesiumGS/cesium/issues/4921">Issue 4921</a>
  */
 Rectangle.validate = function (rectangle) {
+  deprecationWarning(
+    "Rectangle.validate",
+    "Rectangle.validate is a no-op and has been deprecated. It will be removed in Cesium 1.124.",
+  );
+  return Rectangle._validate(rectangle);
+};
+
+/**
+ * Checks a Rectangle's properties and throws if they are not in valid ranges.
+ *
+ * @param {Rectangle} rectangle The rectangle to validate
+ *
+ * @exception {DeveloperError} <code>north</code> must be in the interval [<code>-Pi/2</code>, <code>Pi/2</code>].
+ * @exception {DeveloperError} <code>south</code> must be in the interval [<code>-Pi/2</code>, <code>Pi/2</code>].
+ * @exception {DeveloperError} <code>east</code> must be in the interval [<code>-Pi</code>, <code>Pi</code>].
+ * @exception {DeveloperError} <code>west</code> must be in the interval [<code>-Pi</code>, <code>Pi</code>].
+ * @private
+ */
+Rectangle._validate = function (rectangle) {
   //>>includeStart('debug', pragmas.debug);
   Check.typeOf.object("rectangle", rectangle);
 
@@ -550,7 +571,7 @@ Rectangle.validate = function (rectangle) {
   Check.typeOf.number.greaterThanOrEquals(
     "north",
     north,
-    -CesiumMath.PI_OVER_TWO
+    -CesiumMath.PI_OVER_TWO,
   );
   Check.typeOf.number.lessThanOrEquals("north", north, CesiumMath.PI_OVER_TWO);
 
@@ -558,7 +579,7 @@ Rectangle.validate = function (rectangle) {
   Check.typeOf.number.greaterThanOrEquals(
     "south",
     south,
-    -CesiumMath.PI_OVER_TWO
+    -CesiumMath.PI_OVER_TWO,
   );
   Check.typeOf.number.lessThanOrEquals("south", south, CesiumMath.PI_OVER_TWO);
 
@@ -725,10 +746,10 @@ Rectangle.intersection = function (rectangle, otherRectangle, result) {
   }
 
   const west = CesiumMath.negativePiToPi(
-    Math.max(rectangleWest, otherRectangleWest)
+    Math.max(rectangleWest, otherRectangleWest),
   );
   const east = CesiumMath.negativePiToPi(
-    Math.min(rectangleEast, otherRectangleEast)
+    Math.min(rectangleEast, otherRectangleEast),
   );
 
   if (
@@ -830,10 +851,10 @@ Rectangle.union = function (rectangle, otherRectangle, result) {
   }
 
   const west = CesiumMath.negativePiToPi(
-    Math.min(rectangleWest, otherRectangleWest)
+    Math.min(rectangleWest, otherRectangleWest),
   );
   const east = CesiumMath.negativePiToPi(
-    Math.max(rectangleEast, otherRectangleEast)
+    Math.max(rectangleEast, otherRectangleEast),
   );
 
   result.west = west;
@@ -1000,7 +1021,7 @@ Rectangle.subsection = function (
   southLerp,
   eastLerp,
   northLerp,
-  result
+  result,
 ) {
   //>>includeStart('debug', pragmas.debug);
   Check.typeOf.object("rectangle", rectangle);
@@ -1065,7 +1086,7 @@ Rectangle.MAX_VALUE = Object.freeze(
     -Math.PI,
     -CesiumMath.PI_OVER_TWO,
     Math.PI,
-    CesiumMath.PI_OVER_TWO
-  )
+    CesiumMath.PI_OVER_TWO,
+  ),
 );
 export default Rectangle;

package/Source/Core/RectangleCollisionChecker.js

@@ -42,7 +42,7 @@ RectangleCollisionChecker.prototype.insert = function (id, rectangle) {
   const withId = RectangleWithId.fromRectangleAndId(
     id,
     rectangle,
-    new RectangleWithId()
+    new RectangleWithId(),
   );
   this._tree.insert(withId);
 };
@@ -68,7 +68,7 @@ RectangleCollisionChecker.prototype.remove = function (id, rectangle) {
   const withId = RectangleWithId.fromRectangleAndId(
     id,
     rectangle,
-    removalScratch
+    removalScratch,
   );
   this._tree.remove(withId, idCompare);
 };
@@ -88,7 +88,7 @@ RectangleCollisionChecker.prototype.collides = function (rectangle) {
   const withId = RectangleWithId.fromRectangleAndId(
     "",
     rectangle,
-    collisionScratch
+    collisionScratch,
   );
   return this._tree.collides(withId);
 };