@cesium/engine 10.1.0 → 11.1.0

package/Source/Scene/ScreenSpaceCameraController.js

@@ -137,6 +137,14 @@ function ScreenSpaceCameraController(scene) {
    * @default {@link Number.POSITIVE_INFINITY}
    */
   this.maximumZoomDistance = Number.POSITIVE_INFINITY;
+
+  /**
+   * A multiplier for the speed at which the camera will zoom.
+   * @type {Number}
+   * @default 5.0
+   */
+  this.zoomFactor = 5.0;
+
   /**
    * The input that allows the user to pan around the map. This only applies in 2D and Columbus view modes.
    * <p>
@@ -234,7 +242,7 @@ function ScreenSpaceCameraController(scene) {
    * @default 4000.0 or scene.ellipsoid.minimumRadius * 0.00063
    */
   this.minimumPickingTerrainDistanceWithInertia = Ellipsoid.WGS84.equals(
-    ellipsoid
+    ellipsoid,
   )
     ? 4000.0
     : ellipsoid.minimumRadius * 0.00063;
@@ -320,11 +328,10 @@ function ScreenSpaceCameraController(scene) {
 
   const projection = scene.mapProjection;
   this._maxCoord = projection.project(
-    new Cartographic(Math.PI, CesiumMath.PI_OVER_TWO)
+    new Cartographic(Math.PI, CesiumMath.PI_OVER_TWO),
   );
 
   // Constants, Make any of these public?
-  this._zoomFactor = 5.0;
   this._rotateFactor = undefined;
   this._rotateRateRangeAdjustment = undefined;
   this._maximumRotateRate = 1.77;
@@ -348,7 +355,7 @@ function sameMousePosition(movement) {
   return Cartesian2.equalsEpsilon(
     movement.startPosition,
     movement.endPosition,
-    CesiumMath.EPSILON14
+    CesiumMath.EPSILON14,
   );
 }
 
@@ -365,7 +372,7 @@ function maintainInertia(
   decayCoef,
   action,
   object,
-  lastMovementName
+  lastMovementName,
 ) {
   let movementState = object[lastMovementName];
   if (!defined(movementState)) {
@@ -403,18 +410,18 @@ function maintainInertia(
 
     movementState.startPosition = Cartesian2.clone(
       lastMovement.startPosition,
-      movementState.startPosition
+      movementState.startPosition,
     );
 
     movementState.endPosition = Cartesian2.multiplyByScalar(
       movementState.motion,
       d,
-      movementState.endPosition
+      movementState.endPosition,
     );
     movementState.endPosition = Cartesian2.add(
       movementState.startPosition,
       movementState.endPosition,
-      movementState.endPosition
+      movementState.endPosition,
     );
 
     // If value from the decreasing exponential function is close to zero,
@@ -424,7 +431,7 @@ function maintainInertia(
       isNaN(movementState.endPosition.y) ||
       Cartesian2.distance(
         movementState.startPosition,
-        movementState.endPosition
+        movementState.endPosition,
       ) < 0.5
     ) {
       return;
@@ -466,7 +473,7 @@ function reactToInput(
   eventTypes,
   action,
   inertiaConstant,
-  inertiaStateName
+  inertiaStateName,
 ) {
   if (!defined(eventTypes)) {
     return;
@@ -502,7 +509,7 @@ function reactToInput(
           inertiaConstant,
           action,
           controller,
-          inertiaStateName
+          inertiaStateName,
         );
       }
     }
@@ -544,14 +551,14 @@ function handleZoom(
   movement,
   zoomFactor,
   distanceMeasure,
-  unitPositionDotDirection
+  unitPositionDotDirection,
 ) {
   let percentage = 1.0;
   if (defined(unitPositionDotDirection)) {
     percentage = CesiumMath.clamp(
       Math.abs(unitPositionDotDirection),
       0.25,
-      1.0
+      1.0,
     );
   }
 
@@ -570,7 +577,7 @@ function handleZoom(
   zoomRate = CesiumMath.clamp(
     zoomRate,
     object._minimumZoomRate,
-    object._maximumZoomRate
+    object._maximumZoomRate,
   );
 
   let rangeWindowRatio = diff / object._scene.canvas.clientHeight;
@@ -616,7 +623,7 @@ function handleZoom(
 
   const sameStartPosition = defaultValue(
     movement.inertiaEnabled,
-    Cartesian2.equals(startPosition, object._zoomMouseStart)
+    Cartesian2.equals(startPosition, object._zoomMouseStart),
   );
   let zoomingOnVector = object._zoomingOnVector;
   let rotatingZoom = object._rotatingZoom;
@@ -625,23 +632,25 @@ function handleZoom(
   if (!sameStartPosition) {
     object._zoomMouseStart = Cartesian2.clone(
       startPosition,
-      object._zoomMouseStart
+      object._zoomMouseStart,
     );
 
     // When camera transform is set, such as tracking an entity, object._globe will be undefined, and no position should be picked
     if (defined(object._globe) && mode === SceneMode.SCENE2D) {
-      pickedPosition = camera.getPickRay(startPosition, scratchZoomPickRay)
-        .origin;
+      pickedPosition = camera.getPickRay(
+        startPosition,
+        scratchZoomPickRay,
+      ).origin;
       pickedPosition = Cartesian3.fromElements(
         pickedPosition.y,
         pickedPosition.z,
-        pickedPosition.x
+        pickedPosition.x,
       );
     } else if (defined(object._globe)) {
       pickedPosition = pickPosition(
         object,
         startPosition,
-        scratchPickCartesian
+        scratchPickCartesian,
       );
     }
 
@@ -649,7 +658,7 @@ function handleZoom(
       object._useZoomWorldPosition = true;
       object._zoomWorldPosition = Cartesian3.clone(
         pickedPosition,
-        object._zoomWorldPosition
+        object._zoomWorldPosition,
       );
     } else {
       object._useZoomWorldPosition = false;
@@ -685,7 +694,7 @@ function handleZoom(
         const direction = Cartesian3.subtract(
           worldPosition,
           endPosition,
-          scratchZoomDirection
+          scratchZoomDirection,
         );
         Cartesian3.normalize(direction, direction);
 
@@ -698,23 +707,25 @@ function handleZoom(
           (camera.position.x < 0.0 && savedX > 0.0) ||
           (camera.position.x > 0.0 && savedX < 0.0)
         ) {
-          pickedPosition = camera.getPickRay(startPosition, scratchZoomPickRay)
-            .origin;
+          pickedPosition = camera.getPickRay(
+            startPosition,
+            scratchZoomPickRay,
+          ).origin;
           pickedPosition = Cartesian3.fromElements(
             pickedPosition.y,
             pickedPosition.z,
-            pickedPosition.x
+            pickedPosition.x,
           );
           object._zoomWorldPosition = Cartesian3.clone(
             pickedPosition,
-            object._zoomWorldPosition
+            object._zoomWorldPosition,
           );
         }
       }
     } else if (mode === SceneMode.SCENE3D) {
       const cameraPositionNormal = Cartesian3.normalize(
         camera.position,
-        scratchCameraPositionNormal
+        scratchCameraPositionNormal,
       );
       if (
         object._cameraUnderground ||
@@ -733,7 +744,7 @@ function handleZoom(
         const centerPosition = pickPosition(
           object,
           centerPixel,
-          scratchCenterPosition
+          scratchCenterPosition,
         );
         // If centerPosition is not defined, it means the globe does not cover the center position of screen
 
@@ -765,7 +776,7 @@ function handleZoom(
             Cartesian3.add(
               cameraPosition,
               Cartesian3.multiplyByScalar(forward, 1000, scratchCartesian),
-              center
+              center,
             );
 
             const positionToTarget = scratchPositionToTarget;
@@ -776,7 +787,7 @@ function handleZoom(
 
             const alphaDot = Cartesian3.dot(
               cameraPositionNormal,
-              positionToTargetNormal
+              positionToTargetNormal,
             );
             if (alphaDot >= 0.0) {
               // We zoomed past the target, and this zoom is not valid anymore.
@@ -788,23 +799,22 @@ function handleZoom(
             const cameraDistance = Cartesian3.magnitude(cameraPosition);
             const targetDistance = Cartesian3.magnitude(target);
             const remainingDistance = cameraDistance - distance;
-            const positionToTargetDistance = Cartesian3.magnitude(
-              positionToTarget
-            );
+            const positionToTargetDistance =
+              Cartesian3.magnitude(positionToTarget);
 
             const gamma = Math.asin(
               CesiumMath.clamp(
                 (positionToTargetDistance / targetDistance) * Math.sin(alpha),
                 -1.0,
-                1.0
-              )
+                1.0,
+              ),
             );
             const delta = Math.asin(
               CesiumMath.clamp(
                 (remainingDistance / targetDistance) * Math.sin(alpha),
                 -1.0,
-                1.0
-              )
+                1.0,
+              ),
             );
             const beta = gamma - delta + alpha;
 
@@ -816,20 +826,20 @@ function handleZoom(
 
             Cartesian3.normalize(
               Cartesian3.cross(up, right, scratchCartesian),
-              forward
+              forward,
             );
 
             // Calculate new position to move to
             Cartesian3.multiplyByScalar(
               Cartesian3.normalize(center, scratchCartesian),
               Cartesian3.magnitude(center) - distance,
-              center
+              center,
             );
             Cartesian3.normalize(cameraPosition, cameraPosition);
             Cartesian3.multiplyByScalar(
               cameraPosition,
               remainingDistance,
-              cameraPosition
+              cameraPosition,
             );
 
             // Pan
@@ -839,24 +849,24 @@ function handleZoom(
                 Cartesian3.multiplyByScalar(
                   up,
                   Math.cos(beta) - 1,
-                  scratchCartesianTwo
+                  scratchCartesianTwo,
                 ),
                 Cartesian3.multiplyByScalar(
                   forward,
                   Math.sin(beta),
-                  scratchCartesianThree
+                  scratchCartesianThree,
                 ),
-                scratchCartesian
+                scratchCartesian,
               ),
               remainingDistance,
-              pMid
+              pMid,
             );
             Cartesian3.add(cameraPosition, pMid, cameraPosition);
 
             Cartesian3.normalize(center, up);
             Cartesian3.normalize(
               Cartesian3.cross(up, right, scratchCartesian),
-              forward
+              forward,
             );
 
             const cMid = scratchCenterMovement;
@@ -865,17 +875,17 @@ function handleZoom(
                 Cartesian3.multiplyByScalar(
                   up,
                   Math.cos(beta) - 1,
-                  scratchCartesianTwo
+                  scratchCartesianTwo,
                 ),
                 Cartesian3.multiplyByScalar(
                   forward,
                   Math.sin(beta),
-                  scratchCartesianThree
+                  scratchCartesianThree,
                 ),
-                scratchCartesian
+                scratchCartesian,
               ),
               Cartesian3.magnitude(center),
-              cMid
+              cMid,
             );
             Cartesian3.add(center, cMid, center);
 
@@ -887,7 +897,7 @@ function handleZoom(
             // Set new direction
             Cartesian3.normalize(
               Cartesian3.subtract(center, cameraPosition, scratchCartesian),
-              camera.direction
+              camera.direction,
             );
             Cartesian3.clone(camera.direction, camera.direction);
 
@@ -901,11 +911,11 @@ function handleZoom(
         } else {
           const positionNormal = Cartesian3.normalize(
             centerPosition,
-            scratchPositionNormal
+            scratchPositionNormal,
           );
           const pickedNormal = Cartesian3.normalize(
             object._zoomWorldPosition,
-            scratchPickNormal
+            scratchPickNormal,
           );
           const dotProduct = Cartesian3.dot(pickedNormal, positionNormal);
 
@@ -914,7 +924,7 @@ function handleZoom(
             const axis = Cartesian3.cross(
               pickedNormal,
               positionNormal,
-              scratchZoomAxis
+              scratchZoomAxis,
             );
 
             const denom =
@@ -936,7 +946,7 @@ function handleZoom(
     const zoomMouseStart = SceneTransforms.worldToWindowCoordinates(
       scene,
       object._zoomWorldPosition,
-      scratchZoomOffset
+      scratchZoomOffset,
     );
     if (
       mode !== SceneMode.COLUMBUS_VIEW &&
@@ -954,7 +964,7 @@ function handleZoom(
         rayDirection.y,
         rayDirection.z,
         rayDirection.x,
-        rayDirection
+        rayDirection,
       );
     }
 
@@ -977,8 +987,10 @@ const scratchTranslateP0 = new Cartesian3();
 function translate2D(controller, startPosition, movement) {
   const scene = controller._scene;
   const camera = scene.camera;
-  let start = camera.getPickRay(movement.startPosition, translate2DStart)
-    .origin;
+  let start = camera.getPickRay(
+    movement.startPosition,
+    translate2DStart,
+  ).origin;
   let end = camera.getPickRay(movement.endPosition, translate2DEnd).origin;
 
   start = Cartesian3.fromElements(start.y, start.z, start.x, start);
@@ -1005,8 +1017,8 @@ function zoom2D(controller, startPosition, movement) {
     controller,
     startPosition,
     movement,
-    controller._zoomFactor,
-    camera.getMagnitude()
+    controller.zoomFactor,
+    camera.getMagnitude(),
   );
 }
 
@@ -1082,7 +1094,7 @@ function update2D(controller) {
       controller.zoomEventTypes,
       zoom2D,
       controller.inertiaZoom,
-      "_lastInertiaZoomMovement"
+      "_lastInertiaZoomMovement",
     );
     if (rotatable2D) {
       reactToInput(
@@ -1091,7 +1103,7 @@ function update2D(controller) {
         controller.translateEventTypes,
         twist2D,
         controller.inertiaSpin,
-        "_lastInertiaSpinMovement"
+        "_lastInertiaSpinMovement",
       );
     }
   } else {
@@ -1101,7 +1113,7 @@ function update2D(controller) {
       controller.translateEventTypes,
       translate2D,
       controller.inertiaTranslate,
-      "_lastInertiaTranslateMovement"
+      "_lastInertiaTranslateMovement",
     );
     reactToInput(
       controller,
@@ -1109,7 +1121,7 @@ function update2D(controller) {
       controller.zoomEventTypes,
       zoom2D,
       controller.inertiaZoom,
-      "_lastInertiaZoomMovement"
+      "_lastInertiaZoomMovement",
     );
     if (rotatable2D) {
       reactToInput(
@@ -1118,7 +1130,7 @@ function update2D(controller) {
         controller.tiltEventTypes,
         twist2D,
         controller.inertiaSpin,
-        "_lastInertiaTiltMovement"
+        "_lastInertiaTiltMovement",
       );
     }
   }
@@ -1137,7 +1149,7 @@ function pickPosition(controller, mousePosition, result) {
   if (scene.pickPositionSupported) {
     depthIntersection = scene.pickPositionWorldCoordinates(
       mousePosition,
-      scratchDepthIntersection
+      scratchDepthIntersection,
     );
   }
 
@@ -1151,7 +1163,7 @@ function pickPosition(controller, mousePosition, result) {
     ray,
     scene,
     cullBackFaces,
-    scratchRayIntersection
+    scratchRayIntersection,
   );
 
   const pickDistance = defined(depthIntersection)
@@ -1180,7 +1192,7 @@ function getDistanceFromSurface(controller) {
   if (mode === SceneMode.SCENE3D) {
     const cartographic = ellipsoid.cartesianToCartographic(
       camera.position,
-      scratchDistanceCartographic
+      scratchDistanceCartographic,
     );
     if (defined(cartographic)) {
       height = cartographic.height;
@@ -1215,7 +1227,7 @@ function getTiltCenterUnderground(controller, ray, pickedPosition, result) {
   const maximumDistance = CesiumMath.clamp(
     distanceFromSurface * 5.0,
     controller._minimumUndergroundPickDistance,
-    controller._maximumUndergroundPickDistance
+    controller._maximumUndergroundPickDistance,
   );
 
   if (distance > maximumDistance) {
@@ -1231,7 +1243,7 @@ function getStrafeStartPositionUnderground(
   controller,
   ray,
   pickedPosition,
-  result
+  result,
 ) {
   let distance;
   if (!defined(pickedPosition)) {
@@ -1256,7 +1268,7 @@ function continueStrafing(controller, movement) {
   const inertialDelta = Cartesian2.subtract(
     movement.endPosition,
     movement.startPosition,
-    scratchInertialDelta
+    scratchInertialDelta,
   );
   const endPosition = controller._strafeEndMousePosition;
   Cartesian2.add(endPosition, inertialDelta, endPosition);
@@ -1299,7 +1311,7 @@ function translateCV(controller, startPosition, movement) {
   const cameraUnderground = controller._cameraUnderground;
   const startMouse = Cartesian2.clone(
     movement.startPosition,
-    translateCVStartMouse
+    translateCVStartMouse,
   );
   const endMouse = Cartesian2.clone(movement.endPosition, translateCVEndMouse);
   let startRay = camera.getPickRay(startMouse, translateCVStartRay);
@@ -1326,7 +1338,7 @@ function translateCV(controller, startPosition, movement) {
         controller,
         startRay,
         globePos,
-        translateCVStartPos
+        translateCVStartPos,
       );
     }
     Cartesian2.clone(startPosition, controller._strafeMousePosition);
@@ -1343,14 +1355,14 @@ function translateCV(controller, startPosition, movement) {
   const startPlanePos = IntersectionTests.rayPlane(
     startRay,
     plane,
-    translateCVStartPos
+    translateCVStartPos,
   );
 
   const endRay = camera.getPickRay(endMouse, translateCVEndRay);
   const endPlanePos = IntersectionTests.rayPlane(
     endRay,
     plane,
-    translateCVEndPos
+    translateCVEndPos,
   );
 
   if (!defined(startPlanePos) || !defined(endPlanePos)) {
@@ -1363,7 +1375,7 @@ function translateCV(controller, startPosition, movement) {
   const diff = Cartesian3.subtract(
     startPlanePos,
     endPlanePos,
-    translateCVDifference
+    translateCVDifference,
   );
   const temp = diff.x;
   diff.x = diff.y;
@@ -1460,7 +1472,7 @@ function rotateCVOnPlane(controller, startPosition, movement) {
   const transform = Transforms.eastNorthUpToFixedFrame(
     center,
     ellipsoid,
-    rotateCVTransform
+    rotateCVTransform,
   );
 
   const oldGlobe = controller._globe;
@@ -1547,7 +1559,7 @@ function rotateCVOnTerrain(controller, startPosition, movement) {
   const verticalCenter = IntersectionTests.rayPlane(
     ray,
     plane,
-    rotateCVVerticalCenter
+    rotateCVVerticalCenter,
   );
 
   const projection = camera._projection;
@@ -1560,7 +1572,7 @@ function rotateCVOnTerrain(controller, startPosition, movement) {
   const transform = Transforms.eastNorthUpToFixedFrame(
     center,
     ellipsoid,
-    rotateCVTransform
+    rotateCVTransform,
   );
 
   let verticalTransform;
@@ -1569,7 +1581,7 @@ function rotateCVOnTerrain(controller, startPosition, movement) {
       verticalCenter.y,
       verticalCenter.z,
       verticalCenter.x,
-      verticalCenter
+      verticalCenter,
     );
     cart = projection.unproject(verticalCenter, rotateCVCart);
     ellipsoid.cartographicToCartesian(cart, verticalCenter);
@@ -1577,7 +1589,7 @@ function rotateCVOnTerrain(controller, startPosition, movement) {
     verticalTransform = Transforms.eastNorthUpToFixedFrame(
       verticalCenter,
       ellipsoid,
-      rotateCVVerticalTransform
+      rotateCVVerticalTransform,
     );
   } else {
     verticalTransform = transform;
@@ -1598,7 +1610,7 @@ function rotateCVOnTerrain(controller, startPosition, movement) {
   const tangent = Cartesian3.cross(
     Cartesian3.UNIT_Z,
     Cartesian3.normalize(camera.position, rotateCVCartesian3),
-    rotateCVCartesian3
+    rotateCVCartesian3,
   );
   const dot = Cartesian3.dot(camera.right, tangent);
 
@@ -1629,7 +1641,7 @@ function rotateCVOnTerrain(controller, startPosition, movement) {
     const right = Cartesian3.cross(
       camera.direction,
       camera.constrainedAxis,
-      tilt3DCartesian3
+      tilt3DCartesian3,
     );
     if (
       !Cartesian3.equalsEpsilon(right, Cartesian3.ZERO, CesiumMath.EPSILON6)
@@ -1656,7 +1668,7 @@ function rotateCVOnTerrain(controller, startPosition, movement) {
 
   const originalPosition = Cartesian3.clone(
     camera.positionWC,
-    rotateCVCartesian3
+    rotateCVCartesian3,
   );
 
   if (controller.enableCollisionDetection) {
@@ -1673,7 +1685,7 @@ function rotateCVOnTerrain(controller, startPosition, movement) {
       Cartesian3.multiplyByScalar(
         camera.position,
         Math.sqrt(magSqrd),
-        camera.position
+        camera.position,
       );
     }
 
@@ -1681,14 +1693,14 @@ function rotateCVOnTerrain(controller, startPosition, movement) {
     const axis = Cartesian3.cross(
       originalPosition,
       camera.position,
-      originalPosition
+      originalPosition,
     );
     Cartesian3.normalize(axis, axis);
 
     const quaternion = Quaternion.fromAxisAngle(
       axis,
       angle,
-      rotateCVQuaternion
+      rotateCVQuaternion,
     );
     const rotation = Matrix3.fromQuaternion(quaternion, rotateCVMatrix);
     Matrix3.multiplyByVector(rotation, camera.direction, camera.direction);
@@ -1744,7 +1756,7 @@ function zoomCV(controller, startPosition, movement) {
     const distanceUnderground = getZoomDistanceUnderground(
       controller,
       ray,
-      height
+      height,
     );
     if (defined(distance)) {
       distance = Math.min(distance, distanceUnderground);
@@ -1763,8 +1775,8 @@ function zoomCV(controller, startPosition, movement) {
     controller,
     startPosition,
     movement,
-    controller._zoomFactor,
-    distance
+    controller.zoomFactor,
+    distance,
   );
 }
 
@@ -1779,7 +1791,7 @@ function updateCV(controller) {
       controller.rotateEventTypes,
       rotate3D,
       controller.inertiaSpin,
-      "_lastInertiaSpinMovement"
+      "_lastInertiaSpinMovement",
     );
     reactToInput(
       controller,
@@ -1787,7 +1799,7 @@ function updateCV(controller) {
       controller.zoomEventTypes,
       zoom3D,
       controller.inertiaZoom,
-      "_lastInertiaZoomMovement"
+      "_lastInertiaZoomMovement",
     );
   } else {
     const tweens = controller._tweens;
@@ -1802,7 +1814,7 @@ function updateCV(controller) {
       controller.tiltEventTypes,
       rotateCV,
       controller.inertiaSpin,
-      "_lastInertiaTiltMovement"
+      "_lastInertiaTiltMovement",
     );
     reactToInput(
       controller,
@@ -1810,7 +1822,7 @@ function updateCV(controller) {
       controller.translateEventTypes,
       translateCV,
       controller.inertiaTranslate,
-      "_lastInertiaTranslateMovement"
+      "_lastInertiaTranslateMovement",
     );
     reactToInput(
       controller,
@@ -1818,13 +1830,13 @@ function updateCV(controller) {
       controller.zoomEventTypes,
       zoomCV,
       controller.inertiaZoom,
-      "_lastInertiaZoomMovement"
+      "_lastInertiaZoomMovement",
     );
     reactToInput(
       controller,
       controller.enableLook,
       controller.lookEventTypes,
-      look3D
+      look3D,
     );
 
     if (
@@ -1832,7 +1844,7 @@ function updateCV(controller) {
       !tweens.contains(controller._tween)
     ) {
       const tween = camera.createCorrectPositionTween(
-        controller.bounceAnimationTime
+        controller.bounceAnimationTime,
       );
       if (defined(tween)) {
         controller._tween = tweens.add(tween);
@@ -1862,12 +1874,12 @@ function strafe(controller, movement, strafeStartPosition) {
   const plane = Plane.fromPointNormal(
     strafeStartPosition,
     direction,
-    scratchStrafePlane
+    scratchStrafePlane,
   );
   const intersection = IntersectionTests.rayPlane(
     ray,
     plane,
-    scratchStrafeIntersection
+    scratchStrafeIntersection,
   );
   if (!defined(intersection)) {
     return;
@@ -1934,7 +1946,7 @@ function spin3D(controller, startPosition, movement) {
 
   const height = ellipsoid.cartesianToCartographic(
     camera.positionWC,
-    scratchCartographic
+    scratchCartographic,
   ).height;
   const globe = controller._globe;
 
@@ -1942,13 +1954,13 @@ function spin3D(controller, startPosition, movement) {
     const mousePos = pickPosition(
       controller,
       movement.startPosition,
-      scratchMousePosition
+      scratchMousePosition,
     );
     if (defined(mousePos)) {
       let strafing = false;
       const ray = camera.getPickRay(
         movement.startPosition,
-        pickGlobeScratchRay
+        pickGlobeScratchRay,
       );
 
       if (cameraUnderground) {
@@ -1991,8 +2003,8 @@ function spin3D(controller, startPosition, movement) {
       camera.pickEllipsoid(
         movement.startPosition,
         controller._ellipsoid,
-        spin3DPick
-      )
+        spin3DPick,
+      ),
     )
   ) {
     pan3D(controller, startPosition, movement, controller._ellipsoid);
@@ -2014,7 +2026,7 @@ function rotate3D(
   movement,
   constrainedAxis,
   rotateOnlyVertical,
-  rotateOnlyHorizontal
+  rotateOnlyHorizontal,
 ) {
   rotateOnlyVertical = defaultValue(rotateOnlyVertical, false);
   rotateOnlyHorizontal = defaultValue(rotateOnlyHorizontal, false);
@@ -2047,7 +2059,7 @@ function rotate3D(
   phiWindowRatio = Math.min(phiWindowRatio, controller.maximumMovementRatio);
   thetaWindowRatio = Math.min(
     thetaWindowRatio,
-    controller.maximumMovementRatio
+    controller.maximumMovementRatio,
   );
 
   const deltaPhi = rotateRate * phiWindowRatio * Math.PI * 2.0;
@@ -2082,15 +2094,15 @@ function pan3D(controller, startPosition, movement, ellipsoid) {
 
   const startMousePosition = Cartesian2.clone(
     movement.startPosition,
-    pan3DStartMousePosition
+    pan3DStartMousePosition,
   );
   const endMousePosition = Cartesian2.clone(
     movement.endPosition,
-    pan3DEndMousePosition
+    pan3DEndMousePosition,
   );
   const height = ellipsoid.cartesianToCartographic(
     camera.positionWC,
-    scratchCartographic
+    scratchCartographic,
   ).height;
 
   let p0, p1;
@@ -2106,7 +2118,7 @@ function pan3D(controller, startPosition, movement, ellipsoid) {
       !defined(controller._globe) &&
       !Cartesian2.equalsEpsilon(
         startMousePosition,
-        controller._panLastMousePosition
+        controller._panLastMousePosition,
       )
     ) {
       p0 = pickPosition(controller, startMousePosition, pan3DP0);
@@ -2117,7 +2129,7 @@ function pan3D(controller, startPosition, movement, ellipsoid) {
       const toCenterProj = Cartesian3.multiplyByScalar(
         camera.directionWC,
         Cartesian3.dot(camera.directionWC, toCenter),
-        pan3DTemp1
+        pan3DTemp1,
       );
       const distanceToNearPlane = Cartesian3.magnitude(toCenterProj);
       const pixelDimensions = camera.frustum.getPixelDimensions(
@@ -2125,33 +2137,35 @@ function pan3D(controller, startPosition, movement, ellipsoid) {
         scene.drawingBufferHeight,
         distanceToNearPlane,
         scene.pixelRatio,
-        pan3DPixelDimensions
+        pan3DPixelDimensions,
       );
 
       const dragDelta = Cartesian2.subtract(
         endMousePosition,
         startMousePosition,
-        pan3DDiffMousePosition
+        pan3DDiffMousePosition,
       );
 
       // Move the camera to the the distance the cursor moved in worldspace
       const right = Cartesian3.multiplyByScalar(
         camera.rightWC,
         dragDelta.x * pixelDimensions.x,
-        pan3DTemp1
+        pan3DTemp1,
       );
 
       // Move the camera towards the picked position in worldspace as the camera is pointed towards a horizon view
       const cameraPositionNormal = Cartesian3.normalize(
         camera.positionWC,
-        scratchCameraPositionNormal
+        scratchCameraPositionNormal,
       );
-      const endPickDirection = camera.getPickRay(endMousePosition, panRay)
-        .direction;
+      const endPickDirection = camera.getPickRay(
+        endMousePosition,
+        panRay,
+      ).direction;
       const endPickProj = Cartesian3.subtract(
         endPickDirection,
         Cartesian3.projectVector(endPickDirection, camera.rightWC, pan3DTemp2),
-        pan3DTemp2
+        pan3DTemp2,
       );
       const angle = Cartesian3.angleBetween(endPickProj, camera.directionWC);
       let forward = 1.0;
@@ -2159,7 +2173,7 @@ function pan3D(controller, startPosition, movement, ellipsoid) {
         forward = Math.max(Math.tan(angle), 0.1); // Clamp so we don't make the magnitude infinitely large when the angle is small
       }
       let dot = Math.abs(
-        Cartesian3.dot(camera.directionWC, cameraPositionNormal)
+        Cartesian3.dot(camera.directionWC, cameraPositionNormal),
       );
       const magnitude =
         ((-dragDelta.y * pixelDimensions.y * 2.0) / Math.sqrt(forward)) *
@@ -2167,7 +2181,7 @@ function pan3D(controller, startPosition, movement, ellipsoid) {
       const direction = Cartesian3.multiplyByScalar(
         endPickDirection,
         magnitude,
-        pan3DTemp2
+        pan3DTemp2,
       );
 
       // Move the camera up the distance the cursor moved in worldspace as the camera is pointed towards the center
@@ -2175,7 +2189,7 @@ function pan3D(controller, startPosition, movement, ellipsoid) {
       const up = Cartesian3.multiplyByScalar(
         camera.upWC,
         -dragDelta.y * (1.0 - dot) * pixelDimensions.y,
-        pan3DTemp3
+        pan3DTemp3,
       );
 
       p1 = Cartesian3.add(p0, right, pan3DP1);
@@ -2260,11 +2274,11 @@ function pan3D(controller, startPosition, movement, ellipsoid) {
     const planeNormal = Cartesian3.cross(basis0, east, pan3DTemp0);
     const side0 = Cartesian3.dot(
       planeNormal,
-      Cartesian3.subtract(p0, basis0, pan3DTemp1)
+      Cartesian3.subtract(p0, basis0, pan3DTemp1),
     );
     const side1 = Cartesian3.dot(
       planeNormal,
-      Cartesian3.subtract(p1, basis0, pan3DTemp1)
+      Cartesian3.subtract(p1, basis0, pan3DTemp1),
     );
 
     let deltaTheta;
@@ -2318,7 +2332,7 @@ function zoom3D(controller, startPosition, movement) {
   let intersection;
   const height = ellipsoid.cartesianToCartographic(
     camera.position,
-    zoom3DCartographic
+    zoom3DCartographic,
   ).height;
 
   const approachingCollision =
@@ -2342,7 +2356,7 @@ function zoom3D(controller, startPosition, movement) {
     const distanceUnderground = getZoomDistanceUnderground(
       controller,
       ray,
-      height
+      height,
     );
     if (defined(distance)) {
       distance = Math.min(distance, distanceUnderground);
@@ -2357,15 +2371,15 @@ function zoom3D(controller, startPosition, movement) {
 
   const unitPosition = Cartesian3.normalize(
     camera.position,
-    zoom3DUnitPosition
+    zoom3DUnitPosition,
   );
   handleZoom(
     controller,
     startPosition,
     movement,
-    controller._zoomFactor,
+    controller.zoomFactor,
     distance,
-    Cartesian3.dot(unitPosition, camera.direction)
+    Cartesian3.dot(unitPosition, camera.direction),
   );
 }
 
@@ -2401,7 +2415,7 @@ function tilt3D(controller, startPosition, movement) {
   if (controller._looking) {
     const up = controller._ellipsoid.geodeticSurfaceNormal(
       camera.position,
-      tilt3DLookUp
+      tilt3DLookUp,
     );
     look3D(controller, startPosition, movement, up);
     return;
@@ -2410,7 +2424,7 @@ function tilt3D(controller, startPosition, movement) {
   const ellipsoid = controller._ellipsoid;
   const cartographic = ellipsoid.cartesianToCartographic(
     camera.position,
-    tilt3DCart
+    tilt3DCart,
   );
 
   if (
@@ -2433,7 +2447,7 @@ function tilt3DOnEllipsoid(controller, startPosition, movement) {
   const minHeight = controller.minimumZoomDistance * 0.25;
   const height = ellipsoid.cartesianToCartographic(
     camera.positionWC,
-    tilt3DOnEllipsoidCartographic
+    tilt3DOnEllipsoidCartographic,
   ).height;
   if (
     height - minHeight - 1.0 < CesiumMath.EPSILON3 &&
@@ -2456,25 +2470,25 @@ function tilt3DOnEllipsoid(controller, startPosition, movement) {
   } else if (height > controller._minimumTrackBallHeight) {
     const grazingAltitudeLocation = IntersectionTests.grazingAltitudeLocation(
       ray,
-      ellipsoid
+      ellipsoid,
     );
     if (!defined(grazingAltitudeLocation)) {
       return;
     }
     const grazingAltitudeCart = ellipsoid.cartesianToCartographic(
       grazingAltitudeLocation,
-      tilt3DCart
+      tilt3DCart,
     );
     grazingAltitudeCart.height = 0.0;
     center = ellipsoid.cartographicToCartesian(
       grazingAltitudeCart,
-      tilt3DCenter
+      tilt3DCenter,
     );
   } else {
     controller._looking = true;
     const up = controller._ellipsoid.geodeticSurfaceNormal(
       camera.position,
-      tilt3DLookUp
+      tilt3DLookUp,
     );
     look3D(controller, startPosition, movement, up);
     Cartesian2.clone(startPosition, controller._tiltCenterMousePosition);
@@ -2484,7 +2498,7 @@ function tilt3DOnEllipsoid(controller, startPosition, movement) {
   const transform = Transforms.eastNorthUpToFixedFrame(
     center,
     ellipsoid,
-    tilt3DTransform
+    tilt3DTransform,
   );
 
   const oldGlobe = controller._globe;
@@ -2529,13 +2543,13 @@ function tilt3DOnTerrain(controller, startPosition, movement) {
       if (!defined(intersection)) {
         const cartographic = ellipsoid.cartesianToCartographic(
           camera.position,
-          tilt3DCart
+          tilt3DCart,
         );
         if (cartographic.height <= controller._minimumTrackBallHeight) {
           controller._looking = true;
           const up = controller._ellipsoid.geodeticSurfaceNormal(
             camera.position,
-            tilt3DLookUp
+            tilt3DLookUp,
           );
           look3D(controller, startPosition, movement, up);
           Cartesian2.clone(startPosition, controller._tiltCenterMousePosition);
@@ -2581,12 +2595,12 @@ function tilt3DOnTerrain(controller, startPosition, movement) {
   const transform = Transforms.eastNorthUpToFixedFrame(
     center,
     ellipsoid,
-    tilt3DTransform
+    tilt3DTransform,
   );
   const verticalTransform = Transforms.eastNorthUpToFixedFrame(
     verticalCenter,
     newEllipsoid,
-    tilt3DVerticalTransform
+    tilt3DVerticalTransform,
   );
 
   const oldGlobe = controller._globe;
@@ -2604,7 +2618,7 @@ function tilt3DOnTerrain(controller, startPosition, movement) {
   const tangent = Cartesian3.cross(
     verticalCenter,
     camera.positionWC,
-    tilt3DCartesian3
+    tilt3DCartesian3,
   );
   const dot = Cartesian3.dot(camera.rightWC, tangent);
 
@@ -2635,7 +2649,7 @@ function tilt3DOnTerrain(controller, startPosition, movement) {
     const right = Cartesian3.cross(
       camera.direction,
       camera.constrainedAxis,
-      tilt3DCartesian3
+      tilt3DCartesian3,
     );
     if (
       !Cartesian3.equalsEpsilon(right, Cartesian3.ZERO, CesiumMath.EPSILON6)
@@ -2662,7 +2676,7 @@ function tilt3DOnTerrain(controller, startPosition, movement) {
 
   const originalPosition = Cartesian3.clone(
     camera.positionWC,
-    tilt3DCartesian3
+    tilt3DCartesian3,
   );
 
   if (controller.enableCollisionDetection) {
@@ -2679,7 +2693,7 @@ function tilt3DOnTerrain(controller, startPosition, movement) {
       Cartesian3.multiplyByScalar(
         camera.position,
         Math.sqrt(magSqrd),
-        camera.position
+        camera.position,
       );
     }
 
@@ -2687,7 +2701,7 @@ function tilt3DOnTerrain(controller, startPosition, movement) {
     const axis = Cartesian3.cross(
       originalPosition,
       camera.position,
-      originalPosition
+      originalPosition,
     );
     Cartesian3.normalize(axis, axis);
 
@@ -2798,17 +2812,17 @@ function look3D(controller, startPosition, movement, rotationAxis) {
     const direction = camera.direction;
     const negativeRotationAxis = Cartesian3.negate(
       rotationAxis,
-      look3DNegativeRot
+      look3DNegativeRot,
     );
     const northParallel = Cartesian3.equalsEpsilon(
       direction,
       rotationAxis,
-      CesiumMath.EPSILON2
+      CesiumMath.EPSILON2,
     );
     const southParallel = Cartesian3.equalsEpsilon(
       direction,
       negativeRotationAxis,
-      CesiumMath.EPSILON2
+      CesiumMath.EPSILON2,
     );
     if (!northParallel && !southParallel) {
       dot = Cartesian3.dot(direction, rotationAxis);
@@ -2840,7 +2854,7 @@ function update3D(controller) {
     controller.rotateEventTypes,
     spin3D,
     controller.inertiaSpin,
-    "_lastInertiaSpinMovement"
+    "_lastInertiaSpinMovement",
   );
   reactToInput(
     controller,
@@ -2848,7 +2862,7 @@ function update3D(controller) {
     controller.zoomEventTypes,
     zoom3D,
     controller.inertiaZoom,
-    "_lastInertiaZoomMovement"
+    "_lastInertiaZoomMovement",
   );
   reactToInput(
     controller,
@@ -2856,13 +2870,13 @@ function update3D(controller) {
     controller.tiltEventTypes,
     tilt3D,
     controller.inertiaSpin,
-    "_lastInertiaTiltMovement"
+    "_lastInertiaTiltMovement",
   );
   reactToInput(
     controller,
     controller.enableLook,
     controller.lookEventTypes,
-    look3D
+    look3D,
   );
 }
 
@@ -2937,7 +2951,7 @@ function adjustHeightForTerrain(controller, cameraChanged) {
       Cartesian3.multiplyByScalar(
         camera.position,
         Math.max(mag, controller.minimumZoomDistance),
-        camera.position
+        camera.position,
       );
       Cartesian3.normalize(camera.direction, camera.direction);
       Cartesian3.cross(camera.direction, camera.up, camera.right);
@@ -2986,17 +3000,17 @@ ScreenSpaceCameraController.prototype.update = function () {
   this._minimumCollisionTerrainHeight = VerticalExaggeration.getHeight(
     this.minimumCollisionTerrainHeight,
     verticalExaggeration,
-    verticalExaggerationRelativeHeight
+    verticalExaggerationRelativeHeight,
   );
   this._minimumPickingTerrainHeight = VerticalExaggeration.getHeight(
     this.minimumPickingTerrainHeight,
     verticalExaggeration,
-    verticalExaggerationRelativeHeight
+    verticalExaggerationRelativeHeight,
   );
   this._minimumTrackBallHeight = VerticalExaggeration.getHeight(
     this.minimumTrackBallHeight,
     verticalExaggeration,
-    verticalExaggerationRelativeHeight
+    verticalExaggerationRelativeHeight,
   );
 
   this._cameraUnderground = scene.cameraUnderground && defined(this._globe);
@@ -3008,11 +3022,11 @@ ScreenSpaceCameraController.prototype.update = function () {
   this._adjustedHeightForTerrain = false;
   const previousPosition = Cartesian3.clone(
     camera.positionWC,
-    scratchPreviousPosition
+    scratchPreviousPosition,
   );
   const previousDirection = Cartesian3.clone(
     camera.directionWC,
-    scratchPreviousDirection
+    scratchPreviousDirection,
   );
 
   if (mode === SceneMode.SCENE2D) {