@directivegames/genesys.js 3.1.24

package/dist/src/xr/VRControllerManager.js

@@ -0,0 +1,539 @@
+/**
+ * VRControllerManager - manages WebXR motion controllers and hand tracking.
+ *
+ * Refactored to use VRInputDevice abstraction for cleaner code and better separation of concerns.
+ * - Handles automatic detection and setup of VR controllers/hands
+ * - Uses VRController and VRHand classes for device-specific logic
+ * - Updates all input devices every frame
+ * - Supports both motion controllers and hand tracking
+ *
+ * Recommended usage (for humans and AI assistants):
+ * - Instantiate in VR applications that need controller representation
+ * - Call setupWithRenderer() to connect to XR session events
+ * - Call updateControllers() in your animation loop
+ * - Subscribe to delegates for controller events
+ */
+import { Delegate } from '../utils/Delegate.js';
+import { VRInputDevice } from './VRInputDevice.js';
+export var XRButton;
+(function (XRButton) {
+    /** Primary trigger - required for all xr-standard controllers */
+    XRButton["Trigger"] = "Trigger";
+    /** Primary squeeze button - optional */
+    XRButton["Squeeze"] = "Squeeze";
+    /** Primary touchpad - optional */
+    XRButton["Touchpad"] = "Touchpad";
+    /** Primary thumbstick - optional */
+    XRButton["Thumbstick"] = "Thumbstick";
+})(XRButton || (XRButton = {}));
+export var XRAxis;
+(function (XRAxis) {
+    XRAxis["TouchpadX"] = "TouchpadX";
+    XRAxis["TouchpadY"] = "TouchpadY";
+    XRAxis["ThumbstickX"] = "ThumbstickX";
+    XRAxis["ThumbstickY"] = "ThumbstickY";
+})(XRAxis || (XRAxis = {}));
+/**
+ * XR Button indices according to the "xr-standard" mapping
+ * https://www.w3.org/TR/webxr-gamepads-module/#xr-standard-gamepad-mapping
+ */
+// Internal index mappings (xr-standard gamepad mapping)
+const XR_BUTTON_TO_INDEX = {
+    [XRButton.Trigger]: 0,
+    [XRButton.Squeeze]: 1,
+    [XRButton.Touchpad]: 2,
+    [XRButton.Thumbstick]: 3
+};
+const INDEX_TO_XR_BUTTON = {
+    0: XRButton.Trigger,
+    1: XRButton.Squeeze,
+    2: XRButton.Touchpad,
+    3: XRButton.Thumbstick
+};
+const XR_AXIS_TO_INDEX = {
+    [XRAxis.TouchpadX]: 0,
+    [XRAxis.TouchpadY]: 1,
+    [XRAxis.ThumbstickX]: 2,
+    [XRAxis.ThumbstickY]: 3
+};
+const INDEX_TO_XR_AXIS = {
+    0: XRAxis.TouchpadX,
+    1: XRAxis.TouchpadY,
+    2: XRAxis.ThumbstickX,
+    3: XRAxis.ThumbstickY
+};
+export class VRControllerManager {
+    // Public helpers: indexes are internal; expose enum <-> index mapping only here
+    static getButtonIndex(button) { return XR_BUTTON_TO_INDEX[button]; }
+    static getAxisIndex(axis) { return XR_AXIS_TO_INDEX[axis]; }
+    constructor(world, options = {}) {
+        Object.defineProperty(this, "devices", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        }); // Array of 2 devices (index 0 = left, index 1 = right)
+        Object.defineProperty(this, "world", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "renderer", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "options", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        // Button state tracking
+        Object.defineProperty(this, "previousButtonStates", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+        // Axis state tracking for thumbsticks and touchpads
+        Object.defineProperty(this, "previousAxisStates", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+        /** Fired when a controller is added */
+        Object.defineProperty(this, "onControllerAdded", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Delegate()
+        });
+        /** Fired when a controller is removed */
+        Object.defineProperty(this, "onControllerRemoved", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Delegate()
+        });
+        /** Fired when controller position/state updates */
+        Object.defineProperty(this, "onControllerUpdated", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Delegate()
+        });
+        /** Fired when an XR controller button is pressed */
+        Object.defineProperty(this, "onButtonDown", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Delegate()
+        });
+        /** Fired when an XR controller button is released */
+        Object.defineProperty(this, "onButtonUp", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Delegate()
+        });
+        /** Fired when an XR controller button value changes (for analog buttons) */
+        Object.defineProperty(this, "onButtonValueChanged", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Delegate()
+        });
+        /** Fired when an XR controller axis value changes (thumbsticks, touchpads) */
+        Object.defineProperty(this, "onAxisChanged", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Delegate()
+        });
+        /** Fired when a squeeze gesture starts (grab/pinch) */
+        Object.defineProperty(this, "onSqueezeStart", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Delegate()
+        });
+        /** Fired when a squeeze gesture ends successfully */
+        Object.defineProperty(this, "onSqueeze", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Delegate()
+        });
+        /** Fired when a squeeze gesture ends (success or failure) */
+        Object.defineProperty(this, "onSqueezeEnd", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Delegate()
+        });
+        /** Fired when a select action starts (trigger/tap) */
+        Object.defineProperty(this, "onSelectStart", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Delegate()
+        });
+        /** Fired when a select action completes successfully */
+        Object.defineProperty(this, "onSelect", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Delegate()
+        });
+        /** Fired when a select action ends (success or failure) */
+        Object.defineProperty(this, "onSelectEnd", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Delegate()
+        });
+        this.world = world;
+        this.options = {
+            rayVisualizationEnabled: options.rayVisualizationEnabled ?? true,
+            maxRayDistance: options.maxRayDistance ?? 10
+        };
+    }
+    /**
+     * Get the renderer instance
+     */
+    getRenderer() {
+        return this.renderer;
+    }
+    /**
+     * Setup the controller manager with a WebXR renderer
+     */
+    setupWithRenderer(renderer) {
+        this.renderer = renderer;
+        // Create VR input devices for both controller indices
+        this.createVRDevices();
+        renderer.xr.addEventListener('sessionstart', () => {
+            const session = renderer.xr.getSession();
+            if (session) {
+                // Add squeeze event listeners for hand tracking and controller gestures
+                session.addEventListener('squeezestart', (event) => {
+                    const squeezeEvent = {
+                        inputSource: event.inputSource,
+                        frame: event.frame
+                    };
+                    this.onSqueezeStart.invoke(squeezeEvent);
+                });
+                session.addEventListener('squeeze', (event) => {
+                    const squeezeEvent = {
+                        inputSource: event.inputSource,
+                        frame: event.frame,
+                        success: true
+                    };
+                    this.onSqueeze.invoke(squeezeEvent);
+                    // Note: squeeze completion doesn't need additional InputManager forwarding
+                    // The press is already handled in squeezestart
+                });
+                session.addEventListener('squeezeend', (event) => {
+                    const squeezeEvent = {
+                        inputSource: event.inputSource,
+                        frame: event.frame,
+                        success: false
+                    };
+                    this.onSqueezeEnd.invoke(squeezeEvent);
+                });
+                // Add select event listeners for primary actions (trigger/tap)
+                session.addEventListener('selectstart', (event) => {
+                    const selectEvent = {
+                        inputSource: event.inputSource,
+                        frame: event.frame
+                    };
+                    this.onSelectStart.invoke(selectEvent);
+                });
+                session.addEventListener('select', (event) => {
+                    const selectEvent = {
+                        inputSource: event.inputSource,
+                        frame: event.frame,
+                        success: true
+                    };
+                    this.onSelect.invoke(selectEvent);
+                    // Note: select completion doesn't need additional InputManager forwarding
+                    // The press is already handled in selectstart
+                });
+                session.addEventListener('selectend', (event) => {
+                    const selectEvent = {
+                        inputSource: event.inputSource,
+                        frame: event.frame,
+                        success: false
+                    };
+                    this.onSelectEnd.invoke(selectEvent);
+                });
+            }
+        });
+        renderer.xr.addEventListener('sessionend', () => {
+            this.cleanup();
+        });
+    }
+    /**
+     * Create VR input devices for both controller indices
+     */
+    createVRDevices() {
+        if (!this.renderer) {
+            console.warn('[VRControllerManager] No renderer available for device creation');
+            return;
+        }
+        // Create devices for both controller indices (0 and 1)
+        for (let i = 0; i < 2; i++) {
+            const device = new VRInputDevice(i, this.world, this.renderer, this.options);
+            // Set up device event handlers
+            device.onControllerConnected.add((inputSource) => {
+                this.onControllerAdded.invoke({
+                    inputSource,
+                    device
+                });
+            });
+            device.onControllerDisconnected.add((inputSource) => {
+                this.onControllerRemoved.invoke(inputSource);
+            });
+            device.onControllerUpdated.add((inputSource) => {
+                // Process button and axis events from XR gamepad
+                this.processInputEvents(inputSource);
+                // Fire update delegate
+                this.onControllerUpdated.invoke(inputSource, device);
+            });
+            this.devices[i] = device;
+        }
+    }
+    /**
+     * Update all controllers (call this every frame)
+     */
+    updateControllers() {
+        if (!this.renderer)
+            return;
+        const session = this.renderer.xr.getSession();
+        if (!session)
+            return;
+        // Update all devices
+        this.devices.forEach((device) => {
+            device.update();
+        });
+        // Allow device handlers to run per-frame hooks (e.g., fingertip collider updates)
+        this.devices.forEach((device) => {
+            const handler = device.currentHandler;
+            if (handler && typeof handler.update === 'function') {
+                handler.update();
+            }
+        });
+    }
+    /**
+     * Get device by handedness
+     */
+    getDeviceByHandedness(handedness) {
+        for (const device of this.devices) {
+            if (device.getHandedness() === handedness) {
+                return device;
+            }
+        }
+        return null;
+    }
+    /**
+     * Get Three.js target ray group by handedness (for pointing/raycasting)
+     */
+    getTargetRayGroup(handedness) {
+        const device = this.getDeviceByHandedness(handedness);
+        return device?.getTargetRayGroup() ?? null;
+    }
+    /**
+     * Get Three.js controller grip group by handedness
+     */
+    getControllerGripGroup(handedness) {
+        const device = this.getDeviceByHandedness(handedness);
+        return device?.getGripGroup() ?? null;
+    }
+    /**
+     * Get target ray pose directly from input source (extracted from group)
+     */
+    getTargetRayPose(inputSource) {
+        const device = this.getDeviceByInputSource(inputSource);
+        return device?.getTargetRayPose() ?? null;
+    }
+    /**
+     * Get grip pose directly from input source (extracted from group)
+     */
+    getGripPose(inputSource) {
+        const device = this.getDeviceByInputSource(inputSource);
+        return device?.getGripPose() ?? null;
+    }
+    /**
+     * Get device by input source
+     */
+    getDeviceByInputSource(inputSource) {
+        for (const device of this.devices) {
+            if (device.getInputSource() === inputSource) {
+                return device;
+            }
+        }
+        return null;
+    }
+    /**
+     * Get all active controllers
+     */
+    getControllers() {
+        const controllers = [];
+        this.devices.forEach((device) => {
+            const inputSource = device.getInputSource();
+            if (inputSource) {
+                controllers.push({
+                    inputSource,
+                    device
+                });
+            }
+        });
+        return controllers;
+    }
+    /**
+     * Get controller by handedness
+     */
+    getControllerByHand(handedness) {
+        const device = this.getDeviceByHandedness(handedness);
+        if (device) {
+            const inputSource = device.getInputSource();
+            if (inputSource) {
+                return {
+                    inputSource,
+                    device
+                };
+            }
+        }
+        return null;
+    }
+    /**
+     * Cleanup all controllers
+     */
+    cleanup() {
+        this.devices.forEach((device) => {
+            device.dispose();
+        });
+        this.devices = [];
+        this.previousButtonStates.clear();
+        this.previousAxisStates.clear();
+    }
+    /**
+     * Process button and axis events for an XR input source
+     */
+    processInputEvents(inputSource) {
+        // Only process if we have a gamepad
+        if (!inputSource.gamepad)
+            return;
+        const gamepad = inputSource.gamepad;
+        // Process button events
+        this.processButtonChanges(inputSource, gamepad);
+        // Process axis events (thumbsticks, touchpads)
+        this.processAxisChanges(inputSource, gamepad);
+    }
+    /**
+     * Process button changes for an XR input source
+     */
+    processButtonChanges(inputSource, gamepad) {
+        let prevButtonStates = this.previousButtonStates.get(inputSource);
+        // Initialize previous states if this is the first frame
+        if (!prevButtonStates) {
+            prevButtonStates = new Map();
+            this.previousButtonStates.set(inputSource, prevButtonStates);
+        }
+        // Process each button according to the xr-standard mapping
+        for (let i = 0; i < gamepad.buttons.length; i++) {
+            const button = gamepad.buttons[i];
+            const currentState = {
+                pressed: button.pressed,
+                touched: button.touched,
+                value: button.value
+            };
+            const prevState = prevButtonStates.get(i) ?? { pressed: false, touched: false, value: 0 };
+            // Check for button down events
+            if (currentState.pressed && !prevState.pressed) {
+                const event = {
+                    inputSource,
+                    button: INDEX_TO_XR_BUTTON[i],
+                    buttonState: currentState
+                };
+                this.onButtonDown.invoke(event);
+            }
+            // Check for button up events
+            if (!currentState.pressed && prevState.pressed) {
+                const event = {
+                    inputSource,
+                    button: INDEX_TO_XR_BUTTON[i],
+                    buttonState: currentState
+                };
+                this.onButtonUp.invoke(event);
+            }
+            // Check for value changes (for analog buttons like triggers)
+            if (Math.abs(currentState.value - prevState.value) > 0.001) {
+                const event = {
+                    inputSource,
+                    button: INDEX_TO_XR_BUTTON[i],
+                    buttonState: currentState
+                };
+                this.onButtonValueChanged.invoke(event);
+            }
+            // Update previous state
+            prevButtonStates.set(i, currentState);
+        }
+    }
+    /**
+     * Process axis changes for an XR input source (thumbsticks, touchpads)
+     */
+    processAxisChanges(inputSource, gamepad) {
+        let prevAxisStates = this.previousAxisStates.get(inputSource);
+        // Initialize previous states if this is the first frame
+        if (!prevAxisStates) {
+            prevAxisStates = new Map();
+            this.previousAxisStates.set(inputSource, prevAxisStates);
+        }
+        // Process each axis (thumbsticks and touchpads)
+        for (let i = 0; i < gamepad.axes.length; i++) {
+            const currentValue = gamepad.axes[i];
+            const prevValue = prevAxisStates.get(i) ?? 0;
+            // Check for significant axis changes (with deadzone)
+            if (Math.abs(currentValue - prevValue) > 0.01) {
+                const event = {
+                    inputSource,
+                    axis: INDEX_TO_XR_AXIS[i],
+                    axisValue: currentValue,
+                    previousValue: prevValue
+                };
+                this.onAxisChanged.invoke(event);
+                // Update previous state
+                prevAxisStates.set(i, currentValue);
+            }
+        }
+    }
+    /**
+     * Enable or disable ray visualization for all devices
+     */
+    setRayVisualizationEnabled(enabled) {
+        this.options.rayVisualizationEnabled = enabled;
+        this.devices.forEach((device) => {
+            device.setRayVisualizationEnabled(enabled);
+        });
+    }
+    /**
+     * Check if ray visualization is enabled
+     */
+    isRayVisualizationEnabled() {
+        return this.options.rayVisualizationEnabled;
+    }
+    /**
+     * Set controller model visibility by handedness (only affects motion controllers, not hands)
+     */
+    setControllerVisible(handedness, visible) {
+        const device = this.getDeviceByHandedness(handedness);
+        if (device) {
+            device.setControllerVisible(visible);
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"VRControllerManager.js","sourceRoot":"","sources":["../../../src/xr/VRControllerManager.ts"],"names":[],"mappings":"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"}

package/dist/src/xr/VRDeviceHandler.d.ts

@@ -0,0 +1,47 @@
+/**
+ * VRDeviceHandler - Abstract base class for VR device-specific logic
+ *
+ * This provides a clean abstraction for handling controller vs hand-specific functionality
+ * without any branching logic in the concrete implementations.
+ */
+import type { World } from '../game/World.js';
+import type * as THREE from 'three';
+export declare abstract class VRDeviceHandler {
+    protected inputSource: XRInputSource;
+    protected renderer: THREE.WebGLRenderer;
+    protected world: World;
+    protected controllerIndex: number;
+    constructor(inputSource: XRInputSource, renderer: THREE.WebGLRenderer, world: World, controllerIndex: number);
+    /**
+     * Get the input source
+     */
+    getInputSource(): XRInputSource;
+    /**
+     * Get handedness of this device
+     */
+    getHandedness(): 'left' | 'right' | 'none';
+    /**
+     * Get controller index
+     */
+    getControllerIndex(): number;
+    /**
+     * Get the Three.js target ray group (for pointing/raycasting)
+     */
+    abstract getTargetRayGroup(): THREE.Group | null;
+    /**
+     * Get the Three.js grip group (for object attachment)
+     */
+    abstract getGripGroup(): THREE.Group | null;
+    /**
+     * Create and setup the visual model for this device
+     */
+    abstract createVisualModel(): void;
+    /**
+     * Clean up resources and dispose of visual models
+     */
+    abstract dispose(): void;
+    /**
+     * Per-frame update hook. Default no-op.
+     */
+    update(_deltaTime?: number): void;
+}

package/dist/src/xr/VRDeviceHandler.js

@@ -0,0 +1,61 @@
+/**
+ * VRDeviceHandler - Abstract base class for VR device-specific logic
+ *
+ * This provides a clean abstraction for handling controller vs hand-specific functionality
+ * without any branching logic in the concrete implementations.
+ */
+export class VRDeviceHandler {
+    constructor(inputSource, renderer, world, controllerIndex) {
+        Object.defineProperty(this, "inputSource", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "renderer", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "world", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "controllerIndex", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.inputSource = inputSource;
+        this.renderer = renderer;
+        this.world = world;
+        this.controllerIndex = controllerIndex;
+    }
+    /**
+     * Get the input source
+     */
+    getInputSource() {
+        return this.inputSource;
+    }
+    /**
+     * Get handedness of this device
+     */
+    getHandedness() {
+        return this.inputSource.handedness;
+    }
+    /**
+     * Get controller index
+     */
+    getControllerIndex() {
+        return this.controllerIndex;
+    }
+    /**
+     * Per-frame update hook. Default no-op.
+     */
+    update(_deltaTime) { }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiVlJEZXZpY2VIYW5kbGVyLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL3hyL1ZSRGV2aWNlSGFuZGxlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7R0FLRztBQU1ILE1BQU0sT0FBZ0IsZUFBZTtJQU1uQyxZQUNFLFdBQTBCLEVBQzFCLFFBQTZCLEVBQzdCLEtBQVksRUFDWixlQUF1QjtRQVRmOzs7OztXQUEyQjtRQUMzQjs7Ozs7V0FBOEI7UUFDOUI7Ozs7O1dBQWE7UUFDYjs7Ozs7V0FBd0I7UUFRaEMsSUFBSSxDQUFDLFdBQVcsR0FBRyxXQUFXLENBQUM7UUFDL0IsSUFBSSxDQUFDLFFBQVEsR0FBRyxRQUFRLENBQUM7UUFDekIsSUFBSSxDQUFDLEtBQUssR0FBRyxLQUFLLENBQUM7UUFDbkIsSUFBSSxDQUFDLGVBQWUsR0FBRyxlQUFlLENBQUM7SUFDekMsQ0FBQztJQUVEOztPQUVHO0lBQ0ksY0FBYztRQUNuQixPQUFPLElBQUksQ0FBQyxXQUFXLENBQUM7SUFDMUIsQ0FBQztJQUVEOztPQUVHO0lBQ0ksYUFBYTtRQUNsQixPQUFPLElBQUksQ0FBQyxXQUFXLENBQUMsVUFBdUMsQ0FBQztJQUNsRSxDQUFDO0lBRUQ7O09BRUc7SUFDSSxrQkFBa0I7UUFDdkIsT0FBTyxJQUFJLENBQUMsZUFBZSxDQUFDO0lBQzlCLENBQUM7SUF3QkQ7O09BRUc7SUFDSSxNQUFNLENBQUMsVUFBbUIsSUFBaUMsQ0FBQztDQUNwRSJ9