three-gamepad-controls 0.18.0 → 0.20.0

package/dist/gamepad-stick-processing.d.ts

@@ -0,0 +1,165 @@
+//#region src/gamepad-stick-processing.d.ts
+/**
+ * Geometry used when processing two-dimensional stick values.
+ *
+ * Axial processing transforms each component independently. Radial processing
+ * transforms vector magnitude while preserving direction.
+ */
+type GamepadStickProcessingMode = "axial" | "radial";
+/**
+ * Built-in response curve applied to stick components or magnitude.
+ */
+type GamepadResponseCurve = "linear" | "quadratic" | "cubic";
+/**
+ * Two-dimensional gamepad stick value.
+ */
+type GamepadStick = {
+  /**
+   * Horizontal stick component.
+   */
+  x: number;
+  /**
+   * Vertical stick component.
+   */
+  y: number;
+};
+/**
+ * Pure, stateless transformation applied to a gamepad stick.
+ *
+ * Implementations must not mutate `value`. Stateful processing such as
+ * smoothing belongs in a separate lifecycle-aware abstraction.
+ */
+type GamepadStickProcessor = {
+  /**
+   * Transforms one stick value.
+   *
+   * @param value - Input value from the previous processor.
+   * @returns Processed stick value.
+   */
+  process(value: Readonly<GamepadStick>): GamepadStick;
+};
+/**
+ * Ordered, reusable sequence of stateless stick processors.
+ */
+type GamepadStickPipeline = GamepadStickProcessor & {
+  /**
+   * Processors in execution order.
+   */
+  readonly processors: readonly GamepadStickProcessor[];
+};
+/**
+ * Options for {@link createGamepadDeadzoneProcessor}.
+ */
+type GamepadDeadzoneProcessorOptions = {
+  /**
+   * Dead zone threshold.
+   * @default 0.1
+   */
+  threshold?: number;
+  /**
+   * Whether to process each component or the vector magnitude.
+   * @default "axial"
+   */
+  mode?: GamepadStickProcessingMode;
+  /**
+   * Whether to remap values outside the dead zone to the full output range.
+   * @default false
+   */
+  rescale?: boolean;
+};
+/**
+ * Options for {@link createGamepadResponseCurveProcessor}.
+ */
+type GamepadResponseCurveProcessorOptions = {
+  /**
+   * Curve used to transform values in the normalized input range.
+   */
+  curve: GamepadResponseCurve;
+  /**
+   * Whether to process each component or the vector magnitude.
+   */
+  mode: GamepadStickProcessingMode;
+};
+/**
+ * Options for {@link createGamepadInversionProcessor}.
+ */
+type GamepadInversionProcessorOptions = {
+  /**
+   * Whether to invert the horizontal component.
+   * @default false
+   */
+  invertX?: boolean;
+  /**
+   * Whether to invert the vertical component.
+   * @default false
+   */
+  invertY?: boolean;
+};
+/**
+ * Partial binding for a two-dimensional stick action.
+ *
+ * Omitted fields inherit the action-specific defaults.
+ */
+type GamepadStickBindingOptions = {
+  /**
+   * Axis index used as the horizontal component.
+   */
+  xAxis?: number;
+  /**
+   * Axis index used as the vertical component.
+   */
+  yAxis?: number;
+  /**
+   * Stateless processing pipeline for this action.
+   */
+  pipeline?: GamepadStickPipeline;
+};
+/**
+ * Fully resolved binding used when reading a two-dimensional stick action.
+ */
+type GamepadStickBinding = Required<GamepadStickBindingOptions>;
+/**
+ * Creates an ordered pipeline from stateless stick processors.
+ *
+ * The processor list is copied once. Processor errors are not caught, and a
+ * processor's result is passed directly to the next processor.
+ *
+ * @param processors - Processors in execution order.
+ * @returns Reusable stick pipeline.
+ */
+declare const createGamepadStickPipeline: (...processors: readonly GamepadStickProcessor[]) => GamepadStickPipeline;
+/**
+ * Creates an axial or radial dead zone processor.
+ *
+ * @param options - Optional dead zone configuration.
+ * @returns Stateless dead zone processor.
+ */
+declare const createGamepadDeadzoneProcessor: (options?: GamepadDeadzoneProcessorOptions) => GamepadStickProcessor;
+/**
+ * Creates an axial or radial response curve processor.
+ *
+ * @param options - Response curve configuration.
+ * @returns Stateless response curve processor.
+ */
+declare const createGamepadResponseCurveProcessor: (options: GamepadResponseCurveProcessorOptions) => GamepadStickProcessor;
+/**
+ * Creates a processor that independently inverts stick components.
+ *
+ * @param options - Optional inversion configuration.
+ * @returns Stateless inversion processor.
+ */
+declare const createGamepadInversionProcessor: (options?: GamepadInversionProcessorOptions) => GamepadStickProcessor;
+/**
+ * Historical stick processing used when no custom pipeline is supplied.
+ */
+declare const DEFAULT_GAMEPAD_STICK_PIPELINE: GamepadStickPipeline;
+/**
+ * Resolves a partial stick binding over an action-specific default.
+ *
+ * @param defaults - Complete default binding.
+ * @param options - Optional binding overrides.
+ * @returns Complete resolved binding.
+ */
+declare const resolveGamepadStickBinding: (defaults: GamepadStickBinding, options?: GamepadStickBindingOptions) => GamepadStickBinding;
+//#endregion
+export { DEFAULT_GAMEPAD_STICK_PIPELINE, GamepadDeadzoneProcessorOptions, GamepadInversionProcessorOptions, GamepadResponseCurve, GamepadResponseCurveProcessorOptions, GamepadStick, GamepadStickBinding, GamepadStickBindingOptions, GamepadStickPipeline, GamepadStickProcessingMode, GamepadStickProcessor, createGamepadDeadzoneProcessor, createGamepadInversionProcessor, createGamepadResponseCurveProcessor, createGamepadStickPipeline, resolveGamepadStickBinding };

package/dist/gamepad-stick-processing.js

@@ -0,0 +1,176 @@
+//#region src/gamepad-stick-processing.ts
+const DEFAULT_DEADZONE_PROCESSOR_OPTIONS = {
+	threshold: .1,
+	mode: "axial",
+	rescale: false
+};
+const DEFAULT_INVERSION_PROCESSOR_OPTIONS = {
+	invertX: false,
+	invertY: false
+};
+/**
+* Returns a canonical stick result and preserves the original value when
+* processing produced no change.
+*
+* @param source - Original stick value.
+* @param x - Processed horizontal component.
+* @param y - Processed vertical component.
+* @returns Canonical processed stick value.
+*/
+const createGamepadStickResult = (source, x, y) => {
+	const canonicalX = x === 0 ? 0 : x;
+	const canonicalY = y === 0 ? 0 : y;
+	if (canonicalX === source.x && canonicalY === source.y && !Object.is(source.x, -0) && !Object.is(source.y, -0)) return source;
+	return {
+		x: canonicalX,
+		y: canonicalY
+	};
+};
+/**
+* Transforms the magnitude of a signed scalar while preserving its sign.
+*
+* @param value - Signed scalar value.
+* @param mapMagnitude - Magnitude transformation.
+* @returns Transformed signed value.
+*/
+const mapGamepadSignedMagnitude = (value, mapMagnitude) => {
+	if (value === 0) return 0;
+	return Math.sign(value) * mapMagnitude(Math.abs(value));
+};
+/**
+* Transforms stick magnitude while preserving vector direction.
+*
+* @param value - Stick value to transform.
+* @param mapMagnitude - Magnitude transformation.
+* @returns Stick with transformed magnitude.
+*/
+const mapGamepadStickMagnitude = (value, mapMagnitude) => {
+	const magnitude = Math.hypot(value.x, value.y);
+	if (magnitude === 0) return createGamepadStickResult(value, 0, 0);
+	const mappedMagnitude = mapMagnitude(magnitude);
+	if (mappedMagnitude === magnitude) return createGamepadStickResult(value, value.x, value.y);
+	if (mappedMagnitude === 0) return createGamepadStickResult(value, 0, 0);
+	const scale = mappedMagnitude / magnitude;
+	return createGamepadStickResult(value, value.x * scale, value.y * scale);
+};
+/**
+* Applies a dead zone and remaps the remaining magnitude to `[0, 1]`.
+*
+* @param magnitude - Non-negative input magnitude.
+* @param threshold - Dead zone size.
+* @returns Rescaled magnitude, or `0` when inside a fully closed dead zone.
+*/
+const rescaleGamepadDeadzoneMagnitude = (magnitude, threshold) => {
+	if (magnitude <= threshold || threshold >= 1) return 0;
+	return Math.min((magnitude - threshold) / (1 - threshold), 1);
+};
+/**
+* Applies a built-in curve to a normalized magnitude.
+*
+* Magnitudes above `1` remain unchanged so response curves do not implicitly
+* clamp or normalize custom processor output.
+*
+* @param magnitude - Non-negative component or vector magnitude.
+* @param curve - Curve to apply.
+* @returns Curved magnitude.
+*/
+const applyGamepadResponseCurve = (magnitude, curve) => {
+	if (magnitude > 1) return magnitude;
+	switch (curve) {
+		case "linear": return magnitude;
+		case "quadratic": return magnitude ** 2;
+		case "cubic": return magnitude ** 3;
+	}
+};
+/**
+* Creates an ordered pipeline from stateless stick processors.
+*
+* The processor list is copied once. Processor errors are not caught, and a
+* processor's result is passed directly to the next processor.
+*
+* @param processors - Processors in execution order.
+* @returns Reusable stick pipeline.
+*/
+const createGamepadStickPipeline = (...processors) => {
+	const pipelineProcessors = Object.freeze([...processors]);
+	return Object.freeze({
+		processors: pipelineProcessors,
+		process(value) {
+			let processed = value;
+			for (const processor of pipelineProcessors) processed = processor.process(processed);
+			return processed;
+		}
+	});
+};
+/**
+* Creates an axial or radial dead zone processor.
+*
+* @param options - Optional dead zone configuration.
+* @returns Stateless dead zone processor.
+*/
+const createGamepadDeadzoneProcessor = (options) => {
+	const { threshold, mode, rescale } = {
+		...DEFAULT_DEADZONE_PROCESSOR_OPTIONS,
+		...options
+	};
+	const mapMagnitude = (magnitude) => {
+		if (magnitude < threshold) return 0;
+		return rescale ? rescaleGamepadDeadzoneMagnitude(magnitude, threshold) : magnitude;
+	};
+	return Object.freeze({ process(value) {
+		if (mode === "axial") return createGamepadStickResult(value, mapGamepadSignedMagnitude(value.x, mapMagnitude), mapGamepadSignedMagnitude(value.y, mapMagnitude));
+		return mapGamepadStickMagnitude(value, mapMagnitude);
+	} });
+};
+/**
+* Creates an axial or radial response curve processor.
+*
+* @param options - Response curve configuration.
+* @returns Stateless response curve processor.
+*/
+const createGamepadResponseCurveProcessor = (options) => {
+	const { curve, mode } = options;
+	const mapMagnitude = (magnitude) => applyGamepadResponseCurve(magnitude, curve);
+	return Object.freeze({ process(value) {
+		if (mode === "axial") return createGamepadStickResult(value, mapGamepadSignedMagnitude(value.x, mapMagnitude), mapGamepadSignedMagnitude(value.y, mapMagnitude));
+		return mapGamepadStickMagnitude(value, mapMagnitude);
+	} });
+};
+/**
+* Creates a processor that independently inverts stick components.
+*
+* @param options - Optional inversion configuration.
+* @returns Stateless inversion processor.
+*/
+const createGamepadInversionProcessor = (options) => {
+	const { invertX, invertY } = {
+		...DEFAULT_INVERSION_PROCESSOR_OPTIONS,
+		...options
+	};
+	return Object.freeze({ process(value) {
+		if (!invertX && !invertY) return createGamepadStickResult(value, value.x, value.y);
+		const x = value.x === 0 ? 0 : invertX ? -value.x : value.x;
+		const y = value.y === 0 ? 0 : invertY ? -value.y : value.y;
+		return createGamepadStickResult(value, x, y);
+	} });
+};
+/**
+* Historical stick processing used when no custom pipeline is supplied.
+*/
+const DEFAULT_GAMEPAD_STICK_PIPELINE = createGamepadStickPipeline(createGamepadDeadzoneProcessor());
+/**
+* Resolves a partial stick binding over an action-specific default.
+*
+* @param defaults - Complete default binding.
+* @param options - Optional binding overrides.
+* @returns Complete resolved binding.
+*/
+const resolveGamepadStickBinding = (defaults, options) => {
+	return {
+		xAxis: options?.xAxis ?? defaults.xAxis,
+		yAxis: options?.yAxis ?? defaults.yAxis,
+		pipeline: options?.pipeline ?? defaults.pipeline
+	};
+};
+//#endregion
+export { DEFAULT_GAMEPAD_STICK_PIPELINE, createGamepadDeadzoneProcessor, createGamepadInversionProcessor, createGamepadResponseCurveProcessor, createGamepadStickPipeline, resolveGamepadStickBinding };

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

@@ -1,3 +1,4 @@
+import { GamepadStickBindingOptions } from "./gamepad-stick-processing.js";
 import { GamepadControls, GamepadControlsOptions } from "./gamepad-controls.js";
 import { TrackballControls } from "three/addons/controls/TrackballControls.js";
 //#region src/gamepad-trackball-controls.d.ts
@@ -23,30 +24,20 @@ type GamepadTrackballControlsOptions = GamepadControlsOptions & {
    */
   zoomSpeed: number;
   /**
-   * Axis dead zone threshold in the range `[0, 1]`.
-   * @default 0.1
-   */
-  deadzone: number;
-  /**
-   * Axis index for **horizontal** trackball rotation.
-   * @default 0 - Left stick X
+   * Stick binding used for trackball rotation.
+   * @default Left stick with the default stick pipeline
    */
-  axisRotateX: number;
+  rotateStick: GamepadStickBindingOptions;
   /**
-   * Axis index for **vertical** trackball rotation.
-   * @default 1 - Left stick Y
+   * Stick binding used for panning.
+   * @default Right stick with the default stick pipeline
    */
-  axisRotateY: number;
+  panStick: GamepadStickBindingOptions;
   /**
-   * Axis index for **horizontal** panning.
-   * @default 2 - Right stick X
-   */
-  axisPanX: number;
-  /**
-   * Axis index for **vertical** panning.
-   * @default 3 - Right stick Y
+   * Dead zone threshold for analog trigger values.
+   * @default 0.1
    */
-  axisPanY: number;
+  buttonDeadzone: number;
   /**
    * Button index for zooming **in** (analog trigger value used for proportional zoom).
    * @default 7 - Right trigger

package/dist/gamepad-trackball-controls.js

@@ -1,15 +1,22 @@
 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";
 //#region src/gamepad-trackball-controls.ts
 const DEFAULT_TRACKBALL_OPTIONS = {
 	rotateSpeed: 1,
 	panSpeed: 1,
 	zoomSpeed: 1,
-	deadzone: .1,
-	axisRotateX: GAMEPAD_AXIS.LeftX,
-	axisRotateY: GAMEPAD_AXIS.LeftY,
-	axisPanX: GAMEPAD_AXIS.RightX,
-	axisPanY: GAMEPAD_AXIS.RightY,
+	rotateStick: {
+		xAxis: GAMEPAD_AXIS.LeftX,
+		yAxis: GAMEPAD_AXIS.LeftY,
+		pipeline: DEFAULT_GAMEPAD_STICK_PIPELINE
+	},
+	panStick: {
+		xAxis: GAMEPAD_AXIS.RightX,
+		yAxis: GAMEPAD_AXIS.RightY,
+		pipeline: DEFAULT_GAMEPAD_STICK_PIPELINE
+	},
+	buttonDeadzone: .1,
 	buttonZoomIn: GAMEPAD_BUTTON.RightTrigger,
 	buttonZoomOut: GAMEPAD_BUTTON.LeftTrigger
 };
@@ -32,7 +39,9 @@ var GamepadTrackballControls = class extends GamepadControls {
 		this.#controls = controls;
 		this.#options = {
 			...DEFAULT_TRACKBALL_OPTIONS,
-			...options
+			...options,
+			rotateStick: resolveGamepadStickBinding(DEFAULT_TRACKBALL_OPTIONS.rotateStick, options?.rotateStick),
+			panStick: resolveGamepadStickBinding(DEFAULT_TRACKBALL_OPTIONS.panStick, options?.panStick)
 		};
 	}
 	/**
@@ -41,68 +50,60 @@ var GamepadTrackballControls = class extends GamepadControls {
 	* @param deltaTime - Seconds since the last frame.
 	*/
 	onUpdate(deltaTime) {
-		const { rotateSpeed, panSpeed, zoomSpeed, deadzone, axisRotateX, axisRotateY, axisPanX, axisPanY, buttonZoomIn, buttonZoomOut } = this.#options;
-		this.#queueRotation(deltaTime, rotateSpeed, deadzone, axisRotateX, axisRotateY);
-		this.#queuePan(deltaTime, panSpeed, deadzone, axisPanX, axisPanY);
-		this.#queueZoom(deltaTime, zoomSpeed, deadzone, buttonZoomIn, buttonZoomOut);
+		const { rotateSpeed, panSpeed, zoomSpeed, rotateStick, panStick, buttonDeadzone, buttonZoomIn, buttonZoomOut } = this.#options;
+		this.#queueRotation(deltaTime, rotateSpeed, rotateStick);
+		this.#queuePan(deltaTime, panSpeed, panStick);
+		this.#queueZoom(deltaTime, zoomSpeed, buttonDeadzone, buttonZoomIn, buttonZoomOut);
 	}
 	/**
 	* Queues rotation input into TrackballControls' normalized move state.
 	*
 	* @param deltaTime - Seconds since the last frame.
 	* @param rotateSpeed - User-configured rotation speed multiplier.
-	* @param deadzone - Axis dead zone threshold.
-	* @param axisRotateX - Axis index for horizontal rotation.
-	* @param axisRotateY - Axis index for vertical rotation.
+	* @param rotateStick - Resolved stick binding for rotation.
 	*/
-	#queueRotation(deltaTime, rotateSpeed, deadzone, axisRotateX, axisRotateY) {
+	#queueRotation(deltaTime, rotateSpeed, rotateStick) {
 		const controls = this.#controls;
 		if (controls.noRotate) {
 			controls._movePrev.copy(controls._moveCurr);
 			controls._lastAngle = 0;
 			return;
 		}
-		const input = this.gamepadInput;
-		const rotX = input.axis(axisRotateX, { deadzone });
-		const rotY = input.axis(axisRotateY, { deadzone });
-		if (rotX === 0 && rotY === 0) return;
+		const rotate = this.gamepadInput.stick(rotateStick.xAxis, rotateStick.yAxis, rotateStick.pipeline);
+		if (rotate.x === 0 && rotate.y === 0) return;
 		const scale = rotateSpeed * deltaTime * Math.PI;
-		controls._moveCurr.x += rotX * scale;
-		controls._moveCurr.y += -rotY * scale;
+		controls._moveCurr.x += rotate.x * scale;
+		controls._moveCurr.y += -rotate.y * scale;
 	}
 	/**
 	* Queues pan input into TrackballControls' normalized pan state.
 	*
 	* @param deltaTime - Seconds since the last frame.
 	* @param panSpeed - User-configured pan speed multiplier.
-	* @param deadzone - Axis dead zone threshold.
-	* @param axisPanX - Axis index for horizontal panning.
-	* @param axisPanY - Axis index for vertical panning.
+	* @param panStick - Resolved stick binding for panning.
 	*/
-	#queuePan(deltaTime, panSpeed, deadzone, axisPanX, axisPanY) {
+	#queuePan(deltaTime, panSpeed, panStick) {
 		const controls = this.#controls;
 		if (controls.noPan) {
 			controls._panStart.copy(controls._panEnd);
 			return;
 		}
-		const input = this.gamepadInput;
-		const panX = input.axis(axisPanX, { deadzone });
-		const panY = input.axis(axisPanY, { deadzone });
-		if (panX === 0 && panY === 0) return;
+		const pan = this.gamepadInput.stick(panStick.xAxis, panStick.yAxis, panStick.pipeline);
+		if (pan.x === 0 && pan.y === 0) return;
 		const scale = panSpeed * deltaTime * this.#getInputDampingFactor();
-		controls._panEnd.x += panX * scale;
-		controls._panEnd.y += panY * scale;
+		controls._panEnd.x += pan.x * scale;
+		controls._panEnd.y += pan.y * scale;
 	}
 	/**
 	* Queues trigger zoom input into TrackballControls' normalized zoom state.
 	*
 	* @param deltaTime - Seconds since the last frame.
 	* @param zoomSpeed - User-configured zoom speed multiplier.
-	* @param deadzone - Trigger dead zone threshold.
+	* @param buttonDeadzone - Trigger dead zone threshold.
 	* @param buttonZoomIn - Button index for zooming in.
 	* @param buttonZoomOut - Button index for zooming out.
 	*/
-	#queueZoom(deltaTime, zoomSpeed, deadzone, buttonZoomIn, buttonZoomOut) {
+	#queueZoom(deltaTime, zoomSpeed, buttonDeadzone, buttonZoomIn, buttonZoomOut) {
 		const controls = this.#controls;
 		if (controls.noZoom) {
 			controls._zoomStart.copy(controls._zoomEnd);
@@ -111,7 +112,7 @@ var GamepadTrackballControls = class extends GamepadControls {
 		const input = this.gamepadInput;
 		const triggerIn = input.buttonValue(buttonZoomIn);
 		const triggerOut = input.buttonValue(buttonZoomOut);
-		if (triggerIn <= deadzone && triggerOut <= deadzone) return;
+		if (triggerIn <= buttonDeadzone && triggerOut <= buttonDeadzone) return;
 		controls._zoomEnd.y += (triggerOut - triggerIn) * zoomSpeed * deltaTime * this.#getInputDampingFactor();
 	}
 	/**

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

@@ -1,3 +1,4 @@
+import { GamepadStickBindingOptions } from "./gamepad-stick-processing.js";
 import { GamepadControls, GamepadControlsOptions } from "./gamepad-controls.js";
 import { TransformControls } from "three/addons/controls/TransformControls.js";
 //#region src/gamepad-transform-controls.d.ts
@@ -23,20 +24,10 @@ type GamepadTransformControlsOptions = GamepadControlsOptions & {
    */
   scaleSpeed: number;
   /**
-   * Axis dead zone threshold in the range `[0, 1]`.
-   * @default 0.1
+   * Stick binding used for translation, rotation, and scaling.
+   * @default Left stick with the default stick pipeline
    */
-  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;
+  transformStick: GamepadStickBindingOptions;
   /**
    * Button index for selecting translate mode.
    * @default 0 - South face button

package/dist/gamepad-transform-controls.js

@@ -1,4 +1,5 @@
 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 { Matrix4, Quaternion, Vector2, Vector3 } from "three";
 //#region src/gamepad-transform-controls.ts
@@ -6,9 +7,11 @@ const DEFAULT_TRANSFORM_OPTIONS = {
 	translateSpeed: 1,
 	rotateSpeed: 1,
 	scaleSpeed: 1,
-	deadzone: .1,
-	axisTransformX: GAMEPAD_AXIS.LeftX,
-	axisTransformY: GAMEPAD_AXIS.LeftY,
+	transformStick: {
+		xAxis: GAMEPAD_AXIS.LeftX,
+		yAxis: GAMEPAD_AXIS.LeftY,
+		pipeline: DEFAULT_GAMEPAD_STICK_PIPELINE
+	},
 	buttonTranslate: GAMEPAD_BUTTON.South,
 	buttonRotate: GAMEPAD_BUTTON.East,
 	buttonScale: GAMEPAD_BUTTON.West,
@@ -110,7 +113,8 @@ var GamepadTransformControls = class extends GamepadControls {
 		this.#controls = controls;
 		this.#options = {
 			...DEFAULT_TRANSFORM_OPTIONS,
-			...options
+			...options,
+			transformStick: resolveGamepadStickBinding(DEFAULT_TRANSFORM_OPTIONS.transformStick, options?.transformStick)
 		};
 		this.#activeAxisByMode = {
 			translate: "X",
@@ -166,14 +170,14 @@ var GamepadTransformControls = class extends GamepadControls {
 			this.#endTransform(true);
 			return;
 		}
-		const transformX = this.gamepadInput.axis(this.#options.axisTransformX, { deadzone: this.#options.deadzone });
-		const transformY = this.gamepadInput.axis(this.#options.axisTransformY, { deadzone: this.#options.deadzone });
-		if (transformX === 0 && transformY === 0) {
+		const { transformStick } = this.#options;
+		const transform = this.gamepadInput.stick(transformStick.xAxis, transformStick.yAxis, transformStick.pipeline);
+		if (transform.x === 0 && transform.y === 0) {
 			this.#endTransform(false);
 			return;
 		}
 		if (!this.#isTransforming && !this.#startTransform()) return;
-		if (this.#applyCurrentTransform(deltaTime, transformX, transformY)) {
+		if (this.#applyCurrentTransform(deltaTime, transform.x, transform.y)) {
 			controls.dispatchEvent({ type: "change" });
 			controls.dispatchEvent({ type: "objectChange" });
 		}

package/dist/index.d.ts

@@ -1,5 +1,6 @@
 import { GAMEPAD_AXIS, GAMEPAD_BUTTON, GamepadAxisKey, GamepadAxisValue, GamepadButtonKey, GamepadButtonValue, MAX_GAMEPAD_INDEX, MIN_GAMEPAD_INDEX } from "./core.js";
-import { GamepadAxisOptions, GamepadDeadzoneMode, GamepadInput, GamepadInputEventMap, GamepadInputOptions, GamepadStick, GamepadStickOptions } from "./gamepad-input.js";
+import { DEFAULT_GAMEPAD_STICK_PIPELINE, GamepadDeadzoneProcessorOptions, GamepadInversionProcessorOptions, GamepadResponseCurve, GamepadResponseCurveProcessorOptions, GamepadStick, GamepadStickBinding, GamepadStickBindingOptions, GamepadStickPipeline, GamepadStickProcessingMode, GamepadStickProcessor, createGamepadDeadzoneProcessor, createGamepadInversionProcessor, createGamepadResponseCurveProcessor, createGamepadStickPipeline, resolveGamepadStickBinding } from "./gamepad-stick-processing.js";
+import { GamepadAxisOptions, GamepadInput, GamepadInputEventMap, GamepadInputOptions } from "./gamepad-input.js";
 import { GamepadControls, GamepadControlsEventMap, GamepadControlsOptions } from "./gamepad-controls.js";
 import { GamepadArcballControls, GamepadArcballControlsOptions } from "./gamepad-arcball-controls.js";
 import { GamepadDragControls, GamepadDragControlsOptions } from "./gamepad-drag-controls.js";
@@ -10,4 +11,4 @@ import { GamepadMapControls } from "./gamepad-map-controls.js";
 import { GamepadPointerLockControls, GamepadPointerLockControlsOptions } from "./gamepad-pointer-lock-controls.js";
 import { GamepadTrackballControls, GamepadTrackballControlsOptions } from "./gamepad-trackball-controls.js";
 import { GamepadTransformControls, GamepadTransformControlsOptions } from "./gamepad-transform-controls.js";
-export { GAMEPAD_AXIS, GAMEPAD_BUTTON, GamepadArcballControls, GamepadArcballControlsOptions, GamepadAxisKey, GamepadAxisOptions, GamepadAxisValue, GamepadButtonKey, GamepadButtonValue, GamepadControls, GamepadControlsEventMap, GamepadControlsOptions, GamepadDeadzoneMode, GamepadDragControls, GamepadDragControlsOptions, GamepadFirstPersonControls, GamepadFirstPersonControlsOptions, GamepadFlyControls, GamepadFlyControlsOptions, GamepadInput, GamepadInputEventMap, GamepadInputOptions, GamepadMapControls, GamepadOrbitControls, GamepadOrbitControlsOptions, GamepadPointerLockControls, GamepadPointerLockControlsOptions, GamepadStick, GamepadStickOptions, GamepadTrackballControls, GamepadTrackballControlsOptions, GamepadTransformControls, GamepadTransformControlsOptions, MAX_GAMEPAD_INDEX, MIN_GAMEPAD_INDEX };
+export { DEFAULT_GAMEPAD_STICK_PIPELINE, GAMEPAD_AXIS, GAMEPAD_BUTTON, GamepadArcballControls, GamepadArcballControlsOptions, GamepadAxisKey, GamepadAxisOptions, GamepadAxisValue, GamepadButtonKey, GamepadButtonValue, GamepadControls, GamepadControlsEventMap, GamepadControlsOptions, GamepadDeadzoneProcessorOptions, GamepadDragControls, GamepadDragControlsOptions, GamepadFirstPersonControls, GamepadFirstPersonControlsOptions, GamepadFlyControls, GamepadFlyControlsOptions, GamepadInput, GamepadInputEventMap, GamepadInputOptions, GamepadInversionProcessorOptions, GamepadMapControls, GamepadOrbitControls, GamepadOrbitControlsOptions, GamepadPointerLockControls, GamepadPointerLockControlsOptions, GamepadResponseCurve, GamepadResponseCurveProcessorOptions, GamepadStick, GamepadStickBinding, GamepadStickBindingOptions, GamepadStickPipeline, GamepadStickProcessingMode, GamepadStickProcessor, GamepadTrackballControls, GamepadTrackballControlsOptions, GamepadTransformControls, GamepadTransformControlsOptions, MAX_GAMEPAD_INDEX, MIN_GAMEPAD_INDEX, createGamepadDeadzoneProcessor, createGamepadInversionProcessor, createGamepadResponseCurveProcessor, createGamepadStickPipeline, resolveGamepadStickBinding };

package/dist/index.js

@@ -1,4 +1,5 @@
 import { GAMEPAD_AXIS, GAMEPAD_BUTTON, MAX_GAMEPAD_INDEX, MIN_GAMEPAD_INDEX } from "./core.js";
+import { DEFAULT_GAMEPAD_STICK_PIPELINE, createGamepadDeadzoneProcessor, createGamepadInversionProcessor, createGamepadResponseCurveProcessor, createGamepadStickPipeline, resolveGamepadStickBinding } from "./gamepad-stick-processing.js";
 import { GamepadInput } from "./gamepad-input.js";
 import { GamepadControls } from "./gamepad-controls.js";
 import { GamepadArcballControls } from "./gamepad-arcball-controls.js";
@@ -10,4 +11,4 @@ import { GamepadMapControls } from "./gamepad-map-controls.js";
 import { GamepadPointerLockControls } from "./gamepad-pointer-lock-controls.js";
 import { GamepadTrackballControls } from "./gamepad-trackball-controls.js";
 import { GamepadTransformControls } from "./gamepad-transform-controls.js";
-export { GAMEPAD_AXIS, GAMEPAD_BUTTON, GamepadArcballControls, GamepadControls, GamepadDragControls, GamepadFirstPersonControls, GamepadFlyControls, GamepadInput, GamepadMapControls, GamepadOrbitControls, GamepadPointerLockControls, GamepadTrackballControls, GamepadTransformControls, MAX_GAMEPAD_INDEX, MIN_GAMEPAD_INDEX };
+export { DEFAULT_GAMEPAD_STICK_PIPELINE, GAMEPAD_AXIS, GAMEPAD_BUTTON, GamepadArcballControls, GamepadControls, GamepadDragControls, GamepadFirstPersonControls, GamepadFlyControls, GamepadInput, GamepadMapControls, GamepadOrbitControls, GamepadPointerLockControls, GamepadTrackballControls, GamepadTransformControls, MAX_GAMEPAD_INDEX, MIN_GAMEPAD_INDEX, createGamepadDeadzoneProcessor, createGamepadInversionProcessor, createGamepadResponseCurveProcessor, createGamepadStickPipeline, resolveGamepadStickBinding };

package/package.json

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