three-gamepad-controls 0.24.1 → 0.24.2

package/dist/gamepad-transform-controls.js

@@ -99,8 +99,18 @@ var GamepadTransformControls = class extends GamepadControls {
 	#rotationQuaternion;
 	#rotationQuaternion2;
 	#tempQuaternion;
-	#isTransforming = false;
-	#transformStarted = false;
+	#segment = null;
+	#updating = false;
+	#ending = false;
+	#disposed = false;
+	#interrupted = false;
+	#needsNeutral = false;
+	#pointerRevision = 0;
+	#mouseDownEvent = {
+		type: "mouseDown",
+		mode: "translate"
+	};
+	#onNativeMouseDown;
 	#rotationAmount = 0;
 	#freeRotationX = 0;
 	#freeRotationY = 0;
@@ -151,6 +161,10 @@ var GamepadTransformControls = class extends GamepadControls {
 		this.#rotationQuaternion = new Quaternion();
 		this.#rotationQuaternion2 = new Quaternion();
 		this.#tempQuaternion = new Quaternion();
+		this.#onNativeMouseDown = (event) => {
+			if (event !== this.#mouseDownEvent) this.#pointerRevision += 1;
+		};
+		controls.addEventListener("mouseDown", this.#onNativeMouseDown);
 	}
 	/**
 	* Maps the current gamepad state to `TransformControls` mode, axis,
@@ -159,9 +173,33 @@ var GamepadTransformControls = class extends GamepadControls {
 	* @param deltaTime - Seconds since the last frame.
 	*/
 	onUpdate(deltaTime) {
+		if (this.#updating || this.#ending) return;
+		this.#updating = true;
+		this.#interrupted = false;
+		try {
+			this.#updateTransform(deltaTime);
+		} finally {
+			this.#updating = false;
+		}
+	}
+	/**
+	* Processes one frame of selection, reset, and movement while respecting
+	* segment ownership and the neutral input required before reacquisition.
+	*
+	* @param deltaTime - Seconds since the last frame.
+	*/
+	#updateTransform(deltaTime) {
 		const controls = this.#controls;
+		const { transformStick } = this.#options;
+		const transform = this.gamepadInput.stick(transformStick.xAxis, transformStick.yAxis, transformStick.pipeline);
+		const neutral = transform.x === 0 && transform.y === 0;
+		this.#reconcileSegment();
+		if (neutral) this.#needsNeutral = false;
 		if (!this.#canApplyInput()) return;
-		if (controls.dragging && !this.#isTransforming) return;
+		if (controls.dragging && this.#segment === null) {
+			this.#needsNeutral = !neutral;
+			return;
+		}
 		const startedButtons = this.#getStartedButtons();
 		this.#handleModeAndAxisButtons(startedButtons);
 		if (!this.#canApplyInput()) return;
@@ -172,31 +210,32 @@ var GamepadTransformControls = class extends GamepadControls {
 			this.#endTransform(true);
 			return;
 		}
-		const axis = this.#ensureValidAxis();
-		if (!this.#canApplyInput()) return;
-		if (axis === null) {
-			this.#endTransform(true);
-			return;
-		}
-		const { transformStick } = this.#options;
-		const transform = this.gamepadInput.stick(transformStick.xAxis, transformStick.yAxis, transformStick.pipeline);
-		if (transform.x === 0 && transform.y === 0) {
+		if (neutral) {
 			this.#endTransform(false);
 			return;
 		}
-		if (!this.#isTransforming) this.#startTransform(object);
+		if (this.#needsNeutral) return;
+		const axis = this.#resolveAxis();
+		this.#setActiveAxis(axis);
 		if (!this.#canApplyInput()) return;
-		if (!this.#transformStarted) {
-			this.#transformStarted = true;
-			controls.dispatchEvent({
-				type: "mouseDown",
-				mode: controls.mode
-			});
+		if (axis === null) return;
+		if (this.#segment === null) this.#startTransform(object, axis);
+		if (!this.#canApplyInput()) return;
+		const segment = this.#segment;
+		if (!segment.started) {
+			segment.started = true;
+			const context = this.#readContext();
+			this.#mouseDownEvent.mode = segment.mode;
+			controls.dispatchEvent(this.#mouseDownEvent);
+			this.#afterCallback(context);
 		}
 		if (!this.#canApplyInput()) return;
 		if (this.#applyCurrentTransform(object, axis, deltaTime, transform.x, transform.y)) {
+			const context = this.#readContext();
 			controls.dispatchEvent({ type: "change" });
+			if (!this.#afterCallback(context)) return;
 			controls.dispatchEvent({ type: "objectChange" });
+			this.#afterCallback(context);
 		}
 	}
 	/**
@@ -204,7 +243,13 @@ var GamepadTransformControls = class extends GamepadControls {
 	*/
 	dispose() {
 		super.dispose();
-		this.#endTransform(true);
+		this.#disposed = true;
+		if (this.#ending) return;
+		try {
+			this.#endTransform(true);
+		} finally {
+			this.#controls.removeEventListener("mouseDown", this.#onNativeMouseDown);
+		}
 	}
 	/**
 	* Ends any active transform if the active gamepad disconnects mid-drag.
@@ -215,12 +260,91 @@ var GamepadTransformControls = class extends GamepadControls {
 		this.#endTransform(true);
 		super.onGamepadDisconnected(gamepad);
 	}
+	/**
+	* Checks whether this update can continue applying gamepad input.
+	* Native disable ends the owned segment; a wrapper pause retains it.
+	*
+	* @returns `true` when input remains enabled, a gamepad is available,
+	*          and no callback has interrupted this update.
+	*/
 	#canApplyInput() {
 		if (!this.#controls.enabled) {
 			this.#endTransform(true);
 			return false;
 		}
-		return this.enabled && this.gamepad !== null;
+		return !this.#interrupted && this.enabled && this.gamepad !== null;
+	}
+	/**
+	* Captures the native context and pointer acquisition revision without
+	* modifying the control or copying the attached object's transform.
+	*
+	* @returns A context snapshot for segment and callback validation.
+	*/
+	#readContext() {
+		const { object, mode, space, axis, dragging } = this.#controls;
+		return {
+			object,
+			mode,
+			space,
+			axis,
+			dragging,
+			pointerRevision: this.#pointerRevision
+		};
+	}
+	/**
+	* Compares the current native context and pointer revision with a snapshot.
+	*
+	* @param context - Expected object, selection, dragging state, and pointer revision.
+	* @returns `true` when every captured context field still matches.
+	*/
+	#matchesContext(context) {
+		const controls = this.#controls;
+		return controls.object === context.object && controls.mode === context.mode && controls.space === context.space && controls.axis === context.axis && controls.dragging === context.dragging && this.#pointerRevision === context.pointerRevision;
+	}
+	/**
+	* Ends the owned segment when its context changes or its axis is disallowed.
+	* A change of attached object also requires neutral input before reacquisition.
+	*/
+	#reconcileSegment() {
+		const segment = this.#segment;
+		if (segment === null) return;
+		if (!this.#matchesContext(segment) || !this.#isAxisAllowed(segment.mode, segment.axis)) {
+			if (this.#controls.object !== segment.object) this.#needsNeutral = true;
+			this.#endTransform(false);
+		}
+	}
+	/**
+	* Revalidates context, segment ownership, and permissions after synchronous
+	* callbacks, interrupting this update if its context or segment was invalidated.
+	*
+	* @param context - Context expected after the operation that invoked callbacks.
+	* @returns `true` when this update may continue applying gamepad input.
+	*/
+	#afterCallback(context) {
+		const segment = this.#segment;
+		if (!this.#matchesContext(context)) {
+			this.#interrupted = true;
+			if (this.#controls.object !== context.object) this.#needsNeutral = true;
+		}
+		this.#reconcileSegment();
+		if (segment !== null && this.#segment !== segment) this.#interrupted = true;
+		return this.#canApplyInput();
+	}
+	/**
+	* Writes a native property and revalidates the context after its synchronous
+	* notifications, accounting for the intended property change.
+	*
+	* @param key - Native selection or dragging property to update.
+	* @param value - Value to assign to the selected property.
+	*/
+	#writeProperty(key, value) {
+		const context = {
+			...this.#readContext(),
+			[key]: value
+		};
+		const controls = this.#controls;
+		controls[key] = value;
+		this.#afterCallback(context);
 	}
 	/**
 	* Applies mode, space, and axis button transitions from the current frame.
@@ -249,14 +373,27 @@ var GamepadTransformControls = class extends GamepadControls {
 		if (this.#controls.mode === mode) return;
 		this.#endTransform(false);
 		if (!this.#canApplyInput()) return;
+		const context = {
+			...this.#readContext(),
+			mode
+		};
 		this.#controls.setMode(mode);
-		if (this.#canApplyInput()) this.#ensureValidAxis();
+		if (this.#afterCallback(context)) this.#setActiveAxis(this.#resolveAxis(null));
 	}
+	/**
+	* Ends the owned segment and toggles between local and world transform space
+	* if input remains permitted after the end notification.
+	*/
 	#toggleSpace() {
 		const nextSpace = this.#controls.space === "world" ? "local" : "world";
 		this.#endTransform(false);
 		if (!this.#canApplyInput()) return;
+		const context = {
+			...this.#readContext(),
+			space: nextSpace
+		};
 		this.#controls.setSpace(nextSpace);
+		this.#afterCallback(context);
 	}
 	/**
 	* Selects an explicit axis when it is valid for the current mode.
@@ -267,9 +404,11 @@ var GamepadTransformControls = class extends GamepadControls {
 		if (!this.#isAxisAllowed(this.#controls.mode, axis)) return;
 		this.#endTransform(false);
 		if (!this.#canApplyInput()) return;
-		this.#activeAxisByMode[this.#controls.mode] = axis;
-		this.#ensureValidAxis();
+		this.#setActiveAxis(axis);
 	}
+	/**
+	* Selects the next visible composite axis available in the current mode.
+	*/
 	#cycleCompositeAxis() {
 		const validAxes = this.#getVisibleAxes(COMPOSITE_AXES[this.#controls.mode]);
 		this.#cycleThroughAxes(validAxes, 1);
@@ -289,31 +428,30 @@ var GamepadTransformControls = class extends GamepadControls {
 	* @param direction - `1` for next axis, `-1` for previous axis.
 	*/
 	#cycleThroughAxes(axes, direction) {
+		this.#endTransform(false);
+		if (!this.#canApplyInput()) return;
 		if (axes.length === 0) {
 			this.#setActiveAxis(null);
 			return;
 		}
-		this.#endTransform(false);
-		if (!this.#canApplyInput()) return;
-		const current = this.#activeAxisByMode[this.#controls.mode];
-		const currentIndex = current === null ? -1 : axes.indexOf(current);
+		const current = this.#resolveAxis();
+		const currentIndex = axes.indexOf(current);
 		const nextIndex = currentIndex === -1 ? 0 : (currentIndex + direction + axes.length) % axes.length;
-		this.#activeAxisByMode[this.#controls.mode] = axes[nextIndex];
-		this.#ensureValidAxis();
+		this.#setActiveAxis(axes[nextIndex]);
 	}
 	/**
-	* Ensures the highlighted TransformControls axis is valid and visible.
+	* Resolves selection without writing to the native control or axis memory.
 	*
+	* @param nativeAxis - Preferred native axis, defaulting to the current selection.
+	*                     Pass `null` to use mode memory before the first allowed axis.
 	* @returns The active valid axis, or `null` when no axis is available.
 	*/
-	#ensureValidAxis() {
+	#resolveAxis(nativeAxis = this.#controls.axis) {
 		const mode = this.#controls.mode;
+		if (nativeAxis !== null && this.#isAxisAllowed(mode, nativeAxis)) return nativeAxis;
 		const current = this.#activeAxisByMode[mode];
 		const validAxes = this.#getValidAxes(mode);
-		const nextAxis = current !== null && validAxes.includes(current) ? current : validAxes[0] ?? null;
-		this.#activeAxisByMode[mode] = nextAxis;
-		if (this.#controls.axis !== nextAxis) this.#controls.axis = nextAxis;
-		return nextAxis;
+		return current !== null && validAxes.includes(current) ? current : validAxes[0] ?? null;
 	}
 	/**
 	* Updates both the remembered axis for the current mode and the control axis.
@@ -322,7 +460,7 @@ var GamepadTransformControls = class extends GamepadControls {
 	*/
 	#setActiveAxis(axis) {
 		this.#activeAxisByMode[this.#controls.mode] = axis;
-		if (this.#controls.axis !== axis) this.#controls.axis = axis;
+		if (this.#controls.axis !== axis) this.#writeProperty("axis", axis);
 	}
 	/**
 	* Returns all visible axes supported by a TransformControls mode.
@@ -375,41 +513,71 @@ var GamepadTransformControls = class extends GamepadControls {
 		}
 	}
 	/**
-	* Starts a TransformControls drag interaction for the active object and axis.
+	* Captures a segment's transform origin and claims dragging ownership before
+	* notifying native property listeners. The update publishes `mouseDown` later.
 	*
 	* @param object - Object attached to TransformControls for this update.
+	* @param axis - Valid axis acquired for the new segment.
 	*/
-	#startTransform(object) {
-		const controls = this.#controls;
+	#startTransform(object, axis) {
 		this.#captureTransformStart(object);
-		this.#isTransforming = true;
-		controls.dragging = true;
+		this.#segment = {
+			...this.#readContext(),
+			object,
+			axis,
+			dragging: true,
+			started: false
+		};
+		this.#writeProperty("dragging", true);
 	}
 	/**
-	* Ends an active TransformControls drag interaction.
+	* Releases the owned segment and ends its published interaction once,
+	* preserving pointer ownership and context changes made by callbacks.
 	*
-	* @param clearAxis - Whether to clear the highlighted axis after ending.
+	* @param clearAxis - Whether to clear the highlighted axis if ownership
+	*                    and context still permit it after end notifications.
 	*/
 	#endTransform(clearAxis) {
-		if (!this.#isTransforming) return;
+		const segment = this.#segment;
+		if (segment === null) return;
 		const controls = this.#controls;
-		const started = this.#transformStarted;
-		const mode = controls.mode;
-		this.#isTransforming = false;
-		this.#transformStarted = false;
-		if (started) controls.dispatchEvent({
-			type: "mouseUp",
-			mode
-		});
-		controls.dragging = false;
-		if (clearAxis) this.#setActiveAxis(null);
+		const context = this.#readContext();
+		this.#segment = null;
+		this.#ending = true;
+		try {
+			if (segment.started) controls.dispatchEvent({
+				type: "mouseUp",
+				mode: segment.mode
+			});
+			const unchanged = this.#matchesContext(context);
+			if (!unchanged) {
+				this.#interrupted = true;
+				if (controls.object !== context.object) this.#needsNeutral = true;
+			}
+			const ownsDragging = this.#pointerRevision === segment.pointerRevision;
+			if (ownsDragging && controls.dragging === context.dragging) this.#writeProperty("dragging", false);
+			if (clearAxis && ownsDragging && unchanged && this.#matchesContext({
+				...context,
+				dragging: false
+			}) && controls.axis === segment.axis) this.#setActiveAxis(null);
+		} finally {
+			this.#ending = false;
+			if (this.#disposed) controls.removeEventListener("mouseDown", this.#onNativeMouseDown);
+		}
 	}
+	/**
+	* Restores the owned segment's transform origin through native reset and
+	* resets its accumulators if callbacks leave the same segment active.
+	*/
 	#resetActiveTransform() {
-		const object = this.#controls.object;
-		if (!this.#isTransforming || object === void 0) return;
+		const segment = this.#segment;
+		if (segment === null) return;
+		const context = this.#readContext();
 		this.#controls.reset();
-		this.#accumulatedPosition.copy(object.position);
-		this.#accumulatedScale.copy(object.scale);
+		this.#afterCallback(context);
+		if (this.#segment !== segment) return;
+		this.#accumulatedPosition.copy(segment.object.position);
+		this.#accumulatedScale.copy(segment.object.scale);
 		this.#rotationAmount = 0;
 		this.#freeRotationX = 0;
 		this.#freeRotationY = 0;

package/package.json

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