@cesium/engine 10.1.0 → 11.1.0

package/Source/Scene/Camera.js

@@ -235,7 +235,7 @@ function Camera(scene) {
   const projection = scene.mapProjection;
   this._projection = projection;
   this._maxCoord = projection.project(
-    new Cartographic(Math.PI, CesiumMath.PI_OVER_TWO)
+    new Cartographic(Math.PI, CesiumMath.PI_OVER_TWO),
   );
   this._max2Dfrustum = undefined;
 
@@ -244,7 +244,7 @@ function Camera(scene) {
     this,
     Camera.DEFAULT_VIEW_RECTANGLE,
     this.position,
-    true
+    true,
   );
 
   let mag = Cartesian3.magnitude(this.position);
@@ -272,7 +272,7 @@ Camera.TRANSFORM_2D = new Matrix4(
   0.0,
   0.0,
   0.0,
-  1.0
+  1.0,
 );
 
 /**
@@ -280,7 +280,7 @@ Camera.TRANSFORM_2D = new Matrix4(
  */
 Camera.TRANSFORM_2D_INVERSE = Matrix4.inverseTransformation(
   Camera.TRANSFORM_2D,
-  new Matrix4()
+  new Matrix4(),
 );
 
 /**
@@ -291,7 +291,7 @@ Camera.DEFAULT_VIEW_RECTANGLE = Rectangle.fromDegrees(
   -95.0,
   -20.0,
   -70.0,
-  90.0
+  90.0,
 );
 
 /**
@@ -309,7 +309,7 @@ Camera.DEFAULT_VIEW_FACTOR = 0.5;
 Camera.DEFAULT_OFFSET = new HeadingPitchRange(
   0.0,
   -CesiumMath.PI_OVER_FOUR,
-  0.0
+  0.0,
 );
 
 function updateViewMatrix(camera) {
@@ -318,12 +318,12 @@ function updateViewMatrix(camera) {
     camera._direction,
     camera._up,
     camera._right,
-    camera._viewMatrix
+    camera._viewMatrix,
   );
   Matrix4.multiply(
     camera._viewMatrix,
     camera._actualInvTransform,
-    camera._viewMatrix
+    camera._viewMatrix,
   );
   Matrix4.inverseTransformation(camera._viewMatrix, camera._invViewMatrix);
 }
@@ -332,19 +332,19 @@ function updateCameraDeltas(camera) {
   if (!defined(camera._oldPositionWC)) {
     camera._oldPositionWC = Cartesian3.clone(
       camera.positionWC,
-      camera._oldPositionWC
+      camera._oldPositionWC,
     );
   } else {
     camera.positionWCDeltaMagnitudeLastFrame = camera.positionWCDeltaMagnitude;
     const delta = Cartesian3.subtract(
       camera.positionWC,
       camera._oldPositionWC,
-      camera._oldPositionWC
+      camera._oldPositionWC,
     );
     camera.positionWCDeltaMagnitude = Cartesian3.magnitude(delta);
     camera._oldPositionWC = Cartesian3.clone(
       camera.positionWC,
-      camera._oldPositionWC
+      camera._oldPositionWC,
     );
 
     // Update move timers
@@ -427,14 +427,14 @@ Camera.prototype._updateCameraChanged = function () {
     headingChangedPercentage > percentageChanged
   ) {
     camera._changed.raiseEvent(
-      Math.max(rollChangedPercentage, headingChangedPercentage)
+      Math.max(rollChangedPercentage, headingChangedPercentage),
     );
   }
   if (camera._mode === SceneMode.SCENE2D) {
     if (!defined(camera._changedFrustum)) {
       camera._changedPosition = Cartesian3.clone(
         camera.position,
-        camera._changedPosition
+        camera._changedPosition,
       );
       camera._changedFrustum = camera.frustum.clone();
       return;
@@ -479,7 +479,7 @@ Camera.prototype._updateCameraChanged = function () {
       camera._changed.raiseEvent(areaPercentage);
       camera._changedPosition = Cartesian3.clone(
         camera.position,
-        camera._changedPosition
+        camera._changedPosition,
       );
       camera._changedFrustum = camera.frustum.clone(camera._changedFrustum);
     }
@@ -489,17 +489,17 @@ Camera.prototype._updateCameraChanged = function () {
   if (!defined(camera._changedDirection)) {
     camera._changedPosition = Cartesian3.clone(
       camera.positionWC,
-      camera._changedPosition
+      camera._changedPosition,
     );
     camera._changedDirection = Cartesian3.clone(
       camera.directionWC,
-      camera._changedDirection
+      camera._changedDirection,
     );
     return;
   }
 
   const dirAngle = CesiumMath.acosClamped(
-    Cartesian3.dot(camera.directionWC, camera._changedDirection)
+    Cartesian3.dot(camera.directionWC, camera._changedDirection),
   );
 
   let dirPercentage;
@@ -511,7 +511,7 @@ Camera.prototype._updateCameraChanged = function () {
 
   const distance = Cartesian3.distance(
     camera.positionWC,
-    camera._changedPosition
+    camera._changedPosition,
   );
   const heightPercentage = distance / camera.positionCartographic.height;
 
@@ -522,11 +522,11 @@ Camera.prototype._updateCameraChanged = function () {
     camera._changed.raiseEvent(Math.max(dirPercentage, heightPercentage));
     camera._changedPosition = Cartesian3.clone(
       camera.positionWC,
-      camera._changedPosition
+      camera._changedPosition,
     );
     camera._changedDirection = Cartesian3.clone(
       camera.directionWC,
-      camera._changedDirection
+      camera._changedDirection,
     );
   }
 };
@@ -535,7 +535,7 @@ function convertTransformForColumbusView(camera) {
   Transforms.basisTo2D(
     camera._projection,
     camera._transform,
-    camera._actualTransform
+    camera._actualTransform,
   );
 }
 
@@ -555,16 +555,16 @@ function convertTransformFor2D(camera) {
   const origin = Matrix4.getColumn(
     camera._transform,
     3,
-    scratchCartesian4Origin
+    scratchCartesian4Origin,
   );
   const cartographic = ellipsoid.cartesianToCartographic(
     origin,
-    scratchCartographic
+    scratchCartographic,
   );
 
   const projectedPosition = projection.project(
     cartographic,
-    scratchCartesian3Projection
+    scratchCartesian3Projection,
   );
   const newOrigin = scratchCartesian4NewOrigin;
   newOrigin.x = projectedPosition.z;
@@ -574,13 +574,13 @@ function convertTransformFor2D(camera) {
 
   const newZAxis = Cartesian4.clone(
     Cartesian4.UNIT_X,
-    scratchCartesian4NewZAxis
+    scratchCartesian4NewZAxis,
   );
 
   const xAxis = Cartesian4.add(
     Matrix4.getColumn(camera._transform, 0, scratchCartesian3),
     origin,
-    scratchCartesian3
+    scratchCartesian3,
   );
   ellipsoid.cartesianToCartographic(xAxis, cartographic);
 
@@ -601,7 +601,7 @@ function convertTransformFor2D(camera) {
     const yAxis = Cartesian4.add(
       Matrix4.getColumn(camera._transform, 1, scratchCartesian3),
       origin,
-      scratchCartesian3
+      scratchCartesian3,
     );
     ellipsoid.cartesianToCartographic(yAxis, cartographic);
 
@@ -629,25 +629,25 @@ function convertTransformFor2D(camera) {
     camera._actualTransform,
     0,
     newXAxis,
-    camera._actualTransform
+    camera._actualTransform,
   );
   Matrix4.setColumn(
     camera._actualTransform,
     1,
     newYAxis,
-    camera._actualTransform
+    camera._actualTransform,
   );
   Matrix4.setColumn(
     camera._actualTransform,
     2,
     newZAxis,
-    camera._actualTransform
+    camera._actualTransform,
   );
   Matrix4.setColumn(
     camera._actualTransform,
     3,
     newOrigin,
-    camera._actualTransform
+    camera._actualTransform,
   );
 }
 
@@ -714,7 +714,7 @@ function updateMembers(camera) {
 
     Matrix4.inverseTransformation(
       camera._actualTransform,
-      camera._actualInvTransform
+      camera._actualInvTransform,
     );
 
     camera._modeChanged = false;
@@ -726,15 +726,16 @@ function updateMembers(camera) {
     camera._positionWC = Matrix4.multiplyByPoint(
       transform,
       position,
-      camera._positionWC
+      camera._positionWC,
     );
 
     // Compute the Cartographic position of the camera.
     if (mode === SceneMode.SCENE3D || mode === SceneMode.MORPHING) {
-      camera._positionCartographic = camera._projection.ellipsoid.cartesianToCartographic(
-        camera._positionWC,
-        camera._positionCartographic
-      );
+      camera._positionCartographic =
+        camera._projection.ellipsoid.cartesianToCartographic(
+          camera._positionWC,
+          camera._positionCartographic,
+        );
     } else {
       // The camera position is expressed in the 2D coordinate system where the Y axis is to the East,
       // the Z axis is to the North, and the X axis is out of the map.  Express them instead in the ENU axes where
@@ -757,7 +758,7 @@ function updateMembers(camera) {
   if (directionChanged || upChanged || rightChanged) {
     const det = Cartesian3.dot(
       direction,
-      Cartesian3.cross(up, right, scratchCartesian)
+      Cartesian3.cross(up, right, scratchCartesian),
     );
     if (Math.abs(1.0 - det) > CesiumMath.EPSILON2) {
       //orthonormalize axes
@@ -766,11 +767,11 @@ function updateMembers(camera) {
       const w0 = Cartesian3.multiplyByScalar(
         direction,
         scalar,
-        scratchCartesian
+        scratchCartesian,
       );
       up = Cartesian3.normalize(
         Cartesian3.subtract(up, w0, camera._up),
-        camera._up
+        camera._up,
       );
       Cartesian3.clone(up, camera.up);
 
@@ -783,7 +784,7 @@ function updateMembers(camera) {
     camera._directionWC = Matrix4.multiplyByPointAsVector(
       transform,
       direction,
-      camera._directionWC
+      camera._directionWC,
     );
     Cartesian3.normalize(camera._directionWC, camera._directionWC);
   }
@@ -797,7 +798,7 @@ function updateMembers(camera) {
     camera._rightWC = Matrix4.multiplyByPointAsVector(
       transform,
       right,
-      camera._rightWC
+      camera._rightWC,
     );
     Cartesian3.normalize(camera._rightWC, camera._rightWC);
   }
@@ -998,7 +999,7 @@ Object.defineProperties(Camera.prototype, {
         const transform = Transforms.eastNorthUpToFixedFrame(
           this.positionWC,
           ellipsoid,
-          scratchHPRMatrix2
+          scratchHPRMatrix2,
         );
         this._setTransform(transform);
 
@@ -1029,7 +1030,7 @@ Object.defineProperties(Camera.prototype, {
         const transform = Transforms.eastNorthUpToFixedFrame(
           this.positionWC,
           ellipsoid,
-          scratchHPRMatrix2
+          scratchHPRMatrix2,
         );
         this._setTransform(transform);
 
@@ -1060,7 +1061,7 @@ Object.defineProperties(Camera.prototype, {
         const transform = Transforms.eastNorthUpToFixedFrame(
           this.positionWC,
           ellipsoid,
-          scratchHPRMatrix2
+          scratchHPRMatrix2,
         );
         this._setTransform(transform);
 
@@ -1125,7 +1126,7 @@ Camera.prototype.update = function (mode) {
     !(this.frustum instanceof OrthographicOffCenterFrustum)
   ) {
     throw new DeveloperError(
-      "An OrthographicOffCenterFrustum is required in 2D."
+      "An OrthographicOffCenterFrustum is required in 2D.",
     );
   }
   if (
@@ -1134,7 +1135,7 @@ Camera.prototype.update = function (mode) {
     !(this.frustum instanceof OrthographicFrustum)
   ) {
     throw new DeveloperError(
-      "A PerspectiveFrustum or OrthographicFrustum is required in 3D and Columbus view"
+      "A PerspectiveFrustum or OrthographicFrustum is required in 3D and Columbus view",
     );
   }
   //>>includeEnd('debug');
@@ -1152,7 +1153,7 @@ Camera.prototype.update = function (mode) {
     //>>includeStart('debug', pragmas.debug);
     if (!(frustum instanceof OrthographicOffCenterFrustum)) {
       throw new DeveloperError(
-        "The camera frustum is expected to be orthographic for 2D camera control."
+        "The camera frustum is expected to be orthographic for 2D camera control.",
       );
     }
     //>>includeEnd('debug');
@@ -1217,7 +1218,7 @@ function calculateOrthographicFrustumWidth(camera) {
       ray,
       scene,
       true,
-      scratchRayIntersection
+      scratchRayIntersection,
     );
   }
 
@@ -1225,7 +1226,7 @@ function calculateOrthographicFrustumWidth(camera) {
   if (scene.pickPositionSupported) {
     depthIntersection = scene.pickPositionWorldCoordinates(
       mousePosition,
-      scratchDepthIntersection
+      scratchDepthIntersection,
     );
   }
 
@@ -1271,12 +1272,12 @@ function setView3D(camera, position, hpr) {
   //>>includeEnd('debug');
   const currentTransform = Matrix4.clone(
     camera.transform,
-    scratchSetViewTransform1
+    scratchSetViewTransform1,
   );
   const localTransform = Transforms.eastNorthUpToFixedFrame(
     position,
     camera._projection.ellipsoid,
-    scratchSetViewTransform2
+    scratchSetViewTransform2,
   );
   camera._setTransform(localTransform);
 
@@ -1285,7 +1286,7 @@ function setView3D(camera, position, hpr) {
 
   const rotQuat = Quaternion.fromHeadingPitchRoll(
     hpr,
-    scratchSetViewQuaternion
+    scratchSetViewQuaternion,
   );
   const rotMat = Matrix3.fromQuaternion(rotQuat, scratchSetViewMatrix3);
 
@@ -1301,7 +1302,7 @@ function setView3D(camera, position, hpr) {
 function setViewCV(camera, position, hpr, convert) {
   const currentTransform = Matrix4.clone(
     camera.transform,
-    scratchSetViewTransform1
+    scratchSetViewTransform1,
   );
   camera._setTransform(Matrix4.IDENTITY);
 
@@ -1310,7 +1311,7 @@ function setViewCV(camera, position, hpr, convert) {
       const projection = camera._projection;
       const cartographic = projection.ellipsoid.cartesianToCartographic(
         position,
-        scratchSetViewCartographic
+        scratchSetViewCartographic,
       );
       position = projection.project(cartographic, scratchSetViewCartesian);
     }
@@ -1320,7 +1321,7 @@ function setViewCV(camera, position, hpr, convert) {
 
   const rotQuat = Quaternion.fromHeadingPitchRoll(
     hpr,
-    scratchSetViewQuaternion
+    scratchSetViewQuaternion,
   );
   const rotMat = Matrix3.fromQuaternion(rotQuat, scratchSetViewMatrix3);
 
@@ -1336,7 +1337,7 @@ function setViewCV(camera, position, hpr, convert) {
 function setView2D(camera, position, hpr, convert) {
   const currentTransform = Matrix4.clone(
     camera.transform,
-    scratchSetViewTransform1
+    scratchSetViewTransform1,
   );
   camera._setTransform(Matrix4.IDENTITY);
 
@@ -1345,7 +1346,7 @@ function setView2D(camera, position, hpr, convert) {
       const projection = camera._projection;
       const cartographic = projection.ellipsoid.cartesianToCartographic(
         position,
-        scratchSetViewCartographic
+        scratchSetViewCartographic,
       );
       position = projection.project(cartographic, scratchSetViewCartesian);
     }
@@ -1371,7 +1372,7 @@ function setView2D(camera, position, hpr, convert) {
     hpr.roll = 0.0;
     const rotQuat = Quaternion.fromHeadingPitchRoll(
       hpr,
-      scratchSetViewQuaternion
+      scratchSetViewQuaternion,
     );
     const rotMat = Matrix3.fromQuaternion(rotQuat, scratchSetViewMatrix3);
 
@@ -1389,7 +1390,7 @@ const scratchToHPRRight = new Cartesian3();
 function directionUpToHeadingPitchRoll(camera, position, orientation, result) {
   const direction = Cartesian3.clone(
     orientation.direction,
-    scratchToHPRDirection
+    scratchToHPRDirection,
   );
   const up = Cartesian3.clone(orientation.up, scratchToHPRUp);
 
@@ -1398,11 +1399,11 @@ function directionUpToHeadingPitchRoll(camera, position, orientation, result) {
     const transform = Transforms.eastNorthUpToFixedFrame(
       position,
       ellipsoid,
-      scratchHPRMatrix1
+      scratchHPRMatrix1,
     );
     const invTransform = Matrix4.inverseTransformation(
       transform,
-      scratchHPRMatrix2
+      scratchHPRMatrix2,
     );
 
     Matrix4.multiplyByPointAsVector(invTransform, direction, direction);
@@ -1487,7 +1488,7 @@ Camera.prototype.setView = function (options) {
   options = defaultValue(options, defaultValue.EMPTY_OBJECT);
   let orientation = defaultValue(
     options.orientation,
-    defaultValue.EMPTY_OBJECT
+    defaultValue.EMPTY_OBJECT,
   );
 
   const mode = this._mode;
@@ -1502,12 +1503,12 @@ Camera.prototype.setView = function (options) {
   let convert = defaultValue(options.convert, true);
   let destination = defaultValue(
     options.destination,
-    Cartesian3.clone(this.positionWC, scratchSetViewCartesian)
+    Cartesian3.clone(this.positionWC, scratchSetViewCartesian),
   );
   if (defined(destination) && defined(destination.west)) {
     destination = this.getRectangleCameraCoordinates(
       destination,
-      scratchSetViewCartesian
+      scratchSetViewCartesian,
     );
     //>>includeStart('debug', pragmas.debug);
     // destination.z may be null in 2D, but .x and .y should be numeric
@@ -1523,7 +1524,7 @@ Camera.prototype.setView = function (options) {
       this,
       destination,
       orientation,
-      scratchSetViewOptions.orientation
+      scratchSetViewOptions.orientation,
     );
   }
 
@@ -1563,7 +1564,7 @@ Camera.prototype.flyHome = function (duration) {
     });
   } else if (mode === SceneMode.SCENE3D) {
     const destination = this.getRectangleCameraCoordinates(
-      Camera.DEFAULT_VIEW_RECTANGLE
+      Camera.DEFAULT_VIEW_RECTANGLE,
     );
 
     let mag = Cartesian3.magnitude(destination);
@@ -1582,7 +1583,7 @@ Camera.prototype.flyHome = function (duration) {
     position = Cartesian3.multiplyByScalar(
       Cartesian3.normalize(position, position),
       5.0 * maxRadii,
-      position
+      position,
     );
     this.flyTo({
       destination: position,
@@ -1661,7 +1662,7 @@ Camera.prototype.worldToCameraCoordinatesVector = function (cartesian, result) {
   return Matrix4.multiplyByPointAsVector(
     this._actualInvTransform,
     cartesian,
-    result
+    result,
   );
 };
 
@@ -1728,7 +1729,7 @@ Camera.prototype.cameraToWorldCoordinatesVector = function (cartesian, result) {
   return Matrix4.multiplyByPointAsVector(
     this._actualTransform,
     cartesian,
-    result
+    result,
   );
 };
 
@@ -1976,7 +1977,7 @@ Camera.prototype.look = function (axis, angle) {
   const quaternion = Quaternion.fromAxisAngle(
     axis,
     -turnAngle,
-    lookScratchQuaternion
+    lookScratchQuaternion,
   );
   const rotation = Matrix3.fromQuaternion(quaternion, lookScratchMatrix);
 
@@ -2038,7 +2039,7 @@ Camera.prototype.rotate = function (axis, angle) {
   const quaternion = Quaternion.fromAxisAngle(
     axis,
     -turnAngle,
-    rotateScratchQuaternion
+    rotateScratchQuaternion,
   );
   const rotation = Matrix3.fromQuaternion(quaternion, rotateScratchMatrix);
   Matrix3.multiplyByVector(rotation, this.position, this.position);
@@ -2087,24 +2088,24 @@ function rotateVertical(camera, angle) {
     !Cartesian3.equalsEpsilon(
       camera.position,
       Cartesian3.ZERO,
-      CesiumMath.EPSILON2
+      CesiumMath.EPSILON2,
     )
   ) {
     const p = Cartesian3.normalize(position, rotateVertScratchP);
     const northParallel = Cartesian3.equalsEpsilon(
       p,
       camera.constrainedAxis,
-      CesiumMath.EPSILON2
+      CesiumMath.EPSILON2,
     );
     const southParallel = Cartesian3.equalsEpsilon(
       p,
       Cartesian3.negate(camera.constrainedAxis, rotateVertScratchNegate),
-      CesiumMath.EPSILON2
+      CesiumMath.EPSILON2,
     );
     if (!northParallel && !southParallel) {
       const constrainedAxis = Cartesian3.normalize(
         camera.constrainedAxis,
-        rotateVertScratchA
+        rotateVertScratchA,
       );
 
       let dot = Cartesian3.dot(p, constrainedAxis);
@@ -2115,7 +2116,7 @@ function rotateVertical(camera, angle) {
 
       dot = Cartesian3.dot(
         p,
-        Cartesian3.negate(constrainedAxis, rotateVertScratchNegate)
+        Cartesian3.negate(constrainedAxis, rotateVertScratchNegate),
       );
       angleToAxis = CesiumMath.acosClamped(dot);
       if (angle < 0 && -angle > angleToAxis) {
@@ -2125,7 +2126,7 @@ function rotateVertical(camera, angle) {
       const tangent = Cartesian3.cross(
         constrainedAxis,
         p,
-        rotateVertScratchTan
+        rotateVertScratchTan,
       );
       camera.rotate(tangent, angle);
     } else if ((northParallel && angle < 0) || (southParallel && angle > 0)) {
@@ -2182,7 +2183,7 @@ function zoom2D(camera, amount) {
     !defined(frustum.top)
   ) {
     throw new DeveloperError(
-      "The camera frustum is expected to be orthographic for 2D camera control."
+      "The camera frustum is expected to be orthographic for 2D camera control.",
     );
   }
   //>>includeEnd('debug');
@@ -2294,7 +2295,7 @@ Camera.prototype.getMagnitude = function () {
   } else if (this._mode === SceneMode.SCENE2D) {
     return Math.max(
       this.frustum.right - this.frustum.left,
-      this.frustum.top - this.frustum.bottom
+      this.frustum.top - this.frustum.bottom,
     );
   }
 };
@@ -2349,7 +2350,7 @@ Camera.prototype.lookAt = function (target, offset) {
   const transform = Transforms.eastNorthUpToFixedFrame(
     target,
     ellipsoid,
-    scratchLookAtMatrix4
+    scratchLookAtMatrix4,
   );
   this.lookAtTransform(transform, offset);
 };
@@ -2363,29 +2364,29 @@ function offsetFromHeadingPitchRange(heading, pitch, range) {
   pitch = CesiumMath.clamp(
     pitch,
     -CesiumMath.PI_OVER_TWO,
-    CesiumMath.PI_OVER_TWO
+    CesiumMath.PI_OVER_TWO,
   );
   heading = CesiumMath.zeroToTwoPi(heading) - CesiumMath.PI_OVER_TWO;
 
   const pitchQuat = Quaternion.fromAxisAngle(
     Cartesian3.UNIT_Y,
     -pitch,
-    scratchLookAtHeadingPitchRangeQuaternion1
+    scratchLookAtHeadingPitchRangeQuaternion1,
   );
   const headingQuat = Quaternion.fromAxisAngle(
     Cartesian3.UNIT_Z,
     -heading,
-    scratchLookAtHeadingPitchRangeQuaternion2
+    scratchLookAtHeadingPitchRangeQuaternion2,
   );
   const rotQuat = Quaternion.multiply(headingQuat, pitchQuat, headingQuat);
   const rotMatrix = Matrix3.fromQuaternion(
     rotQuat,
-    scratchHeadingPitchRangeMatrix3
+    scratchHeadingPitchRangeMatrix3,
   );
 
   const offset = Cartesian3.clone(
     Cartesian3.UNIT_X,
-    scratchLookAtHeadingPitchRangeOffset
+    scratchLookAtHeadingPitchRangeOffset,
   );
   Matrix3.multiplyByVector(rotMatrix, offset, offset);
   Cartesian3.negate(offset, offset);
@@ -2428,7 +2429,7 @@ Camera.prototype.lookAtTransform = function (transform, offset) {
   }
   if (this._mode === SceneMode.MORPHING) {
     throw new DeveloperError(
-      "lookAtTransform is not supported while morphing."
+      "lookAtTransform is not supported while morphing.",
     );
   }
   //>>includeEnd('debug');
@@ -2443,7 +2444,7 @@ Camera.prototype.lookAtTransform = function (transform, offset) {
     cartesianOffset = offsetFromHeadingPitchRange(
       offset.heading,
       offset.pitch,
-      offset.range
+      offset.range,
     );
   } else {
     cartesianOffset = offset;
@@ -2521,10 +2522,8 @@ function rectangleCameraPosition3D(camera, rectangle, result, updateCamera) {
   const ellipsoid = camera._projection.ellipsoid;
   const cameraRF = updateCamera ? camera : defaultRF;
 
-  const north = rectangle.north;
-  const south = rectangle.south;
-  let east = rectangle.east;
-  const west = rectangle.west;
+  const { north, south, west } = rectangle;
+  let { east } = rectangle;
 
   // If we go across the International Date Line
   if (west > east) {
@@ -2564,17 +2563,14 @@ function rectangleCameraPosition3D(camera, rectangle, result, updateCamera) {
       !defined(ellipsoidGeodesic) ||
       ellipsoidGeodesic.ellipsoid !== ellipsoid
     ) {
-      viewRectangle3DEllipsoidGeodesic = ellipsoidGeodesic = new EllipsoidGeodesic(
-        undefined,
-        undefined,
-        ellipsoid
-      );
+      viewRectangle3DEllipsoidGeodesic = ellipsoidGeodesic =
+        new EllipsoidGeodesic(undefined, undefined, ellipsoid);
     }
 
     ellipsoidGeodesic.setEndPoints(northCartographic, southCartographic);
     latitude = ellipsoidGeodesic.interpolateUsingFraction(
       0.5,
-      viewRectangle3DCartographic1
+      viewRectangle3DCartographic1,
     ).latitude;
   }
 
@@ -2585,7 +2581,7 @@ function rectangleCameraPosition3D(camera, rectangle, result, updateCamera) {
 
   const center = ellipsoid.cartographicToCartesian(
     centerCartographic,
-    viewRectangle3DCenter
+    viewRectangle3DCenter,
   );
 
   const cart = viewRectangle3DCartographic1;
@@ -2593,32 +2589,32 @@ function rectangleCameraPosition3D(camera, rectangle, result, updateCamera) {
   cart.latitude = north;
   const northEast = ellipsoid.cartographicToCartesian(
     cart,
-    viewRectangle3DNorthEast
+    viewRectangle3DNorthEast,
   );
   cart.longitude = west;
   const northWest = ellipsoid.cartographicToCartesian(
     cart,
-    viewRectangle3DNorthWest
+    viewRectangle3DNorthWest,
   );
   cart.longitude = longitude;
   const northCenter = ellipsoid.cartographicToCartesian(
     cart,
-    viewRectangle3DNorthCenter
+    viewRectangle3DNorthCenter,
   );
   cart.latitude = south;
   const southCenter = ellipsoid.cartographicToCartesian(
     cart,
-    viewRectangle3DSouthCenter
+    viewRectangle3DSouthCenter,
   );
   cart.longitude = east;
   const southEast = ellipsoid.cartographicToCartesian(
     cart,
-    viewRectangle3DSouthEast
+    viewRectangle3DSouthEast,
   );
   cart.longitude = west;
   const southWest = ellipsoid.cartographicToCartesian(
     cart,
-    viewRectangle3DSouthWest
+    viewRectangle3DSouthWest,
   );
 
   Cartesian3.subtract(northWest, center, northWest);
@@ -2638,11 +2634,11 @@ function rectangleCameraPosition3D(camera, rectangle, result, updateCamera) {
   if (camera.frustum instanceof OrthographicFrustum) {
     const width = Math.max(
       Cartesian3.distance(northEast, northWest),
-      Cartesian3.distance(southEast, southWest)
+      Cartesian3.distance(southEast, southWest),
     );
     const height = Math.max(
       Cartesian3.distance(northEast, southEast),
-      Cartesian3.distance(northWest, southWest)
+      Cartesian3.distance(northWest, southWest),
     );
 
     let rightScalar;
@@ -2675,7 +2671,7 @@ function rectangleCameraPosition3D(camera, rectangle, result, updateCamera) {
       computeD(direction, right, northEast, tanTheta),
       computeD(direction, right, southWest, tanTheta),
       computeD(direction, right, northCenter, tanTheta),
-      computeD(direction, right, southCenter, tanTheta)
+      computeD(direction, right, southCenter, tanTheta),
     );
 
     // If the rectangle crosses the equator, compute D at the equator, too, because that's the
@@ -2687,25 +2683,25 @@ function rectangleCameraPosition3D(camera, rectangle, result, updateCamera) {
       equatorCartographic.height = 0.0;
       let equatorPosition = ellipsoid.cartographicToCartesian(
         equatorCartographic,
-        viewRectangle3DEquator
+        viewRectangle3DEquator,
       );
       Cartesian3.subtract(equatorPosition, center, equatorPosition);
       d = Math.max(
         d,
         computeD(direction, up, equatorPosition, tanPhi),
-        computeD(direction, right, equatorPosition, tanTheta)
+        computeD(direction, right, equatorPosition, tanTheta),
       );
 
       equatorCartographic.longitude = east;
       equatorPosition = ellipsoid.cartographicToCartesian(
         equatorCartographic,
-        viewRectangle3DEquator
+        viewRectangle3DEquator,
       );
       Cartesian3.subtract(equatorPosition, center, equatorPosition);
       d = Math.max(
         d,
         computeD(direction, up, equatorPosition, tanPhi),
-        computeD(direction, right, equatorPosition, tanTheta)
+        computeD(direction, right, equatorPosition, tanTheta),
       );
     }
   }
@@ -2713,7 +2709,7 @@ function rectangleCameraPosition3D(camera, rectangle, result, updateCamera) {
   return Cartesian3.add(
     center,
     Cartesian3.multiplyByScalar(direction, -d, viewRectangle3DEquator),
-    result
+    result,
   );
 }
 
@@ -2750,7 +2746,7 @@ function rectangleCameraPositionColumbusView(camera, rectangle, result) {
     result.z =
       Math.max(
         (northEast.x - southWest.x) / tanTheta,
-        (northEast.y - southWest.y) / tanPhi
+        (northEast.y - southWest.y) / tanPhi,
       ) * 0.5;
   } else {
     const width = northEast.x - southWest.x;
@@ -2935,7 +2931,7 @@ Camera.prototype.pickEllipsoid = function (windowPosition, ellipsoid, result) {
       this,
       windowPosition,
       this._projection,
-      result
+      result,
     );
   } else {
     return undefined;
@@ -2965,18 +2961,18 @@ function getPickRayPerspective(camera, windowPosition, result) {
   const nearCenter = Cartesian3.multiplyByScalar(
     camera.directionWC,
     near,
-    pickPerspCenter
+    pickPerspCenter,
   );
   Cartesian3.add(position, nearCenter, nearCenter);
   const xDir = Cartesian3.multiplyByScalar(
     camera.rightWC,
     x * near * tanTheta,
-    pickPerspXDir
+    pickPerspXDir,
   );
   const yDir = Cartesian3.multiplyByScalar(
     camera.upWC,
     y * near * tanPhi,
-    pickPerspYDir
+    pickPerspYDir,
   );
   const direction = Cartesian3.add(nearCenter, xDir, result.direction);
   Cartesian3.add(direction, yDir, direction);
@@ -3021,7 +3017,7 @@ function getPickRayOrthographic(camera, windowPosition, result) {
       result.origin.z,
       result.origin.x,
       result.origin.y,
-      result.origin
+      result.origin,
     );
   }
 
@@ -3083,12 +3079,12 @@ Camera.prototype.distanceToBoundingSphere = function (boundingSphere) {
   const toCenter = Cartesian3.subtract(
     this.positionWC,
     boundingSphere.center,
-    scratchToCenter
+    scratchToCenter,
   );
   const proj = Cartesian3.multiplyByScalar(
     this.directionWC,
     Cartesian3.dot(toCenter, this.directionWC),
-    scratchProj
+    scratchProj,
   );
   return Math.max(0.0, Cartesian3.magnitude(proj) - boundingSphere.radius);
 };
@@ -3106,7 +3102,7 @@ const scratchPixelSize = new Cartesian2();
 Camera.prototype.getPixelSize = function (
   boundingSphere,
   drawingBufferWidth,
-  drawingBufferHeight
+  drawingBufferHeight,
 ) {
   //>>includeStart('debug', pragmas.debug);
   if (!defined(boundingSphere)) {
@@ -3126,7 +3122,7 @@ Camera.prototype.getPixelSize = function (
     drawingBufferHeight,
     distance,
     this._scene.pixelRatio,
-    scratchPixelSize
+    scratchPixelSize,
   );
   return Math.max(pixelSize.x, pixelSize.y);
 };
@@ -3137,7 +3133,7 @@ function createAnimationTemplateCV(
   center,
   maxX,
   maxY,
-  duration
+  duration,
 ) {
   const newPosition = Cartesian3.clone(position);
 
@@ -3158,7 +3154,7 @@ function createAnimationTemplateCV(
       position,
       newPosition,
       value.time,
-      new Cartesian3()
+      new Cartesian3(),
     );
     camera.worldToCameraCoordinatesPoint(interp, camera.position);
   }
@@ -3186,14 +3182,14 @@ function createAnimationCV(camera, duration) {
 
   const normal = camera.worldToCameraCoordinatesVector(
     Cartesian3.UNIT_X,
-    normalScratch
+    normalScratch,
   );
   const scalar =
     -Cartesian3.dot(normal, position) / Cartesian3.dot(normal, direction);
   const center = Cartesian3.add(
     position,
     Cartesian3.multiplyByScalar(direction, scalar, centerScratch),
-    centerScratch
+    centerScratch,
   );
   camera.cameraToWorldCoordinatesPoint(center, center);
 
@@ -3202,7 +3198,7 @@ function createAnimationCV(camera, duration) {
   const tanPhi = Math.tan(camera.frustum.fovy * 0.5);
   const tanTheta = camera.frustum.aspectRatio * tanPhi;
   const distToC = Cartesian3.magnitude(
-    Cartesian3.subtract(position, center, scratchCartesian3Subtract)
+    Cartesian3.subtract(position, center, scratchCartesian3Subtract),
   );
   const dWidth = tanTheta * distToC;
   const dHeight = tanPhi * distToC;
@@ -3228,7 +3224,7 @@ function createAnimationCV(camera, duration) {
         center,
         maxX,
         maxY,
-        duration
+        duration,
       );
     }
   }
@@ -3386,20 +3382,20 @@ Camera.prototype.flyTo = function (options) {
   if (isRectangle) {
     destination = this.getRectangleCameraCoordinates(
       destination,
-      scratchFlyToDestination
+      scratchFlyToDestination,
     );
   }
 
   let orientation = defaultValue(
     options.orientation,
-    defaultValue.EMPTY_OBJECT
+    defaultValue.EMPTY_OBJECT,
   );
   if (defined(orientation.direction)) {
     orientation = directionUpToHeadingPitchRoll(
       this,
       destination,
       orientation,
-      scratchSetViewOptions.orientation
+      scratchSetViewOptions.orientation,
     );
   }
 
@@ -3468,11 +3464,12 @@ Camera.prototype.flyTo = function (options) {
       orientation: orientation,
     });
 
-    this._scene.preloadFlightCullingVolume = preloadFlightCamera.frustum.computeCullingVolume(
-      preloadFlightCamera.positionWC,
-      preloadFlightCamera.directionWC,
-      preloadFlightCamera.upWC
-    );
+    this._scene.preloadFlightCullingVolume =
+      preloadFlightCamera.frustum.computeCullingVolume(
+        preloadFlightCamera.positionWC,
+        preloadFlightCamera.directionWC,
+        preloadFlightCamera.upWC,
+      );
   }
 };
 
@@ -3508,7 +3505,7 @@ const MINIMUM_ZOOM = 100.0;
 
 function adjustBoundingSphereOffset(camera, boundingSphere, offset) {
   offset = HeadingPitchRange.clone(
-    defined(offset) ? offset : Camera.DEFAULT_OFFSET
+    defined(offset) ? offset : Camera.DEFAULT_OFFSET,
   );
 
   const minimumZoom =
@@ -3560,7 +3557,7 @@ Camera.prototype.viewBoundingSphere = function (boundingSphere, offset) {
 
   if (this._mode === SceneMode.MORPHING) {
     throw new DeveloperError(
-      "viewBoundingSphere is not supported while morphing."
+      "viewBoundingSphere is not supported while morphing.",
     );
   }
   //>>includeEnd('debug');
@@ -3617,7 +3614,7 @@ Camera.prototype.flyToBoundingSphere = function (boundingSphere, options) {
   const offset = adjustBoundingSphereOffset(
     this,
     boundingSphere,
-    options.offset
+    options.offset,
   );
 
   let position;
@@ -3625,13 +3622,13 @@ Camera.prototype.flyToBoundingSphere = function (boundingSphere, options) {
     position = Cartesian3.multiplyByScalar(
       Cartesian3.UNIT_Z,
       offset.range,
-      scratchflyToBoundingSphereDestination
+      scratchflyToBoundingSphereDestination,
     );
   } else {
     position = offsetFromHeadingPitchRange(
       offset.heading,
       offset.pitch,
-      offset.range
+      offset.range,
     );
   }
 
@@ -3641,7 +3638,7 @@ Camera.prototype.flyToBoundingSphere = function (boundingSphere, options) {
   const transform = Transforms.eastNorthUpToFixedFrame(
     boundingSphere.center,
     ellipsoid,
-    scratchflyToBoundingSphereTransform
+    scratchflyToBoundingSphereTransform,
   );
   Matrix4.multiplyByPoint(transform, position, position);
 
@@ -3652,29 +3649,29 @@ Camera.prototype.flyToBoundingSphere = function (boundingSphere, options) {
     direction = Cartesian3.subtract(
       boundingSphere.center,
       position,
-      scratchflyToBoundingSphereDirection
+      scratchflyToBoundingSphereDirection,
     );
     Cartesian3.normalize(direction, direction);
 
     up = Matrix4.multiplyByPointAsVector(
       transform,
       Cartesian3.UNIT_Z,
-      scratchflyToBoundingSphereUp
+      scratchflyToBoundingSphereUp,
     );
     if (1.0 - Math.abs(Cartesian3.dot(direction, up)) < CesiumMath.EPSILON6) {
       const rotateQuat = Quaternion.fromAxisAngle(
         direction,
         offset.heading,
-        scratchFlyToBoundingSphereQuaternion
+        scratchFlyToBoundingSphereQuaternion,
       );
       const rotation = Matrix3.fromQuaternion(
         rotateQuat,
-        scratchFlyToBoundingSphereMatrix3
+        scratchFlyToBoundingSphereMatrix3,
       );
 
       Cartesian3.fromCartesian4(
         Matrix4.getColumn(transform, 1, scratchFlyToBoundingSphereCart4),
-        up
+        up,
       );
       Matrix3.multiplyByVector(rotation, up, up);
     }
@@ -3682,7 +3679,7 @@ Camera.prototype.flyToBoundingSphere = function (boundingSphere, options) {
     const right = Cartesian3.cross(
       direction,
       up,
-      scratchflyToBoundingSphereRight
+      scratchflyToBoundingSphereRight,
     );
     Cartesian3.cross(right, direction, up);
     Cartesian3.normalize(up, up);
@@ -3725,7 +3722,7 @@ function computeHorizonQuad(camera, ellipsoid) {
   const q = Cartesian3.multiplyComponents(
     ellipsoid.oneOverRadii,
     p,
-    scratchCartesian3_1
+    scratchCartesian3_1,
   );
 
   const qMagnitude = Cartesian3.magnitude(q);
@@ -3742,11 +3739,11 @@ function computeHorizonQuad(camera, ellipsoid) {
   } else {
     eUnit = Cartesian3.normalize(
       Cartesian3.cross(Cartesian3.UNIT_Z, qUnit, scratchCartesian3_3),
-      scratchCartesian3_3
+      scratchCartesian3_3,
     );
     nUnit = Cartesian3.normalize(
       Cartesian3.cross(qUnit, eUnit, scratchCartesian3_4),
-      scratchCartesian3_4
+      scratchCartesian3_4,
     );
   }
 
@@ -3757,18 +3754,18 @@ function computeHorizonQuad(camera, ellipsoid) {
   const center = Cartesian3.multiplyByScalar(
     qUnit,
     1.0 / qMagnitude,
-    scratchCartesian3_1
+    scratchCartesian3_1,
   );
   const scalar = wMagnitude / qMagnitude;
   const eastOffset = Cartesian3.multiplyByScalar(
     eUnit,
     scalar,
-    scratchCartesian3_2
+    scratchCartesian3_2,
   );
   const northOffset = Cartesian3.multiplyByScalar(
     nUnit,
     scalar,
-    scratchCartesian3_3
+    scratchCartesian3_3,
   );
 
   // A conservative measure for the longitudes would be to use the min/max longitudes of the bounding frustum.
@@ -3805,7 +3802,7 @@ function addToResult(x, y, index, camera, ellipsoid, computedHorizonQuad) {
   const r = camera.pickEllipsoid(
     scratchPickCartesian2,
     ellipsoid,
-    scratchRectCartesian
+    scratchRectCartesian,
   );
   if (defined(r)) {
     cartoArray[index] = ellipsoid.cartesianToCartographic(r, cartoArray[index]);
@@ -3813,7 +3810,7 @@ function addToResult(x, y, index, camera, ellipsoid, computedHorizonQuad) {
   }
   cartoArray[index] = ellipsoid.cartesianToCartographic(
     computedHorizonQuad[index],
-    cartoArray[index]
+    cartoArray[index],
   );
   return 0;
 }
@@ -3830,11 +3827,11 @@ Camera.prototype.computeViewRectangle = function (ellipsoid, result) {
   const cullingVolume = this.frustum.computeCullingVolume(
     this.positionWC,
     this.directionWC,
-    this.upWC
+    this.upWC,
   );
   const boundingSphere = new BoundingSphere(
     Cartesian3.ZERO,
-    ellipsoid.maximumRadius
+    ellipsoid.maximumRadius,
   );
   const visibility = cullingVolume.computeVisibility(boundingSphere);
   if (visibility === Intersect.OUTSIDE) {
@@ -3855,7 +3852,7 @@ Camera.prototype.computeViewRectangle = function (ellipsoid, result) {
     0,
     this,
     ellipsoid,
-    computedHorizonQuad
+    computedHorizonQuad,
   );
   successfulPickCount += addToResult(
     0,
@@ -3863,7 +3860,7 @@ Camera.prototype.computeViewRectangle = function (ellipsoid, result) {
     1,
     this,
     ellipsoid,
-    computedHorizonQuad
+    computedHorizonQuad,
   );
   successfulPickCount += addToResult(
     width,
@@ -3871,7 +3868,7 @@ Camera.prototype.computeViewRectangle = function (ellipsoid, result) {
     2,
     this,
     ellipsoid,
-    computedHorizonQuad
+    computedHorizonQuad,
   );
   successfulPickCount += addToResult(
     width,
@@ -3879,7 +3876,7 @@ Camera.prototype.computeViewRectangle = function (ellipsoid, result) {
     3,
     this,
     ellipsoid,
-    computedHorizonQuad
+    computedHorizonQuad,
   );
 
   if (successfulPickCount < 2) {
@@ -3910,7 +3907,7 @@ Camera.prototype.computeViewRectangle = function (ellipsoid, result) {
     CesiumMath.equalsEpsilon(
       Math.abs(distance),
       CesiumMath.TWO_PI,
-      CesiumMath.EPSILON9
+      CesiumMath.EPSILON9,
     )
   ) {
     result.west = -CesiumMath.PI;