@babylonjs/core 8.37.0 → 8.37.2

package/Cameras/geospatialCamera.d.ts

@@ -3,85 +3,114 @@ import { Vector3, Matrix } from "../Maths/math.vector.js";
 import { Camera } from "./camera.js";
 import type { Scene } from "../scene.js";
 import type { MeshPredicate } from "../Culling/ray.core.js";
-import type { Nullable } from "../types.js";
+import { GeospatialLimits } from "./Limits/geospatialLimits.js";
+import { GeospatialCameraMovement } from "./geospatialCameraMovement.js";
+import type { IVector3Like } from "../Maths/math.like.js";
+import type { EasingFunction } from "../Animations/easing.js";
 type CameraOptions = {
     planetRadius: number;
-    minAltitude?: number;
-    maxAltitude?: number;
-    restingAltitude?: number;
 };
 /**
  * @experimental
  * This camera's movements are limited to a camera orbiting a globe, and as the API evolves it will introduce conversions between cartesian coordinates and true lat/long/alt
  *
  * Please note this is marked as experimental and the API (including the constructor!) will change until we remove that flag
- *
- * Still TODO:
- * - Pitch/yaw limits, input speeds
- * - ZoomToPoint
- * - Conversion between lat/long/alt and cartesian coordinates
  */
 export declare class GeospatialCamera extends Camera {
     inputs: GeospatialCameraInputsManager;
-    /** @internal */
-    _perFrameGeocentricTranslation: Vector3;
-    /** @internal */
-    _perFrameGeocentricRotation: Vector3;
-    /** @internal */
-    _perFrameZoom: number;
     /** If supplied, will be used when picking the globe */
     pickPredicate?: MeshPredicate;
-    /**
-     * Enables rotation around a specific point, instead of default rotation around center
-     * @internal
-     */
-    _alternateRotationPt: Nullable<Vector3>;
-    /** The point on the globe that we are anchoring around. If no alternate rotation point is supplied, this will represent the center of screen*/
-    get center(): Vector3;
-    private _tempGeocentricNormal;
-    private _tempRotationAxis;
-    private _tempRotationMatrix;
-    private _tempPickingRay;
+    /** Movement controller that turns input pixelDeltas into currentFrameDeltas used by camera*/
+    readonly movement: GeospatialCameraMovement;
     private _tempPosition;
     private _viewMatrix;
     private _isViewMatrixDirty;
     private _lookAtVector;
-    private _planetRadius;
-    private _minAltitude;
-    private _maxAltitude?;
-    private _maxCameraRadius?;
-    private _restingAltitude;
-    /** Target of camera when looking along lookAtVector from current position. This does not necessarily represent a point on the globe */
-    private get _target();
+    /** Behavior used for smooth flying animations */
+    private _flyingBehavior;
+    private _flyToTargets;
+    constructor(name: string, scene: Scene, options: CameraOptions, pickPredicate?: MeshPredicate);
+    private _center;
+    /** The point on the globe that we are anchoring around. If no alternate rotation point is supplied, this will represent the center of screen*/
+    get center(): Vector3;
+    /**
+     * Sets the camera position to orbit around a new center point
+     * @param center The world position (ECEF) to orbit around
+     */
+    set center(center: IVector3Like);
+    private _yaw;
+    /**
+     * Gets the camera's yaw (rotation around the geocentric normal) in radians
+     */
+    get yaw(): number;
+    /**
+     * Sets the camera's yaw (rotation around the geocentric normal)
+     * @param yaw The desired yaw angle in radians (0 = north, π/2 = east)
+     */
+    set yaw(yaw: number);
+    private _pitch;
+    /**
+     * Gets the camera's pitch (angle from looking straight at globe)
+     * Pitch is measured from looking straight down at planet center:
+     * - zero pitch = looking straight at planet center (down)
+     * - positive pitch = tilting up away from planet
+     * - π/2 pitch = looking at horizon (perpendicular to geocentric normal)
+     */
+    get pitch(): number;
+    /**
+     * Sets the camera's pitch (angle from looking straight at globe)
+     * @param pitch The desired pitch angle in radians (0 = looking at planet center, π/2 = looking at horizon)
+     */
+    set pitch(pitch: number);
+    private _radius;
+    get radius(): number;
+    /**
+     * Sets the camera's distance from the current center point
+     * @param radius The desired radius
+     */
+    set radius(radius: number);
+    protected _checkLimits(): void;
+    private _tempVect;
+    private _tempEast;
+    private _tempNorth;
+    private _tempUp;
+    private _setOrientation;
     /** The point around which the camera will geocentrically rotate. Uses center (pt we are anchored to) if no alternateRotationPt is defined */
     private get _geocentricRotationPt();
-    constructor(name: string, scene: Scene, options: CameraOptions, pickPredicate?: MeshPredicate);
+    /**
+     * If camera is actively in flight, will update the target properties and use up the remaining duration from original flyTo call
+     *
+     * To start a new flyTo curve entirely, call into flyToAsync again (it will stop the inflight animation)
+     * @param targetYaw
+     * @param targetPitch
+     * @param targetRadius
+     * @param targetCenter
+     */
+    updateFlyToDestination(targetYaw?: number, targetPitch?: number, targetRadius?: number, targetCenter?: Vector3): void;
+    /**
+     * Animate camera towards passed in property values. If undefined, will use current value
+     * @param targetYaw
+     * @param targetPitch
+     * @param targetRadius
+     * @param targetCenter
+     * @param flightDurationMs
+     * @param easingFunction
+     * @returns Promise that will return when the animation is complete (or interuppted by pointer input)
+     */
+    flyToAsync(targetYaw?: number, targetPitch?: number, targetRadius?: number, targetCenter?: Vector3, flightDurationMs?: number, easingFunction?: EasingFunction): Promise<void>;
+    private _limits;
+    get limits(): GeospatialLimits;
     private _resetToDefault;
     /** @internal */
     _getViewMatrix(): Matrix;
     /** @internal */
     _isSynchronizedViewMatrix(): boolean;
-    /**
-     * Applies rotation correction to the camera by calculating a changeOfBasis matrix from the camera's current position to the new position
-     * and transforming the lookAt and up vectors by that matrix before updating the camera position and marking the view matrix as dirty
-     * @param newPos The camera's desired position, before correction is applied
-     */
-    private _applyRotationCorrectionAndSetPos;
-    /**
-     * When the geocentric normal has any translation change (due to dragging), we must ensure the camera remains orbiting around the world origin
-     * We thus need to perform 2 correction steps
-     * 1. Translation correction that keeps the camera at the same radius as before the drag
-     * 2. Rotation correction that keeps the camera facing the globe (so that as we pan, the globe stays centered on screen)
-     */
     private _applyGeocentricTranslation;
     /**
      * This rotation keeps the camera oriented towards the globe as it orbits around it. This is different from cameraCentricRotation which is when the camera rotates around its own axis
      */
     private _applyGeocentricRotation;
-    private _clampZoomDistance;
     private _applyZoom;
-    private _moveCameraAlongVectorByDistance;
-    private get _pickAlongLook();
     _checkInputs(): void;
     attachControl(noPreventDefault?: boolean): void;
     detachControl(): void;

package/Cameras/geospatialCamera.js

@@ -1,66 +1,193 @@
 import { GeospatialCameraInputsManager } from "./geospatialCameraInputsManager.js";
 import { Vector3, Matrix, TmpVectors } from "../Maths/math.vector.js";
 import { Epsilon } from "../Maths/math.constants.js";
-import { Scalar } from "../Maths/math.scalar.js";
 import { Camera } from "./camera.js";
-import { Ray } from "../Culling/ray.js";
+import { GeospatialLimits } from "./Limits/geospatialLimits.js";
+import { ComputeLocalBasisToRefs, GeospatialCameraMovement } from "./geospatialCameraMovement.js";
+import { Vector3CopyToRef, Vector3Dot } from "../Maths/math.vector.functions.js";
+import { Clamp } from "../Maths/math.scalar.functions.js";
+import { InterpolatingBehavior } from "../Behaviors/Cameras/interpolatingBehavior.js";
 /**
  * @experimental
  * This camera's movements are limited to a camera orbiting a globe, and as the API evolves it will introduce conversions between cartesian coordinates and true lat/long/alt
  *
  * Please note this is marked as experimental and the API (including the constructor!) will change until we remove that flag
- *
- * Still TODO:
- * - Pitch/yaw limits, input speeds
- * - ZoomToPoint
- * - Conversion between lat/long/alt and cartesian coordinates
  */
 export class GeospatialCamera extends Camera {
+    constructor(name, scene, options, pickPredicate) {
+        super(name, new Vector3(), scene);
+        // Temp vars
+        this._tempPosition = new Vector3();
+        this._viewMatrix = new Matrix();
+        this._lookAtVector = new Vector3();
+        this._flyToTargets = new Map();
+        this._center = new Vector3();
+        this._yaw = 0;
+        this._pitch = 0;
+        this._radius = 0;
+        this._tempVect = new Vector3();
+        this._tempEast = new Vector3();
+        this._tempNorth = new Vector3();
+        this._tempUp = new Vector3();
+        this._limits = new GeospatialLimits(options.planetRadius);
+        this._resetToDefault(this._limits);
+        this._flyingBehavior = new InterpolatingBehavior();
+        this.addBehavior(this._flyingBehavior);
+        this.movement = new GeospatialCameraMovement(scene, this._limits, this.position, this.center, this._lookAtVector, pickPredicate);
+        this.pickPredicate = pickPredicate;
+        this.inputs = new GeospatialCameraInputsManager(this);
+        this.inputs.addMouse().addMouseWheel().addKeyboard();
+    }
     /** The point on the globe that we are anchoring around. If no alternate rotation point is supplied, this will represent the center of screen*/
     get center() {
-        // NOTE that for now we are falling back to target if no pick on globe (because that shouldn't happen with current implemented inputs)
-        // but eventually we want to return a point on the globe even if the camera is looking off into space
-        return this._pickAlongLook?.pickedPoint ?? this._target;
+        return this._center;
+    }
+    /**
+     * Sets the camera position to orbit around a new center point
+     * @param center The world position (ECEF) to orbit around
+     */
+    set center(center) {
+        this._center.copyFromFloats(center.x, center.y, center.z);
+        this._setOrientation(this._yaw, this._pitch, this._radius, this._center);
+    }
+    /**
+     * Gets the camera's yaw (rotation around the geocentric normal) in radians
+     */
+    get yaw() {
+        return this._yaw;
+    }
+    /**
+     * Sets the camera's yaw (rotation around the geocentric normal)
+     * @param yaw The desired yaw angle in radians (0 = north, π/2 = east)
+     */
+    set yaw(yaw) {
+        this._setOrientation(yaw, this.pitch, this.radius, this.center);
     }
-    /** Target of camera when looking along lookAtVector from current position. This does not necessarily represent a point on the globe */
-    get _target() {
-        return this.position.addToRef(this._lookAtVector, this._tempPosition);
+    /**
+     * Gets the camera's pitch (angle from looking straight at globe)
+     * Pitch is measured from looking straight down at planet center:
+     * - zero pitch = looking straight at planet center (down)
+     * - positive pitch = tilting up away from planet
+     * - π/2 pitch = looking at horizon (perpendicular to geocentric normal)
+     */
+    get pitch() {
+        return this._pitch;
+    }
+    /**
+     * Sets the camera's pitch (angle from looking straight at globe)
+     * @param pitch The desired pitch angle in radians (0 = looking at planet center, π/2 = looking at horizon)
+     */
+    set pitch(pitch) {
+        this._setOrientation(this.yaw, pitch, this.radius, this.center);
+    }
+    get radius() {
+        return this._radius;
+    }
+    /**
+     * Sets the camera's distance from the current center point
+     * @param radius The desired radius
+     */
+    set radius(radius) {
+        this._setOrientation(this.yaw, this.pitch, radius, this.center);
+    }
+    _checkLimits() {
+        const limits = this.limits;
+        this._yaw = Clamp(this._yaw, limits.yawMin, limits.yawMax);
+        this._pitch = Clamp(this._pitch, limits.pitchMin, limits.pitchMax);
+        this._radius = Clamp(this._radius, limits.radiusMin, limits.radiusMax);
+    }
+    _setOrientation(yaw, pitch, radius, center) {
+        this._yaw = yaw;
+        this._pitch = pitch;
+        this._radius = radius;
+        Vector3CopyToRef(center, this._center);
+        // Clamp to limits
+        this._checkLimits();
+        // Refresh local basis at center (treat these as read-only for the whole call)
+        ComputeLocalBasisToRefs(this._center, this._tempEast, this._tempNorth, this._tempUp);
+        // Trig
+        const yawScale = this._scene.useRightHandedSystem ? 1 : -1;
+        const cosYaw = Math.cos(this._yaw * yawScale);
+        const sinYaw = Math.sin(this._yaw * yawScale);
+        const sinPitch = Math.sin(this._pitch); // horizontal weight
+        const cosPitch = Math.cos(this._pitch); // vertical weight (toward center)
+        // Temps
+        const horiz = TmpVectors.Vector3[0];
+        const t1 = TmpVectors.Vector3[1];
+        const t2 = TmpVectors.Vector3[2];
+        const right = TmpVectors.Vector3[3];
+        // horizontalDirection = North*cosYaw + East*sinYaw  (avoids mutating _temp basis vectors)
+        horiz.copyFrom(this._tempNorth).scaleInPlace(cosYaw).addInPlace(t1.copyFrom(this._tempEast).scaleInPlace(sinYaw));
+        // look = horiz*sinPitch - Up*cosPitch
+        this._lookAtVector.copyFrom(horiz).scaleInPlace(sinPitch).addInPlace(t2.copyFrom(this._tempUp).scaleInPlace(-cosPitch)).normalize(); // keep it unit
+        // Build an orthonormal up aligned with geocentric Up
+        // right = normalize(cross(upRef, look))
+        Vector3.CrossToRef(this._tempUp, this._lookAtVector, right);
+        // up = normalize(cross(look, right))
+        Vector3.CrossToRef(this._lookAtVector, right, this.upVector);
+        // Position = center - look * radius  (preserve unit look)
+        this._tempVect.copyFrom(this._lookAtVector).scaleInPlace(-this._radius);
+        this._tempPosition.copyFrom(this._center).addInPlace(this._tempVect);
+        this._position.copyFrom(this._tempPosition);
+        this._isViewMatrixDirty = true;
     }
     /** The point around which the camera will geocentrically rotate. Uses center (pt we are anchored to) if no alternateRotationPt is defined */
     get _geocentricRotationPt() {
-        return this._alternateRotationPt ?? this.center;
+        return this.movement.alternateRotationPt ?? this.center;
     }
-    constructor(name, scene, options, pickPredicate) {
-        super(name, Vector3.Zero(), scene);
-        this._resetToDefault(options);
-        this.pickPredicate = pickPredicate;
-        this.inputs = new GeospatialCameraInputsManager(this);
-        this.inputs.addMouse().addMouseWheel();
+    /**
+     * If camera is actively in flight, will update the target properties and use up the remaining duration from original flyTo call
+     *
+     * To start a new flyTo curve entirely, call into flyToAsync again (it will stop the inflight animation)
+     * @param targetYaw
+     * @param targetPitch
+     * @param targetRadius
+     * @param targetCenter
+     */
+    updateFlyToDestination(targetYaw, targetPitch, targetRadius, targetCenter) {
+        this._flyToTargets.clear();
+        this._flyToTargets.set("yaw", targetYaw);
+        this._flyToTargets.set("pitch", targetPitch);
+        this._flyToTargets.set("radius", targetRadius);
+        this._flyToTargets.set("center", targetCenter);
+        this._flyingBehavior.updateProperties(this._flyToTargets);
+    }
+    /**
+     * Animate camera towards passed in property values. If undefined, will use current value
+     * @param targetYaw
+     * @param targetPitch
+     * @param targetRadius
+     * @param targetCenter
+     * @param flightDurationMs
+     * @param easingFunction
+     * @returns Promise that will return when the animation is complete (or interuppted by pointer input)
+     */
+    async flyToAsync(targetYaw, targetPitch, targetRadius, targetCenter, flightDurationMs = 1000, easingFunction) {
+        this._flyToTargets.clear();
+        this._flyToTargets.set("yaw", targetYaw);
+        this._flyToTargets.set("pitch", targetPitch);
+        this._flyToTargets.set("radius", targetRadius);
+        this._flyToTargets.set("center", targetCenter);
+        return await this._flyingBehavior.animatePropertiesAsync(this._flyToTargets, flightDurationMs, easingFunction);
+    }
+    get limits() {
+        return this._limits;
     }
-    _resetToDefault(options) {
+    _resetToDefault(limits) {
         // Camera configuration vars
-        this._minAltitude = options.minAltitude ?? 5;
-        this._maxAltitude = options.maxAltitude;
-        this._planetRadius = options.planetRadius;
-        this._maxCameraRadius = this._maxAltitude ? this._planetRadius + this._maxAltitude : undefined;
-        this._restingAltitude = options.restingAltitude ?? this._maxCameraRadius ?? this._planetRadius * 4;
-        this.position.copyFromFloats(0, 0, -this._restingAltitude);
-        // Input vars
-        this._perFrameGeocentricRotation = Vector3.Zero();
-        this._perFrameGeocentricTranslation = Vector3.Zero();
-        this._perFrameZoom = 0;
+        const maxCameraRadius = limits.altitudeMax !== undefined ? limits.planetRadius + limits.altitudeMax : undefined;
+        const restingAltitude = maxCameraRadius ?? limits.planetRadius * 4;
+        this.position.copyFromFloats(restingAltitude, 0, 0);
+        this._center.copyFromFloats(limits.planetRadius, 0, 0);
+        this._radius = Vector3.Distance(this.position, this.center);
         // Temp vars
-        this._tempPosition = Vector3.Zero();
-        this._tempRotationAxis = Vector3.Right(); // starting axis used to calculate pitch rotation matrix
-        this._tempRotationMatrix = Matrix.Identity();
-        this._tempGeocentricNormal = Vector3.Zero();
-        this._tempPickingRay = new Ray(this.position, this._lookAtVector);
-        this._tempPickingRay.direction = Vector3.Zero();
+        this._tempPosition = new Vector3();
         // View matrix calculation vars
-        this.upVector = Vector3.Up(); // Up vector of the camera
-        this._lookAtVector = this.position.negate().normalize(); // Lookat vector of the camera
         this._viewMatrix = Matrix.Identity();
+        this._center.subtractToRef(this._position, this._lookAtVector).normalize(); // Lookat vector of the camera
+        this.upVector = Vector3.Up(); // Up vector of the camera (does work for -X look at)
         this._isViewMatrixDirty = true;
+        this._setOrientation(this._yaw, this._pitch, this._radius, this._center);
     }
     /** @internal */
     _getViewMatrix() {
@@ -71,12 +198,12 @@ export class GeospatialCamera extends Camera {
         // Ensure vectors are normalized
         this.upVector.normalize();
         this._lookAtVector.normalize();
-        // Calculate view matrix with camera position and target
+        // Calculate view matrix with camera position and center
         if (this.getScene().useRightHandedSystem) {
-            Matrix.LookAtRHToRef(this.position, this._target, this.upVector, this._viewMatrix);
+            Matrix.LookAtRHToRef(this.position, this._center, this.upVector, this._viewMatrix);
         }
         else {
-            Matrix.LookAtLHToRef(this.position, this._target, this.upVector, this._viewMatrix);
+            Matrix.LookAtLHToRef(this.position, this._center, this.upVector, this._viewMatrix);
         }
         return this._viewMatrix;
     }
@@ -87,133 +214,65 @@ export class GeospatialCamera extends Camera {
         }
         return true;
     }
-    /**
-     * Applies rotation correction to the camera by calculating a changeOfBasis matrix from the camera's current position to the new position
-     * and transforming the lookAt and up vectors by that matrix before updating the camera position and marking the view matrix as dirty
-     * @param newPos The camera's desired position, before correction is applied
-     */
-    _applyRotationCorrectionAndSetPos(newPos) {
-        // Compute changeOfBasis between current camera position and new position
-        ComputeChangeOfBasisToRef(this.position, newPos, this._tempRotationMatrix);
-        // Apply rotation correction to lookat/up vectors
-        Vector3.TransformNormalToRef(this._lookAtVector, this._tempRotationMatrix, this._lookAtVector);
-        Vector3.TransformNormalToRef(this.upVector, this._tempRotationMatrix, this.upVector);
-        // Apply position change and mark viewMatrix as dirty
-        this.position.copyFrom(newPos);
-        this._isViewMatrixDirty = true;
-    }
-    /**
-     * When the geocentric normal has any translation change (due to dragging), we must ensure the camera remains orbiting around the world origin
-     * We thus need to perform 2 correction steps
-     * 1. Translation correction that keeps the camera at the same radius as before the drag
-     * 2. Rotation correction that keeps the camera facing the globe (so that as we pan, the globe stays centered on screen)
-     */
     _applyGeocentricTranslation() {
         // Store pending position (without any corrections applied)
-        this.position.addToRef(this._perFrameGeocentricTranslation, this._tempPosition);
-        // 1. Calculate the altitude correction to keep camera at the same radius when applying translation
-        const tempPositionScaled = TmpVectors.Vector3[2];
-        const offset = TmpVectors.Vector3[3];
-        this._tempPosition.normalizeToRef(tempPositionScaled).scaleInPlace(this.position.length()); // what would tempPosition be if it were scaled to same radius as before
-        this._tempPosition.subtractToRef(tempPositionScaled, offset); // find offset between tempPosition and the tempScaledPosition
-        this._tempPosition.subtractInPlace(offset); // reduce tempPosition by that offset
-        // 2. Calculate the rotation correction to keep camera facing globe
-        this._applyRotationCorrectionAndSetPos(this._tempPosition);
+        this.center.addToRef(this.movement.panDeltaCurrentFrame, this._tempPosition);
+        if (!this.movement.isInterpolating) {
+            // Calculate the position correction to keep camera at the same radius when applying translation
+            this._tempPosition.normalize().scaleInPlace(this.center.length());
+        }
+        // Set center which will call _setOrientation
+        this.center = this._tempPosition;
     }
     /**
      * This rotation keeps the camera oriented towards the globe as it orbits around it. This is different from cameraCentricRotation which is when the camera rotates around its own axis
      */
     _applyGeocentricRotation() {
-        // Normalize key vectors
-        this._geocentricRotationPt.normalizeToRef(this._tempGeocentricNormal);
-        this.upVector.normalize();
-        this._lookAtVector.normalize();
-        const pitchRotationMatrix = Matrix.Identity();
-        const yawRotationMatrix = Matrix.Identity();
-        // First apply pitch
-        if (this._perFrameGeocentricRotation.x !== 0) {
-            // Compute a rotation axis that is perpendicular to both the upVector and the geocentricNormalOfPitchPoint
-            Vector3.CrossToRef(this.upVector, this._tempGeocentricNormal, this._tempRotationAxis);
-            // If upVector and geocentricNormalOfPitchPoint are parallel, fall back to cross(lookAtDirection, geocentricNormalOfPitchPoint)
-            if (this._tempRotationAxis.lengthSquared() <= Epsilon) {
-                Vector3.CrossToRef(this._lookAtVector, this._tempGeocentricNormal, this._tempRotationAxis);
-            }
-            const pitchSign = Math.sign(Vector3.Dot(this._tempGeocentricNormal, this.upVector)); // If negative, camera is upside down
-            // Since these are pointed in opposite directions, we must negate the dot product to get the proper angle
-            const currentPitch = pitchSign * Math.acos(Scalar.Clamp(-Vector3.Dot(this._lookAtVector, this._tempGeocentricNormal), -1, 1));
-            const newPitch = Scalar.Clamp(currentPitch + this._perFrameGeocentricRotation.x, 0, 0.5 * Math.PI - Epsilon);
-            // Build rotation matrix around normalized axis
-            Matrix.RotationAxisToRef(this._tempRotationAxis.normalize(), newPitch - currentPitch, pitchRotationMatrix);
+        const rotationDeltaCurrentFrame = this.movement.rotationDeltaCurrentFrame;
+        if (rotationDeltaCurrentFrame.x !== 0 || rotationDeltaCurrentFrame.y !== 0) {
+            const pitch = rotationDeltaCurrentFrame.x !== 0 ? Clamp(this._pitch + rotationDeltaCurrentFrame.x, 0, 0.5 * Math.PI - Epsilon) : this._pitch;
+            const yaw = rotationDeltaCurrentFrame.y !== 0 ? this._yaw + rotationDeltaCurrentFrame.y : this._yaw;
+            // TODO: If _geocentricRotationPt is not the center, this will need to be adjusted.
+            this._setOrientation(yaw, pitch, this._radius, this._geocentricRotationPt);
         }
-        // Then apply yaw
-        if (this._perFrameGeocentricRotation.y !== 0) {
-            Matrix.RotationAxisToRef(this._tempGeocentricNormal, this._perFrameGeocentricRotation.y, yawRotationMatrix); // this axis changes if we aren't using center of screen for tilt
-        }
-        pitchRotationMatrix.multiplyToRef(yawRotationMatrix, this._tempRotationMatrix);
-        // Offset camera to be (position-pitchPoint) distance from geocentricOrigin, apply rotation to position/up/lookat vectors, then add back the pitchPoint offset
-        this.position.subtractInPlace(this._geocentricRotationPt);
-        Vector3.TransformCoordinatesToRef(this.position, this._tempRotationMatrix, this.position);
-        Vector3.TransformNormalToRef(this.upVector, this._tempRotationMatrix, this.upVector);
-        Vector3.TransformNormalToRef(this._lookAtVector, this._tempRotationMatrix, this._lookAtVector);
-        this.position.addInPlace(this._geocentricRotationPt);
-    }
-    _clampZoomDistance(requestedDistance, pickResultDistance) {
-        // If pickResult is defined
-        if (requestedDistance > 0) {
-            if (pickResultDistance !== undefined) {
-                // If there is a pick, allow movement up to pick - minAltitude
-                if (pickResultDistance - this._minAltitude < 0) {
-                    return 0;
-                }
-                return Math.min(requestedDistance, pickResultDistance - this._minAltitude);
-            }
-            else {
-                return requestedDistance;
-            }
-        }
-        if (requestedDistance < 0) {
-            const maxZoomOut = this._maxCameraRadius ? this._maxCameraRadius - this.position.length() : Number.POSITIVE_INFINITY;
-            return Math.max(requestedDistance, -maxZoomOut);
-        }
-        return 0;
     }
-    _applyZoom(distance) {
-        const pickResult = this._scene.pick(this._scene.pointerX, this._scene.pointerY, this.pickPredicate);
-        if (pickResult.hit && pickResult.ray) {
-            // Zoom to cursor
-            this._moveCameraAlongVectorByDistance(pickResult.ray.direction, this._clampZoomDistance(distance, pickResult.distance));
-        }
-        else {
-            // If no hit under cursor, zoom along lookVector instead
-            this._moveCameraAlongVectorByDistance(this._lookAtVector, this._clampZoomDistance(distance, this._pickAlongLook?.distance));
-        }
-    }
-    _moveCameraAlongVectorByDistance(vector, distance) {
-        if (distance) {
-            vector.scaleAndAddToRef(distance, this._tempPosition);
-            this._applyRotationCorrectionAndSetPos(this._tempPosition);
-        }
-    }
-    get _pickAlongLook() {
-        this._tempPickingRay.origin.copyFrom(this.position);
-        this._tempPickingRay.direction.copyFrom(this._lookAtVector);
-        return this._scene.pickWithRay(this._tempPickingRay, this.pickPredicate);
+    _applyZoom(zoomVector, distance) {
+        // TODO this function will be re-worked shortly after checkin, becuase today it breaks down if you zoom to a point past the center
+        // (ex: tilted view zooming towards cursor near horizon where the center is closer than the cursor point).
+        // Project zoom vector onto lookAt vector to find the amount the camera-to-center distance should change.
+        // - zoom vector is normalized
+        // - distance is how much to move in this call
+        const directionDotLookAt = Vector3Dot(zoomVector, this._lookAtVector);
+        const hasRadialComponent = Math.abs(directionDotLookAt) > Epsilon;
+        const requestedRadius = hasRadialComponent ? this._radius - distance * directionDotLookAt : this._radius;
+        const newRadius = Clamp(requestedRadius, this.limits.radiusMin, this.limits.radiusMax);
+        const actualRadiusChange = newRadius - this._radius;
+        const actualDistanceChange = hasRadialComponent ? actualRadiusChange / directionDotLookAt : 0;
+        // Use this to compute new camera position and new center position.
+        const newCameraPosition = this._position.add(zoomVector.scale(-actualDistanceChange));
+        const newCenter = newCameraPosition.add(this._lookAtVector.scaleToRef(newRadius, TmpVectors.Vector3[3]));
+        // Rescale new center to maintain same altitude as the old center.
+        const currentCenterRadius = this._center.length();
+        const newCenterRadius = newCenter.length();
+        const newCenterRescale = currentCenterRadius / newCenterRadius;
+        newCenter.scaleInPlace(newCenterRescale);
+        // Apply changes
+        this._setOrientation(this._yaw, this._pitch, newRadius, newCenter);
     }
     _checkInputs() {
         this.inputs.checkInputs();
-        if (this._perFrameGeocentricTranslation.lengthSquared() > 0) {
+        // Let movement class handle all per-frame logic
+        this.movement.computeCurrentFrameDeltas();
+        if (this.movement.panDeltaCurrentFrame.lengthSquared() > 0) {
             this._applyGeocentricTranslation();
-            this._perFrameGeocentricTranslation.setAll(0);
             this._isViewMatrixDirty = true;
         }
-        if (this._perFrameGeocentricRotation.lengthSquared() > 0) {
+        if (this.movement.rotationDeltaCurrentFrame.lengthSquared() > 0) {
             this._applyGeocentricRotation();
-            this._perFrameGeocentricRotation.setAll(0);
             this._isViewMatrixDirty = true;
         }
-        if (this._perFrameZoom !== 0) {
-            this._applyZoom(this._perFrameZoom);
-            this._perFrameZoom = 0;
+        if (Math.abs(this.movement.zoomDeltaCurrentFrame) > Epsilon) {
+            this._applyZoom(this.movement.computedPerFrameZoomVector, this.movement.zoomDeltaCurrentFrame);
             this._isViewMatrixDirty = true;
         }
         super._checkInputs();
@@ -225,44 +284,4 @@ export class GeospatialCamera extends Camera {
         this.inputs.detachElement();
     }
 }
-// Helper to build east/north/up basis vectors at a world position
-function ComputeLocalBasisToRefs(worldPos, refEast, refNorth, refUp) {
-    // up = normalized position (geocentric normal)
-    refUp.copyFrom(worldPos).normalize();
-    // east = normalize(up × worldUp)
-    // (cross product of up with world Y gives east except at poles)
-    const worldUp = Vector3.Up(); // (0,1,0)
-    Vector3.CrossToRef(refUp, worldUp, refEast);
-    // at poles, cross with worldForward instead
-    if (refEast.lengthSquared() < Epsilon) {
-        Vector3.CrossToRef(refUp, Vector3.Forward(), refEast);
-    }
-    refEast.normalize();
-    // north = up × east (completes right-handed basis)
-    Vector3.CrossToRef(refUp, refEast, refNorth);
-    refNorth.normalize();
-}
-/**
- * Calculates changeOfBasis matrix from currentPos to newPos and stores it in ref
- * @param currentPos
- * @param newPos
- * @param ref
- * @returns The changeOfBasis matrix from currentPos to newPos
- */
-function ComputeChangeOfBasisToRef(currentPos, newPos, ref) {
-    const currentBasis = TmpVectors.Matrix[5];
-    const newBasis = TmpVectors.Matrix[6];
-    const inverse = TmpVectors.Matrix[7];
-    const east = TmpVectors.Vector3[3];
-    const north = TmpVectors.Vector3[4];
-    const up = TmpVectors.Vector3[5];
-    ComputeLocalBasisToRefs(currentPos, east, north, up);
-    Matrix.FromXYZAxesToRef(east, north, up, currentBasis);
-    ComputeLocalBasisToRefs(newPos, east, north, up);
-    Matrix.FromXYZAxesToRef(east, north, up, newBasis);
-    // Change of basis matrix = basis2 * basis1.inverse()
-    // (since orthonormal, inverse = transpose)
-    currentBasis.transposeToRef(inverse).multiplyToRef(newBasis, ref);
-    return ref;
-}
 //# sourceMappingURL=geospatialCamera.js.map