Camera input mapping system with backward-compatible legacy flag support

packages/dev/core/src/Cameras/Inputs/arcRotateCameraGamepadInput.ts

@@ -98,14 +98,16 @@ export class ArcRotateCameraGamepadInput implements ICameraInput<ArcRotateCamera
                 if (rsValues.x != 0) {
                     const normalizedRX = rsValues.x / this.gamepadRotationSensibility;
                     if (normalizedRX != 0 && Math.abs(normalizedRX) > 0.005) {
-                        camera.inertialAlphaOffset += normalizedRX;
+                        camera.movement.activeInput = true;
+                        camera.movement.rotationAccumulatedPixels.x += normalizedRX;
                     }
                 }
 
                 if (rsValues.y != 0) {
                     const normalizedRY = (rsValues.y / this.gamepadRotationSensibility) * this._yAxisScale;
                     if (normalizedRY != 0 && Math.abs(normalizedRY) > 0.005) {
-                        camera.inertialBetaOffset += normalizedRY;
+                        camera.movement.activeInput = true;
+                        camera.movement.rotationAccumulatedPixels.y += normalizedRY;
                     }
                 }
             }
@@ -114,7 +116,8 @@ export class ArcRotateCameraGamepadInput implements ICameraInput<ArcRotateCamera
             if (lsValues && lsValues.y != 0) {
                 const normalizedLY = lsValues.y / this.gamepadMoveSensibility;
                 if (normalizedLY != 0 && Math.abs(normalizedLY) > 0.005) {
-                    this.camera.inertialRadiusOffset -= normalizedLY;
+                    camera.movement.activeInput = true;
+                    camera.movement.zoomAccumulatedPixels -= normalizedLY;
                 }
             }
         }

packages/dev/core/src/Cameras/Inputs/arcRotateCameraKeyboardMoveInput.ts

@@ -7,6 +7,7 @@ import { type ICameraInput, CameraInputTypes } from "../../Cameras/cameraInputsM
 import { type KeyboardInfo, KeyboardEventTypes } from "../../Events/keyboardEvents";
 import { Tools } from "../../Misc/tools";
 import { type AbstractEngine } from "../../Engines/abstractEngine";
+import { type KeyboardConditions } from "../inputMapper";
 
 /**
  * Manage the keyboard inputs to control the movement of an arc rotate camera.
@@ -49,6 +50,20 @@ export class ArcRotateCameraKeyboardMoveInput implements ICameraInput<ArcRotateC
     @serialize()
     public keysReset = [220];
 
+    /**
+     * Defines the list of key codes associated with the zoom in action.
+     * Only used when CameraMovement is active — these keys always trigger zoom regardless of modifiers.
+     */
+    @serialize()
+    public keysZoomIn: number[] = [187, 107]; // 187 = +/= key, 107 = numpad +
+
+    /**
+     * Defines the list of key codes associated with the zoom out action.
+     * Only used when CameraMovement is active — these keys always trigger zoom regardless of modifiers.
+     */
+    @serialize()
+    public keysZoomOut: number[] = [189, 109]; // 189 = -/_ key, 109 = numpad -
+
     /**
      * Defines the panning sensibility of the inputs.
      * (How fast is the camera panning)
@@ -64,17 +79,35 @@ export class ArcRotateCameraKeyboardMoveInput implements ICameraInput<ArcRotateC
     public zoomingSensibility: number = 25.0;
 
     /**
-     * Defines whether maintaining the alt key down switch the movement mode from
-     * orientation to zoom.
+     * Rotation speed of the camera
      */
     @serialize()
-    public useAltToZoom: boolean = true;
+    public angularSpeed = 0.01;
+
+    private _useAltToZoom: boolean = true;
 
     /**
-     * Rotation speed of the camera
+     * Defines whether alt+arrows/wasd triggers zoom instead of rotation/pan.
+     * When disabled, alt+keyboard events are ignored by the zoom inputMap entry.
+     * Setting this updates the corresponding inputMap entry on the camera's movement system.
      */
     @serialize()
-    public angularSpeed = 0.01;
+    public get useAltToZoom(): boolean {
+        return this._useAltToZoom;
+    }
+
+    public set useAltToZoom(value: boolean) {
+        this._useAltToZoom = value;
+        if (this.camera?.movement) {
+            const input = this.camera.movement.input;
+            const entry = input.getEntry("keyboard", "zoom", { modifiers: { alt: true } });
+            if (!value && entry) {
+                input.inputMap.splice(input.inputMap.indexOf(entry), 1);
+            } else if (value && !entry) {
+                input.addEntry({ source: "keyboard", modifiers: { alt: true }, interaction: "zoom" });
+            }
+        }
+    }
 
     private _keys = new Array<number>();
     private _ctrlPressed: boolean;
@@ -84,6 +117,9 @@ export class ArcRotateCameraKeyboardMoveInput implements ICameraInput<ArcRotateC
     private _engine: AbstractEngine;
     private _scene: Scene;
 
+    /** Cached conditions object to avoid per-frame allocations in checkInputs */
+    private _keyboardConditions: KeyboardConditions = { modifiers: { ctrl: false, alt: false } };
+
     /**
      * Attach the input controls to a specific dom element to get the input from.
      * @param noPreventDefault Defines whether event caught by the controls should call preventdefault() (https://developer.mozilla.org/en-US/docs/Web/API/Event/preventDefault)
@@ -115,7 +151,9 @@ export class ArcRotateCameraKeyboardMoveInput implements ICameraInput<ArcRotateC
                         this.keysDown.indexOf(evt.keyCode) !== -1 ||
                         this.keysLeft.indexOf(evt.keyCode) !== -1 ||
                         this.keysRight.indexOf(evt.keyCode) !== -1 ||
-                        this.keysReset.indexOf(evt.keyCode) !== -1
+                        this.keysReset.indexOf(evt.keyCode) !== -1 ||
+                        this.keysZoomIn.indexOf(evt.keyCode) !== -1 ||
+                        this.keysZoomOut.indexOf(evt.keyCode) !== -1
                     ) {
                         const index = this._keys.indexOf(evt.keyCode);
 
@@ -135,7 +173,9 @@ export class ArcRotateCameraKeyboardMoveInput implements ICameraInput<ArcRotateC
                         this.keysDown.indexOf(evt.keyCode) !== -1 ||
                         this.keysLeft.indexOf(evt.keyCode) !== -1 ||
                         this.keysRight.indexOf(evt.keyCode) !== -1 ||
-                        this.keysReset.indexOf(evt.keyCode) !== -1
+                        this.keysReset.indexOf(evt.keyCode) !== -1 ||
+                        this.keysZoomIn.indexOf(evt.keyCode) !== -1 ||
+                        this.keysZoomOut.indexOf(evt.keyCode) !== -1
                     ) {
                         const index = this._keys.indexOf(evt.keyCode);
 
@@ -179,38 +219,60 @@ export class ArcRotateCameraKeyboardMoveInput implements ICameraInput<ArcRotateC
     public checkInputs(): void {
         if (this._onKeyboardObserver) {
             const camera = this.camera;
+            const input = camera.movement.input;
+
+            this._keyboardConditions.modifiers!.ctrl = this._ctrlPressed;
+            this._keyboardConditions.modifiers!.alt = this._altPressed;
 
             for (let index = 0; index < this._keys.length; index++) {
                 const keyCode = this._keys[index];
-                if (this.keysLeft.indexOf(keyCode) !== -1) {
-                    if (this._ctrlPressed && this.camera._useCtrlForPanning) {
-                        camera.inertialPanningX -= 1 / this.panningSensibility;
-                    } else {
-                        camera.inertialAlphaOffset -= this.angularSpeed;
-                    }
-                } else if (this.keysUp.indexOf(keyCode) !== -1) {
-                    if (this._ctrlPressed && this.camera._useCtrlForPanning) {
-                        camera.inertialPanningY += 1 / this.panningSensibility;
-                    } else if (this._altPressed && this.useAltToZoom) {
-                        camera.inertialRadiusOffset += 1 / this.zoomingSensibility;
-                    } else {
-                        camera.inertialBetaOffset -= this.angularSpeed;
-                    }
-                } else if (this.keysRight.indexOf(keyCode) !== -1) {
-                    if (this._ctrlPressed && this.camera._useCtrlForPanning) {
-                        camera.inertialPanningX += 1 / this.panningSensibility;
-                    } else {
-                        camera.inertialAlphaOffset += this.angularSpeed;
-                    }
-                } else if (this.keysDown.indexOf(keyCode) !== -1) {
-                    if (this._ctrlPressed && this.camera._useCtrlForPanning) {
-                        camera.inertialPanningY -= 1 / this.panningSensibility;
-                    } else if (this._altPressed && this.useAltToZoom) {
-                        camera.inertialRadiusOffset -= 1 / this.zoomingSensibility;
-                    } else {
-                        camera.inertialBetaOffset += this.angularSpeed;
+
+                this._keyboardConditions.key = keyCode;
+
+                // Skip resolveInteraction for the reset key — it has no inputMap entry of its own
+                // and would otherwise spuriously match the catch-all keyboard→rotate entry.
+                if (this.keysReset.indexOf(keyCode) === -1) {
+                    const resolved = input.resolveInteraction("keyboard", this._keyboardConditions);
+
+                    if (resolved) {
+                        // Per-frame impulse magnitude. The inputMap entry's `sensitivity` takes precedence
+                        // when set so consumers can tune feel declaratively (and so we can phase out the
+                        // legacy sensibility/angularSpeed properties over time). When `sensitivity` is
+                        // undefined, fall back to the legacy properties for backward compatibility.
+                        if (resolved.interaction === "pan") {
+                            const panSens = resolved.sensitivity ?? 1 / this.panningSensibility;
+                            if (this.keysLeft.indexOf(keyCode) !== -1) {
+                                input.handlers.pan(-panSens, 0);
+                            } else if (this.keysRight.indexOf(keyCode) !== -1) {
+                                input.handlers.pan(panSens, 0);
+                            } else if (this.keysUp.indexOf(keyCode) !== -1) {
+                                input.handlers.pan(0, panSens);
+                            } else if (this.keysDown.indexOf(keyCode) !== -1) {
+                                input.handlers.pan(0, -panSens);
+                            }
+                        } else if (resolved.interaction === "zoom") {
+                            const zoomSens = resolved.sensitivity ?? 1 / this.zoomingSensibility;
+                            if (this.keysUp.indexOf(keyCode) !== -1 || this.keysZoomIn.indexOf(keyCode) !== -1) {
+                                input.handlers.zoom(zoomSens);
+                            } else if (this.keysDown.indexOf(keyCode) !== -1 || this.keysZoomOut.indexOf(keyCode) !== -1) {
+                                input.handlers.zoom(-zoomSens);
+                            }
+                        } else if (resolved.interaction === "rotate") {
+                            const rotateSens = resolved.sensitivity ?? this.angularSpeed;
+                            if (this.keysLeft.indexOf(keyCode) !== -1) {
+                                input.handlers.rotate(-rotateSens, 0);
+                            } else if (this.keysRight.indexOf(keyCode) !== -1) {
+                                input.handlers.rotate(rotateSens, 0);
+                            } else if (this.keysUp.indexOf(keyCode) !== -1) {
+                                input.handlers.rotate(0, -rotateSens);
+                            } else if (this.keysDown.indexOf(keyCode) !== -1) {
+                                input.handlers.rotate(0, rotateSens);
+                            }
+                        }
                     }
-                } else if (this.keysReset.indexOf(keyCode) !== -1) {
+                }
+
+                if (this.keysReset.indexOf(keyCode) !== -1) {
                     if (camera.useInputToRestoreState) {
                         camera.restoreState();
                     }

packages/dev/core/src/Cameras/Inputs/arcRotateCameraMouseWheelInput.ts

@@ -98,8 +98,11 @@ export class ArcRotateCameraMouseWheelInput implements ICameraInput<ArcRotateCam
                     // If zooming in, estimate the target radius and use that to compute the delta for inertia
                     // this will stop multiple scroll events zooming in from adding too much inertia
                     if (delta > 0) {
+                        // When zoomToMouseLocation is active, the accumulating state lives in our private
+                        // `_zoomToMouseRadiusImpulse` field. Otherwise fall back to the legacy surface.
+                        const currentAccumulated = this.zoomToMouseLocation ? this._zoomToMouseRadiusImpulse : this.camera.inertialRadiusOffset;
                         let estimatedTargetRadius = this.camera.radius;
-                        let targetInertia = this.camera.inertialRadiusOffset + delta;
+                        let targetInertia = currentAccumulated + delta;
                         for (let i = 0; i < 20; i++) {
                             // 20 iterations should be enough to converge
                             if (estimatedTargetRadius <= targetInertia) {
@@ -117,7 +120,11 @@ export class ArcRotateCameraMouseWheelInput implements ICameraInput<ArcRotateCam
                         delta = this._computeDeltaFromMouseWheelLegacyEvent(wheelDelta, estimatedTargetRadius);
                     }
                 } else {
-                    delta = wheelDelta / (this.wheelPrecision * 40);
+                    // The inputMap entry's `sensitivity` takes precedence so consumers can tune
+                    // wheel zoom feel declaratively; fall back to the legacy `wheelPrecision`.
+                    const wheelEntry = this.camera.movement.input.getEntry("wheel", "zoom");
+                    const wheelScale = wheelEntry?.sensitivity ?? 1 / (this.wheelPrecision * 40);
+                    delta = wheelDelta * wheelScale;
                 }
             }
 
@@ -132,10 +139,9 @@ export class ArcRotateCameraMouseWheelInput implements ICameraInput<ArcRotateCam
 
                     this._zoomToMouse(delta);
                 } else {
-                    this.camera.inertialRadiusOffset += delta;
+                    this.camera.movement.zoomAccumulatedPixels += delta;
                 }
             }
-
             if (event.preventDefault) {
                 if (!noPreventDefault) {
                     event.preventDefault();
@@ -171,18 +177,38 @@ export class ArcRotateCameraMouseWheelInput implements ICameraInput<ArcRotateCam
         }
 
         const camera = this.camera;
-        const motion = 0.0 + camera.inertialAlphaOffset + camera.inertialBetaOffset + camera.inertialRadiusOffset;
+        // Motion check based on our private impulse state + the legacy inertialRadiusOffset
+        // surface (so user code that still writes to it continues to animate). Legacy also
+        // included alpha/beta offsets in the motion check — keep that for compatibility so
+        // the hit plane stays updated while the camera rotates.
+        const motion =
+            Math.abs(this._zoomToMouseRadiusImpulse) +
+            this._inertialPanning.lengthSquared() +
+            Math.abs(camera.inertialAlphaOffset) +
+            Math.abs(camera.inertialBetaOffset) +
+            Math.abs(camera.inertialRadiusOffset);
         if (motion) {
             // if zooming is still happening as a result of inertia, then we also need to update
             // the hit plane.
             this._updateHitPlane();
 
-            // Note we cannot  use arcRotateCamera.inertialPlanning here because arcRotateCamera panning
-            // uses a different panningInertia which could cause this panning to get out of sync with
-            // the zooming, and for this to work they must be exactly in sync.
+            // Apply this frame's coupled radius + pan impulse to the camera. They must stay
+            // in lockstep so the cursor remains at the zoom focal point — keep pan here instead
+            // of routing through `arcRotateCamera.inertialPanning` which uses a different
+            // `panningInertia`.
             camera.target.addInPlace(this._inertialPanning);
-            this._inertialPanning.scaleInPlace(camera.inertia);
+            camera.radius -= this._zoomToMouseRadiusImpulse;
+
+            // Framerate-independent decay — matches legacy `* camera.inertia` exactly at 60fps
+            // and preserves glide duration at any other fps.
+            const decay = camera.movement.getFrameIndependentDecay(camera.inertia);
+            this._inertialPanning.scaleInPlace(decay);
+            this._zoomToMouseRadiusImpulse *= decay;
+
             this._zeroIfClose(this._inertialPanning);
+            if (Math.abs(this._zoomToMouseRadiusImpulse) < Epsilon) {
+                this._zoomToMouseRadiusImpulse = 0;
+            }
         }
     }
 
@@ -237,19 +263,30 @@ export class ArcRotateCameraMouseWheelInput implements ICameraInput<ArcRotateCam
 
     private _inertialPanning: Vector3 = Vector3.Zero();
 
+    /**
+     * Private impulse state for the zoomToMouseLocation path. Replaces the legacy use of
+     * `camera.inertialRadiusOffset` so that the coupled radius/pan impulses can be decayed
+     * with framerate-independent semantics (via `CameraMovement.getFrameIndependentDecay`)
+     * without disturbing the general inertialRadiusOffset back-compat surface.
+     */
+    private _zoomToMouseRadiusImpulse: number = 0;
+
     private _zoomToMouse(delta: number) {
         const camera = this.camera;
         const inertiaComp = 1 - camera.inertia;
+        // inputScale corrects per-frame impulse so that the decayed sum matches the legacy 60fps total
+        // at any actual framerate. At 60fps inputScale = 1 (no-op).
+        const inputScale = camera.movement.getFrameIndependentInputScale(camera.inertia);
         if (camera.lowerRadiusLimit) {
             const lowerLimit = camera.lowerRadiusLimit ?? 0;
-            if (camera.radius - (camera.inertialRadiusOffset + delta) / inertiaComp < lowerLimit) {
-                delta = (camera.radius - lowerLimit) * inertiaComp - camera.inertialRadiusOffset;
+            if (camera.radius - (this._zoomToMouseRadiusImpulse + delta * inputScale) / inertiaComp < lowerLimit) {
+                delta = ((camera.radius - lowerLimit) * inertiaComp - this._zoomToMouseRadiusImpulse) / inputScale;
             }
         }
         if (camera.upperRadiusLimit) {
             const upperLimit = camera.upperRadiusLimit ?? 0;
-            if (camera.radius - (camera.inertialRadiusOffset + delta) / inertiaComp > upperLimit) {
-                delta = (camera.radius - upperLimit) * inertiaComp - camera.inertialRadiusOffset;
+            if (camera.radius - (this._zoomToMouseRadiusImpulse + delta * inputScale) / inertiaComp > upperLimit) {
+                delta = ((camera.radius - upperLimit) * inertiaComp - this._zoomToMouseRadiusImpulse) / inputScale;
             }
         }
 
@@ -264,9 +301,11 @@ export class ArcRotateCameraMouseWheelInput implements ICameraInput<ArcRotateCam
         vec.subtractToRef(camera.target, directionToZoomLocation);
         directionToZoomLocation.scaleInPlace(ratio);
         directionToZoomLocation.scaleInPlace(inertiaComp);
+
+        directionToZoomLocation.scaleInPlace(inputScale);
         this._inertialPanning.addInPlace(directionToZoomLocation);
 
-        camera.inertialRadiusOffset += delta;
+        this._zoomToMouseRadiusImpulse += delta * inputScale;
     }
 
     // Sets x y or z of passed in vector to zero if less than Epsilon.