@cesium/engine 10.1.0 → 11.1.0

package/Source/Core/Matrix4.js

@@ -69,7 +69,7 @@ function Matrix4(
   column0Row3,
   column1Row3,
   column2Row3,
-  column3Row3
+  column3Row3,
 ) {
   this[0] = defaultValue(column0Row0, 0.0);
   this[1] = defaultValue(column0Row1, 0.0);
@@ -190,7 +190,7 @@ Matrix4.packArray = function (array, result) {
   } else if (!Array.isArray(result) && result.length !== resultLength) {
     //>>includeStart('debug', pragmas.debug);
     throw new DeveloperError(
-      "If result is a typed array, it must have exactly array.length * 16 elements"
+      "If result is a typed array, it must have exactly array.length * 16 elements",
     );
     //>>includeEnd('debug');
   } else if (result.length !== resultLength) {
@@ -261,7 +261,7 @@ Matrix4.clone = function (matrix, result) {
       matrix[3],
       matrix[7],
       matrix[11],
-      matrix[15]
+      matrix[15],
     );
   }
   result[0] = matrix[0];
@@ -353,7 +353,7 @@ Matrix4.fromRowMajorArray = function (values, result) {
       values[12],
       values[13],
       values[14],
-      values[15]
+      values[15],
     );
   }
   result[0] = values[0];
@@ -408,7 +408,7 @@ Matrix4.fromRotationTranslation = function (rotation, translation, result) {
       0.0,
       0.0,
       0.0,
-      1.0
+      1.0,
     );
   }
 
@@ -452,7 +452,7 @@ Matrix4.fromTranslationQuaternionRotationScale = function (
   translation,
   rotation,
   scale,
-  result
+  result,
 ) {
   //>>includeStart('debug', pragmas.debug);
   Check.typeOf.object("translation", translation);
@@ -520,7 +520,7 @@ Matrix4.fromTranslationQuaternionRotationScale = function (
  */
 Matrix4.fromTranslationRotationScale = function (
   translationRotationScale,
-  result
+  result,
 ) {
   //>>includeStart('debug', pragmas.debug);
   Check.typeOf.object("translationRotationScale", translationRotationScale);
@@ -530,7 +530,7 @@ Matrix4.fromTranslationRotationScale = function (
     translationRotationScale.translation,
     translationRotationScale.rotation,
     translationRotationScale.scale,
-    result
+    result,
   );
 };
 
@@ -588,7 +588,7 @@ Matrix4.fromScale = function (scale, result) {
       0.0,
       0.0,
       0.0,
-      1.0
+      1.0,
     );
   }
 
@@ -648,7 +648,7 @@ Matrix4.fromUniformScale = function (scale, result) {
       0.0,
       0.0,
       0.0,
-      1.0
+      1.0,
     );
   }
 
@@ -738,11 +738,11 @@ Matrix4.fromCamera = function (camera, result) {
   Cartesian3.normalize(direction, fromCameraF);
   Cartesian3.normalize(
     Cartesian3.cross(fromCameraF, up, fromCameraR),
-    fromCameraR
+    fromCameraR,
   );
   Cartesian3.normalize(
     Cartesian3.cross(fromCameraR, fromCameraF, fromCameraU),
-    fromCameraU
+    fromCameraU,
   );
 
   const sX = fromCameraR.x;
@@ -793,7 +793,7 @@ Matrix4.fromCamera = function (camera, result) {
       0.0,
       0.0,
       0.0,
-      1.0
+      1.0,
     );
   }
   result[0] = sX;
@@ -835,7 +835,7 @@ Matrix4.computePerspectiveFieldOfView = function (
   aspectRatio,
   near,
   far,
-  result
+  result,
 ) {
   //>>includeStart('debug', pragmas.debug);
   Check.typeOf.number.greaterThan("fovY", fovY, 0.0);
@@ -890,7 +890,7 @@ Matrix4.computeOrthographicOffCenter = function (
   top,
   near,
   far,
-  result
+  result,
 ) {
   //>>includeStart('debug', pragmas.debug);
   Check.typeOf.number("left", left);
@@ -937,8 +937,8 @@ Matrix4.computeOrthographicOffCenter = function (
  *
  * @param {number} left The number of meters to the left of the camera that will be in view.
  * @param {number} right The number of meters to the right of the camera that will be in view.
- * @param {number} bottom The number of meters below of the camera that will be in view.
- * @param {number} top The number of meters above of the camera that will be in view.
+ * @param {number} bottom The number of meters below the camera that will be in view.
+ * @param {number} top The number of meters above the camera that will be in view.
  * @param {number} near The distance to the near plane in meters.
  * @param {number} far The distance to the far plane in meters.
  * @param {Matrix4} result The object in which the result will be stored.
@@ -951,7 +951,7 @@ Matrix4.computePerspectiveOffCenter = function (
   top,
   near,
   far,
-  result
+  result,
 ) {
   //>>includeStart('debug', pragmas.debug);
   Check.typeOf.number("left", left);
@@ -1007,7 +1007,7 @@ Matrix4.computeInfinitePerspectiveOffCenter = function (
   bottom,
   top,
   near,
-  result
+  result,
 ) {
   //>>includeStart('debug', pragmas.debug);
   Check.typeOf.number("left", left);
@@ -1067,7 +1067,7 @@ Matrix4.computeViewportTransformation = function (
   viewport,
   nearDepthRange,
   farDepthRange,
-  result
+  result,
 ) {
   if (!defined(result)) {
     result = new Matrix4();
@@ -1600,13 +1600,13 @@ Matrix4.getScale = function (matrix, result) {
   //>>includeEnd('debug');
 
   result.x = Cartesian3.magnitude(
-    Cartesian3.fromElements(matrix[0], matrix[1], matrix[2], scratchColumn)
+    Cartesian3.fromElements(matrix[0], matrix[1], matrix[2], scratchColumn),
   );
   result.y = Cartesian3.magnitude(
-    Cartesian3.fromElements(matrix[4], matrix[5], matrix[6], scratchColumn)
+    Cartesian3.fromElements(matrix[4], matrix[5], matrix[6], scratchColumn),
   );
   result.z = Cartesian3.magnitude(
-    Cartesian3.fromElements(matrix[8], matrix[9], matrix[10], scratchColumn)
+    Cartesian3.fromElements(matrix[8], matrix[9], matrix[10], scratchColumn),
   );
   return result;
 };
@@ -2826,11 +2826,11 @@ Matrix4.inverse = function (matrix, result) {
       Matrix3.equalsEpsilon(
         Matrix4.getMatrix3(matrix, scratchInverseRotation),
         scratchMatrix3Zero,
-        CesiumMath.EPSILON7
+        CesiumMath.EPSILON7,
       ) &&
       Cartesian4.equals(
         Matrix4.getRow(matrix, 3, scratchBottomRow),
-        scratchExpectedBottomRow
+        scratchExpectedBottomRow,
       )
     ) {
       result[0] = 0.0;
@@ -2853,7 +2853,7 @@ Matrix4.inverse = function (matrix, result) {
     }
 
     throw new RuntimeError(
-      "matrix is not invertible because its determinate is zero."
+      "matrix is not invertible because its determinate is zero.",
     );
   }
 
@@ -2958,7 +2958,7 @@ Matrix4.inverseTranspose = function (matrix, result) {
 
   return Matrix4.inverse(
     Matrix4.transpose(matrix, scratchTransposeMatrix),
-    result
+    result,
   );
 };
 
@@ -2985,8 +2985,8 @@ Matrix4.IDENTITY = Object.freeze(
     0.0,
     0.0,
     0.0,
-    1.0
-  )
+    1.0,
+  ),
 );
 
 /**
@@ -3012,8 +3012,8 @@ Matrix4.ZERO = Object.freeze(
     0.0,
     0.0,
     0.0,
-    0.0
-  )
+    0.0,
+  ),
 );
 
 /**

package/Source/Core/MorphWeightSpline.js

@@ -51,7 +51,7 @@ function MorphWeightSpline(options) {
   Check.typeOf.number.greaterThanOrEquals("weights.length", weights.length, 3);
   if (weights.length % times.length !== 0) {
     throw new DeveloperError(
-      "times.length must be a factor of weights.length."
+      "times.length must be a factor of weights.length.",
     );
   }
   //>>includeEnd('debug');
@@ -143,7 +143,7 @@ MorphWeightSpline.prototype.evaluate = function (time, result) {
 
   const i = (this._lastTimeIndex = this.findTimeInterval(
     time,
-    this._lastTimeIndex
+    this._lastTimeIndex,
   ));
   const u = (time - times[i]) / (times[i + 1] - times[i]);
 

package/Source/Core/NearFarScalar.js

@@ -58,7 +58,7 @@ NearFarScalar.clone = function (nearFarScalar, result) {
       nearFarScalar.near,
       nearFarScalar.nearValue,
       nearFarScalar.far,
-      nearFarScalar.farValue
+      nearFarScalar.farValue,
     );
   }
 

package/Source/Core/Occluder.js

@@ -91,11 +91,10 @@ Object.defineProperties(Occluder.prototype, {
       const cameraToOccluderVec = Cartesian3.subtract(
         this._occluderPosition,
         cameraPosition,
-        scratchCartesian3
-      );
-      let invCameraToOccluderDistance = Cartesian3.magnitudeSquared(
-        cameraToOccluderVec
+        scratchCartesian3,
       );
+      let invCameraToOccluderDistance =
+        Cartesian3.magnitudeSquared(cameraToOccluderVec);
       const occluderRadiusSqrd = this._occluderRadius * this._occluderRadius;
 
       let horizonDistance;
@@ -103,14 +102,14 @@ Object.defineProperties(Occluder.prototype, {
       let horizonPlanePosition;
       if (invCameraToOccluderDistance > occluderRadiusSqrd) {
         horizonDistance = Math.sqrt(
-          invCameraToOccluderDistance - occluderRadiusSqrd
+          invCameraToOccluderDistance - occluderRadiusSqrd,
         );
         invCameraToOccluderDistance =
           1.0 / Math.sqrt(invCameraToOccluderDistance);
         horizonPlaneNormal = Cartesian3.multiplyByScalar(
           cameraToOccluderVec,
           invCameraToOccluderDistance,
-          scratchCartesian3
+          scratchCartesian3,
         );
         const nearPlaneDistance =
           horizonDistance * horizonDistance * invCameraToOccluderDistance;
@@ -119,9 +118,9 @@ Object.defineProperties(Occluder.prototype, {
           Cartesian3.multiplyByScalar(
             horizonPlaneNormal,
             nearPlaneDistance,
-            scratchCartesian3
+            scratchCartesian3,
           ),
-          scratchCartesian3
+          scratchCartesian3,
         );
       } else {
         horizonDistance = Number.MAX_VALUE;
@@ -146,7 +145,7 @@ Object.defineProperties(Occluder.prototype, {
 Occluder.fromBoundingSphere = function (
   occluderBoundingSphere,
   cameraPosition,
-  result
+  result,
 ) {
   //>>includeStart('debug', pragmas.debug);
   if (!defined(occluderBoundingSphere)) {
@@ -192,7 +191,7 @@ Occluder.prototype.isPointVisible = function (occludee) {
     let tempVec = Cartesian3.subtract(
       occludee,
       this._occluderPosition,
-      tempVecScratch
+      tempVecScratch,
     );
     let temp = this._occluderRadius;
     temp = Cartesian3.magnitudeSquared(tempVec) - temp * temp;
@@ -226,7 +225,7 @@ const occludeePositionScratch = new Cartesian3();
 Occluder.prototype.isBoundingSphereVisible = function (occludee) {
   const occludeePosition = Cartesian3.clone(
     occludee.center,
-    occludeePositionScratch
+    occludeePositionScratch,
   );
   const occludeeRadius = occludee.radius;
 
@@ -234,7 +233,7 @@ Occluder.prototype.isBoundingSphereVisible = function (occludee) {
     let tempVec = Cartesian3.subtract(
       occludeePosition,
       this._occluderPosition,
-      tempVecScratch
+      tempVecScratch,
     );
     let temp = this._occluderRadius - occludeeRadius;
     temp = Cartesian3.magnitudeSquared(tempVec) - temp * temp;
@@ -244,7 +243,7 @@ Occluder.prototype.isBoundingSphereVisible = function (occludee) {
         tempVec = Cartesian3.subtract(
           occludeePosition,
           this._cameraPosition,
-          tempVec
+          tempVec,
         );
         return (
           temp * temp + occludeeRadius * occludeeRadius >
@@ -260,7 +259,7 @@ Occluder.prototype.isBoundingSphereVisible = function (occludee) {
       tempVec = Cartesian3.subtract(
         occludeePosition,
         this._cameraPosition,
-        tempVec
+        tempVec,
       );
       const tempVecMagnitudeSquared = Cartesian3.magnitudeSquared(tempVec);
       const occluderRadiusSquared = this._occluderRadius * this._occluderRadius;
@@ -301,8 +300,6 @@ const tempScratch = new Cartesian3();
  * const cameraPosition = new Cesium.Cartesian3(0, 0, 0);
  * const occluder = new Cesium.Occluder(sphere1, cameraPosition);
  * occluder.computeVisibility(sphere2); //returns Visibility.NONE
- *
- * @see Occluder#isVisible
  */
 Occluder.prototype.computeVisibility = function (occludeeBS) {
   //>>includeStart('debug', pragmas.debug);
@@ -326,7 +323,7 @@ Occluder.prototype.computeVisibility = function (occludeeBS) {
     let tempVec = Cartesian3.subtract(
       occludeePosition,
       this._occluderPosition,
-      tempScratch
+      tempScratch,
     );
     let temp = this._occluderRadius - occludeeRadius;
     const occluderToOccludeeDistSqrd = Cartesian3.magnitudeSquared(tempVec);
@@ -338,7 +335,7 @@ Occluder.prototype.computeVisibility = function (occludeeBS) {
       tempVec = Cartesian3.subtract(
         occludeePosition,
         this._cameraPosition,
-        tempVec
+        tempVec,
       );
       const cameraToOccludeeDistSqrd = Cartesian3.magnitudeSquared(tempVec);
       if (
@@ -366,7 +363,7 @@ Occluder.prototype.computeVisibility = function (occludeeBS) {
       tempVec = Cartesian3.subtract(
         occludeePosition,
         this._horizonPlanePosition,
-        tempVec
+        tempVec,
       );
       return Cartesian3.dot(tempVec, this._horizonPlaneNormal) > -occludeeRadius
         ? Visibility.PARTIAL
@@ -407,7 +404,7 @@ const occludeePointScratch = new Cartesian3();
 Occluder.computeOccludeePoint = function (
   occluderBoundingSphere,
   occludeePosition,
-  positions
+  positions,
 ) {
   //>>includeStart('debug', pragmas.debug);
   if (!defined(occluderBoundingSphere)) {
@@ -429,7 +426,7 @@ Occluder.computeOccludeePoint = function (
   //>>includeStart('debug', pragmas.debug);
   if (Cartesian3.equals(occluderPosition, occludeePosition)) {
     throw new DeveloperError(
-      "occludeePosition must be different than occluderBoundingSphere.center"
+      "occludeePosition must be different than occluderBoundingSphere.center",
     );
   }
   //>>includeEnd('debug');
@@ -437,7 +434,7 @@ Occluder.computeOccludeePoint = function (
   // Compute a plane with a normal from the occluder to the occludee position.
   const occluderPlaneNormal = Cartesian3.normalize(
     Cartesian3.subtract(occludeePos, occluderPosition, occludeePointScratch),
-    occludeePointScratch
+    occludeePointScratch,
   );
   const occluderPlaneD = -Cartesian3.dot(occluderPlaneNormal, occluderPosition);
 
@@ -446,14 +443,14 @@ Occluder.computeOccludeePoint = function (
   const aRotationVector = Occluder._anyRotationVector(
     occluderPosition,
     occluderPlaneNormal,
-    occluderPlaneD
+    occluderPlaneD,
   );
   let dot = Occluder._horizonToPlaneNormalDotProduct(
     occluderBoundingSphere,
     occluderPlaneNormal,
     occluderPlaneD,
     aRotationVector,
-    positions[0]
+    positions[0],
   );
   if (!dot) {
     //The position is inside the mimimum radius, which is invalid
@@ -466,7 +463,7 @@ Occluder.computeOccludeePoint = function (
       occluderPlaneNormal,
       occluderPlaneD,
       aRotationVector,
-      positions[i]
+      positions[i],
     );
     if (!tempDot) {
       //The position is inside the minimum radius, which is invalid
@@ -488,9 +485,9 @@ Occluder.computeOccludeePoint = function (
     Cartesian3.multiplyByScalar(
       occluderPlaneNormal,
       distance,
-      occludeePointScratch
+      occludeePointScratch,
     ),
-    occludeePointScratch
+    occludeePointScratch,
   );
 };
 
@@ -515,7 +512,7 @@ Occluder.computeOccludeePointFromRectangle = function (rectangle, ellipsoid) {
     rectangle,
     ellipsoid,
     0.0,
-    computeOccludeePointFromRectangleScratch
+    computeOccludeePointFromRectangleScratch,
   );
   const bs = BoundingSphere.fromPoints(positions);
 
@@ -525,7 +522,7 @@ Occluder.computeOccludeePointFromRectangle = function (rectangle, ellipsoid) {
     return Occluder.computeOccludeePoint(
       new BoundingSphere(ellipsoidCenter, ellipsoid.minimumRadius),
       bs.center,
-      positions
+      positions,
     );
   }
 
@@ -536,7 +533,7 @@ const tempVec0Scratch = new Cartesian3();
 Occluder._anyRotationVector = function (
   occluderPosition,
   occluderPlaneNormal,
-  occluderPlaneD
+  occluderPlaneD,
 ) {
   const tempVec0 = Cartesian3.abs(occluderPlaneNormal, tempVec0Scratch);
   let majorAxis = tempVec0.x > tempVec0.y ? 0 : 1;
@@ -572,12 +569,12 @@ Occluder._anyRotationVector = function (
       Cartesian3.add(
         tempVec0,
         Cartesian3.multiplyByScalar(tempVec1, u, tempVec),
-        tempVec0
+        tempVec0,
       ),
       occluderPosition,
-      tempVec0
+      tempVec0,
     ),
-    tempVec0
+    tempVec0,
   );
 };
 
@@ -587,17 +584,17 @@ Occluder._rotationVector = function (
   occluderPlaneNormal,
   occluderPlaneD,
   position,
-  anyRotationVector
+  anyRotationVector,
 ) {
   //Determine the angle between the occluder plane normal and the position direction
   let positionDirection = Cartesian3.subtract(
     position,
     occluderPosition,
-    posDirectionScratch
+    posDirectionScratch,
   );
   positionDirection = Cartesian3.normalize(
     positionDirection,
-    positionDirection
+    positionDirection,
   );
   if (
     Cartesian3.dot(occluderPlaneNormal, positionDirection) <
@@ -607,7 +604,7 @@ Occluder._rotationVector = function (
     const crossProduct = Cartesian3.cross(
       occluderPlaneNormal,
       positionDirection,
-      positionDirection
+      positionDirection,
     );
     const length = Cartesian3.magnitude(crossProduct);
     if (length > CesiumMath.EPSILON13) {
@@ -628,12 +625,12 @@ Occluder._horizonToPlaneNormalDotProduct = function (
   occluderPlaneNormal,
   occluderPlaneD,
   anyRotationVector,
-  position
+  position,
 ) {
   const pos = Cartesian3.clone(position, posScratch1);
   const occluderPosition = Cartesian3.clone(
     occluderBS.center,
-    occluerPosScratch
+    occluerPosScratch,
   );
   const occluderRadius = occluderBS.radius;
 
@@ -641,11 +638,10 @@ Occluder._horizonToPlaneNormalDotProduct = function (
   let positionToOccluder = Cartesian3.subtract(
     occluderPosition,
     pos,
-    posScratch2
-  );
-  const occluderToPositionDistanceSquared = Cartesian3.magnitudeSquared(
-    positionToOccluder
+    posScratch2,
   );
+  const occluderToPositionDistanceSquared =
+    Cartesian3.magnitudeSquared(positionToOccluder);
   const occluderRadiusSquared = occluderRadius * occluderRadius;
   if (occluderToPositionDistanceSquared < occluderRadiusSquared) {
     return false;
@@ -656,26 +652,26 @@ Occluder._horizonToPlaneNormalDotProduct = function (
     occluderToPositionDistanceSquared - occluderRadiusSquared;
   const horizonDistance = Math.sqrt(horizonDistanceSquared);
   const occluderToPositionDistance = Math.sqrt(
-    occluderToPositionDistanceSquared
+    occluderToPositionDistanceSquared,
   );
   const invOccluderToPositionDistance = 1.0 / occluderToPositionDistance;
   const cosTheta = horizonDistance * invOccluderToPositionDistance;
   const horizonPlaneDistance = cosTheta * horizonDistance;
   positionToOccluder = Cartesian3.normalize(
     positionToOccluder,
-    positionToOccluder
+    positionToOccluder,
   );
   const horizonPlanePosition = Cartesian3.add(
     pos,
     Cartesian3.multiplyByScalar(
       positionToOccluder,
       horizonPlaneDistance,
-      horizonPlanePosScratch
+      horizonPlanePosScratch,
     ),
-    horizonPlanePosScratch
+    horizonPlanePosScratch,
   );
   const horizonCrossDistance = Math.sqrt(
-    horizonDistanceSquared - horizonPlaneDistance * horizonPlaneDistance
+    horizonDistanceSquared - horizonPlaneDistance * horizonPlaneDistance,
   );
 
   //Rotate the position to occluder vector 90 degrees
@@ -684,7 +680,7 @@ Occluder._horizonToPlaneNormalDotProduct = function (
     occluderPlaneNormal,
     occluderPlaneD,
     pos,
-    anyRotationVector
+    anyRotationVector,
   );
   let horizonCrossDirection = Cartesian3.fromElements(
     tempVec.x * tempVec.x * positionToOccluder.x +
@@ -696,35 +692,35 @@ Occluder._horizonToPlaneNormalDotProduct = function (
     (tempVec.x * tempVec.z - tempVec.y) * positionToOccluder.x +
       (tempVec.y * tempVec.z + tempVec.x) * positionToOccluder.y +
       tempVec.z * tempVec.z * positionToOccluder.z,
-    posScratch1
+    posScratch1,
   );
   horizonCrossDirection = Cartesian3.normalize(
     horizonCrossDirection,
-    horizonCrossDirection
+    horizonCrossDirection,
   );
 
   //Horizon positions
   const offset = Cartesian3.multiplyByScalar(
     horizonCrossDirection,
     horizonCrossDistance,
-    posScratch1
+    posScratch1,
   );
   tempVec = Cartesian3.normalize(
     Cartesian3.subtract(
       Cartesian3.add(horizonPlanePosition, offset, posScratch2),
       occluderPosition,
-      posScratch2
+      posScratch2,
     ),
-    posScratch2
+    posScratch2,
   );
   const dot0 = Cartesian3.dot(occluderPlaneNormal, tempVec);
   tempVec = Cartesian3.normalize(
     Cartesian3.subtract(
       Cartesian3.subtract(horizonPlanePosition, offset, tempVec),
       occluderPosition,
-      tempVec
+      tempVec,
     ),
-    tempVec
+    tempVec,
   );
   const dot1 = Cartesian3.dot(occluderPlaneNormal, tempVec);
   return dot0 < dot1 ? dot0 : dot1;

package/Source/Core/OpenCageGeocoderService.js

@@ -51,7 +51,7 @@ function OpenCageGeocoderService(url, apiKey, params) {
   this._params = defaultValue(params, {});
   this._credit = new Credit(
     `Geodata copyright <a href="https://www.openstreetmap.org/">OpenStreetMap</a> contributors`,
-    false
+    false,
   );
 }
 
@@ -117,7 +117,7 @@ OpenCageGeocoderService.prototype.geocode = async function (query) {
           bounds.southwest.lng,
           bounds.southwest.lat,
           bounds.northeast.lng,
-          bounds.northeast.lat
+          bounds.northeast.lat,
         );
       } else {
         const lon = resultObject.geometry.lat;