3dtiles-inspector 0.2.3 → 0.2.4

package/dist/inspector-assets/viewer/app.js

@@ -45136,10 +45136,10 @@ function createGeoCameraController({
   const right = new Vector3();
   const backward = new Vector3();
   const quaternion = new Quaternion();
-  function isCenterModePosition(value) {
+  function isCenterModePosition2(value) {
     return value.lengthSq() <= centerModeDistanceSq;
   }
-  function getLocalFrame(referencePoint) {
+  function getLocalFrame2(referencePoint) {
     const ellipsoid = getActiveEllipsoid();
     ellipsoid.getPositionToCartographic(referencePoint, cartographicTarget);
     ellipsoid.getEastNorthUpFrame(
@@ -45186,7 +45186,7 @@ function createGeoCameraController({
     if (referencePoint.lengthSq() < centerModeDistanceSq || !getActiveEllipsoid()) {
       return target.identity();
     }
-    getLocalFrame(referencePoint);
+    getLocalFrame2(referencePoint);
     basis.makeBasis(east, north, up);
     return target.setFromRotationMatrix(basis);
   }
@@ -45201,7 +45201,7 @@ function createGeoCameraController({
     );
     return Math.max(radius / Math.sin(limitingHalfFov), 1);
   }
-  function getCenterModeHeadingPitchRollForward(heading, pitch) {
+  function getCenterModeHeadingPitchRollForward2(heading, pitch) {
     const cosPitch = Math.cos(pitch);
     forward.set(
       Math.sin(heading) * cosPitch,
@@ -45210,14 +45210,14 @@ function createGeoCameraController({
     );
     return forward.normalize();
   }
-  function getHeadingPitchRollForward(referencePoint, heading, pitch) {
-    if (isCenterModePosition(referencePoint)) {
-      return getCenterModeHeadingPitchRollForward(heading, pitch);
+  function getHeadingPitchRollForward2(referencePoint, heading, pitch) {
+    if (isCenterModePosition2(referencePoint)) {
+      return getCenterModeHeadingPitchRollForward2(heading, pitch);
     }
     if (referencePoint.lengthSq() < 1e-6) {
       return forward.set(0, 0, -1);
     }
-    getLocalFrame(referencePoint);
+    getLocalFrame2(referencePoint);
     const cosPitch = Math.cos(pitch);
     const sinPitch = Math.sin(pitch);
     const cosHeading = Math.cos(heading);
@@ -45225,8 +45225,8 @@ function createGeoCameraController({
     forward.copy(north).multiplyScalar(cosHeading * cosPitch).addScaledVector(east, sinHeading * cosPitch).addScaledVector(up, sinPitch).normalize();
     return forward;
   }
-  function getCenterModeHeadingPitchRollBasis(heading, pitch, roll) {
-    getCenterModeHeadingPitchRollForward(heading, pitch);
+  function getCenterModeHeadingPitchRollBasis2(heading, pitch, roll) {
+    getCenterModeHeadingPitchRollForward2(heading, pitch);
     right.copy(WORLD_RIGHT).multiplyScalar(Math.cos(heading)).addScaledVector(CENTER_NORTH, -Math.sin(heading)).normalize();
     up.crossVectors(right, forward).normalize();
     if (roll !== 0) {
@@ -45235,14 +45235,14 @@ function createGeoCameraController({
     }
     backward.copy(forward).negate();
   }
-  function getHeadingPitchRollQuaternion(referencePoint, heading, pitch, roll) {
-    if (isCenterModePosition(referencePoint)) {
-      getCenterModeHeadingPitchRollBasis(heading, pitch, roll);
+  function getHeadingPitchRollQuaternion2(referencePoint, heading, pitch, roll) {
+    if (isCenterModePosition2(referencePoint)) {
+      getCenterModeHeadingPitchRollBasis2(heading, pitch, roll);
     } else if (referencePoint.lengthSq() < 1e-6) {
       quaternion.identity();
       return quaternion;
     } else {
-      getHeadingPitchRollForward(referencePoint, heading, pitch);
+      getHeadingPitchRollForward2(referencePoint, heading, pitch);
       right.copy(east).multiplyScalar(Math.cos(heading)).addScaledVector(north, -Math.sin(heading)).normalize();
       up.crossVectors(right, forward).normalize();
       if (roll !== 0) {
@@ -45254,7 +45254,7 @@ function createGeoCameraController({
     basis.makeBasis(right, up, backward);
     return quaternion.setFromRotationMatrix(basis);
   }
-  function getBoundingSphereFlyToPosition(target, range, options) {
+  function getBoundingSphereFlyToPosition2(target, range, options) {
     const { heading, pitch } = options;
     if (heading === void 0 && pitch === void 0) {
       const direction = target.lengthSq() > 1e-6 ? position.copy(target).normalize() : camera.position.lengthSq() > 1e-6 ? position.copy(camera.position).normalize() : position.set(0, -1, 0);
@@ -45262,15 +45262,15 @@ function createGeoCameraController({
     }
     const resolvedHeading = heading ?? 0;
     const resolvedPitch = pitch ?? -Math.PI / 2;
-    const centerForward = getCenterModeHeadingPitchRollForward(
+    const centerForward = getCenterModeHeadingPitchRollForward2(
       resolvedHeading,
       resolvedPitch
     );
     const centerPosition = position.copy(target).addScaledVector(centerForward, -range);
-    if (isCenterModePosition(centerPosition)) {
+    if (isCenterModePosition2(centerPosition)) {
       return centerPosition;
     }
-    const resolvedForward = getHeadingPitchRollForward(
+    const resolvedForward = getHeadingPitchRollForward2(
       target,
       resolvedHeading,
       resolvedPitch
@@ -45291,13 +45291,13 @@ function createGeoCameraController({
     } else {
       offsetDistance = getCameraDistanceForBoundingSphere(safeRadius);
     }
-    const nextPosition = getBoundingSphereFlyToPosition(
+    const nextPosition = getBoundingSphereFlyToPosition2(
       target,
       offsetDistance,
       options
     );
-    const nextQuaternion = getHeadingPitchRollQuaternion(
-      isCenterModePosition(nextPosition) ? nextPosition : target,
+    const nextQuaternion = getHeadingPitchRollQuaternion2(
+      isCenterModePosition2(nextPosition) ? nextPosition : target,
       options.heading ?? 0,
       options.pitch ?? -Math.PI / 2,
       options.roll ?? 0
@@ -65854,7 +65854,7 @@ var init_cameraController = __esm({
       const minScale = 0;
       metrics.distanceScale = baseScale;
       metrics.transitionWeight = 0;
-      if (!__privateGet(this, _ellipsoid)) {
+      if (!__privateGet(this, _ellipsoid) || __privateMethod(this, _CameraController_instances, isCameraCenterMode_fn).call(this)) {
         return metrics;
       }
       const taperStartRadius = __privateGet(this, _ellipsoidMaxRadius) * 1.5;
@@ -65903,7 +65903,7 @@ var init_cameraController = __esm({
       const source = _vec4.copy(__privateGet(this, _camera3).position);
       let distanceScale = 1;
       let transitionWeight = 0;
-      if (zoomAmount < 0 && __privateGet(this, _ellipsoid)) {
+      if (zoomAmount < 0 && __privateGet(this, _ellipsoid) && !__privateMethod(this, _CameraController_instances, isCameraCenterMode_fn).call(this)) {
         const metrics = __privateMethod(this, _CameraController_instances, getZoomOutMetrics_fn).call(this, source, hit.virtual ? null : hit);
         distanceScale = metrics.distanceScale;
         transitionWeight = metrics.transitionWeight;
@@ -66096,9 +66096,9 @@ function createViewerScene({
     60,
     window.innerWidth / window.innerHeight,
     1,
-    2e7
+    12e6
   );
-  camera.position.set(0, 0, 175e5);
+  camera.position.set(0, 0, 12e6);
   camera.updateMatrixWorld(true);
   const contentGroup = new Group();
   scene.add(contentGroup);
@@ -67650,6 +67650,505 @@ var init_setPositionController = __esm({
   }
 });
 
+// src/viewer/navigation/cameraFlyTo.js
+function eastNorthUpToFixedFrame(origin) {
+  _geoUp.copy(origin).multiply(_oneOverRadiiSquared).normalize();
+  _geoEast.set(0, 0, 1).cross(_geoUp).normalize();
+  _geoNorth.copy(_geoUp).cross(_geoEast).normalize();
+  return _matrix3.set(
+    _geoEast.x,
+    _geoNorth.x,
+    _geoUp.x,
+    origin.x,
+    _geoEast.y,
+    _geoNorth.y,
+    _geoUp.y,
+    origin.y,
+    _geoEast.z,
+    _geoNorth.z,
+    _geoUp.z,
+    origin.z,
+    0,
+    0,
+    0,
+    1
+  );
+}
+function createCameraFlight(camera, position, target, options = {}) {
+  const duration = options.duration ?? 2500;
+  const endPosition = position.clone();
+  const endQuaternion = getEndQuaternion(endPosition, target, options);
+  const endPose = getUprightHeadingPitchAtPose(endPosition, endQuaternion);
+  const endRoll = getRollAtPose(endPosition, endQuaternion);
+  const endZoom = camera instanceof OrthographicCamera ? Math.max(options.endZoom ?? camera.zoom, 1e-6) : null;
+  return buildFlightState(camera, {
+    duration,
+    endPosition,
+    endQuaternion,
+    endZoom,
+    endHeading: endPose.heading,
+    endPitch: endPose.pitch,
+    endRoll
+  });
+}
+function getFlyToParamsFromBoundingSphere(camera, target, radius, options = {}) {
+  const safeRadius = Math.max(radius, 1);
+  let offsetDistance = safeRadius;
+  let endZoom = options.endZoom;
+  if (camera instanceof PerspectiveCamera) {
+    const verticalFov = MathUtils.degToRad(camera.fov);
+    const horizontalFov = 2 * Math.atan(Math.tan(verticalFov / 2) * camera.aspect);
+    const minHalfFov = Math.max(0.1, Math.min(verticalFov, horizontalFov) / 2);
+    offsetDistance = safeRadius / Math.sin(minHalfFov) + safeRadius * 0.75;
+  } else if (camera instanceof OrthographicCamera) {
+    const visibleHeight = Math.max(safeRadius * 2.8, 1);
+    endZoom = (camera.top - camera.bottom) / visibleHeight;
+    offsetDistance = Math.max(safeRadius * 2, visibleHeight * 0.5);
+  }
+  const position = getBoundingSphereFlyToPosition(
+    camera,
+    target,
+    offsetDistance,
+    options
+  );
+  return {
+    position,
+    target: target.clone(),
+    options: {
+      ...options,
+      endZoom
+    }
+  };
+}
+function flyTo(camera, flight, time) {
+  if (flight.startTime === null) {
+    flight.startTime = time;
+  }
+  const rawT = MathUtils.clamp(
+    (time - flight.startTime) / flight.duration,
+    0,
+    1
+  );
+  const easedT = rawT < 0.5 ? 4 * rawT * rawT * rawT : 1 - Math.pow(-2 * rawT + 2, 3) / 2;
+  const position = getFlyToPosition(flight, easedT);
+  const quaternion = flight.maintainUpright ? getUprightInterpolatedQuaternion(flight, position, easedT) : _flyQuaternion.slerpQuaternions(
+    flight.startQuaternion,
+    flight.endQuaternion,
+    easedT
+  );
+  const zoom = flight.startZoom !== null && flight.endZoom !== null ? MathUtils.lerp(flight.startZoom, flight.endZoom, easedT) : null;
+  applyFlyToPose(camera, position, quaternion, zoom);
+  return rawT === 1;
+}
+function getFlyToPosition(flight, t2) {
+  const { startPosition, endPosition, arcHeight } = flight;
+  const startLength = startPosition.length();
+  const endLength = endPosition.length();
+  if (startLength < 1e-6 || endLength < 1e-6) {
+    return _flyDirection.lerpVectors(startPosition, endPosition, t2);
+  }
+  _flyDirectionStart.copy(startPosition).divideScalar(startLength);
+  _flyDirectionEnd.copy(endPosition).divideScalar(endLength);
+  const angle = _flyDirectionStart.angleTo(_flyDirectionEnd);
+  if (angle > 1e-5) {
+    if (angle < Math.PI - 1e-5) {
+      _flyAxis.crossVectors(_flyDirectionStart, _flyDirectionEnd).normalize();
+    } else {
+      _flyAxis.crossVectors(_flyDirectionStart, _flyWorldUp);
+      if (_flyAxis.lengthSq() < 1e-6) {
+        _flyAxis.crossVectors(_flyDirectionStart, _flyWorldNorth);
+      }
+      _flyAxis.normalize();
+    }
+    _flyDirection.copy(_flyDirectionStart).applyAxisAngle(_flyAxis, angle * t2).normalize();
+  } else {
+    _flyDirection.copy(_flyDirectionStart);
+  }
+  const radius = MathUtils.lerp(startLength, endLength, t2) + Math.sin(Math.PI * t2) * arcHeight;
+  return _flyDirection.multiplyScalar(radius);
+}
+function getUprightInterpolatedQuaternion(flight, position, t2) {
+  const heading = lerpAngle(flight.startHeading, flight.endHeading, t2);
+  const pitch = MathUtils.lerp(flight.startPitch, flight.endPitch, t2);
+  return getHeadingPitchRollQuaternion(position, heading, pitch, 0);
+}
+function buildFlightState(camera, {
+  duration,
+  endPosition,
+  endQuaternion,
+  endZoom,
+  endHeading,
+  endPitch,
+  endRoll
+}) {
+  const startPosition = camera.position.clone();
+  const startQuaternion = camera.quaternion.clone();
+  const startPose = getUprightHeadingPitchAtPose(
+    startPosition,
+    startQuaternion
+  );
+  const startRoll = getRollAtPose(startPosition, startQuaternion);
+  const startZoom = camera instanceof OrthographicCamera ? camera.zoom : null;
+  if (isImmediateFlight(
+    duration,
+    startPosition,
+    endPosition,
+    startQuaternion,
+    endQuaternion,
+    startZoom,
+    endZoom
+  )) {
+    applyFlyToPose(camera, endPosition, endQuaternion, endZoom);
+    return null;
+  }
+  return {
+    startTime: null,
+    duration,
+    startPosition,
+    endPosition,
+    startQuaternion,
+    endQuaternion,
+    startZoom,
+    endZoom,
+    arcHeight: getArcHeight(startPosition, endPosition),
+    maintainUpright: shouldMaintainUpright(startRoll, endRoll),
+    startHeading: startPose.heading,
+    endHeading,
+    startPitch: startPose.pitch,
+    endPitch
+  };
+}
+function isImmediateFlight(duration, startPosition, endPosition, startQuaternion, endQuaternion, startZoom, endZoom) {
+  return duration <= 0 || startPosition.distanceToSquared(endPosition) < 1e-6 && startQuaternion.angleTo(endQuaternion) < 1e-6 && (startZoom === null || endZoom === null || Math.abs(startZoom - endZoom) < 1e-6);
+}
+function getArcHeight(startPosition, endPosition) {
+  const chordLength = startPosition.distanceTo(endPosition);
+  return Math.max(
+    chordLength * 0.35,
+    Math.abs(endPosition.length() - startPosition.length()) * 0.5,
+    500
+  );
+}
+function shouldMaintainUpright(startRoll, endRoll) {
+  return Math.abs(startRoll) <= UPRIGHT_ROLL_THRESHOLD && Math.abs(endRoll) <= UPRIGHT_ROLL_THRESHOLD;
+}
+function getLookAtQuaternion(position, target) {
+  if (isCenterModePosition(position)) {
+    _matrix3.lookAt(position, target, _flyCenterUp);
+    return new Quaternion().setFromRotationMatrix(_matrix3);
+  }
+  _flyUp.copy(target);
+  if (_flyUp.lengthSq() < 1e-6) {
+    _flyUp.copy(_flyWorldUp);
+  } else {
+    _flyUp.normalize();
+  }
+  _flyEast.crossVectors(_flyWorldNorth, _flyUp);
+  if (_flyEast.lengthSq() < 1e-6) {
+    _flyEast.crossVectors(_flyWorldUp, _flyUp);
+  }
+  if (_flyEast.lengthSq() < 1e-6) {
+    _flyEast.set(1, 0, 0);
+  }
+  _flyEast.normalize();
+  _flyUp.crossVectors(_flyUp, _flyEast).normalize();
+  _matrix3.lookAt(position, target, _flyUp);
+  return new Quaternion().setFromRotationMatrix(_matrix3);
+}
+function getForwardFromQuaternion(quaternion, target) {
+  return target.set(0, 0, -1).applyQuaternion(quaternion).normalize();
+}
+function getUprightHeadingPitchAtPose(position, quaternion) {
+  if (isCenterModePosition(position)) {
+    const forward2 = getForwardFromQuaternion(quaternion, _flyForward);
+    _flyCameraRight.set(1, 0, 0).applyQuaternion(quaternion);
+    _flyReferenceRight.copy(_flyCameraRight).projectOnPlane(_flyCenterUp);
+    let heading2 = 0;
+    if (_flyReferenceRight.lengthSq() > HEADING_RIGHT_DEGENERATE_EPSILON) {
+      _flyReferenceRight.normalize();
+      heading2 = Math.atan2(
+        -_flyReferenceRight.dot(_flyCenterNorth),
+        _flyReferenceRight.dot(_flyWorldRight)
+      );
+    } else {
+      const horizontalForward = _flyDirection.copy(forward2).projectOnPlane(_flyCenterUp);
+      if (horizontalForward.lengthSq() > HEADING_RIGHT_DEGENERATE_EPSILON) {
+        horizontalForward.normalize();
+        heading2 = Math.atan2(
+          horizontalForward.dot(_flyWorldRight),
+          horizontalForward.dot(_flyCenterNorth)
+        );
+      }
+    }
+    return {
+      heading: heading2,
+      pitch: Math.asin(MathUtils.clamp(forward2.dot(_flyCenterUp), -1, 1))
+    };
+  }
+  if (position.lengthSq() < 1e-6) {
+    return {
+      heading: 0,
+      pitch: 0
+    };
+  }
+  const forward = getForwardFromQuaternion(quaternion, _flyForward);
+  getLocalFrame(position);
+  _flyCameraRight.set(1, 0, 0).applyQuaternion(quaternion);
+  _flyReferenceRight.copy(_flyCameraRight).projectOnPlane(_flyUp);
+  let heading = 0;
+  if (_flyReferenceRight.lengthSq() > HEADING_RIGHT_DEGENERATE_EPSILON) {
+    _flyReferenceRight.normalize();
+    heading = Math.atan2(
+      -_flyReferenceRight.dot(_flyNorth),
+      _flyReferenceRight.dot(_flyEast)
+    );
+  } else {
+    const horizontalForward = _flyDirection.copy(forward).projectOnPlane(_flyUp);
+    if (horizontalForward.lengthSq() > HEADING_RIGHT_DEGENERATE_EPSILON) {
+      horizontalForward.normalize();
+      heading = Math.atan2(
+        horizontalForward.dot(_flyEast),
+        horizontalForward.dot(_flyNorth)
+      );
+    }
+  }
+  return {
+    heading,
+    pitch: Math.asin(MathUtils.clamp(forward.dot(_flyUp), -1, 1))
+  };
+}
+function getRollAtPose(position, quaternion) {
+  const forward = getForwardFromQuaternion(quaternion, _flyForward);
+  if (isCenterModePosition(position)) {
+    if (Math.abs(forward.dot(_flyCenterUp)) >= ROLL_UNDEFINED_DOT_THRESHOLD) {
+      return 0;
+    }
+    getReferenceBasis(
+      forward,
+      _flyWorldRight,
+      _flyCenterUp,
+      _flyReferenceRight,
+      _flyReferenceUp
+    );
+  } else {
+    if (position.lengthSq() < 1e-6) {
+      return 0;
+    }
+    getLocalFrame(position);
+    if (Math.abs(forward.dot(_flyUp)) >= ROLL_UNDEFINED_DOT_THRESHOLD) {
+      return 0;
+    }
+    getReferenceBasis(
+      forward,
+      _flyEast,
+      _flyUp,
+      _flyReferenceRight,
+      _flyReferenceUp
+    );
+  }
+  _flyReferenceUp.projectOnPlane(forward);
+  _flyCameraUp.set(0, 1, 0).applyQuaternion(quaternion).projectOnPlane(forward);
+  if (_flyReferenceUp.lengthSq() < 1e-6 || _flyCameraUp.lengthSq() < 1e-6) {
+    return 0;
+  }
+  _flyReferenceUp.normalize();
+  _flyCameraUp.normalize();
+  return Math.atan2(
+    _flyDirection.crossVectors(_flyReferenceUp, _flyCameraUp).dot(forward),
+    _flyReferenceUp.dot(_flyCameraUp)
+  );
+}
+function getEndQuaternion(position, target, options) {
+  const { heading, pitch, roll } = options;
+  if (heading === void 0 && pitch === void 0 && roll === void 0) {
+    return getLookAtQuaternion(position, target);
+  }
+  if (heading === void 0 && pitch === void 0) {
+    const quaternion = getLookAtQuaternion(position, target);
+    if (roll) {
+      _flyForward.subVectors(target, position).normalize();
+      quaternion.multiply(_flyQuaternion.setFromAxisAngle(_flyForward, roll));
+    }
+    return quaternion;
+  }
+  return getHeadingPitchRollQuaternion(
+    isCenterModePosition(position) ? position : target,
+    heading ?? 0,
+    pitch ?? -Math.PI / 2,
+    roll ?? 0
+  );
+}
+function getBoundingSphereFlyToPosition(camera, target, range, options) {
+  const { heading, pitch } = options;
+  if (heading === void 0 && pitch === void 0) {
+    const direction = target.lengthSq() > 1e-6 ? _flyDirection.copy(target).normalize() : camera.position.lengthSq() > 1e-6 ? _flyDirection.copy(camera.position).normalize() : _flyDirection.set(0, -1, 0);
+    return direction.multiplyScalar(range).add(target);
+  }
+  const resolvedHeading = heading ?? 0;
+  const resolvedPitch = pitch ?? -Math.PI / 2;
+  const centerForward = getCenterModeHeadingPitchRollForward(
+    resolvedHeading,
+    resolvedPitch
+  );
+  const centerPosition = _flyDirection.copy(target).addScaledVector(centerForward, -range);
+  if (isCenterModePosition(centerPosition)) {
+    return centerPosition;
+  }
+  const forward = getHeadingPitchRollForward(
+    target,
+    resolvedHeading,
+    resolvedPitch
+  );
+  return _flyDirection.copy(target).addScaledVector(forward, -range);
+}
+function getHeadingPitchRollQuaternion(referencePoint, heading, pitch, roll) {
+  if (isCenterModePosition(referencePoint)) {
+    getCenterModeHeadingPitchRollBasis(heading, pitch, roll);
+    _matrix1.makeBasis(_flyRight, _flyUp, _flyBackward);
+    return new Quaternion().setFromRotationMatrix(_matrix1);
+  }
+  if (referencePoint.lengthSq() < 1e-6) {
+    return new Quaternion();
+  }
+  getHeadingPitchRollBasis(referencePoint, heading, pitch, roll);
+  _matrix1.makeBasis(_flyRight, _flyUp, _flyBackward);
+  return new Quaternion().setFromRotationMatrix(_matrix1);
+}
+function getHeadingPitchRollForward(referencePoint, heading, pitch) {
+  if (isCenterModePosition(referencePoint)) {
+    return getCenterModeHeadingPitchRollForward(heading, pitch);
+  }
+  if (referencePoint.lengthSq() < 1e-6) {
+    return _flyForward.set(0, 0, -1);
+  }
+  getLocalFrame(referencePoint);
+  const cosPitch = Math.cos(pitch);
+  const sinPitch = Math.sin(pitch);
+  const cosHeading = Math.cos(heading);
+  const sinHeading = Math.sin(heading);
+  _flyForward.copy(_flyNorth).multiplyScalar(cosHeading * cosPitch).addScaledVector(_flyEast, sinHeading * cosPitch).addScaledVector(_flyUp, sinPitch).normalize();
+  return _flyForward;
+}
+function getCenterModeHeadingPitchRollForward(heading, pitch) {
+  const cosPitch = Math.cos(pitch);
+  const sinPitch = Math.sin(pitch);
+  const cosHeading = Math.cos(heading);
+  const sinHeading = Math.sin(heading);
+  _flyForward.set(
+    sinHeading * cosPitch,
+    cosHeading * cosPitch,
+    sinPitch
+  );
+  return _flyForward.normalize();
+}
+function getHeadingPitchRollBasis(referencePoint, heading, pitch, roll) {
+  if (isCenterModePosition(referencePoint)) {
+    getCenterModeHeadingPitchRollBasis(heading, pitch, roll);
+    return;
+  }
+  getHeadingPitchRollForward(referencePoint, heading, pitch);
+  _flyRight.copy(_flyEast).multiplyScalar(Math.cos(heading)).addScaledVector(_flyNorth, -Math.sin(heading)).normalize();
+  _flyUp.crossVectors(_flyRight, _flyForward).normalize();
+  if (roll !== 0) {
+    _flyRight.applyAxisAngle(_flyForward, roll).normalize();
+    _flyUp.applyAxisAngle(_flyForward, roll).normalize();
+  }
+  _flyBackward.copy(_flyForward).negate();
+}
+function getCenterModeHeadingPitchRollBasis(heading, pitch, roll) {
+  getCenterModeHeadingPitchRollForward(heading, pitch);
+  _flyRight.copy(_flyWorldRight).multiplyScalar(Math.cos(heading)).addScaledVector(_flyCenterNorth, -Math.sin(heading)).normalize();
+  _flyUp.crossVectors(_flyRight, _flyForward).normalize();
+  if (roll !== 0) {
+    _flyRight.applyAxisAngle(_flyForward, roll).normalize();
+    _flyUp.applyAxisAngle(_flyForward, roll).normalize();
+  }
+  _flyBackward.copy(_flyForward).negate();
+}
+function getLocalFrame(target) {
+  _matrix1.copy(eastNorthUpToFixedFrame(target));
+  _flyEast.setFromMatrixColumn(_matrix1, 0).normalize();
+  _flyNorth.setFromMatrixColumn(_matrix1, 1).normalize();
+  _flyUp.setFromMatrixColumn(_matrix1, 2).normalize();
+}
+function isCenterModePosition(position) {
+  return position.lengthSq() <= CAMERA_CENTER_MODE_DISTANCE_SQ;
+}
+function getReferenceBasis(forward, east, up, rightTarget, upTarget) {
+  rightTarget.crossVectors(forward, up);
+  if (rightTarget.lengthSq() < 1e-6) {
+    rightTarget.copy(east).projectOnPlane(forward);
+    if (rightTarget.lengthSq() < 1e-6) {
+      rightTarget.set(1, 0, 0).projectOnPlane(forward);
+    }
+  }
+  rightTarget.normalize();
+  upTarget.crossVectors(rightTarget, forward).normalize();
+}
+function lerpAngle(start, end, t2) {
+  let delta = end - start;
+  if (delta > Math.PI) {
+    delta -= Math.PI * 2;
+  } else if (delta < -Math.PI) {
+    delta += Math.PI * 2;
+  }
+  return start + delta * t2;
+}
+function applyFlyToPose(camera, position, quaternion, zoom = null) {
+  camera.position.copy(position);
+  camera.quaternion.copy(quaternion);
+  if (camera instanceof OrthographicCamera && zoom !== null) {
+    camera.zoom = Math.max(zoom, 1e-6);
+    camera.updateProjectionMatrix();
+  }
+  camera.updateMatrixWorld();
+}
+var _matrix3, _matrix1, _flyDirectionStart, _flyDirectionEnd, _flyDirection, _flyAxis, _flyWorldNorth, _flyWorldRight, _flyCenterNorth, _flyCenterUp, _flyWorldUp, _flyUp, _flyEast, _flyNorth, _flyForward, _flyRight, _flyBackward, _flyCameraUp, _flyCameraRight, _flyReferenceUp, _flyReferenceRight, _flyQuaternion, _ellipsoidRadii, _oneOverRadiiSquared, _geoEast, _geoNorth, _geoUp, UPRIGHT_ROLL_THRESHOLD, ROLL_UNDEFINED_DOT_THRESHOLD, HEADING_RIGHT_DEGENERATE_EPSILON;
+var init_cameraFlyTo = __esm({
+  "src/viewer/navigation/cameraFlyTo.js"() {
+    init_three_module();
+    init_config();
+    _matrix3 = new Matrix4();
+    _matrix1 = new Matrix4();
+    _flyDirectionStart = new Vector3();
+    _flyDirectionEnd = new Vector3();
+    _flyDirection = new Vector3();
+    _flyAxis = new Vector3();
+    _flyWorldNorth = new Vector3(0, 0, 1);
+    _flyWorldRight = new Vector3(1, 0, 0);
+    _flyCenterNorth = new Vector3(0, 1, 0);
+    _flyCenterUp = new Vector3(0, 0, 1);
+    _flyWorldUp = new Vector3(0, 1, 0);
+    _flyUp = new Vector3();
+    _flyEast = new Vector3();
+    _flyNorth = new Vector3();
+    _flyForward = new Vector3();
+    _flyRight = new Vector3();
+    _flyBackward = new Vector3();
+    _flyCameraUp = new Vector3();
+    _flyCameraRight = new Vector3();
+    _flyReferenceUp = new Vector3();
+    _flyReferenceRight = new Vector3();
+    _flyQuaternion = new Quaternion();
+    _ellipsoidRadii = new Vector3(
+      6378137,
+      6378137,
+      6356752314245179e-9
+    );
+    _oneOverRadiiSquared = new Vector3(
+      1 / (_ellipsoidRadii.x * _ellipsoidRadii.x),
+      1 / (_ellipsoidRadii.y * _ellipsoidRadii.y),
+      1 / (_ellipsoidRadii.z * _ellipsoidRadii.z)
+    );
+    _geoEast = new Vector3();
+    _geoNorth = new Vector3();
+    _geoUp = new Vector3();
+    UPRIGHT_ROLL_THRESHOLD = MathUtils.degToRad(5);
+    ROLL_UNDEFINED_DOT_THRESHOLD = Math.cos(MathUtils.degToRad(5));
+    HEADING_RIGHT_DEGENERATE_EPSILON = 1e-6;
+  }
+});
+
 // src/viewer/navigation/flyTo.js
 function createFlyToController({
   camera,
@@ -67669,6 +68168,8 @@ function createFlyToController({
   const pickRaycaster = new Raycaster();
   const pickTargets = [];
   const sphere = new Sphere();
+  let activeCameraFlight = null;
+  let activeCameraFlightStatus = "";
   function getActiveEllipsoid() {
     return getTiles()?.ellipsoid || globeController.getEllipsoid();
   }
@@ -67710,6 +68211,43 @@ function createFlyToController({
     }
     return geoCamera.getCartographicFromWorldPosition(coordinateWorldPosition);
   }
+  function startCameraFlight(position, target, options = {}, { activeStatus = "Moving camera.", doneStatus = "Moved camera." } = {}) {
+    cameraController.setCamera(camera);
+    activeCameraFlight = createCameraFlight(camera, position, target, options);
+    activeCameraFlightStatus = doneStatus;
+    if (!activeCameraFlight) {
+      cameraController.setCamera(camera);
+      setStatus(doneStatus);
+      return;
+    }
+    setStatus(activeStatus);
+  }
+  function startBoundingSphereFlight(target, radius, options = {}, status = {}) {
+    const flyToParams = getFlyToParamsFromBoundingSphere(
+      camera,
+      target,
+      radius,
+      options
+    );
+    startCameraFlight(
+      flyToParams.position,
+      flyToParams.target,
+      flyToParams.options,
+      status
+    );
+  }
+  function update(time = performance.now()) {
+    if (!activeCameraFlight) {
+      return false;
+    }
+    const done = flyTo(camera, activeCameraFlight, time);
+    if (done) {
+      activeCameraFlight = null;
+      setStatus(activeCameraFlightStatus);
+      activeCameraFlightStatus = "";
+    }
+    return true;
+  }
   async function applyTilesSetPositionFromPointerEvent(event) {
     const coordinate = pickCoordinateFromPointerEvent(event);
     if (!coordinate) {
@@ -67731,27 +68269,29 @@ function createFlyToController({
       return null;
     }
   }
-  function frameTileset() {
+  function frameTileset({
+    activeStatus = "Moving camera to the tileset.",
+    doneStatus = "Moved camera to the tileset."
+  } = {}) {
     if (!getTilesetBoundingSphere(sphere)) {
       return false;
     }
-    const pose = geoCamera.getFlyToPoseFromBoundingSphere(
+    startBoundingSphereFlight(
       sphere.center,
-      sphere.radius,
-      moveToTilesPose
+      sphere.radius / 2,
+      moveToTilesPose,
+      {
+        activeStatus,
+        doneStatus
+      }
     );
-    camera.position.copy(pose.position);
-    camera.quaternion.copy(pose.quaternion);
-    camera.updateMatrixWorld(true);
-    cameraController.setCamera(camera);
     return true;
   }
   function moveCameraToTiles() {
     if (frameTileset()) {
-      setStatus("Moved camera to the tileset.");
-    } else {
-      setStatus("Tileset is not ready to frame yet.", true);
+      return;
     }
+    setStatus("Tileset is not ready to frame yet.", true);
   }
   function moveCameraToCoordinate(coordinate) {
     geoCamera.getCoordinateWorldPosition(
@@ -67760,16 +68300,15 @@ function createFlyToController({
       coordinate.height,
       coordinateWorldPosition
     );
-    const pose = geoCamera.getFlyToPoseFromBoundingSphere(
+    startBoundingSphereFlight(
       coordinateWorldPosition,
       moveToCoordinateRadius,
-      moveToTilesPose
+      moveToTilesPose,
+      {
+        activeStatus: "Moving camera to the specified coordinate.",
+        doneStatus: "Moved camera to the specified coordinate."
+      }
     );
-    camera.position.copy(pose.position);
-    camera.quaternion.copy(pose.quaternion);
-    camera.updateMatrixWorld(true);
-    cameraController.setCamera(camera);
-    setStatus("Moved camera to the specified coordinate.");
   }
   return {
     applyTilesSetPositionFromPointerEvent,
@@ -67777,12 +68316,14 @@ function createFlyToController({
     getActiveEllipsoid,
     moveCameraToCoordinate,
     moveCameraToTiles,
-    pickCoordinateFromPointerEvent
+    pickCoordinateFromPointerEvent,
+    update
   };
 }
 var init_flyTo = __esm({
   "src/viewer/navigation/flyTo.js"() {
     init_three_module();
+    init_cameraFlyTo();
     init_utils();
   }
 });
@@ -70686,7 +71227,7 @@ var require_app = __commonJS({
     var geoCamera = createGeoCameraController({
       camera,
       centerModeDistanceSq: CAMERA_CENTER_MODE_DISTANCE_SQ,
-      getActiveEllipsoid: () => flyTo.getActiveEllipsoid()
+      getActiveEllipsoid: () => flyTo2.getActiveEllipsoid()
     });
     var geometricError = createGeometricErrorController({
       defaultErrorTarget: DEFAULT_ERROR_TARGET,
@@ -70705,7 +71246,7 @@ var require_app = __commonJS({
       target.radius *= editableGroup.matrixWorld.getMaxScaleOnAxis();
       return true;
     }
-    var flyTo = createFlyToController({
+    var flyTo2 = createFlyToController({
       camera,
       cameraController,
       domElement: renderer.domElement,
@@ -70727,7 +71268,7 @@ var require_app = __commonJS({
       syncTransformControlsState: () => transformModeController.syncControls(),
       transformControls,
       applyTilesPlacementFromPointerEvent: async (event) => {
-        const coordinate = await flyTo.applyTilesSetPositionFromPointerEvent(event);
+        const coordinate = await flyTo2.applyTilesSetPositionFromPointerEvent(event);
         if (coordinate) {
           updateCoordinateInputs(
             coordinate.latitude,
@@ -70815,7 +71356,7 @@ var require_app = __commonJS({
     transformModeController.setMode(null);
     function moveCameraToTiles() {
       cancelPositionPickModes();
-      flyTo.moveCameraToTiles();
+      flyTo2.moveCameraToTiles();
     }
     function moveCameraToCoordinate() {
       cancelPositionPickModes();
@@ -70823,7 +71364,7 @@ var require_app = __commonJS({
       if (!coordinate) {
         return;
       }
-      flyTo.moveCameraToCoordinate(coordinate);
+      flyTo2.moveCameraToCoordinate(coordinate);
     }
     async function moveTilesToCoordinate() {
       cancelPositionPickModes();
@@ -70898,9 +71439,11 @@ var require_app = __commonJS({
         if (framed) {
           return;
         }
-        if (flyTo.frameTileset()) {
+        if (flyTo2.frameTileset({
+          activeStatus: "Framing tileset...",
+          doneStatus: "Tileset ready."
+        })) {
           framed = true;
-          setStatus("Tileset ready.");
         }
       };
       next.addEventListener(
@@ -71021,6 +71564,7 @@ var require_app = __commonJS({
     loadTileset(TILESET_URL);
     function frame() {
       cameraController.update();
+      flyTo2.update();
       rootTransform.flush();
       globeController.update();
       tiles?.update();