@directivegames/genesys.js 3.1.24

package/dist/src/systems/InputManager.js

@@ -0,0 +1,1025 @@
+/**
+ * InputManager centralizes keyboard, mouse, gamepad, and touch handling for Genesys.
+ *
+ * Detailed explanation:
+ * - Listens to DOM events and distributes them to registered `IInputHandler` implementations.
+ * - Tracks current input state, pointer lock, and provides helper queries for button presses.
+ * - Manages gamepad connections and polling so gameplay code can be agnostic of the hardware.
+ * - Provides touch input support with virtual joystick using nipplejs for mobile devices.
+ * - Detects and reports swipe and tap gestures with configurable thresholds.
+ *
+ * Recommended usage (for humans and AI assistants):
+ * - Instantiate once per world and add your custom handlers via `addInputHandler`.
+ * - Use `requestPointerLock` in response to user interaction if your controls need exclusive mouse input.
+ * - Touch input is automatically enabled on mobile browsers detected by `isMobileBrowser()`.
+ * - Virtual joystick provides movement input for mobile devices and can be customized via options.
+ * - Swipe and tap gestures can be detected by implementing handleSwipe/handleTap or subscribing to onSwipe/onTap delegates.
+ * - Avoid directly reading DOM events; rely on this manager to ensure consistent behavior across platforms.
+ */
+import * as THREE from 'three';
+import { Delegate } from '../utils/Delegate.js';
+import { getEnv, isMobileBrowser, isNode } from '../utils/Utils.js';
+/**
+ * Enum for mouse buttons
+ * @enum {number}
+ */
+export var MouseButton;
+(function (MouseButton) {
+    MouseButton[MouseButton["Left"] = 0] = "Left";
+    MouseButton[MouseButton["Middle"] = 1] = "Middle";
+    MouseButton[MouseButton["Right"] = 2] = "Right";
+})(MouseButton || (MouseButton = {}));
+export var VirtualJoystickIndex;
+(function (VirtualJoystickIndex) {
+    VirtualJoystickIndex[VirtualJoystickIndex["Left"] = 0] = "Left";
+    VirtualJoystickIndex[VirtualJoystickIndex["Right"] = 1] = "Right";
+})(VirtualJoystickIndex || (VirtualJoystickIndex = {}));
+/**
+ * Swipe direction enum
+ */
+export var SwipeDirection;
+(function (SwipeDirection) {
+    SwipeDirection["Up"] = "up";
+    SwipeDirection["Down"] = "down";
+    SwipeDirection["Left"] = "left";
+    SwipeDirection["Right"] = "right";
+})(SwipeDirection || (SwipeDirection = {}));
+/**
+ * Enumeration for standard gamepad buttons
+ */
+export var GamepadButton;
+(function (GamepadButton) {
+    GamepadButton[GamepadButton["FaceBottom"] = 0] = "FaceBottom";
+    GamepadButton[GamepadButton["FaceRight"] = 1] = "FaceRight";
+    GamepadButton[GamepadButton["FaceLeft"] = 2] = "FaceLeft";
+    GamepadButton[GamepadButton["FaceTop"] = 3] = "FaceTop";
+    GamepadButton[GamepadButton["LeftBumper"] = 4] = "LeftBumper";
+    GamepadButton[GamepadButton["RightBumper"] = 5] = "RightBumper";
+    GamepadButton[GamepadButton["LeftTrigger"] = 6] = "LeftTrigger";
+    GamepadButton[GamepadButton["RightTrigger"] = 7] = "RightTrigger";
+    GamepadButton[GamepadButton["Select"] = 8] = "Select";
+    GamepadButton[GamepadButton["Start"] = 9] = "Start";
+    GamepadButton[GamepadButton["LeftStick"] = 10] = "LeftStick";
+    GamepadButton[GamepadButton["RightStick"] = 11] = "RightStick";
+    GamepadButton[GamepadButton["DpadUp"] = 12] = "DpadUp";
+    GamepadButton[GamepadButton["DpadDown"] = 13] = "DpadDown";
+    GamepadButton[GamepadButton["DpadLeft"] = 14] = "DpadLeft";
+    GamepadButton[GamepadButton["DpadRight"] = 15] = "DpadRight";
+})(GamepadButton || (GamepadButton = {}));
+/**
+ * Enumeration for standard gamepad axes
+ */
+export var GamepadAxis;
+(function (GamepadAxis) {
+    GamepadAxis[GamepadAxis["LeftStickX"] = 0] = "LeftStickX";
+    GamepadAxis[GamepadAxis["LeftStickY"] = 1] = "LeftStickY";
+    GamepadAxis[GamepadAxis["RightStickX"] = 2] = "RightStickX";
+    GamepadAxis[GamepadAxis["RightStickY"] = 3] = "RightStickY";
+})(GamepadAxis || (GamepadAxis = {}));
+/**
+ * Centralized input management system for handling keyboard, mouse, gamepad, and touch input
+ *
+ * Features:
+ * - Distributes input events to registered handlers
+ * - Tracks current input state (keys pressed, mouse buttons, position)
+ * - Provides pointer lock functionality
+ * - Normalizes mouse coordinates to NDC (Normalized Device Coordinates)
+ * - Manages gamepad connections and input
+ * - Handles touch input with normalized coordinates and pressure data
+ * - Provides virtual joystick support for mobile devices using nipplejs
+ * - Detects swipe gestures with configurable distance, velocity, and duration thresholds
+ * - Detects tap gestures with configurable duration and movement thresholds
+ * - Automatically enables touch input on mobile browsers
+ */
+export class InputManager {
+    /**
+       * Creates a new InputManager instance
+       * @param options - Required configuration including DOM element and World reference
+       */
+    constructor(options) {
+        Object.defineProperty(this, "options", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: options
+        });
+        Object.defineProperty(this, "keys", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Set()
+        });
+        Object.defineProperty(this, "mousePosition", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new THREE.Vector2()
+        });
+        Object.defineProperty(this, "mouseButtons", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Set()
+        });
+        Object.defineProperty(this, "inputHandlers", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        Object.defineProperty(this, "pointerLockOptions", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "inputEnabled", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: true
+        });
+        // Gamepad related properties
+        Object.defineProperty(this, "connectedGamepads", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+        Object.defineProperty(this, "previousButtonStates", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+        Object.defineProperty(this, "previousAxisValues", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+        Object.defineProperty(this, "gamepadDeadzone", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0.1
+        });
+        Object.defineProperty(this, "isPollingGamepads", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        Object.defineProperty(this, "gamepadRafId", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "boundHandleGamepadConnected", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: () => { }
+        });
+        Object.defineProperty(this, "boundHandleGamepadDisconnected", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: () => { }
+        });
+        Object.defineProperty(this, "onGamepadConnected", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Delegate()
+        });
+        Object.defineProperty(this, "onGamepadDisconnected", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Delegate()
+        });
+        // Touch related properties
+        Object.defineProperty(this, "virtualJoysticks", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+        Object.defineProperty(this, "leftJoystickZone", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "rightJoystickZone", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        // Gesture detection properties
+        Object.defineProperty(this, "touchStartPosition", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "touchStartTime", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
+        Object.defineProperty(this, "touchMoved", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        // Gesture thresholds with defaults
+        Object.defineProperty(this, "swipeMinDistance", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 50
+        });
+        Object.defineProperty(this, "swipeMaxDuration", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 1000
+        });
+        Object.defineProperty(this, "swipeMinVelocity", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 100
+        });
+        Object.defineProperty(this, "tapMaxDuration", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 300
+        });
+        Object.defineProperty(this, "tapMaxMovement", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 10
+        });
+        Object.defineProperty(this, "onSwipe", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Delegate()
+        });
+        Object.defineProperty(this, "onTap", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Delegate()
+        });
+        Object.defineProperty(this, "abortController", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new AbortController()
+        });
+        // Apply custom swipe options
+        if (options.swipeOptions) {
+            this.swipeMinDistance = options.swipeOptions.minDistance ?? this.swipeMinDistance;
+            this.swipeMaxDuration = options.swipeOptions.maxDuration ?? this.swipeMaxDuration;
+            this.swipeMinVelocity = options.swipeOptions.minVelocity ?? this.swipeMinVelocity;
+        }
+        // Apply custom tap options
+        if (options.tapOptions) {
+            this.tapMaxDuration = options.tapOptions.maxDuration ?? this.tapMaxDuration;
+            this.tapMaxMovement = options.tapOptions.maxMovement ?? this.tapMaxMovement;
+        }
+        this.setupEventListeners();
+    }
+    beginPlay() {
+        this.setupTouchInput();
+    }
+    endPlay() {
+        this.destroyTouchInput();
+    }
+    /**
+     * Cleans up resources used by the input manager
+     */
+    destroy() {
+        this.abortController.abort();
+        // Clean up gamepad resources
+        this.stopGamepadPolling();
+        this.connectedGamepads.clear();
+        this.previousButtonStates.clear();
+        this.previousAxisValues.clear();
+        // Clean up touch resources
+        this.destroyTouchInput();
+        this.inputHandlers = [];
+    }
+    /**
+       * Requests pointer lock on the renderer element
+       * @param options - Optional configuration for pointer lock behavior
+       * @remarks
+       * Pointer lock hides the cursor and provides raw mouse movement data,
+       * which is useful for first-person controls
+       */
+    requestPointerLock(options) {
+        this.pointerLockOptions = options ?? {};
+    }
+    /**
+       * Registers an input handler to receive input events
+       * @param handler - The handler to add
+       * @remarks
+       * Handlers are called in the order they were added until one returns true
+       */
+    addInputHandler(handler) {
+        handler.setInputManager(this);
+        this.inputHandlers.push(handler);
+    }
+    /**
+       * Unregisters an input handler
+       * @param handler - The handler to remove
+       */
+    removeInputHandler(handler) {
+        const index = this.inputHandlers.indexOf(handler);
+        if (index !== -1) {
+            handler.setInputManager(null);
+            this.inputHandlers.splice(index, 1);
+        }
+    }
+    /**
+       * Enables or disables input processing
+       * @param enabled - When true, input events will be processed; when false, all input events are ignored
+       */
+    setInputEnabled(enabled) {
+        this.inputEnabled = enabled;
+    }
+    /**
+       * Checks if input processing is currently enabled
+       * @returns True if input processing is enabled, false otherwise
+       */
+    isInputEnabled() {
+        return this.inputEnabled;
+    }
+    /**
+     * Gets all currently connected gamepads
+     * @returns An array of connected gamepads
+     */
+    getConnectedGamepads() {
+        return Array.from(this.connectedGamepads.values());
+    }
+    /**
+     * Gets a gamepad by its index
+     * @param index The index of the gamepad to get
+     * @returns The gamepad or null if not found
+     */
+    getGamepad(index) {
+        return this.connectedGamepads.get(index) ?? null;
+    }
+    /**
+     * Gets the current value of a gamepad button
+     * @param gamepadIndex The index of the gamepad
+     * @param buttonIndex The index of the button
+     * @returns The button value (0.0 to 1.0) or 0 if not pressed/not found
+     */
+    getGamepadButtonValue(gamepadIndex, buttonIndex) {
+        const gamepad = this.connectedGamepads.get(gamepadIndex);
+        if (!gamepad || buttonIndex >= gamepad.buttons.length)
+            return 0;
+        return gamepad.buttons[buttonIndex].value;
+    }
+    /**
+     * Gets the current value of a gamepad axis
+     * @param gamepadIndex The index of the gamepad
+     * @param axisIndex The index of the axis
+     * @returns The axis value (-1.0 to 1.0) or 0 if not found
+     */
+    getGamepadAxisValue(gamepadIndex, axisIndex) {
+        const gamepad = this.connectedGamepads.get(gamepadIndex);
+        if (!gamepad || axisIndex >= gamepad.axes.length)
+            return 0;
+        const value = gamepad.axes[axisIndex];
+        // Apply deadzone
+        return Math.abs(value) < this.gamepadDeadzone ? 0 : value;
+    }
+    /**
+     * Starts polling for gamepad input
+     */
+    startGamepadPolling() {
+        if (this.isPollingGamepads)
+            return;
+        this.isPollingGamepads = true;
+        this.pollGamepads();
+    }
+    /**
+     * Stops polling for gamepad input
+     */
+    stopGamepadPolling() {
+        if (!this.isPollingGamepads)
+            return;
+        this.isPollingGamepads = false;
+        if (this.gamepadRafId !== null) {
+            cancelAnimationFrame(this.gamepadRafId);
+            this.gamepadRafId = null;
+        }
+    }
+    //====================================================================================================
+    shouldIgnoreInput() {
+        return !this.isInputEnabled() || !this.options.world.deref()?.isPlaying();
+    }
+    setupEventListeners() {
+        if (isNode()) {
+            return;
+        }
+        const options = { signal: this.abortController.signal };
+        window.addEventListener('keydown', this.handleKeyDown.bind(this), options);
+        window.addEventListener('keyup', this.handleKeyUp.bind(this), options);
+        this.options.rendererDomElement.addEventListener('mousedown', this.handleMouseDown.bind(this), options);
+        this.options.rendererDomElement.addEventListener('mouseup', this.handleMouseUp.bind(this), options);
+        this.options.rendererDomElement.addEventListener('mousemove', this.handleMouseMove.bind(this), options);
+        this.options.rendererDomElement.addEventListener('click', this.handleMouseClick.bind(this), options);
+        // Setup touch event listeners for swipe and tap detection
+        this.options.rendererDomElement.addEventListener('touchstart', this.handleTouchStart.bind(this), options);
+        this.options.rendererDomElement.addEventListener('touchmove', this.handleTouchMove.bind(this), options);
+        this.options.rendererDomElement.addEventListener('touchend', this.handleTouchEnd.bind(this), options);
+        this.options.rendererDomElement.addEventListener('touchcancel', this.handleTouchCancel.bind(this), options);
+        // Setup pointer lock change listeners
+        document.addEventListener('pointerlockchange', this.handlePointerLockChange.bind(this), options);
+        document.addEventListener('mozpointerlockchange', this.handlePointerLockChange.bind(this), options);
+        document.addEventListener('webkitpointerlockchange', this.handlePointerLockChange.bind(this), options);
+        // Setup gamepad listeners if enabled
+        if (this.options.enableGamepad !== false) {
+            // Bind methods once to ensure we can remove them later
+            this.boundHandleGamepadConnected = this.handleGamepadConnected.bind(this);
+            this.boundHandleGamepadDisconnected = this.handleGamepadDisconnected.bind(this);
+            window.addEventListener('gamepadconnected', this.boundHandleGamepadConnected, options);
+            window.addEventListener('gamepaddisconnected', this.boundHandleGamepadDisconnected, options);
+            // Check for already connected gamepads that may have been missed by the event
+            const gamepads = navigator.getGamepads();
+            for (const gamepad of gamepads) {
+                if (gamepad) {
+                    this.handleGamepadConnected({ gamepad });
+                }
+            }
+        }
+    }
+    handleKeyDown(e) {
+        if (this.shouldIgnoreInput() || this.keys.has(e.key)) {
+            return;
+        }
+        this.keys.add(e.key);
+        for (const handler of this.inputHandlers) {
+            if (handler.handleKeyDown(e)) {
+                break;
+            }
+        }
+    }
+    handleKeyUp(e) {
+        if (this.shouldIgnoreInput()) {
+            return;
+        }
+        this.keys.delete(e.key);
+        for (const handler of this.inputHandlers) {
+            if (handler.handleKeyUp(e)) {
+                break;
+            }
+        }
+    }
+    handleMouseDown(e) {
+        if (this.shouldIgnoreInput()) {
+            return;
+        }
+        this.mouseButtons.add(e.button);
+        for (const handler of this.inputHandlers) {
+            if (handler.handleMouseDown(e.button, e)) {
+                break;
+            }
+        }
+    }
+    handleMouseUp(e) {
+        if (this.shouldIgnoreInput()) {
+            return;
+        }
+        this.mouseButtons.delete(e.button);
+        for (const handler of this.inputHandlers) {
+            if (handler.handleMouseUp(e.button, e)) {
+                break;
+            }
+        }
+    }
+    handleMouseClick(e) {
+        if (this.shouldIgnoreInput()) {
+            return;
+        }
+        if (this.pointerLockOptions && !this.isPointerLocked()) {
+            if (this.options.rendererDomElement.requestPointerLock) {
+                this.options.rendererDomElement.requestPointerLock(this.pointerLockOptions);
+            }
+        }
+        for (const handler of this.inputHandlers) {
+            if (handler.handleMouseClick(e.button, e)) {
+                break;
+            }
+        }
+    }
+    handleMouseMove(e) {
+        if (this.shouldIgnoreInput()) {
+            return;
+        }
+        const rect = this.options.rendererDomElement.getBoundingClientRect();
+        this.mousePosition.x = ((e.clientX - rect.left) / rect.width) * 2 - 1;
+        this.mousePosition.y = -((e.clientY - rect.top) / rect.height) * 2 + 1;
+        for (const handler of this.inputHandlers) {
+            if (handler.handleMouseMove(e)) {
+                break;
+            }
+        }
+    }
+    /**
+       * Checks if a specific key is currently pressed
+       * @param key - The key to check (case-sensitive)
+       * @returns True if the key is currently pressed down
+       */
+    isKeyDown(key) {
+        return this.keys.has(key);
+    }
+    /**
+       * Checks if a specific mouse button is currently pressed
+       * @param button - The button index to check (0=left, 1=middle, 2=right)
+       * @returns True if the button is currently pressed down
+       */
+    isMouseButtonDown(button) {
+        return this.mouseButtons.has(button);
+    }
+    /**
+       * Gets the current mouse position in Normalized Device Coordinates (NDC)
+       * @returns A Vector2 where:
+       *          - x ranges from -1 (left) to 1 (right)
+       *          - y ranges from -1 (bottom) to 1 (top)
+       */
+    getMousePosition() {
+        return this.mousePosition.clone();
+    }
+    /**
+       * Checks if pointer lock is currently active on the renderer element
+       * @returns True if pointer lock is active
+       */
+    isPointerLocked() {
+        return document.pointerLockElement === this.options.rendererDomElement;
+    }
+    /**
+       * Releases pointer lock if currently active
+       */
+    exitPointerLock() {
+        this.pointerLockOptions = null;
+        if (document.exitPointerLock) {
+            document.exitPointerLock();
+        }
+    }
+    // Gamepad handling methods
+    handleGamepadConnected(event) {
+        const gamepad = event.gamepad;
+        this.connectedGamepads.set(gamepad.index, gamepad);
+        this.previousButtonStates.set(gamepad.index, new Map());
+        this.previousAxisValues.set(gamepad.index, new Map());
+        // Initialize button states
+        const buttonStates = this.previousButtonStates.get(gamepad.index);
+        for (let i = 0; i < gamepad.buttons.length; i++) {
+            buttonStates.set(i, gamepad.buttons[i].pressed);
+        }
+        // Initialize axis values
+        const axisValues = this.previousAxisValues.get(gamepad.index);
+        for (let i = 0; i < gamepad.axes.length; i++) {
+            axisValues.set(i, gamepad.axes[i]);
+        }
+        // Start polling if we have connected gamepads and aren't already polling
+        if (!this.isPollingGamepads && this.connectedGamepads.size > 0) {
+            this.startGamepadPolling();
+        }
+        this.onGamepadConnected.invoke(gamepad);
+    }
+    handleGamepadDisconnected(event) {
+        const gamepad = event.gamepad;
+        this.connectedGamepads.delete(gamepad.index);
+        this.previousButtonStates.delete(gamepad.index);
+        this.previousAxisValues.delete(gamepad.index);
+        // Stop polling if no gamepads are connected
+        if (this.connectedGamepads.size === 0) {
+            this.stopGamepadPolling();
+        }
+        this.onGamepadDisconnected.invoke(gamepad);
+    }
+    pollGamepads() {
+        if (!this.isPollingGamepads)
+            return;
+        this.gamepadRafId = requestAnimationFrame(this.pollGamepads.bind(this));
+        // Skip polling if input is disabled or world is not playing
+        if (this.shouldIgnoreInput())
+            return;
+        // Process standard gamepads
+        this.pollStandardGamepads();
+    }
+    pollStandardGamepads() {
+        // Get all connected gamepads
+        const gamepads = navigator.getGamepads();
+        if (!gamepads)
+            return;
+        // Process each gamepad
+        for (const gamepad of gamepads) {
+            if (!gamepad)
+                continue;
+            // Update the stored gamepad reference
+            this.connectedGamepads.set(gamepad.index, gamepad);
+            // Check for button changes
+            for (let i = 0; i < gamepad.buttons.length; i++) {
+                const button = gamepad.buttons[i];
+                const buttonStates = this.previousButtonStates.get(gamepad.index);
+                const wasPressed = buttonStates.get(i) ?? false;
+                const isPressed = button.pressed;
+                // If button state changed
+                if (wasPressed !== isPressed) {
+                    buttonStates.set(i, isPressed);
+                    // Fire appropriate event
+                    if (isPressed) {
+                        // Button was pressed
+                        for (const handler of this.inputHandlers) {
+                            if (handler.handleGamepadButtonDown && handler.handleGamepadButtonDown(gamepad.index, i, button.value)) {
+                                break;
+                            }
+                        }
+                    }
+                    else {
+                        // Button was released
+                        for (const handler of this.inputHandlers) {
+                            if (handler.handleGamepadButtonUp && handler.handleGamepadButtonUp(gamepad.index, i)) {
+                                break;
+                            }
+                        }
+                    }
+                }
+            }
+            // Check for axis changes
+            for (let i = 0; i < gamepad.axes.length; i++) {
+                const currentValue = gamepad.axes[i];
+                const axisValues = this.previousAxisValues.get(gamepad.index);
+                const previousValue = axisValues.get(i) ?? 0;
+                // Apply deadzone to both values for comparison
+                const deadzonedCurrent = Math.abs(currentValue) < this.gamepadDeadzone ? 0 : currentValue;
+                const deadzonedPrevious = Math.abs(previousValue) < this.gamepadDeadzone ? 0 : previousValue;
+                // If axis value changed significantly
+                if (Math.abs(deadzonedCurrent - deadzonedPrevious) > 0.01) {
+                    axisValues.set(i, currentValue);
+                    // Notify handlers
+                    for (const handler of this.inputHandlers) {
+                        if (handler.handleGamepadAxisChange && handler.handleGamepadAxisChange(gamepad.index, i, deadzonedCurrent)) {
+                            break;
+                        }
+                    }
+                }
+            }
+        }
+    }
+    // Touch event handlers for swipe and tap detection
+    handleTouchStart(e) {
+        if (this.shouldIgnoreInput()) {
+            return;
+        }
+        // Only track single touch for swipe/tap detection
+        if (e.touches.length === 1) {
+            const touch = e.touches[0];
+            this.touchStartPosition = new THREE.Vector2(touch.clientX, touch.clientY);
+            this.touchStartTime = performance.now();
+            this.touchMoved = false;
+        }
+    }
+    handleTouchMove(e) {
+        if (this.shouldIgnoreInput()) {
+            return;
+        }
+        // Track if touch has moved
+        if (e.touches.length === 1 && this.touchStartPosition) {
+            const touch = e.touches[0];
+            const currentPosition = new THREE.Vector2(touch.clientX, touch.clientY);
+            const distance = this.touchStartPosition.distanceTo(currentPosition);
+            if (distance > this.tapMaxMovement) {
+                this.touchMoved = true;
+            }
+        }
+    }
+    handleTouchEnd(e) {
+        if (this.shouldIgnoreInput()) {
+            return;
+        }
+        if (!this.touchStartPosition) {
+            return;
+        }
+        const touch = e.changedTouches[0];
+        const endPosition = new THREE.Vector2(touch.clientX, touch.clientY);
+        const duration = performance.now() - this.touchStartTime;
+        const distance = this.touchStartPosition.distanceTo(endPosition);
+        // Check for tap gesture
+        if (!this.touchMoved && duration <= this.tapMaxDuration && distance <= this.tapMaxMovement) {
+            this.handleTapGesture(endPosition, e);
+        }
+        // Check for swipe gesture
+        else if (this.touchMoved && duration <= this.swipeMaxDuration && distance >= this.swipeMinDistance) {
+            const velocity = (distance / duration) * 1000; // Convert to pixels per second
+            if (velocity >= this.swipeMinVelocity) {
+                this.handleSwipeGesture(this.touchStartPosition, endPosition, distance, duration, velocity, e);
+            }
+        }
+        // Reset touch tracking
+        this.touchStartPosition = null;
+        this.touchStartTime = 0;
+        this.touchMoved = false;
+    }
+    handleTouchCancel(e) {
+        // Reset touch tracking on cancel
+        this.touchStartPosition = null;
+        this.touchStartTime = 0;
+        this.touchMoved = false;
+    }
+    handleTapGesture(position, event) {
+        // Calculate normalized position (NDC)
+        const rect = this.options.rendererDomElement.getBoundingClientRect();
+        const normalizedPosition = new THREE.Vector2(((position.x - rect.left) / rect.width) * 2 - 1, -((position.y - rect.top) / rect.height) * 2 + 1);
+        const tapData = {
+            position: position.clone(),
+            normalizedPosition,
+            event
+        };
+        // Distribute to handlers
+        for (const handler of this.inputHandlers) {
+            if (handler.handleTap && handler.handleTap(tapData)) {
+                break;
+            }
+        }
+        // Invoke delegate
+        this.onTap.invoke(tapData);
+    }
+    handleSwipeGesture(startPosition, endPosition, distance, duration, velocity, event) {
+        // Calculate swipe direction
+        const dx = endPosition.x - startPosition.x;
+        const dy = endPosition.y - startPosition.y;
+        const absDx = Math.abs(dx);
+        const absDy = Math.abs(dy);
+        let direction;
+        if (absDx > absDy) {
+            // Horizontal swipe
+            direction = dx > 0 ? SwipeDirection.Right : SwipeDirection.Left;
+        }
+        else {
+            // Vertical swipe
+            direction = dy > 0 ? SwipeDirection.Down : SwipeDirection.Up;
+        }
+        const swipeData = {
+            direction,
+            startPosition: startPosition.clone(),
+            endPosition: endPosition.clone(),
+            distance,
+            duration,
+            velocity,
+            event
+        };
+        // Distribute to handlers
+        for (const handler of this.inputHandlers) {
+            if (handler.handleSwipe && handler.handleSwipe(swipeData)) {
+                break;
+            }
+        }
+        // Invoke delegate
+        this.onSwipe.invoke(swipeData);
+    }
+    // Handle pointer lock change events
+    handlePointerLockChange() {
+        // This method handles changes to the pointer lock state
+        // It can be used to add additional logic when pointer lock is acquired or released
+    }
+    // Touch input setup and management methods
+    async setupTouchInput() {
+        const debugTouchInput = getEnv('VITE_DEBUG_TOUCH_INPUT') === 'true';
+        if (isNode()) {
+            return;
+        }
+        if (!isMobileBrowser() && !debugTouchInput) {
+            return;
+        }
+        // Check if virtual joystick is explicitly hidden
+        if (this.options.virtualJoystickOptions?.hidden) {
+            return;
+        }
+        // cannot import the nipplejs module globally as it requires the window global
+        const nipplejs = await import('nipplejs');
+        const nippleModule = nipplejs.default || nipplejs;
+        const defaultOptions = {
+            size: 120,
+            opacity: 0.7,
+            color: 'white',
+            mode: 'static',
+            fadeTime: 250
+        };
+        const joystickOptions = {
+            ...defaultOptions,
+            ...this.options.virtualJoystickOptions
+        };
+        try {
+            // Calculate joystick zone size based on joystick size plus padding for interaction
+            const zoneSize = joystickOptions.size * 1.5; // Extra space for comfortable interaction
+            // Create left joystick zone
+            this.leftJoystickZone = document.createElement('div');
+            this.leftJoystickZone.style.position = 'absolute';
+            this.leftJoystickZone.style.left = '20px';
+            this.leftJoystickZone.style.bottom = '20px';
+            this.leftJoystickZone.style.width = `${zoneSize}px`;
+            this.leftJoystickZone.style.height = `${zoneSize}px`;
+            this.leftJoystickZone.style.pointerEvents = 'auto';
+            if (debugTouchInput) {
+                this.leftJoystickZone.style.border = '2px solid rgba(255, 0, 0, 0.5)';
+                this.leftJoystickZone.style.backgroundColor = 'rgba(255, 0, 0, 0.1)';
+                this.leftJoystickZone.style.boxSizing = 'border-box';
+            }
+            this.options.gameContainer.appendChild(this.leftJoystickZone);
+            // Create right joystick zone
+            this.rightJoystickZone = document.createElement('div');
+            this.rightJoystickZone.style.position = 'absolute';
+            this.rightJoystickZone.style.right = '20px';
+            this.rightJoystickZone.style.bottom = '20px';
+            this.rightJoystickZone.style.width = `${zoneSize}px`;
+            this.rightJoystickZone.style.height = `${zoneSize}px`;
+            this.rightJoystickZone.style.pointerEvents = 'auto';
+            if (debugTouchInput) {
+                this.rightJoystickZone.style.border = '2px solid rgba(0, 0, 255, 0.5)';
+                this.rightJoystickZone.style.backgroundColor = 'rgba(0, 0, 255, 0.1)';
+                this.rightJoystickZone.style.boxSizing = 'border-box';
+            }
+            this.options.gameContainer.appendChild(this.rightJoystickZone);
+            const leftStick = nippleModule.create({
+                zone: this.leftJoystickZone,
+                mode: joystickOptions.mode,
+                position: { left: '50%', bottom: '50%' },
+                size: joystickOptions.size,
+                color: joystickOptions.color,
+                fadeTime: joystickOptions.fadeTime,
+                restOpacity: joystickOptions.opacity * 0.5,
+                threshold: 0.1,
+                catchDistance: 200,
+            });
+            const rightStick = nippleModule.create({
+                zone: this.rightJoystickZone,
+                mode: joystickOptions.mode,
+                position: { left: '50%', bottom: '50%' },
+                size: joystickOptions.size,
+                color: joystickOptions.color,
+                fadeTime: joystickOptions.fadeTime,
+                restOpacity: joystickOptions.opacity * 0.5,
+                threshold: 0.1,
+                catchDistance: 200
+            });
+            this.virtualJoysticks.set(VirtualJoystickIndex.Left, leftStick);
+            this.virtualJoysticks.set(VirtualJoystickIndex.Right, rightStick);
+            // Bind virtual joystick events
+            const leftHandler = this.handleVirtualJoystickEvent.bind(this, VirtualJoystickIndex.Left);
+            leftStick.on('start', leftHandler);
+            leftStick.on('move', leftHandler);
+            leftStick.on('end', leftHandler);
+            const rightHandler = this.handleVirtualJoystickEvent.bind(this, VirtualJoystickIndex.Right);
+            rightStick.on('start', rightHandler);
+            rightStick.on('move', rightHandler);
+            rightStick.on('end', rightHandler);
+        }
+        catch (error) {
+            console.warn('Failed to initialize virtual joystick:', error);
+        }
+    }
+    destroyTouchInput() {
+        if (this.leftJoystickZone) {
+            this.leftJoystickZone.remove();
+            this.leftJoystickZone = null;
+        }
+        if (this.rightJoystickZone) {
+            this.rightJoystickZone.remove();
+            this.rightJoystickZone = null;
+        }
+        for (const joystick of this.virtualJoysticks.values()) {
+            joystick.destroy();
+        }
+        this.virtualJoysticks.clear();
+    }
+    // Virtual joystick event handlers
+    handleVirtualJoystickEvent(index, event, output) {
+        if (this.shouldIgnoreInput()) {
+            return;
+        }
+        if (event.type === 'start' || event.type === 'move' || event.type === 'end') {
+            const joystickData = {
+                type: event.type,
+                position: new THREE.Vector2(output.position.x, output.position.y),
+            };
+            // Distribute to handlers
+            for (const handler of this.inputHandlers) {
+                if (handler.handleVirtualJoystick && handler.handleVirtualJoystick(index, joystickData)) {
+                    break;
+                }
+            }
+        }
+    }
+    /**
+     * Checks if virtual joystick is enabled
+     * @returns True if virtual joystick is enabled
+     */
+    isVirtualJoystickEnabled() {
+        return !!this.virtualJoysticks.values.length;
+    }
+    /**
+     * Shows the virtual joystick by setting visibility to visible
+     * Only works if joysticks have been initialized
+     */
+    showVirtualJoystick() {
+        if (this.leftJoystickZone) {
+            this.leftJoystickZone.style.visibility = 'visible';
+        }
+        if (this.rightJoystickZone) {
+            this.rightJoystickZone.style.visibility = 'visible';
+        }
+    }
+    /**
+     * Hides the virtual joystick by setting visibility to hidden
+     * The joystick will still capture events but won't be visible
+     */
+    hideVirtualJoystick() {
+        if (this.leftJoystickZone) {
+            this.leftJoystickZone.style.visibility = 'hidden';
+        }
+        if (this.rightJoystickZone) {
+            this.rightJoystickZone.style.visibility = 'hidden';
+        }
+    }
+    /**
+     * Checks if the virtual joystick is currently visible
+     * @returns True if visible, false if hidden or not initialized
+     */
+    isVirtualJoystickVisible() {
+        if (!this.leftJoystickZone) {
+            return false;
+        }
+        return this.leftJoystickZone.style.visibility !== 'hidden';
+    }
+}
+/**
+ * Base class for input handlers that provides default implementations for all methods
+ * Subclasses can override specific methods to handle specific input events
+ */
+export class BaseInputHandler {
+    constructor() {
+        Object.defineProperty(this, "inputManager", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+    }
+    handleKeyDown(e) {
+        return false;
+    }
+    handleKeyUp(e) {
+        return false;
+    }
+    handleMouseDown(button, e) {
+        return false;
+    }
+    handleMouseUp(button, e) {
+        return false;
+    }
+    handleMouseMove(e) {
+        return false;
+    }
+    handleMouseClick(button, e) {
+        return false;
+    }
+    handleGamepadButtonDown(gamepadIndex, buttonIndex, value) {
+        return false;
+    }
+    handleGamepadButtonUp(gamepadIndex, buttonIndex) {
+        return false;
+    }
+    handleGamepadAxisChange(gamepadIndex, axisIndex, value) {
+        return false;
+    }
+    handleVirtualJoystick(index, joystickData) {
+        return false;
+    }
+    handleSwipe(swipeData) {
+        return false;
+    }
+    handleTap(tapData) {
+        return false;
+    }
+    setInputManager(manager) {
+        this.inputManager = manager;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"InputManager.js","sourceRoot":"","sources":["../../../src/systems/InputManager.ts"],"names":[],"mappings":"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"}