three-gamepad-controls 0.9.0 → 0.10.0

package/README.md

@@ -46,3 +46,4 @@ bun add three-gamepad-controls
 - [GamepadOrbitControls](./docs/gamepad-orbit-controls.md) — Gamepad support for `OrbitControls`.
 - [GamepadPointerLockControls](./docs/gamepad-pointer-lock-controls.md) — Gamepad support for `PointerLockControls`.
 - [GamepadTrackballControls](./docs/gamepad-trackball-controls.md) — Gamepad support for `TrackballControls`.
+- [GamepadTransformControls](./docs/gamepad-transform-controls.md) — Gamepad support for `TransformControls`.

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

@@ -0,0 +1,132 @@
+import { GamepadControls } from "./gamepad-controls.js";
+import { TransformControls } from "three/addons/controls/TransformControls.js";
+
+//#region src/gamepad-transform-controls.d.ts
+/**
+ * Configuration for {@link GamepadTransformControls}.
+ *
+ * Every property has a sensible default, so you only need to pass the properties you want to override.
+ */
+type GamepadTransformControlsOptions = {
+  /**
+   * Screen-relative translation speed multiplier.
+   * @default 1.0
+   */
+  translateSpeed: number;
+  /**
+   * Rotation speed multiplier.
+   * @default 1.0
+   */
+  rotateSpeed: number;
+  /**
+   * Scale speed multiplier.
+   * @default 1.0
+   */
+  scaleSpeed: number;
+  /**
+   * Axis dead zone threshold in the range `[0, 1]`.
+   * @default 0.1
+   */
+  deadzone: number;
+  /**
+   * Axis index for **horizontal** transform input.
+   * @default 0 - Left stick X
+   */
+  axisTransformX: number;
+  /**
+   * Axis index for **vertical** transform input.
+   * @default 1 - Left stick Y
+   */
+  axisTransformY: number;
+  /**
+   * Button index for selecting translate mode.
+   * @default 0 - South face button
+   */
+  buttonTranslate: number;
+  /**
+   * Button index for selecting rotate mode.
+   * @default 1 - East face button
+   */
+  buttonRotate: number;
+  /**
+   * Button index for selecting scale mode.
+   * @default 2 - West face button
+   */
+  buttonScale: number;
+  /**
+   * Button index for toggling world/local space.
+   * @default 3 - North face button
+   */
+  buttonToggleSpace: number;
+  /**
+   * Button index for selecting the X axis.
+   * @default 15 - D-pad right
+   */
+  buttonAxisX: number;
+  /**
+   * Button index for selecting the Y axis.
+   * @default 12 - D-pad up
+   */
+  buttonAxisY: number;
+  /**
+   * Button index for selecting the Z axis.
+   * @default 14 - D-pad left
+   */
+  buttonAxisZ: number;
+  /**
+   * Button index for cycling composite axes in the active mode.
+   * @default 13 - D-pad down
+   */
+  buttonAxisComposite: number;
+  /**
+   * Button index for selecting the previous valid axis.
+   * @default 4 - Left shoulder
+   */
+  buttonAxisPrevious: number;
+  /**
+   * Button index for selecting the next valid axis.
+   * @default 5 - Right shoulder
+   */
+  buttonAxisNext: number;
+  /**
+   * Button index for resetting the active transform.
+   * @default 9 - Start button
+   */
+  buttonReset: number;
+};
+/**
+ * Adds gamepad support to Three.js `TransformControls`.
+ *
+ * Modes and axes are selected explicitly with buttons. Moving the transform
+ * stick starts a native-style transform interaction, and releasing it ends
+ * the interaction while keeping the active axis highlighted.
+ */
+declare class GamepadTransformControls extends GamepadControls {
+  #private;
+  /**
+   * @param controls - A Three.js `TransformControls` instance.
+   * @param options - Optional overrides for the default behavior.
+   *                  Any property not provided falls back to its default value.
+   */
+  constructor(controls: TransformControls, options?: Partial<GamepadTransformControlsOptions>);
+  /**
+   * Maps the current gamepad state to `TransformControls` mode, axis,
+   * translate, rotate, scale, and reset behavior.
+   *
+   * @param deltaTime - Seconds since the last frame.
+   * @param gamepad - Fresh gamepad snapshot provided by the base class.
+   */
+  protected onUpdate(deltaTime: number, gamepad: Gamepad): void;
+  /**
+   * Ends any active transform before disposing the gamepad lifecycle listeners.
+   */
+  dispose(): void;
+  /**
+   * Ends any active transform if the active gamepad disconnects mid-drag.
+   *
+   * @param gamepad - The gamepad that just disconnected.
+   */
+  protected onGamepadDisconnected(gamepad: Gamepad): void;
+}
+//#endregion
+export { GamepadTransformControls, GamepadTransformControlsOptions };

package/dist/gamepad-transform-controls.js

@@ -0,0 +1,634 @@
+import { GAMEPAD_AXIS, GAMEPAD_BUTTON } from "./core.js";
+import { GamepadControls } from "./gamepad-controls.js";
+import { Matrix4, Quaternion, Vector2, Vector3 } from "three";
+//#region src/gamepad-transform-controls.ts
+/**
+* Default options merged in the constructor when no explicit configuration is provided.
+*/
+const DEFAULT_TRANSFORM_OPTIONS = {
+	translateSpeed: 1,
+	rotateSpeed: 1,
+	scaleSpeed: 1,
+	deadzone: .1,
+	axisTransformX: GAMEPAD_AXIS.LeftX,
+	axisTransformY: GAMEPAD_AXIS.LeftY,
+	buttonTranslate: GAMEPAD_BUTTON.South,
+	buttonRotate: GAMEPAD_BUTTON.East,
+	buttonScale: GAMEPAD_BUTTON.West,
+	buttonToggleSpace: GAMEPAD_BUTTON.North,
+	buttonAxisX: GAMEPAD_BUTTON.DPadRight,
+	buttonAxisY: GAMEPAD_BUTTON.DPadUp,
+	buttonAxisZ: GAMEPAD_BUTTON.DPadLeft,
+	buttonAxisComposite: GAMEPAD_BUTTON.DPadDown,
+	buttonAxisPrevious: GAMEPAD_BUTTON.LeftShoulder,
+	buttonAxisNext: GAMEPAD_BUTTON.RightShoulder,
+	buttonReset: GAMEPAD_BUTTON.Start
+};
+const MODE_AXES = {
+	translate: [
+		"X",
+		"Y",
+		"Z",
+		"XY",
+		"YZ",
+		"XZ",
+		"XYZ"
+	],
+	rotate: [
+		"X",
+		"Y",
+		"Z",
+		"E",
+		"XYZE"
+	],
+	scale: [
+		"X",
+		"Y",
+		"Z",
+		"XYZ"
+	]
+};
+const COMPOSITE_AXES = {
+	translate: [
+		"XY",
+		"YZ",
+		"XZ",
+		"XYZ"
+	],
+	rotate: ["E", "XYZE"],
+	scale: ["XYZ"]
+};
+const PROJECTED_AXIS_EPSILON = .001;
+/**
+* Adds gamepad support to Three.js `TransformControls`.
+*
+* Modes and axes are selected explicitly with buttons. Moving the transform
+* stick starts a native-style transform interaction, and releasing it ends
+* the interaction while keeping the active axis highlighted.
+*/
+var GamepadTransformControls = class extends GamepadControls {
+	#controls;
+	#options;
+	#pressedButtons;
+	#activeAxisByMode;
+	#viewSize;
+	#parentInverse;
+	#cameraWorldPosition;
+	#cameraForward;
+	#cameraRight;
+	#cameraUp;
+	#eye;
+	#axisWorld;
+	#axisWorld2;
+	#axisLocal;
+	#worldDelta;
+	#localDelta;
+	#worldPositionStart;
+	#worldPosition;
+	#positionStart;
+	#accumulatedPosition;
+	#snappedPosition;
+	#parentPosition;
+	#parentScale;
+	#scaleStart;
+	#accumulatedScale;
+	#snappedScale;
+	#worldQuaternionStart;
+	#quaternionStart;
+	#parentQuaternion;
+	#parentQuaternionInv;
+	#rotationQuaternion;
+	#rotationQuaternion2;
+	#tempQuaternion;
+	#isTransforming = false;
+	#rotationAmount = 0;
+	#freeRotationX = 0;
+	#freeRotationY = 0;
+	/**
+	* @param controls - A Three.js `TransformControls` instance.
+	* @param options - Optional overrides for the default behavior.
+	*                  Any property not provided falls back to its default value.
+	*/
+	constructor(controls, options) {
+		super();
+		this.#controls = controls;
+		this.#options = {
+			...DEFAULT_TRANSFORM_OPTIONS,
+			...options
+		};
+		this.#pressedButtons = /* @__PURE__ */ new Set();
+		this.#activeAxisByMode = {
+			translate: "X",
+			rotate: "X",
+			scale: "X"
+		};
+		this.#viewSize = new Vector2();
+		this.#parentInverse = new Matrix4();
+		this.#cameraWorldPosition = new Vector3();
+		this.#cameraForward = new Vector3();
+		this.#cameraRight = new Vector3();
+		this.#cameraUp = new Vector3();
+		this.#eye = new Vector3();
+		this.#axisWorld = new Vector3();
+		this.#axisWorld2 = new Vector3();
+		this.#axisLocal = new Vector3();
+		this.#worldDelta = new Vector3();
+		this.#localDelta = new Vector3();
+		this.#worldPositionStart = new Vector3();
+		this.#worldPosition = new Vector3();
+		this.#positionStart = new Vector3();
+		this.#accumulatedPosition = new Vector3();
+		this.#snappedPosition = new Vector3();
+		this.#parentPosition = new Vector3();
+		this.#parentScale = new Vector3(1, 1, 1);
+		this.#scaleStart = new Vector3();
+		this.#accumulatedScale = new Vector3();
+		this.#snappedScale = new Vector3();
+		this.#worldQuaternionStart = new Quaternion();
+		this.#quaternionStart = new Quaternion();
+		this.#parentQuaternion = new Quaternion();
+		this.#parentQuaternionInv = new Quaternion();
+		this.#rotationQuaternion = new Quaternion();
+		this.#rotationQuaternion2 = new Quaternion();
+		this.#tempQuaternion = new Quaternion();
+	}
+	/**
+	* Maps the current gamepad state to `TransformControls` mode, axis,
+	* translate, rotate, scale, and reset behavior.
+	*
+	* @param deltaTime - Seconds since the last frame.
+	* @param gamepad - Fresh gamepad snapshot provided by the base class.
+	*/
+	onUpdate(deltaTime, gamepad) {
+		const startedButtons = this.#getStartedButtons(gamepad);
+		this.#handleModeAndAxisButtons(startedButtons);
+		if (startedButtons.has(this.#options.buttonReset)) this.#resetActiveTransform();
+		const controls = this.#controls;
+		if (!controls.enabled || controls.object === void 0) {
+			this.#endTransform(true);
+			return;
+		}
+		if (this.#ensureValidAxis() === null) {
+			this.#endTransform(true);
+			return;
+		}
+		const transformX = this.#applyDeadzone(gamepad.axes[this.#options.axisTransformX] ?? 0, this.#options.deadzone);
+		const transformY = this.#applyDeadzone(gamepad.axes[this.#options.axisTransformY] ?? 0, this.#options.deadzone);
+		if (transformX === 0 && transformY === 0) {
+			this.#endTransform(false);
+			return;
+		}
+		if (!this.#isTransforming && !this.#startTransform()) return;
+		if (this.#applyCurrentTransform(deltaTime, transformX, transformY)) {
+			controls.dispatchEvent({ type: "change" });
+			controls.dispatchEvent({ type: "objectChange" });
+		}
+	}
+	/**
+	* Ends any active transform before disposing the gamepad lifecycle listeners.
+	*/
+	dispose() {
+		this.#endTransform(true);
+		this.#pressedButtons.clear();
+		super.dispose();
+	}
+	/**
+	* Ends any active transform if the active gamepad disconnects mid-drag.
+	*
+	* @param gamepad - The gamepad that just disconnected.
+	*/
+	onGamepadDisconnected(gamepad) {
+		this.#endTransform(true);
+		this.#pressedButtons.clear();
+		super.onGamepadDisconnected(gamepad);
+	}
+	#handleModeAndAxisButtons(startedButtons) {
+		const { buttonTranslate, buttonRotate, buttonScale, buttonToggleSpace, buttonAxisX, buttonAxisY, buttonAxisZ, buttonAxisComposite, buttonAxisPrevious, buttonAxisNext } = this.#options;
+		if (startedButtons.has(buttonTranslate)) this.#setMode("translate");
+		if (startedButtons.has(buttonRotate)) this.#setMode("rotate");
+		if (startedButtons.has(buttonScale)) this.#setMode("scale");
+		if (startedButtons.has(buttonToggleSpace)) this.#toggleSpace();
+		if (startedButtons.has(buttonAxisX)) this.#selectAxis("X");
+		if (startedButtons.has(buttonAxisY)) this.#selectAxis("Y");
+		if (startedButtons.has(buttonAxisZ)) this.#selectAxis("Z");
+		if (startedButtons.has(buttonAxisComposite)) this.#cycleCompositeAxis();
+		if (startedButtons.has(buttonAxisPrevious)) this.#cycleAxis(-1);
+		if (startedButtons.has(buttonAxisNext)) this.#cycleAxis(1);
+	}
+	#setMode(mode) {
+		if (this.#controls.mode === mode) return;
+		this.#endTransform(false);
+		this.#controls.setMode(mode);
+		this.#ensureValidAxis();
+	}
+	#toggleSpace() {
+		const nextSpace = this.#controls.space === "world" ? "local" : "world";
+		this.#endTransform(false);
+		this.#controls.setSpace(nextSpace);
+	}
+	#selectAxis(axis) {
+		if (!this.#isAxisAllowed(this.#controls.mode, axis)) return;
+		this.#endTransform(false);
+		this.#activeAxisByMode[this.#controls.mode] = axis;
+		this.#ensureValidAxis();
+	}
+	#cycleCompositeAxis() {
+		const validAxes = COMPOSITE_AXES[this.#controls.mode].filter((axis) => this.#isAxisVisible(axis));
+		this.#cycleThroughAxes(validAxes, 1);
+	}
+	#cycleAxis(direction) {
+		this.#cycleThroughAxes(this.#getValidAxes(this.#controls.mode), direction);
+	}
+	#cycleThroughAxes(axes, direction) {
+		if (axes.length === 0) {
+			this.#setActiveAxis(null);
+			return;
+		}
+		this.#endTransform(false);
+		const current = this.#activeAxisByMode[this.#controls.mode];
+		const currentIndex = current === null ? -1 : axes.indexOf(current);
+		const nextIndex = currentIndex === -1 ? 0 : (currentIndex + direction + axes.length) % axes.length;
+		this.#activeAxisByMode[this.#controls.mode] = axes[nextIndex] ?? null;
+		this.#ensureValidAxis();
+	}
+	#ensureValidAxis() {
+		const mode = this.#controls.mode;
+		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;
+	}
+	#setActiveAxis(axis) {
+		this.#activeAxisByMode[this.#controls.mode] = axis;
+		if (this.#controls.axis !== axis) this.#controls.axis = axis;
+	}
+	#getValidAxes(mode) {
+		return MODE_AXES[mode].filter((axis) => this.#isAxisVisible(axis));
+	}
+	#isAxisAllowed(mode, axis) {
+		return MODE_AXES[mode].includes(axis) && this.#isAxisVisible(axis);
+	}
+	#isAxisVisible(axis) {
+		const controls = this.#controls;
+		switch (axis) {
+			case "X": return controls.showX;
+			case "Y": return controls.showY;
+			case "Z": return controls.showZ;
+			case "XY": return controls.showX && controls.showY && controls.showXY;
+			case "YZ": return controls.showY && controls.showZ && controls.showYZ;
+			case "XZ": return controls.showX && controls.showZ && controls.showXZ;
+			case "XYZ":
+			case "XYZE": return controls.showX && controls.showY && controls.showZ;
+			case "E": return true;
+		}
+	}
+	#startTransform() {
+		const controls = this.#controls;
+		const object = controls.object;
+		if (object === void 0 || controls.axis === null) return false;
+		this.#captureTransformStart(object);
+		controls.dragging = true;
+		this.#isTransforming = true;
+		controls.dispatchEvent({
+			type: "mouseDown",
+			mode: controls.mode
+		});
+		return true;
+	}
+	#endTransform(clearAxis) {
+		const controls = this.#controls;
+		if (this.#isTransforming) {
+			this.#isTransforming = false;
+			controls.dispatchEvent({
+				type: "mouseUp",
+				mode: controls.mode
+			});
+			controls.dragging = false;
+		}
+		if (clearAxis) this.#setActiveAxis(null);
+	}
+	#resetActiveTransform() {
+		const object = this.#controls.object;
+		if (!this.#isTransforming || object === void 0) return;
+		this.#controls.reset();
+		this.#accumulatedPosition.copy(object.position);
+		this.#accumulatedScale.copy(object.scale);
+		this.#rotationAmount = 0;
+		this.#freeRotationX = 0;
+		this.#freeRotationY = 0;
+	}
+	#captureTransformStart(object) {
+		object.updateWorldMatrix(true, false);
+		object.parent?.updateWorldMatrix(true, false);
+		this.#positionStart.copy(object.position);
+		this.#quaternionStart.copy(object.quaternion);
+		this.#scaleStart.copy(object.scale);
+		this.#accumulatedPosition.copy(object.position);
+		this.#accumulatedScale.copy(object.scale);
+		object.matrixWorld.decompose(this.#worldPositionStart, this.#worldQuaternionStart, this.#snappedScale);
+		this.#captureParentTransform(object);
+		this.#controls._positionStart.copy(this.#positionStart);
+		this.#controls._quaternionStart.copy(this.#quaternionStart);
+		this.#controls._scaleStart.copy(this.#scaleStart);
+		this.#controls.pointStart.set(0, 0, 0);
+		this.#controls.pointEnd.set(0, 0, 0);
+		this.#rotationAmount = 0;
+		this.#freeRotationX = 0;
+		this.#freeRotationY = 0;
+	}
+	#captureParentTransform(object) {
+		if (object.parent === null) {
+			this.#parentPosition.set(0, 0, 0);
+			this.#parentQuaternion.identity();
+			this.#parentQuaternionInv.identity();
+			this.#parentScale.set(1, 1, 1);
+			return;
+		}
+		object.parent.updateWorldMatrix(true, false);
+		object.parent.matrixWorld.decompose(this.#parentPosition, this.#parentQuaternion, this.#parentScale);
+		this.#parentQuaternionInv.copy(this.#parentQuaternion).invert();
+	}
+	#applyCurrentTransform(deltaTime, transformX, transformY) {
+		switch (this.#controls.mode) {
+			case "translate": return this.#applyTranslate(deltaTime, transformX, transformY);
+			case "rotate": return this.#applyRotate(deltaTime, transformX, transformY);
+			case "scale": return this.#applyScale(deltaTime, transformX, transformY);
+		}
+	}
+	#applyTranslate(deltaTime, transformX, transformY) {
+		const controls = this.#controls;
+		const object = controls.object;
+		const axis = controls.axis;
+		if (object === void 0 || axis === null) return false;
+		this.#updateCameraState(object);
+		this.#worldDelta.set(0, 0, 0);
+		const scale = controls.axis === "XYZ" ? "world" : controls.space;
+		const speed = controls.axis === "XYZ" ? this.#options.translateSpeed * deltaTime : (this.#viewSize.x + this.#viewSize.y) / 2 * this.#options.translateSpeed * deltaTime;
+		if (axis === "XYZ") {
+			this.#worldDelta.addScaledVector(this.#cameraRight, transformX * this.#viewSize.x * speed);
+			this.#worldDelta.addScaledVector(this.#cameraUp, -transformY * this.#viewSize.y * speed);
+		} else this.#addAxisTranslation(axis, scale, transformX, transformY, speed);
+		if (this.#worldDelta.lengthSq() === 0) return false;
+		this.#worldDeltaToLocalDelta(this.#worldDelta, this.#localDelta);
+		this.#accumulatedPosition.add(this.#localDelta);
+		this.#applyAccumulatedPosition(object, axis, scale);
+		return true;
+	}
+	#addAxisTranslation(axis, space, transformX, transformY, distance) {
+		for (const letter of [
+			"X",
+			"Y",
+			"Z"
+		]) {
+			if (!axis.includes(letter)) continue;
+			this.#getTransformAxisWorld(letter, space, this.#axisWorld);
+			this.#worldDelta.addScaledVector(this.#axisWorld, this.#getProjectedAxisInput(this.#axisWorld, transformX, transformY, this.#getDominantInput(transformX, -transformY)) * distance);
+		}
+	}
+	#applyAccumulatedPosition(object, axis, space) {
+		this.#snappedPosition.copy(this.#accumulatedPosition);
+		if (this.#controls.translationSnap !== null) this.#snapPosition(object, axis, space, this.#controls.translationSnap);
+		this.#snappedPosition.x = Math.max(this.#controls.minX, Math.min(this.#controls.maxX, this.#snappedPosition.x));
+		this.#snappedPosition.y = Math.max(this.#controls.minY, Math.min(this.#controls.maxY, this.#snappedPosition.y));
+		this.#snappedPosition.z = Math.max(this.#controls.minZ, Math.min(this.#controls.maxZ, this.#snappedPosition.z));
+		object.position.copy(this.#snappedPosition);
+		object.updateMatrixWorld();
+	}
+	#snapPosition(object, axis, space, snap) {
+		if (snap <= 0) return;
+		if (space === "world") {
+			this.#localPositionToWorld(object, this.#snappedPosition);
+			for (const letter of [
+				"X",
+				"Y",
+				"Z"
+			]) if (axis.includes(letter)) this.#setVectorComponent(this.#worldPosition, letter, this.#snapValue(this.#getVectorComponent(this.#worldPosition, letter), snap));
+			this.#worldPositionToLocal(object, this.#worldPosition);
+			return;
+		}
+		this.#tempQuaternion.copy(this.#quaternionStart).invert();
+		this.#snappedPosition.applyQuaternion(this.#tempQuaternion);
+		for (const letter of [
+			"X",
+			"Y",
+			"Z"
+		]) if (axis.includes(letter)) this.#setVectorComponent(this.#snappedPosition, letter, this.#snapValue(this.#getVectorComponent(this.#snappedPosition, letter), snap));
+		this.#snappedPosition.applyQuaternion(this.#quaternionStart);
+	}
+	#applyRotate(deltaTime, transformX, transformY) {
+		const controls = this.#controls;
+		const object = controls.object;
+		const axis = controls.axis;
+		if (object === void 0 || axis === null) return false;
+		this.#updateCameraState(object);
+		const angleScale = this.#options.rotateSpeed * deltaTime * Math.PI;
+		if (axis === "XYZE") {
+			this.#freeRotationX += transformX * angleScale;
+			this.#freeRotationY += -transformY * angleScale;
+			this.#applyFreeRotation(object);
+			return true;
+		}
+		let input;
+		if (axis === "E") {
+			this.#axisWorld.copy(this.#cameraForward).normalize();
+			input = this.#getDominantInput(transformX, -transformY);
+		} else if (axis === "X" || axis === "Y" || axis === "Z") {
+			const space = controls.space;
+			this.#getTransformAxisWorld(axis, space, this.#axisWorld);
+			input = this.#getRotationAxisInput(this.#axisWorld, transformX, transformY);
+		} else return false;
+		this.#rotationAmount += input * angleScale;
+		const angle = this.#snapRotation(this.#rotationAmount);
+		if (axis !== "E" && controls.space === "local") {
+			this.#setUnitAxis(axis, this.#axisLocal);
+			this.#rotationQuaternion.setFromAxisAngle(this.#axisLocal, angle);
+			object.quaternion.copy(this.#quaternionStart).multiply(this.#rotationQuaternion).normalize();
+		} else this.#applyWorldRotation(object, this.#axisWorld, angle);
+		object.updateMatrixWorld();
+		return true;
+	}
+	#applyWorldRotation(object, worldAxis, angle) {
+		this.#axisLocal.copy(worldAxis).applyQuaternion(this.#parentQuaternionInv).normalize();
+		this.#rotationQuaternion.setFromAxisAngle(this.#axisLocal, angle);
+		object.quaternion.copy(this.#rotationQuaternion).multiply(this.#quaternionStart).normalize();
+	}
+	#applyFreeRotation(object) {
+		const angleX = this.#snapRotation(this.#freeRotationX);
+		const angleY = this.#snapRotation(this.#freeRotationY);
+		this.#axisWorld.copy(this.#cameraUp).normalize();
+		this.#axisWorld2.copy(this.#cameraRight).normalize();
+		this.#axisLocal.copy(this.#axisWorld).applyQuaternion(this.#parentQuaternionInv).normalize();
+		this.#rotationQuaternion.setFromAxisAngle(this.#axisLocal, angleX);
+		this.#axisLocal.copy(this.#axisWorld2).applyQuaternion(this.#parentQuaternionInv).normalize();
+		this.#rotationQuaternion2.setFromAxisAngle(this.#axisLocal, angleY);
+		object.quaternion.copy(this.#rotationQuaternion2).multiply(this.#rotationQuaternion).multiply(this.#quaternionStart).normalize();
+		object.updateMatrixWorld();
+	}
+	#applyScale(deltaTime, transformX, transformY) {
+		const controls = this.#controls;
+		const object = controls.object;
+		const axis = controls.axis;
+		if (object === void 0 || axis === null) return false;
+		this.#updateCameraState(object);
+		const input = axis === "XYZ" ? this.#getDominantInput(transformX, -transformY) : this.#getProjectedScaleInput(axis, transformX, transformY);
+		const factor = Math.exp(input * this.#options.scaleSpeed * deltaTime);
+		if (!Number.isFinite(factor) || factor === 1) return false;
+		if (axis.includes("X")) this.#accumulatedScale.x *= factor;
+		if (axis.includes("Y")) this.#accumulatedScale.y *= factor;
+		if (axis.includes("Z")) this.#accumulatedScale.z *= factor;
+		this.#snappedScale.copy(this.#accumulatedScale);
+		if (controls.scaleSnap !== null && controls.scaleSnap > 0) {
+			if (axis.includes("X")) this.#snappedScale.x = this.#snapScale(this.#snappedScale.x, controls.scaleSnap);
+			if (axis.includes("Y")) this.#snappedScale.y = this.#snapScale(this.#snappedScale.y, controls.scaleSnap);
+			if (axis.includes("Z")) this.#snappedScale.z = this.#snapScale(this.#snappedScale.z, controls.scaleSnap);
+		}
+		object.scale.copy(this.#snappedScale);
+		object.updateMatrixWorld();
+		return true;
+	}
+	#getProjectedScaleInput(axis, transformX, transformY) {
+		if (axis !== "X" && axis !== "Y" && axis !== "Z") return this.#getDominantInput(transformX, -transformY);
+		this.#getTransformAxisWorld(axis, "local", this.#axisWorld);
+		return this.#getProjectedAxisInput(this.#axisWorld, transformX, transformY, this.#getDominantInput(transformX, -transformY));
+	}
+	#updateCameraState(object) {
+		const camera = this.#controls.camera;
+		camera.updateMatrixWorld();
+		object.updateWorldMatrix(true, false);
+		this.#cameraRight.setFromMatrixColumn(camera.matrixWorld, 0).normalize();
+		this.#cameraUp.setFromMatrixColumn(camera.matrixWorld, 1).normalize();
+		camera.getWorldDirection(this.#cameraForward).normalize();
+		camera.getWorldPosition(this.#cameraWorldPosition);
+		this.#worldPosition.setFromMatrixPosition(object.matrixWorld);
+		this.#eye.copy(this.#cameraWorldPosition).sub(this.#worldPosition).normalize();
+		this.#updateViewSizeAtObjectDepth(camera);
+	}
+	#updateViewSizeAtObjectDepth(camera) {
+		if (this.#isOrthographicCamera(camera)) {
+			this.#viewSize.set(Math.abs(camera.right - camera.left) / camera.zoom, Math.abs(camera.top - camera.bottom) / camera.zoom);
+			return;
+		}
+		if (this.#isPerspectiveCamera(camera)) {
+			const depth = Math.max(Number.EPSILON, this.#worldPosition.subVectors(this.#worldPosition, this.#cameraWorldPosition).dot(this.#cameraForward));
+			const height = 2 * Math.tan(camera.fov * Math.PI / 360) * depth;
+			this.#viewSize.set(height * camera.aspect, height);
+			return;
+		}
+		this.#viewSize.set(1, 1);
+	}
+	#getTransformAxisWorld(axis, space, target) {
+		this.#setUnitAxis(axis, target);
+		if (space === "local") target.applyQuaternion(this.#worldQuaternionStart);
+		return target.normalize();
+	}
+	#getRotationAxisInput(axisWorld, transformX, transformY) {
+		this.#axisWorld2.crossVectors(axisWorld, this.#eye);
+		if (this.#axisWorld2.lengthSq() < PROJECTED_AXIS_EPSILON) return this.#getDominantInput(transformX, -transformY);
+		return this.#getProjectedAxisInput(this.#axisWorld2.normalize(), transformX, transformY, this.#getDominantInput(transformX, -transformY));
+	}
+	#getProjectedAxisInput(axisWorld, transformX, transformY, fallback) {
+		const screenX = axisWorld.dot(this.#cameraRight);
+		const screenY = -axisWorld.dot(this.#cameraUp);
+		const length = Math.hypot(screenX, screenY);
+		if (length < PROJECTED_AXIS_EPSILON) return fallback;
+		return (transformX * screenX + transformY * screenY) / length;
+	}
+	#worldDeltaToLocalDelta(worldDelta, target) {
+		target.copy(worldDelta).applyQuaternion(this.#parentQuaternionInv);
+		this.#divideByParentScale(target);
+		return target;
+	}
+	#localPositionToWorld(object, localPosition) {
+		if (object.parent === null) {
+			this.#worldPosition.copy(localPosition);
+			return;
+		}
+		object.parent.updateWorldMatrix(true, false);
+		this.#worldPosition.copy(localPosition).applyMatrix4(object.parent.matrixWorld);
+	}
+	#worldPositionToLocal(object, worldPosition) {
+		if (object.parent === null) {
+			this.#snappedPosition.copy(worldPosition);
+			return;
+		}
+		object.parent.updateWorldMatrix(true, false);
+		this.#parentInverse.copy(object.parent.matrixWorld).invert();
+		this.#snappedPosition.copy(worldPosition).applyMatrix4(this.#parentInverse);
+	}
+	#divideByParentScale(target) {
+		target.x = this.#parentScale.x === 0 ? 0 : target.x / this.#parentScale.x;
+		target.y = this.#parentScale.y === 0 ? 0 : target.y / this.#parentScale.y;
+		target.z = this.#parentScale.z === 0 ? 0 : target.z / this.#parentScale.z;
+	}
+	#setUnitAxis(axis, target) {
+		switch (axis) {
+			case "X": return target.set(1, 0, 0);
+			case "Y": return target.set(0, 1, 0);
+			case "Z": return target.set(0, 0, 1);
+		}
+	}
+	#getVectorComponent(vector, axis) {
+		switch (axis) {
+			case "X": return vector.x;
+			case "Y": return vector.y;
+			case "Z": return vector.z;
+		}
+	}
+	#setVectorComponent(vector, axis, value) {
+		switch (axis) {
+			case "X":
+				vector.x = value;
+				return;
+			case "Y":
+				vector.y = value;
+				return;
+			case "Z":
+				vector.z = value;
+				return;
+		}
+	}
+	#snapRotation(value) {
+		const snap = this.#controls.rotationSnap;
+		return snap === null || snap <= 0 ? value : this.#snapValue(value, snap);
+	}
+	#snapValue(value, snap) {
+		return Math.round(value / snap) * snap;
+	}
+	#snapScale(value, snap) {
+		return this.#snapValue(value, snap) || snap;
+	}
+	#getDominantInput(inputX, inputY) {
+		return Math.abs(inputX) >= Math.abs(inputY) ? inputX : inputY;
+	}
+	#getStartedButtons(gamepad) {
+		const startedButtons = /* @__PURE__ */ new Set();
+		for (let index = 0; index < gamepad.buttons.length; index += 1) {
+			const pressed = gamepad.buttons[index]?.pressed ?? false;
+			const wasPressed = this.#pressedButtons.has(index);
+			if (pressed) {
+				this.#pressedButtons.add(index);
+				if (!wasPressed) startedButtons.add(index);
+			} else this.#pressedButtons.delete(index);
+		}
+		return startedButtons;
+	}
+	#isPerspectiveCamera(camera) {
+		return camera.isPerspectiveCamera === true;
+	}
+	#isOrthographicCamera(camera) {
+		return camera.isOrthographicCamera === true;
+	}
+	/**
+	* Returns `value` unchanged, or `0` if below the dead zone `threshold`.
+	*
+	* @param value - Raw axis value, typically in `[-1, 1]`.
+	* @param threshold - Dead zone size; values below this magnitude are zeroed.
+	*/
+	#applyDeadzone(value, threshold) {
+		return Math.abs(value) < threshold ? 0 : value;
+	}
+};
+//#endregion
+export { GamepadTransformControls };

package/dist/index.d.ts

@@ -8,4 +8,5 @@ import { GamepadOrbitControls, GamepadOrbitControlsOptions } from "./gamepad-orb
 import { GamepadMapControls } from "./gamepad-map-controls.js";
 import { GamepadPointerLockControls, GamepadPointerLockControlsOptions } from "./gamepad-pointer-lock-controls.js";
 import { GamepadTrackballControls, GamepadTrackballControlsOptions } from "./gamepad-trackball-controls.js";
-export { GAMEPAD_AXIS, GAMEPAD_BUTTON, GamepadArcballControls, GamepadArcballControlsOptions, GamepadAxisKey, GamepadAxisValue, GamepadButtonKey, GamepadButtonValue, GamepadControls, GamepadControlsEventMap, GamepadDragControls, GamepadDragControlsOptions, GamepadFirstPersonControls, GamepadFirstPersonControlsOptions, GamepadFlyControls, GamepadFlyControlsOptions, GamepadMapControls, GamepadOrbitControls, GamepadOrbitControlsOptions, GamepadPointerLockControls, GamepadPointerLockControlsOptions, GamepadTrackballControls, GamepadTrackballControlsOptions };
+import { GamepadTransformControls, GamepadTransformControlsOptions } from "./gamepad-transform-controls.js";
+export { GAMEPAD_AXIS, GAMEPAD_BUTTON, GamepadArcballControls, GamepadArcballControlsOptions, GamepadAxisKey, GamepadAxisValue, GamepadButtonKey, GamepadButtonValue, GamepadControls, GamepadControlsEventMap, GamepadDragControls, GamepadDragControlsOptions, GamepadFirstPersonControls, GamepadFirstPersonControlsOptions, GamepadFlyControls, GamepadFlyControlsOptions, GamepadMapControls, GamepadOrbitControls, GamepadOrbitControlsOptions, GamepadPointerLockControls, GamepadPointerLockControlsOptions, GamepadTrackballControls, GamepadTrackballControlsOptions, GamepadTransformControls, GamepadTransformControlsOptions };

package/dist/index.js

@@ -8,4 +8,5 @@ import { GamepadOrbitControls } from "./gamepad-orbit-controls.js";
 import { GamepadMapControls } from "./gamepad-map-controls.js";
 import { GamepadPointerLockControls } from "./gamepad-pointer-lock-controls.js";
 import { GamepadTrackballControls } from "./gamepad-trackball-controls.js";
-export { GAMEPAD_AXIS, GAMEPAD_BUTTON, GamepadArcballControls, GamepadControls, GamepadDragControls, GamepadFirstPersonControls, GamepadFlyControls, GamepadMapControls, GamepadOrbitControls, GamepadPointerLockControls, GamepadTrackballControls };
+import { GamepadTransformControls } from "./gamepad-transform-controls.js";
+export { GAMEPAD_AXIS, GAMEPAD_BUTTON, GamepadArcballControls, GamepadControls, GamepadDragControls, GamepadFirstPersonControls, GamepadFlyControls, GamepadMapControls, GamepadOrbitControls, GamepadPointerLockControls, GamepadTrackballControls, GamepadTransformControls };

package/package.json

@@ -2,7 +2,7 @@
   "name": "three-gamepad-controls",
   "description": "Gamepad support for Three.js controls.",
   "author": "Kasnix",
-  "version": "0.9.0",
+  "version": "0.10.0",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/luckasnix/three-gamepad-controls.git"