@cesium/engine 11.0.0 → 12.0.0

package/Source/Scene/ScreenSpaceCameraController.js

@@ -242,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;
@@ -271,6 +271,16 @@ function ScreenSpaceCameraController(scene) {
    * @default true
    */
   this.enableCollisionDetection = true;
+  /**
+   * The angle, relative to the ellipsoid normal, restricting the maximum amount that the user can tilt the camera. If <code>undefined</code>, the angle of the camera tilt is unrestricted.
+   * @type {number|undefined}
+   * @default undefined
+   *
+   * @example
+   * // Prevent the camera from tilting below the ellipsoid surface
+   * viewer.scene.screenSpaceCameraController.maximumTiltAngle = Math.PI / 2.0;
+   */
+  this.maximumTiltAngle = undefined;
 
   this._scene = scene;
   this._globe = undefined;
@@ -328,7 +338,7 @@ 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?
@@ -355,7 +365,7 @@ function sameMousePosition(movement) {
   return Cartesian2.equalsEpsilon(
     movement.startPosition,
     movement.endPosition,
-    CesiumMath.EPSILON14
+    CesiumMath.EPSILON14,
   );
 }
 
@@ -372,7 +382,7 @@ function maintainInertia(
   decayCoef,
   action,
   object,
-  lastMovementName
+  lastMovementName,
 ) {
   let movementState = object[lastMovementName];
   if (!defined(movementState)) {
@@ -410,18 +420,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,
@@ -431,7 +441,7 @@ function maintainInertia(
       isNaN(movementState.endPosition.y) ||
       Cartesian2.distance(
         movementState.startPosition,
-        movementState.endPosition
+        movementState.endPosition,
       ) < 0.5
     ) {
       return;
@@ -473,7 +483,7 @@ function reactToInput(
   eventTypes,
   action,
   inertiaConstant,
-  inertiaStateName
+  inertiaStateName,
 ) {
   if (!defined(eventTypes)) {
     return;
@@ -509,7 +519,7 @@ function reactToInput(
           inertiaConstant,
           action,
           controller,
-          inertiaStateName
+          inertiaStateName,
         );
       }
     }
@@ -551,14 +561,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,
     );
   }
 
@@ -577,7 +587,7 @@ function handleZoom(
   zoomRate = CesiumMath.clamp(
     zoomRate,
     object._minimumZoomRate,
-    object._maximumZoomRate
+    object._maximumZoomRate,
   );
 
   let rangeWindowRatio = diff / object._scene.canvas.clientHeight;
@@ -623,7 +633,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;
@@ -632,23 +642,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,
       );
     }
 
@@ -656,7 +668,7 @@ function handleZoom(
       object._useZoomWorldPosition = true;
       object._zoomWorldPosition = Cartesian3.clone(
         pickedPosition,
-        object._zoomWorldPosition
+        object._zoomWorldPosition,
       );
     } else {
       object._useZoomWorldPosition = false;
@@ -692,7 +704,7 @@ function handleZoom(
         const direction = Cartesian3.subtract(
           worldPosition,
           endPosition,
-          scratchZoomDirection
+          scratchZoomDirection,
         );
         Cartesian3.normalize(direction, direction);
 
@@ -705,23 +717,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 ||
@@ -740,7 +754,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
 
@@ -772,7 +786,7 @@ function handleZoom(
             Cartesian3.add(
               cameraPosition,
               Cartesian3.multiplyByScalar(forward, 1000, scratchCartesian),
-              center
+              center,
             );
 
             const positionToTarget = scratchPositionToTarget;
@@ -783,7 +797,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.
@@ -795,23 +809,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;
 
@@ -823,20 +836,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
@@ -846,24 +859,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;
@@ -872,17 +885,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);
 
@@ -894,7 +907,7 @@ function handleZoom(
             // Set new direction
             Cartesian3.normalize(
               Cartesian3.subtract(center, cameraPosition, scratchCartesian),
-              camera.direction
+              camera.direction,
             );
             Cartesian3.clone(camera.direction, camera.direction);
 
@@ -908,11 +921,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);
 
@@ -921,7 +934,7 @@ function handleZoom(
             const axis = Cartesian3.cross(
               pickedNormal,
               positionNormal,
-              scratchZoomAxis
+              scratchZoomAxis,
             );
 
             const denom =
@@ -943,7 +956,7 @@ function handleZoom(
     const zoomMouseStart = SceneTransforms.worldToWindowCoordinates(
       scene,
       object._zoomWorldPosition,
-      scratchZoomOffset
+      scratchZoomOffset,
     );
     if (
       mode !== SceneMode.COLUMBUS_VIEW &&
@@ -961,7 +974,7 @@ function handleZoom(
         rayDirection.y,
         rayDirection.z,
         rayDirection.x,
-        rayDirection
+        rayDirection,
       );
     }
 
@@ -984,8 +997,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);
@@ -1013,7 +1028,7 @@ function zoom2D(controller, startPosition, movement) {
     startPosition,
     movement,
     controller.zoomFactor,
-    camera.getMagnitude()
+    camera.getMagnitude(),
   );
 }
 
@@ -1089,7 +1104,7 @@ function update2D(controller) {
       controller.zoomEventTypes,
       zoom2D,
       controller.inertiaZoom,
-      "_lastInertiaZoomMovement"
+      "_lastInertiaZoomMovement",
     );
     if (rotatable2D) {
       reactToInput(
@@ -1098,7 +1113,7 @@ function update2D(controller) {
         controller.translateEventTypes,
         twist2D,
         controller.inertiaSpin,
-        "_lastInertiaSpinMovement"
+        "_lastInertiaSpinMovement",
       );
     }
   } else {
@@ -1108,7 +1123,7 @@ function update2D(controller) {
       controller.translateEventTypes,
       translate2D,
       controller.inertiaTranslate,
-      "_lastInertiaTranslateMovement"
+      "_lastInertiaTranslateMovement",
     );
     reactToInput(
       controller,
@@ -1116,7 +1131,7 @@ function update2D(controller) {
       controller.zoomEventTypes,
       zoom2D,
       controller.inertiaZoom,
-      "_lastInertiaZoomMovement"
+      "_lastInertiaZoomMovement",
     );
     if (rotatable2D) {
       reactToInput(
@@ -1125,7 +1140,7 @@ function update2D(controller) {
         controller.tiltEventTypes,
         twist2D,
         controller.inertiaSpin,
-        "_lastInertiaTiltMovement"
+        "_lastInertiaTiltMovement",
       );
     }
   }
@@ -1144,7 +1159,7 @@ function pickPosition(controller, mousePosition, result) {
   if (scene.pickPositionSupported) {
     depthIntersection = scene.pickPositionWorldCoordinates(
       mousePosition,
-      scratchDepthIntersection
+      scratchDepthIntersection,
     );
   }
 
@@ -1158,7 +1173,7 @@ function pickPosition(controller, mousePosition, result) {
     ray,
     scene,
     cullBackFaces,
-    scratchRayIntersection
+    scratchRayIntersection,
   );
 
   const pickDistance = defined(depthIntersection)
@@ -1187,7 +1202,7 @@ function getDistanceFromSurface(controller) {
   if (mode === SceneMode.SCENE3D) {
     const cartographic = ellipsoid.cartesianToCartographic(
       camera.position,
-      scratchDistanceCartographic
+      scratchDistanceCartographic,
     );
     if (defined(cartographic)) {
       height = cartographic.height;
@@ -1222,7 +1237,7 @@ function getTiltCenterUnderground(controller, ray, pickedPosition, result) {
   const maximumDistance = CesiumMath.clamp(
     distanceFromSurface * 5.0,
     controller._minimumUndergroundPickDistance,
-    controller._maximumUndergroundPickDistance
+    controller._maximumUndergroundPickDistance,
   );
 
   if (distance > maximumDistance) {
@@ -1238,7 +1253,7 @@ function getStrafeStartPositionUnderground(
   controller,
   ray,
   pickedPosition,
-  result
+  result,
 ) {
   let distance;
   if (!defined(pickedPosition)) {
@@ -1263,7 +1278,7 @@ function continueStrafing(controller, movement) {
   const inertialDelta = Cartesian2.subtract(
     movement.endPosition,
     movement.startPosition,
-    scratchInertialDelta
+    scratchInertialDelta,
   );
   const endPosition = controller._strafeEndMousePosition;
   Cartesian2.add(endPosition, inertialDelta, endPosition);
@@ -1306,7 +1321,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);
@@ -1333,7 +1348,7 @@ function translateCV(controller, startPosition, movement) {
         controller,
         startRay,
         globePos,
-        translateCVStartPos
+        translateCVStartPos,
       );
     }
     Cartesian2.clone(startPosition, controller._strafeMousePosition);
@@ -1350,14 +1365,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)) {
@@ -1370,7 +1385,7 @@ function translateCV(controller, startPosition, movement) {
   const diff = Cartesian3.subtract(
     startPlanePos,
     endPlanePos,
-    translateCVDifference
+    translateCVDifference,
   );
   const temp = diff.x;
   diff.x = diff.y;
@@ -1467,7 +1482,7 @@ function rotateCVOnPlane(controller, startPosition, movement) {
   const transform = Transforms.eastNorthUpToFixedFrame(
     center,
     ellipsoid,
-    rotateCVTransform
+    rotateCVTransform,
   );
 
   const oldGlobe = controller._globe;
@@ -1554,7 +1569,7 @@ function rotateCVOnTerrain(controller, startPosition, movement) {
   const verticalCenter = IntersectionTests.rayPlane(
     ray,
     plane,
-    rotateCVVerticalCenter
+    rotateCVVerticalCenter,
   );
 
   const projection = camera._projection;
@@ -1567,7 +1582,7 @@ function rotateCVOnTerrain(controller, startPosition, movement) {
   const transform = Transforms.eastNorthUpToFixedFrame(
     center,
     ellipsoid,
-    rotateCVTransform
+    rotateCVTransform,
   );
 
   let verticalTransform;
@@ -1576,7 +1591,7 @@ function rotateCVOnTerrain(controller, startPosition, movement) {
       verticalCenter.y,
       verticalCenter.z,
       verticalCenter.x,
-      verticalCenter
+      verticalCenter,
     );
     cart = projection.unproject(verticalCenter, rotateCVCart);
     ellipsoid.cartographicToCartesian(cart, verticalCenter);
@@ -1584,7 +1599,7 @@ function rotateCVOnTerrain(controller, startPosition, movement) {
     verticalTransform = Transforms.eastNorthUpToFixedFrame(
       verticalCenter,
       ellipsoid,
-      rotateCVVerticalTransform
+      rotateCVVerticalTransform,
     );
   } else {
     verticalTransform = transform;
@@ -1605,7 +1620,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);
 
@@ -1636,7 +1651,7 @@ function rotateCVOnTerrain(controller, startPosition, movement) {
     const right = Cartesian3.cross(
       camera.direction,
       camera.constrainedAxis,
-      tilt3DCartesian3
+      tilt3DCartesian3,
     );
     if (
       !Cartesian3.equalsEpsilon(right, Cartesian3.ZERO, CesiumMath.EPSILON6)
@@ -1663,7 +1678,7 @@ function rotateCVOnTerrain(controller, startPosition, movement) {
 
   const originalPosition = Cartesian3.clone(
     camera.positionWC,
-    rotateCVCartesian3
+    rotateCVCartesian3,
   );
 
   if (controller.enableCollisionDetection) {
@@ -1680,7 +1695,7 @@ function rotateCVOnTerrain(controller, startPosition, movement) {
       Cartesian3.multiplyByScalar(
         camera.position,
         Math.sqrt(magSqrd),
-        camera.position
+        camera.position,
       );
     }
 
@@ -1688,14 +1703,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);
@@ -1751,7 +1766,7 @@ function zoomCV(controller, startPosition, movement) {
     const distanceUnderground = getZoomDistanceUnderground(
       controller,
       ray,
-      height
+      height,
     );
     if (defined(distance)) {
       distance = Math.min(distance, distanceUnderground);
@@ -1771,7 +1786,7 @@ function zoomCV(controller, startPosition, movement) {
     startPosition,
     movement,
     controller.zoomFactor,
-    distance
+    distance,
   );
 }
 
@@ -1786,7 +1801,7 @@ function updateCV(controller) {
       controller.rotateEventTypes,
       rotate3D,
       controller.inertiaSpin,
-      "_lastInertiaSpinMovement"
+      "_lastInertiaSpinMovement",
     );
     reactToInput(
       controller,
@@ -1794,7 +1809,7 @@ function updateCV(controller) {
       controller.zoomEventTypes,
       zoom3D,
       controller.inertiaZoom,
-      "_lastInertiaZoomMovement"
+      "_lastInertiaZoomMovement",
     );
   } else {
     const tweens = controller._tweens;
@@ -1809,7 +1824,7 @@ function updateCV(controller) {
       controller.tiltEventTypes,
       rotateCV,
       controller.inertiaSpin,
-      "_lastInertiaTiltMovement"
+      "_lastInertiaTiltMovement",
     );
     reactToInput(
       controller,
@@ -1817,7 +1832,7 @@ function updateCV(controller) {
       controller.translateEventTypes,
       translateCV,
       controller.inertiaTranslate,
-      "_lastInertiaTranslateMovement"
+      "_lastInertiaTranslateMovement",
     );
     reactToInput(
       controller,
@@ -1825,13 +1840,13 @@ function updateCV(controller) {
       controller.zoomEventTypes,
       zoomCV,
       controller.inertiaZoom,
-      "_lastInertiaZoomMovement"
+      "_lastInertiaZoomMovement",
     );
     reactToInput(
       controller,
       controller.enableLook,
       controller.lookEventTypes,
-      look3D
+      look3D,
     );
 
     if (
@@ -1839,7 +1854,7 @@ function updateCV(controller) {
       !tweens.contains(controller._tween)
     ) {
       const tween = camera.createCorrectPositionTween(
-        controller.bounceAnimationTime
+        controller.bounceAnimationTime,
       );
       if (defined(tween)) {
         controller._tween = tweens.add(tween);
@@ -1869,12 +1884,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;
@@ -1941,7 +1956,7 @@ function spin3D(controller, startPosition, movement) {
 
   const height = ellipsoid.cartesianToCartographic(
     camera.positionWC,
-    scratchCartographic
+    scratchCartographic,
   ).height;
   const globe = controller._globe;
 
@@ -1949,13 +1964,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) {
@@ -1998,8 +2013,8 @@ function spin3D(controller, startPosition, movement) {
       camera.pickEllipsoid(
         movement.startPosition,
         controller._ellipsoid,
-        spin3DPick
-      )
+        spin3DPick,
+      ),
     )
   ) {
     pan3D(controller, startPosition, movement, controller._ellipsoid);
@@ -2021,7 +2036,7 @@ function rotate3D(
   movement,
   constrainedAxis,
   rotateOnlyVertical,
-  rotateOnlyHorizontal
+  rotateOnlyHorizontal,
 ) {
   rotateOnlyVertical = defaultValue(rotateOnlyVertical, false);
   rotateOnlyHorizontal = defaultValue(rotateOnlyHorizontal, false);
@@ -2054,11 +2069,20 @@ function rotate3D(
   phiWindowRatio = Math.min(phiWindowRatio, controller.maximumMovementRatio);
   thetaWindowRatio = Math.min(
     thetaWindowRatio,
-    controller.maximumMovementRatio
+    controller.maximumMovementRatio,
   );
 
   const deltaPhi = rotateRate * phiWindowRatio * Math.PI * 2.0;
-  const deltaTheta = rotateRate * thetaWindowRatio * Math.PI;
+  let deltaTheta = rotateRate * thetaWindowRatio * Math.PI;
+
+  if (defined(constrainedAxis) && defined(controller.maximumTiltAngle)) {
+    const maximumTiltAngle = controller.maximumTiltAngle;
+    const dotProduct = Cartesian3.dot(camera.direction, constrainedAxis);
+    const tilt = Math.PI - Math.acos(dotProduct) + deltaTheta;
+    if (tilt > maximumTiltAngle) {
+      deltaTheta -= tilt - maximumTiltAngle;
+    }
+  }
 
   if (!rotateOnlyVertical) {
     camera.rotateRight(deltaPhi);
@@ -2089,15 +2113,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;
@@ -2113,7 +2137,7 @@ function pan3D(controller, startPosition, movement, ellipsoid) {
       !defined(controller._globe) &&
       !Cartesian2.equalsEpsilon(
         startMousePosition,
-        controller._panLastMousePosition
+        controller._panLastMousePosition,
       )
     ) {
       p0 = pickPosition(controller, startMousePosition, pan3DP0);
@@ -2124,7 +2148,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(
@@ -2132,33 +2156,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;
@@ -2166,7 +2192,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)) *
@@ -2174,7 +2200,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
@@ -2182,7 +2208,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);
@@ -2267,11 +2293,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;
@@ -2325,7 +2351,7 @@ function zoom3D(controller, startPosition, movement) {
   let intersection;
   const height = ellipsoid.cartesianToCartographic(
     camera.position,
-    zoom3DCartographic
+    zoom3DCartographic,
   ).height;
 
   const approachingCollision =
@@ -2349,7 +2375,7 @@ function zoom3D(controller, startPosition, movement) {
     const distanceUnderground = getZoomDistanceUnderground(
       controller,
       ray,
-      height
+      height,
     );
     if (defined(distance)) {
       distance = Math.min(distance, distanceUnderground);
@@ -2364,7 +2390,7 @@ function zoom3D(controller, startPosition, movement) {
 
   const unitPosition = Cartesian3.normalize(
     camera.position,
-    zoom3DUnitPosition
+    zoom3DUnitPosition,
   );
   handleZoom(
     controller,
@@ -2372,7 +2398,7 @@ function zoom3D(controller, startPosition, movement) {
     movement,
     controller.zoomFactor,
     distance,
-    Cartesian3.dot(unitPosition, camera.direction)
+    Cartesian3.dot(unitPosition, camera.direction),
   );
 }
 
@@ -2408,7 +2434,7 @@ function tilt3D(controller, startPosition, movement) {
   if (controller._looking) {
     const up = controller._ellipsoid.geodeticSurfaceNormal(
       camera.position,
-      tilt3DLookUp
+      tilt3DLookUp,
     );
     look3D(controller, startPosition, movement, up);
     return;
@@ -2417,7 +2443,7 @@ function tilt3D(controller, startPosition, movement) {
   const ellipsoid = controller._ellipsoid;
   const cartographic = ellipsoid.cartesianToCartographic(
     camera.position,
-    tilt3DCart
+    tilt3DCart,
   );
 
   if (
@@ -2440,7 +2466,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 &&
@@ -2463,25 +2489,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);
@@ -2491,7 +2517,7 @@ function tilt3DOnEllipsoid(controller, startPosition, movement) {
   const transform = Transforms.eastNorthUpToFixedFrame(
     center,
     ellipsoid,
-    tilt3DTransform
+    tilt3DTransform,
   );
 
   const oldGlobe = controller._globe;
@@ -2536,13 +2562,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);
@@ -2588,12 +2614,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;
@@ -2611,7 +2637,7 @@ function tilt3DOnTerrain(controller, startPosition, movement) {
   const tangent = Cartesian3.cross(
     verticalCenter,
     camera.positionWC,
-    tilt3DCartesian3
+    tilt3DCartesian3,
   );
   const dot = Cartesian3.dot(camera.rightWC, tangent);
 
@@ -2642,7 +2668,7 @@ function tilt3DOnTerrain(controller, startPosition, movement) {
     const right = Cartesian3.cross(
       camera.direction,
       camera.constrainedAxis,
-      tilt3DCartesian3
+      tilt3DCartesian3,
     );
     if (
       !Cartesian3.equalsEpsilon(right, Cartesian3.ZERO, CesiumMath.EPSILON6)
@@ -2669,7 +2695,7 @@ function tilt3DOnTerrain(controller, startPosition, movement) {
 
   const originalPosition = Cartesian3.clone(
     camera.positionWC,
-    tilt3DCartesian3
+    tilt3DCartesian3,
   );
 
   if (controller.enableCollisionDetection) {
@@ -2686,7 +2712,7 @@ function tilt3DOnTerrain(controller, startPosition, movement) {
       Cartesian3.multiplyByScalar(
         camera.position,
         Math.sqrt(magSqrd),
-        camera.position
+        camera.position,
       );
     }
 
@@ -2694,7 +2720,7 @@ function tilt3DOnTerrain(controller, startPosition, movement) {
     const axis = Cartesian3.cross(
       originalPosition,
       camera.position,
-      originalPosition
+      originalPosition,
     );
     Cartesian3.normalize(axis, axis);
 
@@ -2805,17 +2831,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);
@@ -2847,7 +2873,7 @@ function update3D(controller) {
     controller.rotateEventTypes,
     spin3D,
     controller.inertiaSpin,
-    "_lastInertiaSpinMovement"
+    "_lastInertiaSpinMovement",
   );
   reactToInput(
     controller,
@@ -2855,7 +2881,7 @@ function update3D(controller) {
     controller.zoomEventTypes,
     zoom3D,
     controller.inertiaZoom,
-    "_lastInertiaZoomMovement"
+    "_lastInertiaZoomMovement",
   );
   reactToInput(
     controller,
@@ -2863,13 +2889,13 @@ function update3D(controller) {
     controller.tiltEventTypes,
     tilt3D,
     controller.inertiaSpin,
-    "_lastInertiaTiltMovement"
+    "_lastInertiaTiltMovement",
   );
   reactToInput(
     controller,
     controller.enableLook,
     controller.lookEventTypes,
-    look3D
+    look3D,
   );
 }
 
@@ -2944,7 +2970,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);
@@ -2993,17 +3019,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);
@@ -3015,11 +3041,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) {