three-gamepad-controls 0.25.6 → 0.25.8

package/dist/gamepad-arcball-controls.d.ts

@@ -76,6 +76,9 @@ export type GamepadArcballControlsOptions = GamepadControlsOptions & {
  * needed after manual camera or target changes, matching Arcball's native API.
  * Gamepad `start`, `change`, and `end` events are dispatched on the native controls.
  * The balanced session belongs to this wrapper, including isolated focus commands.
+ * Zoom and focus preserve native `adjustNearFar` clipping and projection behavior,
+ * including restoration of the native initial planes on the next scale operation
+ * after adjustment is disabled. Focus without zoom leaves clipping unchanged.
  */
 export declare class GamepadArcballControls extends GamepadControls {
   #private;

package/dist/gamepad-arcball-controls.js

@@ -1,7 +1,7 @@
 import { GAMEPAD_AXIS, GAMEPAD_BUTTON } from "./core.js";
 import { DEFAULT_GAMEPAD_STICK_PIPELINE, resolveGamepadStickBinding } from "./gamepad-stick-processing.js";
 import { GamepadControls } from "./gamepad-controls.js";
-import { Vector2, Vector3 } from "three";
+import { Box3, Matrix4, Sphere, Vector2, Vector3 } from "three";
 // src/gamepad-arcball-controls.ts
 const DEFAULT_ARCBALL_OPTIONS = {
 	rotateSpeed: 1,
@@ -34,6 +34,9 @@ const ZOOM_NOTCHES_PER_SECOND = 8;
 * needed after manual camera or target changes, matching Arcball's native API.
 * Gamepad `start`, `change`, and `end` events are dispatched on the native controls.
 * The balanced session belongs to this wrapper, including isolated focus commands.
+* Zoom and focus preserve native `adjustNearFar` clipping and projection behavior,
+* including restoration of the native initial planes on the next scale operation
+* after adjustment is disabled. Focus without zoom leaves clipping unchanged.
 */
 var GamepadArcballControls = class extends GamepadControls {
 	#controls;
@@ -45,6 +48,9 @@ var GamepadArcballControls = class extends GamepadControls {
 	#cameraForward;
 	#cameraRight;
 	#previousUp;
+	#scaleMatrix = new Matrix4();
+	#gizmoBounds = new Box3();
+	#gizmoSphere = new Sphere();
 	/** Whether this wrapper owns an active gamepad interaction. */
 	#wasInteracting = false;
 	/** Blocks recursive updates while a frame is being processed. */
@@ -274,7 +280,8 @@ var GamepadArcballControls = class extends GamepadControls {
 		controls.updateMatrixState();
 		const transformation = controls.scale(size, controls._gizmos.position);
 		if (transformation === void 0) return false;
-		this.#applyTransform(transformation);
+		this.#applyScaleTransform(transformation);
+		controls.updateMatrixState();
 		return true;
 	}
 	/**
@@ -303,7 +310,19 @@ var GamepadArcballControls = class extends GamepadControls {
 		if (point === null) return false;
 		const controls = this.#controls;
 		controls.updateMatrixState();
-		controls.focus(point, controls.scaleFactor);
+		const descriptor = Object.getOwnPropertyDescriptor(controls, "applyTransformMatrix");
+		const applyScale = (transformation) => {
+			this.#applyScaleTransform(transformation);
+		};
+		controls.applyTransformMatrix = applyScale;
+		try {
+			controls.focus(point, controls.scaleFactor);
+		} finally {
+			if (controls.applyTransformMatrix === applyScale) {
+				if (descriptor) Object.defineProperty(controls, "applyTransformMatrix", descriptor);
+				else Reflect.deleteProperty(controls, "applyTransformMatrix");
+			}
+		}
 		controls.updateMatrixState();
 		return true;
 	}
@@ -317,6 +336,43 @@ var GamepadArcballControls = class extends GamepadControls {
 		this.#controls.updateMatrixState();
 	}
 	/**
+	* Applies native scale matrices and geometric side effects exactly once.
+	* Arcball's own applicator gates these effects on inaccessible state Symbols.
+	* Reproduce its scale/focus branch without entering or borrowing pointer state;
+	* native scale() and focus() still own the transformation and limit calculations.
+	* Cached baselines must stay intact until focus() restores its temporary ones.
+	*
+	* @param transformation - Native camera and gizmo scale transformations.
+	*/
+	#applyScaleTransform(transformation) {
+		const controls = this.#controls;
+		const camera = controls.object;
+		const gizmos = controls._gizmos;
+		if (transformation.camera !== null) {
+			this.#scaleMatrix.copy(controls._cameraMatrixState).premultiply(transformation.camera).decompose(camera.position, camera.quaternion, camera.scale);
+			camera.updateMatrix();
+		}
+		if (transformation.gizmos !== null) {
+			this.#scaleMatrix.copy(controls._gizmoMatrixState).premultiply(transformation.gizmos).decompose(gizmos.position, gizmos.quaternion, gizmos.scale);
+			gizmos.updateMatrix();
+		}
+		controls._tbRadius = controls.calculateTbRadius(camera);
+		if (controls.adjustNearFar) {
+			const distance = camera.position.distanceTo(gizmos.position);
+			this.#gizmoBounds.setFromObject(gizmos).getBoundingSphere(this.#gizmoSphere);
+			const { radius, center } = this.#gizmoSphere;
+			const adjustedNear = Math.max(controls._nearPos0, radius + center.length());
+			const adjustedFar = Math.min(controls._farPos0, -radius + center.length());
+			camera.near = distance - Math.min(adjustedNear, distance - controls._initialNear);
+			camera.far = distance - Math.min(adjustedFar, distance - controls._initialFar);
+			camera.updateProjectionMatrix();
+		} else if (camera.near !== controls._initialNear || camera.far !== controls._initialFar) {
+			camera.near = controls._initialNear;
+			camera.far = controls._initialFar;
+			camera.updateProjectionMatrix();
+		}
+	}
+	/**
 	* Consumes a focus-button press and resolves the viewport center hit point.
 	*
 	* @param buttonFocus - Button index configured for focus.

package/dist/gamepad-map-controls.d.ts

@@ -7,8 +7,8 @@ import { MapControls } from "three/addons/controls/MapControls.js";
  * mouse conventions. All options from {@link GamepadOrbitControlsOptions} are available.
  *
  * Call `update()` inside the render loop **before** `MapControls.update()`.
- * Gamepad interaction events, pause semantics, and combined native/wrapper speeds
- * are inherited from {@link GamepadOrbitControls}.
+ * Gamepad interaction events, pause semantics, combined native/wrapper speeds,
+ * and automatic-rotation suspension are inherited from {@link GamepadOrbitControls}.
  */
 export declare class GamepadMapControls extends GamepadOrbitControls {
   /**

package/dist/gamepad-map-controls.js

@@ -18,8 +18,8 @@ const DEFAULT_MAP_OPTIONS = {
 * mouse conventions. All options from {@link GamepadOrbitControlsOptions} are available.
 *
 * Call `update()` inside the render loop **before** `MapControls.update()`.
-* Gamepad interaction events, pause semantics, and combined native/wrapper speeds
-* are inherited from {@link GamepadOrbitControls}.
+* Gamepad interaction events, pause semantics, combined native/wrapper speeds,
+* and automatic-rotation suspension are inherited from {@link GamepadOrbitControls}.
 */
 var GamepadMapControls = class extends GamepadOrbitControls {
 	/**

package/dist/gamepad-orbit-controls.d.ts

@@ -55,6 +55,8 @@ export type GamepadOrbitControlsOptions = GamepadControlsOptions & {
  * Bindings and speeds are configurable via {@link GamepadOrbitControlsOptions}.
  * The wrapper dispatches balanced gamepad `start` and `end` events on the native
  * controls; native operations and damping remain responsible for `change`.
+ * Accepted input suspends automatic rotation through every native update in the
+ * frame, preserving autoRotate configuration, pointer state, and residual damping.
  */
 export declare class GamepadOrbitControls extends GamepadControls {
   #private;
@@ -81,7 +83,8 @@ export declare class GamepadOrbitControls extends GamepadControls {
   protected onUpdate(deltaTime: number): void;
   /**
    * Removes gamepad listeners and ends only this wrapper's active interaction.
-   * Repeated calls are safe; the native controls and their damping are preserved.
+   * Restores the owned native update adapter even when an end listener throws.
+   * Repeated calls are safe and disposal is terminal; native damping is preserved.
    */
   dispose(): void;
   /**

package/dist/gamepad-orbit-controls.js

@@ -27,10 +27,18 @@ const DEFAULT_ORBIT_OPTIONS = {
 * Bindings and speeds are configurable via {@link GamepadOrbitControlsOptions}.
 * The wrapper dispatches balanced gamepad `start` and `end` events on the native
 * controls; native operations and damping remain responsible for `change`.
+* Accepted input suspends automatic rotation through every native update in the
+* frame, preserving autoRotate configuration, pointer state, and residual damping.
 */
 var GamepadOrbitControls = class extends GamepadControls {
 	#controls;
 	#options;
+	#originalUpdate;
+	#originalUpdateDescriptor;
+	#nativeUpdate;
+	#autoRotationFrame = null;
+	#nativeUpdating = false;
+	#disposed = false;
 	/** Whether this wrapper owns an active gamepad interaction. */
 	#interacting = false;
 	/** Blocks recursive updates while a frame is being processed. */
@@ -51,6 +59,10 @@ var GamepadOrbitControls = class extends GamepadControls {
 			rotateStick: resolveGamepadStickBinding(DEFAULT_ORBIT_OPTIONS.rotateStick, options?.rotateStick),
 			panStick: resolveGamepadStickBinding(DEFAULT_ORBIT_OPTIONS.panStick, options?.panStick)
 		};
+		this.#originalUpdate = controls.update;
+		this.#originalUpdateDescriptor = Object.getOwnPropertyDescriptor(controls, "update");
+		this.#nativeUpdate = (delta) => this.#updateNative(delta);
+		controls.update = this.#nativeUpdate;
 	}
 	/**
 	* Polls the gamepad and applies input, ignoring updates from synchronous listeners.
@@ -60,10 +72,14 @@ var GamepadOrbitControls = class extends GamepadControls {
 	* @param deltaTime - Seconds since the last frame.
 	*/
 	update(deltaTime) {
-		if (this.#updating || this.#ending) return;
+		if (this.#updating || this.#ending || this.#nativeUpdating || this.#disposed) return;
+		this.#autoRotationFrame = null;
 		this.#updating = true;
 		try {
 			super.update(deltaTime);
+		} catch (error) {
+			this.#autoRotationFrame = null;
+			throw error;
 		} finally {
 			this.#updating = false;
 		}
@@ -81,59 +97,77 @@ var GamepadOrbitControls = class extends GamepadControls {
 		}
 		const { rotateStick, panStick, buttonDeadzone, buttonDollyIn, buttonDollyOut } = this.#options;
 		const input = this.gamepadInput;
+		const gamepad = input.gamepad;
+		const object = this.#controls.object;
 		const rotate = input.stick(rotateStick.xAxis, rotateStick.yAxis, rotateStick.pipeline);
 		const pan = input.stick(panStick.xAxis, panStick.yAxis, panStick.pipeline);
 		const triggerIn = input.buttonValue(buttonDollyIn);
 		const triggerOut = input.buttonValue(buttonDollyOut);
 		const frame = {
-			rotateX: rotate.x,
-			rotateY: rotate.y,
-			panX: pan.x,
-			panY: pan.y,
-			dollyIn: triggerIn > buttonDeadzone ? triggerIn : 0,
-			dollyOut: triggerOut > buttonDeadzone ? triggerOut : 0
+			gamepad,
+			object,
+			delta: deltaTime,
+			input: {
+				rotateX: rotate.x,
+				rotateY: rotate.y,
+				panX: pan.x,
+				panY: pan.y,
+				dollyIn: triggerIn > buttonDeadzone ? triggerIn : 0,
+				dollyOut: triggerOut > buttonDeadzone ? triggerOut : 0
+			}
 		};
-		let actions = this.#acceptActions(frame, deltaTime);
+		let actions = this.#acceptActions(frame);
 		if (actions === null) return;
 		if (!this.#interacting) {
 			this.#interacting = true;
 			this.#controls.dispatchEvent({ type: "start" });
-			actions = this.#acceptActions(frame, deltaTime);
+			actions = this.#acceptActions(frame);
 			if (actions === null) return;
 		}
 		const controls = this.#controls;
 		if (actions.rotateX !== 0) {
 			controls.rotateLeft(actions.rotateX);
-			actions = this.#acceptActions(frame, deltaTime);
+			actions = this.#acceptActions(frame);
 			if (actions === null) return;
 		}
 		if (actions.rotateY !== 0) {
 			controls.rotateUp(actions.rotateY);
-			actions = this.#acceptActions(frame, deltaTime);
+			actions = this.#acceptActions(frame);
 			if (actions === null) return;
 		}
 		if (actions.panX !== 0 || actions.panY !== 0) {
 			controls.pan(actions.panX, actions.panY);
-			actions = this.#acceptActions(frame, deltaTime);
+			actions = this.#acceptActions(frame);
 			if (actions === null) return;
 		}
 		if (actions.dollyIn !== 0) {
 			controls.dollyIn(1 / (1 + actions.dollyIn));
-			actions = this.#acceptActions(frame, deltaTime);
+			actions = this.#acceptActions(frame);
 			if (actions === null) return;
 		}
 		if (actions.dollyOut !== 0) {
 			controls.dollyOut(1 / (1 + actions.dollyOut));
-			this.#acceptActions(frame, deltaTime);
+			this.#acceptActions(frame);
 		}
 	}
 	/**
 	* Removes gamepad listeners and ends only this wrapper's active interaction.
-	* Repeated calls are safe; the native controls and their damping are preserved.
+	* Restores the owned native update adapter even when an end listener throws.
+	* Repeated calls are safe and disposal is terminal; native damping is preserved.
 	*/
 	dispose() {
+		if (this.#disposed) return;
+		this.#disposed = true;
+		this.#autoRotationFrame = null;
 		super.dispose();
-		this.#endInteraction();
+		try {
+			this.#endInteraction();
+		} finally {
+			if (this.#controls.update === this.#nativeUpdate) {
+				if (this.#originalUpdateDescriptor === void 0) Reflect.deleteProperty(this.#controls, "update");
+				else Object.defineProperty(this.#controls, "update", this.#originalUpdateDescriptor);
+			}
+		}
 	}
 	/**
 	* Ends the owned interaction before forwarding the active gamepad's disconnection.
@@ -149,17 +183,29 @@ var GamepadOrbitControls = class extends GamepadControls {
 	* Native disable or lack of actionable input ends the owned session; a wrapper
 	* pause stops application while retaining it. Geometric limits do not erase intent.
 	*
-	* @param input - Already processed sticks and filtered triggers for this frame.
-	* @param delta - Frame duration in seconds.
+	* @param frame - Cached input and the destination that owns it.
 	* @returns Accepted frame deltas, or `null` when input application must stop.
 	*/
-	#acceptActions(input, delta) {
-		const controls = this.#controls;
-		if (!controls.enabled) {
+	#acceptActions(frame) {
+		if (!this.#controls.enabled) {
 			this.#endInteraction();
 			return null;
 		}
-		if (!this.enabled || this.gamepad === null) return null;
+		if (!this.#ownsFrame(frame)) {
+			this.#autoRotationFrame = null;
+			return null;
+		}
+		const actions = this.#resolveActions(frame.input, frame.delta);
+		if (actions === null) {
+			this.#endInteraction();
+			return null;
+		}
+		this.#autoRotationFrame = frame;
+		return actions;
+	}
+	/** Resolves current permissions and gains without events or pipeline reads. */
+	#resolveActions(input, delta) {
+		const controls = this.#controls;
 		const rotate = controls.enableRotate ? controls.rotateSpeed * this.#options.rotateSpeed * delta * Math.PI : 0;
 		const pan = controls.enablePan ? controls.panSpeed * this.#options.panSpeed * delta * 500 : 0;
 		const zoom = controls.enableZoom ? controls.zoomSpeed * this.#options.zoomSpeed * delta : 0;
@@ -171,17 +217,68 @@ var GamepadOrbitControls = class extends GamepadControls {
 			dollyIn: input.dollyIn * zoom,
 			dollyOut: input.dollyOut * zoom
 		};
-		if (!Object.values(actions).some((value) => value !== 0)) {
-			this.#endInteraction();
-			return null;
-		}
+		if (!Object.values(actions).some((value) => value !== 0)) return null;
 		return actions;
 	}
+	/** Checks the live wrapper, selected snapshot, and camera after callbacks. */
+	#ownsFrame(frame) {
+		return !this.#disposed && this.enabled && this.gamepad === frame.gamepad && this.#controls.object === frame.object;
+	}
+	/** Releases invalid intent without ending a paused interaction or repolling. */
+	#suppressAutoRotation() {
+		const frame = this.#autoRotationFrame;
+		if (frame === null) return false;
+		if (!this.#controls.enabled || !this.#ownsFrame(frame) || this.#resolveActions(frame.input, frame.delta) === null) {
+			this.#autoRotationFrame = null;
+			return false;
+		}
+		return true;
+	}
+	/**
+	* Masks only the automatic angle for this call, retaining intent for subsequent
+	* internal and external updates. Native pointer gating and damping stay intact.
+	* Restores owned descriptors and makes retained masks inert even on failure.
+	*/
+	#updateNative(delta) {
+		if (this.#nativeUpdating) return false;
+		const controls = this.#controls;
+		this.#nativeUpdating = true;
+		try {
+			if (!this.#suppressAutoRotation()) return this.#originalUpdate.call(controls, delta);
+			const descriptor = Object.getOwnPropertyDescriptor(controls, "_getAutoRotationAngle");
+			const original = controls._getAutoRotationAngle;
+			const enumerable = descriptor?.enumerable ?? false;
+			let masking = true;
+			const angle = (delta) => masking && this.#suppressAutoRotation() ? 0 : original.call(controls, delta);
+			Object.defineProperty(controls, "_getAutoRotationAngle", {
+				configurable: true,
+				enumerable,
+				writable: true,
+				value: angle
+			});
+			try {
+				return this.#originalUpdate.call(controls, delta);
+			} finally {
+				masking = false;
+				const current = Object.getOwnPropertyDescriptor(controls, "_getAutoRotationAngle");
+				if (current?.value === angle && current.configurable === true && current.enumerable === enumerable && current.writable === true) {
+					if (descriptor === void 0) Reflect.deleteProperty(controls, "_getAutoRotationAngle");
+					else Object.defineProperty(controls, "_getAutoRotationAngle", descriptor);
+				}
+			}
+		} catch (error) {
+			this.#autoRotationFrame = null;
+			throw error;
+		} finally {
+			this.#nativeUpdating = false;
+		}
+	}
 	/**
 	* Releases session ownership before dispatching the native `end` event once.
 	* Blocks recursive updates during finalization without clearing native input or damping.
 	*/
 	#endInteraction() {
+		this.#autoRotationFrame = null;
 		if (!this.#interacting) return;
 		this.#interacting = false;
 		this.#ending = true;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "three-gamepad-controls",
   "description": "Gamepad support for Three.js controls.",
-  "version": "0.25.6",
+  "version": "0.25.8",
   "license": "MIT",
   "homepage": "https://github.com/luckasnix/three-gamepad-controls#readme",
   "author": {