3dtiles-inspector 0.2.2 → 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();
   }
 });
@@ -67954,6 +68495,15 @@ function clientPointToNdc(point, domRect) {
     y: 1 - (point.y - domRect.top) / domRect.height * 2
   };
 }
+function getClientSelectionQuad(start, end) {
+  const clientRect = getClientSelectionRect(start, end);
+  return [
+    new Vector2(clientRect.minX, clientRect.minY),
+    new Vector2(clientRect.maxX, clientRect.minY),
+    new Vector2(clientRect.maxX, clientRect.maxY),
+    new Vector2(clientRect.minX, clientRect.maxY)
+  ];
+}
 function getNdcSelectionRect(clientRect, domRect) {
   const topLeft = clientPointToNdc(
     new Vector2(clientRect.minX, clientRect.minY),
@@ -67970,6 +68520,19 @@ function getNdcSelectionRect(clientRect, domRect) {
     maxY: Math.max(topLeft.y, bottomRight.y)
   };
 }
+function getNdcSelectionQuad(clientPoints, domRect) {
+  return clientPoints.map((point) => clientPointToNdc(point, domRect));
+}
+function getNdcBounds(points) {
+  const xs2 = points.map((point) => point.x);
+  const ys2 = points.map((point) => point.y);
+  return {
+    maxX: Math.max(...xs2),
+    maxY: Math.max(...ys2),
+    minX: Math.min(...xs2),
+    minY: Math.min(...ys2)
+  };
+}
 function updateOverlayRect(overlayEl, rectEl, clientRect) {
   if (!overlayEl || !rectEl) {
     return;
@@ -68151,10 +68714,10 @@ function createFarPlaneData({
     width
   };
 }
-function createFrustumData(camera, rect, depthRange) {
+function createFrustumDataFromQuad(camera, quad, depthRange) {
   const { farDepth, nearDepth } = normalizeDepthRange(camera, depthRange);
-  const centerX = (rect.minX + rect.maxX) * 0.5;
-  const centerY = (rect.minY + rect.maxY) * 0.5;
+  const centerX = quad.reduce((total, point) => total + point.x, 0) / quad.length;
+  const centerY = quad.reduce((total, point) => total + point.y, 0) / quad.length;
   const nearCenter = createPointAtViewDepth(
     camera,
     centerX,
@@ -68181,55 +68744,13 @@ function createFrustumData(camera, rect, depthRange) {
   const insidePoint = selectionForward.clone().multiplyScalar((nearDistance + farDistance) * 0.5).add(camera.position);
   plane.setFromNormalAndCoplanarPoint(selectionForward, farCenter);
   const farClipPlane = plane.clone();
-  const farTopLeft = createPointOnPlane(
-    camera,
-    rect.minX,
-    rect.maxY,
-    farClipPlane
-  );
-  const farTopRight = createPointOnPlane(
-    camera,
-    rect.maxX,
-    rect.maxY,
-    farClipPlane
-  );
-  const farBottomRight = createPointOnPlane(
-    camera,
-    rect.maxX,
-    rect.minY,
-    farClipPlane
-  );
-  const farBottomLeft = createPointOnPlane(
-    camera,
-    rect.minX,
-    rect.minY,
-    farClipPlane
+  const [farTopLeft, farTopRight, farBottomRight, farBottomLeft] = quad.map(
+    (point) => createPointOnPlane(camera, point.x, point.y, farClipPlane)
   );
   plane.setFromNormalAndCoplanarPoint(selectionForward, nearCenter);
   const nearPlane = plane.clone();
-  const nearTopLeft = createPointOnPlane(
-    camera,
-    rect.minX,
-    rect.maxY,
-    nearPlane
-  );
-  const nearTopRight = createPointOnPlane(
-    camera,
-    rect.maxX,
-    rect.maxY,
-    nearPlane
-  );
-  const nearBottomRight = createPointOnPlane(
-    camera,
-    rect.maxX,
-    rect.minY,
-    nearPlane
-  );
-  const nearBottomLeft = createPointOnPlane(
-    camera,
-    rect.minX,
-    rect.minY,
-    nearPlane
+  const [nearTopLeft, nearTopRight, nearBottomRight, nearBottomLeft] = quad.map(
+    (point) => createPointOnPlane(camera, point.x, point.y, nearPlane)
   );
   if (!farTopLeft || !farTopRight || !farBottomRight || !farBottomLeft || !nearTopLeft || !nearTopRight || !nearBottomRight || !nearBottomLeft) {
     return null;
@@ -68306,8 +68827,21 @@ function createFrustumData(camera, rect, depthRange) {
     selectionForward: selectionForward.toArray()
   };
 }
+function createFrustumData(camera, rect, depthRange) {
+  return createFrustumDataFromQuad(
+    camera,
+    [
+      { x: rect.minX, y: rect.maxY },
+      { x: rect.maxX, y: rect.maxY },
+      { x: rect.maxX, y: rect.minY },
+      { x: rect.minX, y: rect.minY }
+    ],
+    depthRange
+  );
+}
 function createSelectionData({
   camera,
+  clientPoints,
   domElement,
   end,
   getDepthRange,
@@ -68317,19 +68851,27 @@ function createSelectionData({
   if (domRect.width <= 0 || domRect.height <= 0) {
     return null;
   }
-  const clientRect = getClientSelectionRect(start, end);
+  const hasClientQuad = Array.isArray(clientPoints) && clientPoints.length === 4;
+  const points = hasClientQuad ? clientPoints : getClientSelectionQuad(start, end);
+  const clientRect = {
+    maxX: Math.max(...points.map((point) => point.x)),
+    maxY: Math.max(...points.map((point) => point.y)),
+    minX: Math.min(...points.map((point) => point.x)),
+    minY: Math.min(...points.map((point) => point.y))
+  };
   const width = clientRect.maxX - clientRect.minX;
   const height = clientRect.maxY - clientRect.minY;
   if (width * width + height * height < SCREEN_SELECTION_MIN_DRAG_DISTANCE_SQ) {
     return null;
   }
-  const rect = getNdcSelectionRect(clientRect, domRect);
+  const quad = getNdcSelectionQuad(points, domRect);
+  const rect = hasClientQuad ? getNdcBounds(quad) : getNdcSelectionRect(clientRect, domRect);
   camera.updateProjectionMatrix();
   camera.updateMatrixWorld(true);
   cameraPosition.copy(camera.position);
   const depthRange = normalizeDepthRange(camera, getDepthRange());
   const viewProjectionMatrix = new Matrix4().multiplyMatrices(camera.projectionMatrix, camera.matrixWorldInverse).toArray();
-  const frustum = createFrustumData(camera, rect, depthRange);
+  const frustum = hasClientQuad ? createFrustumDataFromQuad(camera, quad, depthRange) : createFrustumData(camera, rect, depthRange);
   if (!frustum) {
     return null;
   }
@@ -68687,6 +69229,8 @@ function createScreenSelectionPointerTracker({
   camera,
   domElement,
   getDepthRange,
+  onOverlayClear,
+  onOverlayUpdate,
   onSelectionCreated,
   overlayEl,
   rectEl
@@ -68695,8 +69239,18 @@ function createScreenSelectionPointerTracker({
   let drag = null;
   function clearDrag() {
     drag = null;
+    onOverlayClear?.();
     clearOverlay(overlayEl, rectEl);
   }
+  function updateDragOverlay() {
+    const clientRect = {
+      ...getClientSelectionRect(drag.start, drag.current)
+    };
+    if (onOverlayUpdate?.(clientRect) === true) {
+      return;
+    }
+    updateOverlayRect(overlayEl, rectEl, clientRect);
+  }
   function setActive(nextActive) {
     active = !!nextActive;
     if (!active) {
@@ -68715,11 +69269,7 @@ function createScreenSelectionPointerTracker({
       start: dragStart.clone(),
       current: dragCurrent.clone()
     };
-    updateOverlayRect(
-      overlayEl,
-      rectEl,
-      getClientSelectionRect(drag.start, drag.current)
-    );
+    updateDragOverlay();
     domElement.setPointerCapture?.(event.pointerId);
     event.preventDefault();
     event.stopPropagation();
@@ -68731,11 +69281,7 @@ function createScreenSelectionPointerTracker({
     }
     const domRect = domElement.getBoundingClientRect();
     getClampedClientPoint(event, domRect, drag.current);
-    updateOverlayRect(
-      overlayEl,
-      rectEl,
-      getClientSelectionRect(drag.start, drag.current)
-    );
+    updateDragOverlay();
     event.preventDefault();
     event.stopPropagation();
     return true;
@@ -68744,6 +69290,9 @@ function createScreenSelectionPointerTracker({
     if (!active || !drag || event.pointerId !== drag.pointerId) {
       return false;
     }
+    const clientRect = {
+      ...getClientSelectionRect(drag.start, drag.current)
+    };
     const selection = createSelectionData({
       camera,
       domElement,
@@ -68753,7 +69302,7 @@ function createScreenSelectionPointerTracker({
     });
     domElement.releasePointerCapture?.(event.pointerId);
     clearDrag();
-    onSelectionCreated(selection);
+    onSelectionCreated(selection, clientRect);
     event.preventDefault();
     event.stopPropagation();
     return true;
@@ -68832,6 +69381,56 @@ function getScreenSelectionPayload(selection) {
     viewProjectionMatrix: selection.viewProjectionMatrix.slice()
   };
 }
+function setScreenSelectionShape(selection, {
+  cameraPosition: sourceCameraPosition,
+  depthRange,
+  farPlane,
+  planeMatrices,
+  rect,
+  selectionForward: sourceSelectionForward,
+  viewProjectionMatrix
+}, currentTransformMatrix) {
+  if (!selection) {
+    return;
+  }
+  const previousFarDepth = Number(selection.depthRange?.farDepth);
+  const copiedPlaneMatrices = planeMatrices.map((matrix) => matrix.slice());
+  const referenceTransformMatrix = copyMatrix4Array(currentTransformMatrix);
+  selection.basePlaneMatrices = copiedPlaneMatrices.map(
+    (matrix) => matrix.slice()
+  );
+  selection.cameraPosition = copyVectorArray(sourceCameraPosition);
+  selection.currentTransformMatrix = referenceTransformMatrix.slice();
+  selection.depthRange = copyDepthRange(depthRange);
+  selection.farPlane = copyFarPlane(farPlane);
+  selection.planeMatrices = copiedPlaneMatrices;
+  selection.referenceTransformMatrix = referenceTransformMatrix;
+  selection.rect = copyRect(rect);
+  selection.selectionForward = copyVectorArray(sourceSelectionForward, [
+    0,
+    0,
+    -1
+  ]);
+  selection.viewProjectionMatrix = viewProjectionMatrix.slice();
+  updateScreenSelectionWorldState(selection, currentTransformMatrix);
+  if (!Number.isFinite(previousFarDepth)) {
+    return;
+  }
+  const nextFarDepth = Math.min(
+    selection.depthRange.maxFarDepth,
+    Math.max(
+      selection.depthRange.nearDepth + SCREEN_SELECTION_MIN_DEPTH_RANGE,
+      previousFarDepth
+    )
+  );
+  if (Math.abs(nextFarDepth - selection.depthRange.farDepth) > 1e-9) {
+    setScreenSelectionFarDepth(
+      selection,
+      nextFarDepth,
+      currentTransformMatrix
+    );
+  }
+}
 function updateScreenSelectionWorldState(selection, currentTransformMatrix, active = selection?.farHandle?.visible) {
   if (!selection) {
     return;
@@ -68876,6 +69475,313 @@ var init_screenSelection = __esm({
   }
 });
 
+// src/viewer/screenSelection/editOverlay.js
+function clampValue(value, min, max) {
+  return Math.min(max, Math.max(min, value));
+}
+function copyClientPoint(point) {
+  return {
+    x: Number(point?.x) || 0,
+    y: Number(point?.y) || 0
+  };
+}
+function copyClientPoints(points) {
+  return points.map(copyClientPoint);
+}
+function getClientPointsBounds(points) {
+  const xs2 = points.map((point) => point.x);
+  const ys2 = points.map((point) => point.y);
+  return {
+    maxX: Math.max(...xs2),
+    maxY: Math.max(...ys2),
+    minX: Math.min(...xs2),
+    minY: Math.min(...ys2)
+  };
+}
+function getClientRectPoints(rect) {
+  return [
+    { x: Number(rect?.minX) || 0, y: Number(rect?.minY) || 0 },
+    { x: Number(rect?.maxX) || 0, y: Number(rect?.minY) || 0 },
+    { x: Number(rect?.maxX) || 0, y: Number(rect?.maxY) || 0 },
+    { x: Number(rect?.minX) || 0, y: Number(rect?.maxY) || 0 }
+  ];
+}
+function clampClientPoint(point, domRect) {
+  return {
+    x: clampValue(point.x, domRect.left, domRect.right),
+    y: clampValue(point.y, domRect.top, domRect.bottom)
+  };
+}
+function clampClientPoints(points, domElement) {
+  const domRect = domElement.getBoundingClientRect();
+  return points.map((point) => clampClientPoint(point, domRect));
+}
+function getPointTurnCross(a2, b5, c2) {
+  return (b5.x - a2.x) * (c2.y - b5.y) - (b5.y - a2.y) * (c2.x - b5.x);
+}
+function isConvexClientQuad(points) {
+  if (!Array.isArray(points) || points.length !== 4) {
+    return false;
+  }
+  let turnSign = 0;
+  for (let index = 0; index < points.length; index++) {
+    const cross = getPointTurnCross(
+      points[index],
+      points[(index + 1) % points.length],
+      points[(index + 2) % points.length]
+    );
+    if (Math.abs(cross) <= SCREEN_EDIT_MIN_CONVEX_CROSS_ABS) {
+      return false;
+    }
+    const nextSign = Math.sign(cross);
+    if (turnSign === 0) {
+      turnSign = nextSign;
+    } else if (nextSign !== turnSign) {
+      return false;
+    }
+  }
+  return true;
+}
+function getPartPoint(points, part) {
+  const indices = SCREEN_EDIT_PART_POINT_INDICES[part] || [];
+  if (indices.length === 0) {
+    return { x: 0, y: 0 };
+  }
+  const x5 = indices.reduce((total, index) => total + points[index].x, 0) / indices.length;
+  const y6 = indices.reduce((total, index) => total + points[index].y, 0) / indices.length;
+  return { x: x5, y: y6 };
+}
+function getPartAngle(points, part) {
+  const indices = SCREEN_EDIT_PART_POINT_INDICES[part] || [];
+  if (indices.length !== 2) {
+    return null;
+  }
+  const start = points[indices[0]];
+  const end = points[indices[1]];
+  return Math.atan2(end.y - start.y, end.x - start.x);
+}
+function getPartLength(points, part) {
+  const indices = SCREEN_EDIT_PART_POINT_INDICES[part] || [];
+  if (indices.length !== 2) {
+    return null;
+  }
+  const start = points[indices[0]];
+  const end = points[indices[1]];
+  return Math.hypot(end.x - start.x, end.y - start.y);
+}
+function interpolatePoint(a2, b5, t2) {
+  return {
+    x: a2.x + (b5.x - a2.x) * t2,
+    y: a2.y + (b5.y - a2.y) * t2
+  };
+}
+function updateScreenEditGrid(grid, localPoints, visible) {
+  if (!grid) {
+    return;
+  }
+  grid.replaceChildren();
+  grid.hidden = !visible;
+  if (!visible) {
+    return;
+  }
+  const [topLeft, topRight, bottomRight, bottomLeft] = localPoints;
+  for (let index = 1; index < SCREEN_EDIT_GRID_DIVISIONS; index++) {
+    const t2 = index / SCREEN_EDIT_GRID_DIVISIONS;
+    const top = interpolatePoint(topLeft, topRight, t2);
+    const bottom = interpolatePoint(bottomLeft, bottomRight, t2);
+    const left = interpolatePoint(topLeft, bottomLeft, t2);
+    const right = interpolatePoint(topRight, bottomRight, t2);
+    const verticalLine = document.createElementNS(
+      "http://www.w3.org/2000/svg",
+      "line"
+    );
+    const horizontalLine = document.createElementNS(
+      "http://www.w3.org/2000/svg",
+      "line"
+    );
+    verticalLine.setAttribute("x1", String(top.x));
+    verticalLine.setAttribute("y1", String(top.y));
+    verticalLine.setAttribute("x2", String(bottom.x));
+    verticalLine.setAttribute("y2", String(bottom.y));
+    horizontalLine.setAttribute("x1", String(left.x));
+    horizontalLine.setAttribute("y1", String(left.y));
+    horizontalLine.setAttribute("x2", String(right.x));
+    horizontalLine.setAttribute("y2", String(right.y));
+    grid.append(verticalLine, horizontalLine);
+  }
+}
+function ensureEditableRectHandles(rectEl) {
+  if (!rectEl || rectEl.dataset.editHandlesReady === "true") {
+    return;
+  }
+  const svg2 = document.createElementNS("http://www.w3.org/2000/svg", "svg");
+  const polygon = document.createElementNS(
+    "http://www.w3.org/2000/svg",
+    "polygon"
+  );
+  const grid = document.createElementNS("http://www.w3.org/2000/svg", "g");
+  svg2.classList.add("screen-selection-edit-svg");
+  grid.classList.add("screen-selection-edit-grid");
+  polygon.classList.add("screen-selection-edit-polygon");
+  svg2.append(polygon, grid);
+  rectEl.appendChild(svg2);
+  SCREEN_EDIT_HANDLE_PARTS.forEach((part) => {
+    const handle = document.createElement("span");
+    handle.classList.add(
+      "screen-selection-edit-handle",
+      `screen-selection-edit-${part}`
+    );
+    handle.dataset.editPart = part;
+    rectEl.appendChild(handle);
+  });
+  rectEl.dataset.editHandlesReady = "true";
+}
+function pointSegmentDistanceSq(point, start, end) {
+  const dx = end.x - start.x;
+  const dy = end.y - start.y;
+  const lengthSq = dx * dx + dy * dy;
+  if (lengthSq <= 1e-12) {
+    const px2 = point.x - start.x;
+    const py2 = point.y - start.y;
+    return px2 * px2 + py2 * py2;
+  }
+  const t2 = clampValue(
+    ((point.x - start.x) * dx + (point.y - start.y) * dy) / lengthSq,
+    0,
+    1
+  );
+  const x5 = start.x + dx * t2;
+  const y6 = start.y + dy * t2;
+  const px = point.x - x5;
+  const py = point.y - y6;
+  return px * px + py * py;
+}
+function createScreenEditOverlay({ overlayEl, rectEl }) {
+  let activePart = null;
+  function applyActivePart() {
+    SCREEN_EDIT_HANDLE_PARTS.forEach((part) => {
+      const handle = rectEl?.querySelector(`[data-edit-part="${part}"]`);
+      handle?.classList.toggle("active", part === activePart);
+    });
+  }
+  function render(clientPoints, { showGrid = false } = {}) {
+    ensureEditableRectHandles(rectEl);
+    rectEl?.classList.add("editable");
+    rectEl?.classList.toggle("drawing", showGrid);
+    const bounds = getClientPointsBounds(clientPoints);
+    updateOverlayRect(overlayEl, rectEl, bounds);
+    const width = Math.max(1, bounds.maxX - bounds.minX);
+    const height = Math.max(1, bounds.maxY - bounds.minY);
+    const localPoints = clientPoints.map((point) => ({
+      x: point.x - bounds.minX,
+      y: point.y - bounds.minY
+    }));
+    const svg2 = rectEl?.querySelector(".screen-selection-edit-svg");
+    const polygon = rectEl?.querySelector(".screen-selection-edit-polygon");
+    const grid = rectEl?.querySelector(".screen-selection-edit-grid");
+    svg2?.setAttribute("viewBox", `0 0 ${width} ${height}`);
+    polygon?.setAttribute(
+      "points",
+      localPoints.map((point) => `${point.x},${point.y}`).join(" ")
+    );
+    updateScreenEditGrid(grid, localPoints, showGrid);
+    SCREEN_EDIT_HANDLE_PARTS.forEach((part) => {
+      const point = getPartPoint(localPoints, part);
+      const handle = rectEl?.querySelector(`[data-edit-part="${part}"]`);
+      if (!handle) {
+        return;
+      }
+      handle.style.left = `${point.x}px`;
+      handle.style.top = `${point.y}px`;
+      const angle = getPartAngle(localPoints, part);
+      const length = getPartLength(localPoints, part);
+      if (length != null) {
+        const maxVisualLength = Math.max(0, length - 2);
+        const visualLength = Math.max(
+          0,
+          Math.min(SCREEN_EDIT_EDGE_HANDLE_MAX_LENGTH, maxVisualLength)
+        );
+        const activeScaleX = visualLength > 0 ? Math.min(
+          SCREEN_EDIT_EDGE_HANDLE_ACTIVE_SCALE_X,
+          Math.max(1, maxVisualLength / visualLength)
+        ) : 1;
+        handle.style.width = `${visualLength}px`;
+        handle.style.height = `${length <= SCREEN_EDIT_EDGE_HANDLE_MIN_LENGTH ? 2 : 4}px`;
+        handle.style.setProperty(
+          "--screen-selection-edit-active-scale-x",
+          String(activeScaleX)
+        );
+        handle.style.setProperty(
+          "--screen-selection-edit-active-scale-y",
+          String(SCREEN_EDIT_EDGE_HANDLE_ACTIVE_SCALE_Y)
+        );
+      } else {
+        handle.style.width = "";
+        handle.style.height = "";
+        handle.style.removeProperty("--screen-selection-edit-active-scale-x");
+        handle.style.removeProperty("--screen-selection-edit-active-scale-y");
+      }
+      handle.style.transform = angle == null ? "translate(-50%, -50%)" : `translate(-50%, -50%) rotate(${angle}rad)`;
+    });
+    applyActivePart();
+  }
+  function clear() {
+    activePart = null;
+    rectEl?.classList.remove("drawing", "editable");
+    applyActivePart();
+  }
+  function setActivePart(part) {
+    activePart = SCREEN_EDIT_HANDLE_PARTS.includes(part) ? part : null;
+    applyActivePart();
+  }
+  return {
+    clear,
+    render,
+    setActivePart
+  };
+}
+var SCREEN_EDIT_EDGE_HIT_SIZE, SCREEN_EDIT_CORNER_HIT_SIZE, SCREEN_EDIT_EDGE_HANDLE_MAX_LENGTH, SCREEN_EDIT_EDGE_HANDLE_MIN_LENGTH, SCREEN_EDIT_EDGE_HANDLE_ACTIVE_SCALE_X, SCREEN_EDIT_EDGE_HANDLE_ACTIVE_SCALE_Y, SCREEN_EDIT_GRID_DIVISIONS, SCREEN_EDIT_MIN_CONVEX_CROSS_ABS, SCREEN_EDIT_HANDLE_PARTS, SCREEN_EDIT_CORNER_PARTS, SCREEN_EDIT_EDGE_PARTS, SCREEN_EDIT_PART_POINT_INDICES;
+var init_editOverlay = __esm({
+  "src/viewer/screenSelection/editOverlay.js"() {
+    init_geometry();
+    SCREEN_EDIT_EDGE_HIT_SIZE = 8;
+    SCREEN_EDIT_CORNER_HIT_SIZE = 16;
+    SCREEN_EDIT_EDGE_HANDLE_MAX_LENGTH = 26;
+    SCREEN_EDIT_EDGE_HANDLE_MIN_LENGTH = 6;
+    SCREEN_EDIT_EDGE_HANDLE_ACTIVE_SCALE_X = 1.5;
+    SCREEN_EDIT_EDGE_HANDLE_ACTIVE_SCALE_Y = 1.5;
+    SCREEN_EDIT_GRID_DIVISIONS = 8;
+    SCREEN_EDIT_MIN_CONVEX_CROSS_ABS = 1e-3;
+    SCREEN_EDIT_HANDLE_PARTS = [
+      "top-left",
+      "top",
+      "top-right",
+      "right",
+      "bottom-right",
+      "bottom",
+      "bottom-left",
+      "left"
+    ];
+    SCREEN_EDIT_CORNER_PARTS = [
+      "top-left",
+      "top-right",
+      "bottom-right",
+      "bottom-left"
+    ];
+    SCREEN_EDIT_EDGE_PARTS = ["top", "right", "bottom", "left"];
+    SCREEN_EDIT_PART_POINT_INDICES = {
+      "bottom-left": [3],
+      "bottom-right": [2],
+      bottom: [2, 3],
+      left: [3, 0],
+      right: [1, 2],
+      top: [0, 1],
+      "top-left": [0],
+      "top-right": [1]
+    };
+  }
+});
+
 // src/viewer/dom/cropUi.js
 function updateCropControls({
   activeScreenSelectionId,
@@ -68993,9 +69899,13 @@ function createCropController({
   let nextSelectionId = 1;
   let activeSelectionId = null;
   let pendingMode = false;
+  let pendingScreenEdit = null;
+  let pendingEditDrag = null;
+  let editCursor = "";
   let hasGaussianSplats = false;
   const sphere = new Sphere();
   const cameraForward2 = new Vector3();
+  const screenEditOverlay = createScreenEditOverlay({ overlayEl, rectEl });
   function getActiveSelection() {
     if (activeSelectionId == null) {
       return null;
@@ -69011,6 +69921,115 @@ function createCropController({
       }))
     ];
   }
+  function setEditCursor(cursor) {
+    const nextCursor = cursor || "";
+    if (editCursor === nextCursor) {
+      return;
+    }
+    domElement.style.cursor = nextCursor;
+    editCursor = nextCursor;
+  }
+  function clearEditCursor() {
+    setEditCursor("");
+  }
+  function getActivePendingEdit() {
+    if (!pendingScreenEdit || activeSelectionId !== pendingScreenEdit.selectionId) {
+      return null;
+    }
+    const match = pendingSelections.find(
+      (selection) => selection.id === pendingScreenEdit.selectionId
+    );
+    return match ? pendingScreenEdit : null;
+  }
+  function clearScreenEditOverlay() {
+    screenEditOverlay.clear();
+    clearEditCursor();
+  }
+  function syncPendingEditOverlay() {
+    const edit = getActivePendingEdit();
+    if (!edit) {
+      clearScreenEditOverlay();
+      if (!pendingMode) {
+        clearOverlay(overlayEl, rectEl);
+      }
+      return;
+    }
+    screenEditOverlay.render(edit.clientPoints, { showGrid: false });
+  }
+  function createCameraPoseSnapshot() {
+    camera.updateMatrixWorld(true);
+    return {
+      position: camera.position.toArray(),
+      projectionMatrix: camera.projectionMatrix.toArray(),
+      quaternion: camera.quaternion.toArray()
+    };
+  }
+  function projectionChanged(source, target) {
+    if (!Array.isArray(source) || !Array.isArray(target)) {
+      return true;
+    }
+    return source.some(
+      (value, index) => Math.abs(value - target[index]) > CAMERA_PROJECTION_EPSILON
+    );
+  }
+  function cameraPoseChanged(cameraPose) {
+    if (!cameraPose) {
+      return true;
+    }
+    camera.updateMatrixWorld(true);
+    const dx = camera.position.x - cameraPose.position[0];
+    const dy = camera.position.y - cameraPose.position[1];
+    const dz = camera.position.z - cameraPose.position[2];
+    if (dx * dx + dy * dy + dz * dz > CAMERA_POSITION_EPSILON_SQ) {
+      return true;
+    }
+    const quaternion = cameraPose.quaternion;
+    const quaternionDot = Math.abs(
+      camera.quaternion.x * quaternion[0] + camera.quaternion.y * quaternion[1] + camera.quaternion.z * quaternion[2] + camera.quaternion.w * quaternion[3]
+    );
+    if (1 - Math.min(1, quaternionDot) > CAMERA_QUATERNION_EPSILON) {
+      return true;
+    }
+    return projectionChanged(
+      camera.projectionMatrix.toArray(),
+      cameraPose.projectionMatrix
+    );
+  }
+  function clearPendingScreenEdit() {
+    pendingScreenEdit = null;
+    pendingEditDrag = null;
+    syncPendingEditOverlay();
+  }
+  function freezePendingScreenEdit(showStatus = false) {
+    const hadEdit = !!pendingScreenEdit;
+    if (!hadEdit) {
+      return false;
+    }
+    clearPendingScreenEdit();
+    if (showStatus) {
+      setStatus(
+        "Screen selection shape fixed after camera movement. Drag the 3D far plane, then Confirm or Cancel."
+      );
+    }
+    return true;
+  }
+  function freezePendingScreenEditIfCameraChanged() {
+    if (!pendingScreenEdit || pendingEditDrag) {
+      return false;
+    }
+    if (!cameraPoseChanged(pendingScreenEdit.cameraPose)) {
+      return false;
+    }
+    return freezePendingScreenEdit(true);
+  }
+  function createPendingScreenEdit(selection, clientRect) {
+    pendingScreenEdit = {
+      cameraPose: createCameraPoseSnapshot(),
+      clientPoints: clampClientPoints(getClientRectPoints(clientRect), domElement),
+      selectionId: selection.id
+    };
+    syncPendingEditOverlay();
+  }
   function syncWorldState() {
     const transform = getCurrentRootTransformArray();
     getEntries().forEach(({ selection }) => {
@@ -69090,10 +70109,171 @@ function createCropController({
     camera,
     domElement,
     getDepthRange,
+    onOverlayClear: clearScreenEditOverlay,
+    onOverlayUpdate: (clientRect) => {
+      screenEditOverlay.render(getClientRectPoints(clientRect), {
+        showGrid: true
+      });
+      return true;
+    },
     onSelectionCreated: handleSelectionCreated,
     overlayEl,
     rectEl
   });
+  function createEditHit(part) {
+    return { cursor: "grab", part };
+  }
+  function getPendingEditHit(event) {
+    if (freezePendingScreenEditIfCameraChanged()) {
+      return null;
+    }
+    const edit = getActivePendingEdit();
+    if (!edit) {
+      return null;
+    }
+    const pointer = { x: event.clientX, y: event.clientY };
+    for (const part of SCREEN_EDIT_CORNER_PARTS) {
+      const point = getPartPoint(edit.clientPoints, part);
+      const dx = pointer.x - point.x;
+      const dy = pointer.y - point.y;
+      if (dx * dx + dy * dy <= SCREEN_EDIT_CORNER_HIT_SIZE ** 2) {
+        return createEditHit(part);
+      }
+    }
+    for (const part of SCREEN_EDIT_EDGE_PARTS) {
+      const [startIndex, endIndex] = SCREEN_EDIT_PART_POINT_INDICES[part];
+      if (pointSegmentDistanceSq(
+        pointer,
+        edit.clientPoints[startIndex],
+        edit.clientPoints[endIndex]
+      ) <= SCREEN_EDIT_EDGE_HIT_SIZE ** 2) {
+        return createEditHit(part);
+      }
+    }
+    return null;
+  }
+  function getPendingEditDragPoints(event) {
+    const { part, startClientX, startClientY, startPoints } = pendingEditDrag;
+    const domRect = domElement.getBoundingClientRect();
+    const indices = SCREEN_EDIT_PART_POINT_INDICES[part] || [];
+    let dx = event.clientX - startClientX;
+    let dy = event.clientY - startClientY;
+    indices.forEach((index) => {
+      const point = startPoints[index];
+      dx = Math.max(dx, domRect.left - point.x);
+      dx = Math.min(dx, domRect.right - point.x);
+      dy = Math.max(dy, domRect.top - point.y);
+      dy = Math.min(dy, domRect.bottom - point.y);
+    });
+    return startPoints.map(
+      (point, index) => indices.includes(index) ? {
+        x: point.x + dx,
+        y: point.y + dy
+      } : copyClientPoint(point)
+    );
+  }
+  function updatePendingEditSelection(clientPoints) {
+    const edit = getActivePendingEdit();
+    if (!edit) {
+      return false;
+    }
+    const match = findSelection(edit.selectionId);
+    if (!match) {
+      return false;
+    }
+    if (!isConvexClientQuad(clientPoints)) {
+      return false;
+    }
+    const selectionData = createSelectionData({
+      camera,
+      clientPoints,
+      domElement,
+      getDepthRange
+    });
+    if (!selectionData) {
+      return false;
+    }
+    edit.clientPoints = copyClientPoints(clientPoints);
+    setScreenSelectionShape(
+      match.selection,
+      selectionData,
+      getCurrentRootTransformArray()
+    );
+    syncPendingEditOverlay();
+    syncTransformControlsState();
+    return true;
+  }
+  function handlePendingEditPointerDown(event) {
+    if (event.button !== 0) {
+      return false;
+    }
+    const hit = getPendingEditHit(event);
+    if (!hit) {
+      return false;
+    }
+    pendingEditDrag = {
+      part: hit.part,
+      pointerId: event.pointerId,
+      startClientX: event.clientX,
+      startClientY: event.clientY,
+      startPoints: copyClientPoints(pendingScreenEdit.clientPoints),
+      updated: false
+    };
+    domElement.setPointerCapture?.(event.pointerId);
+    screenEditOverlay.setActivePart(hit.part);
+    setEditCursor("grabbing");
+    event.preventDefault();
+    event.stopPropagation();
+    return true;
+  }
+  function handlePendingEditPointerMove(event) {
+    if (pendingEditDrag) {
+      if (event.pointerId !== pendingEditDrag.pointerId) {
+        return false;
+      }
+      pendingEditDrag.updated = updatePendingEditSelection(getPendingEditDragPoints(event)) || pendingEditDrag.updated;
+      event.preventDefault();
+      event.stopPropagation();
+      return true;
+    }
+    if (event.buttons) {
+      return false;
+    }
+    const hit = getPendingEditHit(event);
+    screenEditOverlay.setActivePart(hit?.part);
+    setEditCursor(hit?.cursor || "");
+    return false;
+  }
+  function handlePendingEditPointerUp(event) {
+    if (!pendingEditDrag || event.pointerId !== pendingEditDrag.pointerId) {
+      return false;
+    }
+    domElement.releasePointerCapture?.(event.pointerId);
+    const updated = pendingEditDrag.updated;
+    pendingEditDrag = null;
+    const hit = getPendingEditHit(event);
+    screenEditOverlay.setActivePart(hit?.part);
+    setEditCursor(hit?.cursor || "");
+    setStatus(
+      updated ? "Updated screen selection convex quadrilateral." : "Screen selection must stay convex.",
+      !updated
+    );
+    event.preventDefault();
+    event.stopPropagation();
+    return true;
+  }
+  function handlePendingEditPointerCancel(event) {
+    if (!pendingEditDrag || event.pointerId !== pendingEditDrag.pointerId) {
+      return false;
+    }
+    domElement.releasePointerCapture?.(event.pointerId);
+    pendingEditDrag = null;
+    screenEditOverlay.setActivePart(null);
+    clearEditCursor();
+    event.preventDefault();
+    event.stopPropagation();
+    return true;
+  }
   function setMode(active) {
     pendingMode = active && hasGaussianSplats && pendingSelections.length === 0;
     pointerTracker.setActive(pendingMode);
@@ -69106,6 +70286,7 @@ function createCropController({
     }
     cameraController.enabled = !transformControls.dragging;
     syncTransformControlsState();
+    syncPendingEditOverlay();
     refreshUi();
   }
   function cancelMode() {
@@ -69114,7 +70295,7 @@ function createCropController({
     }
     setMode(false);
   }
-  function handleSelectionCreated(selectionData) {
+  function handleSelectionCreated(selectionData, clientRect) {
     if (pendingSelections.length > 0) {
       setMode(false);
       setStatus(
@@ -69136,12 +70317,13 @@ function createCropController({
     pendingSelections.push(selection);
     activeSelectionId = selection.id;
     setMode(false);
+    createPendingScreenEdit(selection, clientRect);
     syncEditSdfs();
     syncFarHandles();
     syncTransformControlsState();
     refreshUi();
     setStatus(
-      "Added screen exclude selection. Drag the 3D far plane, then Confirm or Cancel before drawing another."
+      "Added screen exclude selection. Drag corner points or edges into a convex quadrilateral before moving the camera, then adjust the 3D far plane and Confirm or Cancel."
     );
   }
   function toggle() {
@@ -69173,6 +70355,7 @@ function createCropController({
     }
     const count = pendingSelections.length;
     selections.push(...pendingSelections);
+    clearPendingScreenEdit();
     pendingSelections = [];
     activeSelectionId = null;
     setMode(false);
@@ -69193,6 +70376,7 @@ function createCropController({
     )) {
       activeSelectionId = null;
     }
+    clearPendingScreenEdit();
     pendingSelections.forEach(disposeScreenSelection);
     pendingSelections = [];
     syncEditSdfs();
@@ -69259,10 +70443,12 @@ function createCropController({
     setTransformMode(null);
     syncEditSdfs();
     syncFarHandles();
+    syncPendingEditOverlay();
     refreshUi();
     syncTransformControlsState();
+    const canEditPendingRect = !wasActive && !!getActivePendingEdit();
     setStatus(
-      wasActive ? "Screen selection deactivated." : "Drag the 3D far plane handle to adjust screen selection depth."
+      wasActive ? "Screen selection deactivated." : canEditPendingRect ? "Drag corner points or edges into a convex quadrilateral before moving the camera, or drag the 3D far plane to adjust depth." : "Drag the 3D far plane handle to adjust screen selection depth."
     );
   }
   function removeFromList(list, selectionId) {
@@ -69283,6 +70469,9 @@ function createCropController({
     if (Number(selectionId) === activeSelectionId) {
       activeSelectionId = null;
     }
+    if (Number(selectionId) === pendingScreenEdit?.selectionId) {
+      clearPendingScreenEdit();
+    }
     syncEditSdfs();
     syncFarHandles();
     refreshUi();
@@ -69300,6 +70489,7 @@ function createCropController({
     selections = [];
     pendingSelections = [];
     activeSelectionId = null;
+    clearPendingScreenEdit();
     syncEditSdfs();
     syncFarHandles();
     refreshUi();
@@ -69313,6 +70503,7 @@ function createCropController({
     activeSelectionId = null;
     syncEditSdfs();
     syncFarHandles();
+    syncPendingEditOverlay();
     cancelMode();
     refreshUi();
   }
@@ -69323,8 +70514,44 @@ function createCropController({
     activeSelectionId = null;
     syncEditSdfs();
     syncFarHandles();
+    syncPendingEditOverlay();
     refreshUi();
   }
+  function shouldCapturePointerDown(event) {
+    return event.button === 0 && (pendingMode || getPendingEditHit(event) !== null);
+  }
+  function handlePointerDown(event) {
+    if (pointerTracker.handlePointerDown(event)) {
+      return true;
+    }
+    return handlePendingEditPointerDown(event);
+  }
+  function handlePointerMove(event) {
+    if (pointerTracker.handlePointerMove(event)) {
+      return true;
+    }
+    return handlePendingEditPointerMove(event);
+  }
+  function handlePointerUp(event) {
+    if (pointerTracker.handlePointerUp(event)) {
+      return true;
+    }
+    return handlePendingEditPointerUp(event);
+  }
+  function handlePointerCancel(event) {
+    if (pointerTracker.handlePointerCancel(event)) {
+      return true;
+    }
+    return handlePendingEditPointerCancel(event);
+  }
+  cameraController.addEventListener(
+    "update",
+    freezePendingScreenEditIfCameraChanged
+  );
+  cameraController.addEventListener(
+    "finish",
+    freezePendingScreenEditIfCameraChanged
+  );
   return {
     cancel,
     cancelMode,
@@ -69334,25 +70561,32 @@ function createCropController({
     getActiveSelection,
     getPayload,
     getPendingMode: () => pendingMode,
-    handlePointerCancel: pointerTracker.handlePointerCancel,
-    handlePointerDown: pointerTracker.handlePointerDown,
-    handlePointerMove: pointerTracker.handlePointerMove,
-    handlePointerUp: pointerTracker.handlePointerUp,
+    handlePointerCancel,
+    handlePointerDown,
+    handlePointerMove,
+    handlePointerUp,
     handleSelectionRemove,
     handleSelectionSelect,
     handleTransformControlObjectChange,
     hasPendingSelections: () => pendingSelections.length > 0,
     notifyTransformModeChanged,
     setHasGaussianSplats,
+    shouldCapturePointerDown,
     syncWorldState,
     toggle
   };
 }
+var CAMERA_POSITION_EPSILON_SQ, CAMERA_QUATERNION_EPSILON, CAMERA_PROJECTION_EPSILON;
 var init_cropController = __esm({
   "src/viewer/screenSelection/cropController.js"() {
     init_three_module();
     init_screenSelection();
+    init_geometry();
+    init_editOverlay();
     init_cropUi();
+    CAMERA_POSITION_EPSILON_SQ = 1e-12;
+    CAMERA_QUATERNION_EPSILON = 1e-10;
+    CAMERA_PROJECTION_EPSILON = 1e-10;
   }
 });
 
@@ -69961,7 +71195,7 @@ var require_app = __commonJS({
       savedControlDisabledStates = null;
     }
     cameraController.setPointerDownFilter((event) => {
-      return !(cropController?.getPendingMode() && event.button === 0);
+      return !(cropController?.shouldCapturePointerDown(event) ?? false);
     });
     var { transformControls, transformControlsHelper } = createViewerTransformControls({
       camera,
@@ -69993,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,
@@ -70012,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,
@@ -70034,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,
@@ -70122,7 +71356,7 @@ var require_app = __commonJS({
     transformModeController.setMode(null);
     function moveCameraToTiles() {
       cancelPositionPickModes();
-      flyTo.moveCameraToTiles();
+      flyTo2.moveCameraToTiles();
     }
     function moveCameraToCoordinate() {
       cancelPositionPickModes();
@@ -70130,7 +71364,7 @@ var require_app = __commonJS({
       if (!coordinate) {
         return;
       }
-      flyTo.moveCameraToCoordinate(coordinate);
+      flyTo2.moveCameraToCoordinate(coordinate);
     }
     async function moveTilesToCoordinate() {
       cancelPositionPickModes();
@@ -70205,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(
@@ -70328,6 +71564,7 @@ var require_app = __commonJS({
     loadTileset(TILESET_URL);
     function frame() {
       cameraController.update();
+      flyTo2.update();
       rootTransform.flush();
       globeController.update();
       tiles?.update();