@directivegames/genesys.js 3.1.24

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

@@ -0,0 +1,23 @@
+/**
+ * VRHandHandler - Handles VR hand tracking
+ *
+ * Pure hand tracking logic with no branching - knows exactly how to handle hands.
+ */
+import * as THREE from 'three';
+import { VRDeviceHandler } from './VRDeviceHandler.js';
+import type { World } from '../game/World.js';
+export declare class VRHandHandler extends VRDeviceHandler {
+    private handGroup;
+    private handModel;
+    private handPointer;
+    private pointerActor;
+    private pointerCollider;
+    private getXRHandTipObject;
+    constructor(inputSource: XRInputSource, renderer: THREE.WebGLRenderer, world: World, controllerIndex: number);
+    getTargetRayGroup(): THREE.Group | null;
+    getGripGroup(): THREE.Group | null;
+    createVisualModel(): void;
+    private createPointerCollider;
+    update(): void;
+    dispose(): void;
+}

package/dist/src/xr/VRHandHandler.js

@@ -0,0 +1,161 @@
+/**
+ * VRHandHandler - Handles VR hand tracking
+ *
+ * Pure hand tracking logic with no branching - knows exactly how to handle hands.
+ */
+import * as THREE from 'three';
+import { OculusHandModel } from 'three/addons/webxr/OculusHandModel.js';
+import { OculusHandPointerModel } from 'three/addons/webxr/OculusHandPointerModel.js';
+import { Actor } from '../actors/Actor.js';
+import { CollisionShapeComponent, CollisionShapeType } from '../components/CollisionShapeComponent.js';
+import { PhysicsMotionType } from '../physics/PhysicsTypes.js';
+import { DefaultCollisionProfile } from '../systems/collision/CollisionTypes.js';
+import { VRDeviceHandler } from './VRDeviceHandler.js';
+export class VRHandHandler extends VRDeviceHandler {
+    getXRHandTipObject() {
+        if (!this.handGroup)
+            return null;
+        const hand = this.handGroup;
+        if (hand.joints) {
+            const tip = hand.joints['index-finger-tip'];
+            return tip ?? null;
+        }
+        return null;
+    }
+    constructor(inputSource, renderer, world, controllerIndex) {
+        super(inputSource, renderer, world, controllerIndex);
+        Object.defineProperty(this, "handGroup", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "handModel", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "handPointer", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "pointerActor", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "pointerCollider", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        this.createVisualModel();
+    }
+    getTargetRayGroup() {
+        if (!this.renderer?.xr.isPresenting) {
+            return null;
+        }
+        return this.handPointer?.pointerObject;
+    }
+    getGripGroup() {
+        if (!this.renderer?.xr.isPresenting) {
+            return null;
+        }
+        // For hands, return the controller group (target ray space)
+        return this.handPointer?.pointerObject;
+    }
+    createVisualModel() {
+        if (!this.renderer) {
+            return;
+        }
+        // Add controller groups to scene (important for ray visualization!)
+        const controller = this.renderer.xr.getController(this.controllerIndex);
+        this.handGroup = this.renderer.xr.getHand(this.controllerIndex);
+        this.world.scene.add(controller);
+        this.world.scene.add(this.handGroup);
+        // Create hand models
+        this.handModel = new OculusHandModel(this.handGroup);
+        this.handPointer = new OculusHandPointerModel(this.handGroup, controller);
+        this.handGroup.add(this.handModel);
+        this.handGroup.add(this.handPointer);
+        console.log(`[VRHandHandler] Created hand model for ${this.getHandedness()} hand`);
+        // Create fingertip pointer collider (trigger-only)
+        this.createPointerCollider();
+    }
+    createPointerCollider() {
+        const world = this.world;
+        if (!world || !this.handGroup)
+            return;
+        this.pointerCollider = new CollisionShapeComponent({
+            shapeType: CollisionShapeType.Sphere,
+            physicsOptions: {
+                enabled: true,
+                motionType: PhysicsMotionType.KinematicPositionBased,
+                gravityScale: 0,
+                generateCollisionEvents: true,
+                collisionProfile: DefaultCollisionProfile.Trigger
+            },
+            enableDebugVisualization: false
+        });
+        this.pointerCollider.name = 'VRPointerCollider';
+        this.pointerCollider.scale.setScalar(0.02); // ~2cm radius
+        // Make sure physics doesn't try to drive transform
+        this.pointerCollider.setPhysicsTransformUpdateFlags({
+            sendPosition: true,
+            sendRotation: true,
+            receivePosition: false,
+            receiveRotation: false
+        });
+        // Create a lightweight actor container for the collider
+        this.pointerActor = new Actor({ rootComponent: this.pointerCollider });
+        world.addActor(this.pointerActor);
+    }
+    update() {
+        if (!this.pointerCollider || !this.handGroup)
+            return;
+        // Try to get fingertip from hand joints if available
+        let worldPos = null;
+        const tip = this.getXRHandTipObject();
+        if (tip) {
+            tip.updateMatrixWorld(true);
+            worldPos = new THREE.Vector3().setFromMatrixPosition(tip.matrixWorld);
+        }
+        if (!worldPos)
+            return;
+        // Move kinematic trigger to fingertip position
+        this.pointerCollider.setWorldPosition(worldPos);
+        const physics = this.pointerCollider.getPhysicsEngine();
+        if (physics) {
+            physics.updateTransform(this.pointerCollider);
+        }
+    }
+    dispose() {
+        if (this.pointerActor) {
+            const world = this.world;
+            if (world) {
+                world.removeActors(this.pointerActor);
+            }
+            this.pointerActor = null;
+            this.pointerCollider = null;
+        }
+        if (this.handModel && this.handGroup) {
+            this.handGroup.remove(this.handModel);
+            this.handModel = null;
+        }
+        if (this.handPointer && this.handGroup) {
+            this.handGroup.remove(this.handPointer);
+            this.handPointer = null;
+        }
+        if (this.handGroup && this.handGroup.parent) {
+            this.handGroup.parent.remove(this.handGroup);
+            this.handGroup = null;
+        }
+        console.log(`[VRHandHandler] Disposed hand model for ${this.getHandedness()} hand`);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,100 @@
+/**
+ * VRInputDevice - Manages a single VR input device (controller or hand)
+ *
+ * This class handles the lifecycle of a VR input device, listening for connected/disconnected
+ * events and creating the appropriate handler based on device type. Uses clean abstractions
+ * to eliminate branching logic.
+ */
+import * as THREE from 'three';
+import { Delegate } from '../utils/Delegate.js';
+import type { VRControllerOptions } from './VRControllerManager.js';
+import type { World } from '../game/World.js';
+export declare class VRInputDevice {
+    private controllerIndex;
+    private world;
+    private renderer;
+    private options;
+    private controller;
+    private currentHandler;
+    private rayLine;
+    private rayHitSphere;
+    private maxRayDistance;
+    readonly onControllerConnected: Delegate<[XRInputSource], void>;
+    readonly onControllerDisconnected: Delegate<[XRInputSource], void>;
+    readonly onControllerUpdated: Delegate<[XRInputSource], void>;
+    constructor(controllerIndex: number, world: World, renderer: THREE.WebGLRenderer, options: Required<VRControllerOptions>);
+    /**
+     * Set up event listeners for controller connection/disconnection
+     */
+    private setupEventListeners;
+    /**
+     * Handle controller connected event - creates appropriate handler
+     */
+    private handleControllerConnected;
+    /**
+     * Handle controller disconnected event - cleans up handler
+     */
+    private handleControllerDisconnected;
+    /**
+     * Update device state (call every frame)
+     */
+    update(): void;
+    /**
+     * Get target ray pose for raycasting (extracted from target ray group)
+     */
+    getTargetRayPose(): {
+        origin: THREE.Vector3;
+        direction: THREE.Vector3;
+    } | null;
+    /**
+     * Get grip pose for object attachment (extracted from grip group)
+     */
+    getGripPose(): {
+        position: THREE.Vector3;
+        quaternion: THREE.Quaternion;
+    } | null;
+    /**
+     * Get the Three.js target ray group (for pointing/raycasting)
+     */
+    getTargetRayGroup(): THREE.Group | null;
+    /**
+     * Get the Three.js grip group
+     */
+    getGripGroup(): THREE.Group | null;
+    /**
+     * Get current input source
+     */
+    getInputSource(): XRInputSource | null;
+    /**
+     * Get controller index
+     */
+    getControllerIndex(): number;
+    /**
+     * Get handedness of this device
+     */
+    getHandedness(): 'left' | 'right' | 'none';
+    /**
+     * Create ray visualization objects
+     */
+    private createRayVisualization;
+    /**
+     * Clean up ray visualization objects
+     */
+    private cleanupRayVisualization;
+    /**
+     * Update ray visualization
+     */
+    private updateRayVisualization;
+    /**
+     * Enable or disable ray visualization
+     */
+    setRayVisualizationEnabled(enabled: boolean): void;
+    /**
+     * Set controller model visibility (only works for motion controllers, not hands)
+     */
+    setControllerVisible(visible: boolean): void;
+    /**
+     * Clean up resources
+     */
+    dispose(): void;
+}

package/dist/src/xr/VRInputDevice.js

@@ -0,0 +1,367 @@
+/**
+ * VRInputDevice - Manages a single VR input device (controller or hand)
+ *
+ * This class handles the lifecycle of a VR input device, listening for connected/disconnected
+ * events and creating the appropriate handler based on device type. Uses clean abstractions
+ * to eliminate branching logic.
+ */
+import * as THREE from 'three';
+import { Delegate } from '../utils/Delegate.js';
+import { VRControllerHandler } from './VRControllerHandler.js';
+import { VRHandHandler } from './VRHandHandler.js';
+export class VRInputDevice {
+    constructor(controllerIndex, world, renderer, options) {
+        Object.defineProperty(this, "controllerIndex", {
+            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, "renderer", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "options", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        // Three.js objects
+        Object.defineProperty(this, "controller", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        // Current device handler (clean abstraction - no branching!)
+        Object.defineProperty(this, "currentHandler", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        // Ray visualization
+        Object.defineProperty(this, "rayLine", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "rayHitSphere", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "maxRayDistance", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 10
+        });
+        // Events
+        Object.defineProperty(this, "onControllerConnected", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Delegate()
+        });
+        Object.defineProperty(this, "onControllerDisconnected", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Delegate()
+        });
+        Object.defineProperty(this, "onControllerUpdated", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Delegate()
+        });
+        this.controllerIndex = controllerIndex;
+        this.world = world;
+        this.renderer = renderer;
+        this.options = options;
+        this.maxRayDistance = options.maxRayDistance;
+        // Get Three.js controller object
+        this.controller = this.renderer.xr.getController(controllerIndex);
+        // Set up event listeners
+        this.setupEventListeners();
+    }
+    /**
+     * Set up event listeners for controller connection/disconnection
+     */
+    setupEventListeners() {
+        this.controller.addEventListener('connected', (event) => {
+            const inputSource = event.data;
+            this.handleControllerConnected(inputSource);
+        });
+        this.controller.addEventListener('disconnected', (event) => {
+            const inputSource = event.data;
+            this.handleControllerDisconnected(inputSource);
+        });
+    }
+    /**
+     * Handle controller connected event - creates appropriate handler
+     */
+    handleControllerConnected(inputSource) {
+        console.log(`[VRInputDevice ${this.controllerIndex}] Controller connected: ${inputSource.handedness} ${inputSource.hand ? 'hand' : 'controller'}`);
+        // Clean disposal of any existing handler
+        if (this.currentHandler) {
+            this.currentHandler.dispose();
+            this.currentHandler = null;
+        }
+        // Create appropriate handler based on device type (no branching in handlers!)
+        if (inputSource.hand) {
+            this.currentHandler = new VRHandHandler(inputSource, this.renderer, this.world, this.controllerIndex);
+        }
+        else {
+            this.currentHandler = new VRControllerHandler(inputSource, this.renderer, this.world, this.controllerIndex);
+        }
+        // Set up ray visualization now that device is connected
+        this.createRayVisualization();
+        this.onControllerConnected.invoke(inputSource);
+    }
+    /**
+     * Handle controller disconnected event - cleans up handler
+     */
+    handleControllerDisconnected(inputSource) {
+        console.log(`[VRInputDevice ${this.controllerIndex}] Controller disconnected: ${inputSource.handedness}`);
+        if (this.currentHandler) {
+            this.currentHandler.dispose();
+            this.currentHandler = null;
+        }
+        // Clean up ray visualization when device disconnects
+        this.cleanupRayVisualization();
+        this.onControllerDisconnected.invoke(inputSource);
+    }
+    /**
+     * Update device state (call every frame)
+     */
+    update() {
+        if (!this.currentHandler || !this.renderer?.xr.isPresenting) {
+            return;
+        }
+        this.updateRayVisualization();
+        this.onControllerUpdated.invoke(this.currentHandler.getInputSource());
+    }
+    // ===== Utility Methods (extract poses from groups) =====
+    /**
+     * Get target ray pose for raycasting (extracted from target ray group)
+     */
+    getTargetRayPose() {
+        const group = this.currentHandler?.getTargetRayGroup();
+        if (!group)
+            return null;
+        // Force matrix update
+        group.updateMatrixWorld(true);
+        // Extract origin from group position
+        const origin = new THREE.Vector3();
+        origin.setFromMatrixPosition(group.matrixWorld);
+        // Extract direction from group rotation (forward is -Z)
+        const direction = new THREE.Vector3(0, 0, -1);
+        direction.transformDirection(group.matrixWorld);
+        return { origin, direction };
+    }
+    /**
+     * Get grip pose for object attachment (extracted from grip group)
+     */
+    getGripPose() {
+        const group = this.currentHandler?.getGripGroup();
+        if (!group)
+            return null;
+        const position = new THREE.Vector3();
+        const quaternion = new THREE.Quaternion();
+        group.getWorldPosition(position);
+        group.getWorldQuaternion(quaternion);
+        return { position, quaternion };
+    }
+    /**
+     * Get the Three.js target ray group (for pointing/raycasting)
+     */
+    getTargetRayGroup() {
+        return this.currentHandler?.getTargetRayGroup() ?? null;
+    }
+    /**
+     * Get the Three.js grip group
+     */
+    getGripGroup() {
+        return this.currentHandler?.getGripGroup() ?? null;
+    }
+    /**
+     * Get current input source
+     */
+    getInputSource() {
+        return this.currentHandler?.getInputSource() ?? null;
+    }
+    /**
+     * Get controller index
+     */
+    getControllerIndex() {
+        return this.controllerIndex;
+    }
+    /**
+     * Get handedness of this device
+     */
+    getHandedness() {
+        return this.currentHandler?.getHandedness() ?? 'none';
+    }
+    /**
+     * Create ray visualization objects
+     */
+    createRayVisualization() {
+        if (!this.options.rayVisualizationEnabled)
+            return;
+        // Clean up existing ray visualization first
+        this.cleanupRayVisualization();
+        // Create hit point sphere
+        const sphereGeometry = new THREE.SphereGeometry(0.02, 8, 8);
+        const sphereMaterial = new THREE.MeshBasicMaterial({
+            color: 0x00ff00, // Will be updated based on handedness
+            transparent: true,
+            opacity: 0.9,
+            depthTest: true, // Ensure sphere is always visible
+            depthWrite: true
+        });
+        this.rayHitSphere = new THREE.Mesh(sphereGeometry, sphereMaterial);
+        this.rayHitSphere.visible = false;
+        this.rayHitSphere.renderOrder = 1000; // Render on top
+        this.world.scene.add(this.rayHitSphere);
+        // Create ray line as a thin cylinder (more reliable than Line in VR)
+        const lineGeometry = new THREE.CylinderGeometry(0.001, 0.001, 1, 8);
+        const lineMaterial = new THREE.MeshBasicMaterial({
+            color: 0x00ff00, // Will be updated based on handedness
+            transparent: true,
+            opacity: 0.8,
+            depthTest: true,
+            depthWrite: true
+        });
+        this.rayLine = new THREE.Mesh(lineGeometry, lineMaterial);
+        this.rayLine.visible = false;
+        this.rayLine.renderOrder = 1000; // Render on top
+        this.world.scene.add(this.rayLine);
+    }
+    /**
+     * Clean up ray visualization objects
+     */
+    cleanupRayVisualization() {
+        if (this.rayHitSphere) {
+            this.world.scene.remove(this.rayHitSphere);
+            this.rayHitSphere.geometry.dispose();
+            this.rayHitSphere.material.dispose();
+            this.rayHitSphere = null;
+        }
+        if (this.rayLine) {
+            this.world.scene.remove(this.rayLine);
+            this.rayLine.geometry.dispose();
+            this.rayLine.material.dispose();
+            this.rayLine = null;
+        }
+    }
+    /**
+     * Update ray visualization
+     */
+    updateRayVisualization() {
+        if (!this.options.rayVisualizationEnabled || !this.rayHitSphere || !this.rayLine) {
+            return;
+        }
+        const rayData = this.getTargetRayPose();
+        if (!rayData) {
+            this.rayHitSphere.visible = false;
+            this.rayLine.visible = false;
+            return;
+        }
+        const { origin, direction } = rayData;
+        const handedness = this.getHandedness();
+        const color = handedness === 'left' ? 0x00ff00 : 0xff0000; // Green for left, red for right
+        // Perform physics raycast
+        const physicsEngine = this.world.getPhysicsEngine();
+        if (!physicsEngine) {
+            this.rayHitSphere.visible = false;
+            this.rayLine.visible = false;
+            return;
+        }
+        const hitResults = physicsEngine.performHitTest({
+            origin,
+            direction,
+            maxDistance: this.maxRayDistance,
+            stopOnFirstHit: true,
+            collisionProfile: null,
+            ignoredActors: [],
+            ignoredComponents: []
+        });
+        let endPoint;
+        const shortRayDistance = 0.5; // Short ray when not hitting anything
+        if (hitResults.length > 0) {
+            // Hit something - show full ray to hit point
+            const hitPoint = hitResults[0].hitLocation;
+            this.rayHitSphere.position.copy(hitPoint);
+            this.rayHitSphere.visible = true;
+            endPoint = hitPoint.clone();
+            // Update sphere color
+            const sphereMaterial = this.rayHitSphere.material;
+            sphereMaterial.color.setHex(color);
+            sphereMaterial.opacity = 0.8;
+        }
+        else {
+            // No hit - show short ray
+            this.rayHitSphere.visible = false;
+            endPoint = origin.clone().add(direction.clone().multiplyScalar(shortRayDistance));
+        }
+        // Update ray line (cylinder) position and orientation
+        const distance = origin.distanceTo(endPoint);
+        const midPoint = origin.clone().add(endPoint).multiplyScalar(0.5);
+        // Position the cylinder at the midpoint
+        this.rayLine.position.copy(midPoint);
+        // Scale the cylinder to match the ray length
+        this.rayLine.scale.set(1, distance, 1);
+        // Orient the cylinder to point from origin to endPoint
+        this.rayLine.lookAt(endPoint);
+        this.rayLine.rotateX(Math.PI / 2); // Cylinder is along Y axis, rotate to Z
+        this.rayLine.visible = true;
+        // Update line color
+        const lineMaterial = this.rayLine.material;
+        lineMaterial.color.setHex(color);
+        lineMaterial.opacity = 0.8;
+    }
+    /**
+     * Enable or disable ray visualization
+     */
+    setRayVisualizationEnabled(enabled) {
+        this.options.rayVisualizationEnabled = enabled;
+        if (this.rayHitSphere) {
+            this.rayHitSphere.visible = enabled && this.rayHitSphere.visible;
+        }
+        if (this.rayLine) {
+            this.rayLine.visible = enabled && this.rayLine.visible;
+        }
+    }
+    /**
+     * Set controller model visibility (only works for motion controllers, not hands)
+     */
+    setControllerVisible(visible) {
+        if (this.currentHandler instanceof VRControllerHandler) {
+            this.currentHandler.setControllerVisible(visible);
+        }
+    }
+    /**
+     * Clean up resources
+     */
+    dispose() {
+        if (this.currentHandler) {
+            this.currentHandler.dispose();
+            this.currentHandler = null;
+        }
+        this.cleanupRayVisualization();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"VRInputDevice.js","sourceRoot":"","sources":["../../../src/xr/VRInputDevice.ts"],"names":[],"mappings":"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"}