@directivegames/genesys.js 3.1.24

package/dist/src/xr/VRPawn.js

@@ -0,0 +1,771 @@
+/**
+ * VRPawn - a pawn specifically designed for VR experiences.
+ *
+ * Detailed explanation:
+ * - Extends the base Pawn class with VR-specific features
+ * - Manages VR controllers through VRControllerManager with visual representation
+ * - Integrates VR input with the unified InputManager system
+ * - Provides delegates for VR session and controller events
+ *
+ * Recommended usage (for humans and AI assistants):
+ * - Use in VR games where controller representation and tracking is needed
+ * - Handle VR input through standard IInputHandler interface (PlayerController)
+ * - Subscribe to controller/session delegates for VR-specific events
+ */
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import * as THREE from 'three';
+import { Pawn } from '../actors/Pawn.js';
+import { CAMERA_FAR, CAMERA_FOV, CAMERA_NEAR, CHARACTER_HEIGHT } from '../const.js';
+import { EngineClass } from '../systems/ClassRegistry.js';
+import { Delegate } from '../utils/Delegate.js';
+// Target detection now based on components rather than VR-specific actor subclasses
+import { VRGrabbableComponent } from './actor-components/VRGrabbableComponent.js';
+import { VRInteractableComponent } from './actor-components/VRInteractableComponent.js';
+import { VRControllerManager } from './VRControllerManager.js';
+let VRPawn = class VRPawn extends Pawn {
+    constructor(options = {}) {
+        // Force a camera if not provided, and set a default position
+        const camera = options.camera ?? new THREE.PerspectiveCamera(CAMERA_FOV, 1, CAMERA_NEAR, CAMERA_FAR);
+        camera.position.set(0, CHARACTER_HEIGHT, 0);
+        const vrOptions = {
+            ...options,
+            camera: camera
+        };
+        super(vrOptions);
+        Object.defineProperty(this, "controllerManager", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "xrRenderer", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        // Registered VR input handlers with priorities
+        Object.defineProperty(this, "vrInputHandlers", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        Object.defineProperty(this, "vrHandlerSeq", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
+        // WebXR reference space management
+        Object.defineProperty(this, "baseReferenceSpace", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "currentReferenceSpace", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        // Tracking space management for proper rotation around player
+        Object.defineProperty(this, "trackingSpaceOriginInWorldSpace", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new THREE.Vector3(0, 0, 0)
+        });
+        Object.defineProperty(this, "trackingSpaceHeadingDegrees", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
+        // VR hand attachment state moved to VRGrabComponent
+        // Controller state (visibility flags) and velocity tracking
+        Object.defineProperty(this, "hiddenControllers", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+        Object.defineProperty(this, "controllerVelocities", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+        Object.defineProperty(this, "previousControllerPositions", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+        Object.defineProperty(this, "hoverActorByHand", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: { left: null, right: null }
+        });
+        Object.defineProperty(this, "pendingTeleportTarget", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "frozenHeadLocalXZ", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        /** Delegate fired when VR session starts */
+        Object.defineProperty(this, "onVRSessionStart", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Delegate()
+        });
+        /** Delegate fired when VR session ends */
+        Object.defineProperty(this, "onVRSessionEnd", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Delegate()
+        });
+        /** Delegate fired when a controller is added */
+        Object.defineProperty(this, "onControllerAdded", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Delegate()
+        });
+        /** Delegate fired when a controller is removed */
+        Object.defineProperty(this, "onControllerRemoved", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Delegate()
+        });
+        /** Delegate fired when controller updates */
+        Object.defineProperty(this, "onControllerUpdated", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Delegate()
+        });
+        // Initialize controller manager - will be created when added to world
+        this.controllerManager = null; // Will be set in doBeginPlay
+    }
+    //====================================================================================================
+    // Public VR input handler registration
+    //====================================================================================================
+    addVRInputHandler(handler, priority = 0) {
+        if (this.vrInputHandlers.some(e => e.handler === handler))
+            return;
+        this.vrInputHandlers.push({ handler, priority, seq: this.vrHandlerSeq++ });
+    }
+    removeVRInputHandler(handler) {
+        const index = this.vrInputHandlers.findIndex(e => e.handler === handler);
+        if (index !== -1) {
+            this.vrInputHandlers.splice(index, 1);
+        }
+    }
+    setVRInputHandlerPriority(handler, priority) {
+        const entry = this.vrInputHandlers.find(e => e.handler === handler);
+        if (entry)
+            entry.priority = priority;
+    }
+    getOrderedVRHandlers() {
+        return this.vrInputHandlers
+            .slice()
+            .sort((a, b) => (b.priority - a.priority) || (a.seq - b.seq))
+            .map(e => e.handler);
+    }
+    /**
+     * Gets the VR controller manager
+     */
+    getControllerManager() {
+        return this.controllerManager ?? null;
+    }
+    isXRPresenting() {
+        return !!this.xrRenderer?.xr.isPresenting;
+    }
+    isTeleportReady() {
+        if (!this.xrRenderer?.xr.isPresenting)
+            return false;
+        const frame = this.xrRenderer.xr.getFrame();
+        const referenceSpace = this.xrRenderer.xr.getReferenceSpace();
+        return !!(frame && referenceSpace && this.baseReferenceSpace);
+    }
+    /** Capture or clear the head local XZ to use for the next teleport. */
+    setTeleportHeadLocalXZ(xz) {
+        this.frozenHeadLocalXZ = xz ? xz.clone() : null;
+    }
+    /** Get current head local XZ (relative to reference space), if available. */
+    getCurrentHeadLocalPositionXZ() {
+        if (!this.xrRenderer?.xr.isPresenting)
+            return null;
+        const frame = this.xrRenderer.xr.getFrame();
+        const referenceSpace = this.baseReferenceSpace ?? this.xrRenderer.xr.getReferenceSpace();
+        if (!frame || !referenceSpace)
+            return null;
+        const viewerPose = frame.getViewerPose(referenceSpace);
+        if (!viewerPose)
+            return null;
+        return new THREE.Vector3(viewerPose.transform.position.x, 0, viewerPose.transform.position.z);
+    }
+    doBeginPlay() {
+        super.doBeginPlay();
+        // Create controller manager now that we have a world (if not already created)
+        const world = this.getWorld();
+        if (world && !this.controllerManager) {
+            this.controllerManager = new VRControllerManager(world, this.options.controllerOptions);
+            this.setupControllerEventHandlers();
+        }
+        // Auto-setup VR tracking if XR is enabled in the game loop
+        const gameLoop = this.world?.gameLoop;
+        try {
+            if (gameLoop?.isXREnabled()) {
+                const threeRenderer = gameLoop?.renderer?.renderer;
+                if (threeRenderer) {
+                    this.setupVRTracking(threeRenderer);
+                }
+            }
+        }
+        catch (_e) {
+            console.error('[VRPawn] Failed to setup VR tracking:', _e);
+        }
+        // Always keep controllers updated automatically each frame
+        this.onTickPrePhysics.add(() => {
+            this.updateControllers();
+        });
+        this.onTickPostPhysics.add(() => {
+            if (this.pendingTeleportTarget && this.isTeleportReady()) {
+                const target = this.pendingTeleportTarget.clone();
+                this.pendingTeleportTarget = null;
+                const session = this.xrRenderer.xr.getSession();
+                this.performWebXRTeleportation(session, target);
+            }
+        });
+    }
+    /**
+     * Setup event handlers for the controller manager
+     */
+    setupControllerEventHandlers() {
+        // Forward controller manager events
+        this.controllerManager.onControllerAdded.add((controllerInfo) => {
+            this.onControllerAdded.invoke(controllerInfo);
+        });
+        this.controllerManager.onControllerRemoved.add((inputSource) => {
+            this.onControllerRemoved.invoke(inputSource);
+        });
+        this.controllerManager.onControllerUpdated.add((inputSource, device) => {
+            this.onControllerUpdated.invoke(inputSource, new THREE.Object3D());
+        });
+    }
+    /**
+     * Setup direct VR input handling from VRControllerManager
+     */
+    setupDirectVRInputHandling() {
+        if (!this.controllerManager)
+            return;
+        // Connect to button events
+        this.controllerManager.onButtonDown.add((event) => {
+            this.handleVRButtonDown(event.inputSource, event.button, event.buttonState.value);
+        });
+        this.controllerManager.onButtonUp.add((event) => {
+            this.handleVRButtonUp(event.inputSource, event.button);
+        });
+        // Connect to axis events
+        this.controllerManager.onAxisChanged.add((event) => {
+            this.handleVRAxisChange(event.inputSource, event.axis, event.axisValue);
+        });
+        // Connect to WebXR gesture events
+        this.controllerManager.onSqueezeStart.add((event) => {
+            this.handleSqueezeStart(event);
+        });
+        this.controllerManager.onSqueeze.add((event) => {
+            this.handleSqueeze(event);
+        });
+        this.controllerManager.onSqueezeEnd.add((event) => {
+            this.handleSqueezeEnd(event);
+        });
+        this.controllerManager.onSelectStart.add((event) => {
+            this.handleSelectStart(event);
+        });
+        this.controllerManager.onSelect.add((event) => {
+            this.handleSelect(event);
+        });
+        this.controllerManager.onSelectEnd.add((event) => {
+            this.handleSelectEnd(event);
+        });
+    }
+    /**
+     * Gets controller info by handedness
+     */
+    getControllerByHand(handedness) {
+        return this.controllerManager.getControllerByHand(handedness);
+    }
+    /**
+     * Gets all active controllers
+     */
+    getControllers() {
+        return this.controllerManager.getControllers();
+    }
+    /**
+     * Gets the target ray pose for a specific hand for raycasting
+     * @param hand The hand to get the ray pose for
+     * @returns Object with ray origin and direction, or null if not available
+     */
+    getTargetRayPose(hand) {
+        if (!this.controllerManager) {
+            return null;
+        }
+        // Find the input source for this hand
+        const controller = this.getControllerByHand(hand);
+        if (!controller) {
+            return null;
+        }
+        // Get ray pose directly from input source
+        return this.controllerManager.getTargetRayPose(controller.inputSource);
+    }
+    /**
+     * Updates controllers (call this every frame)
+     */
+    updateControllers() {
+        this.controllerManager.updateControllers();
+        this.updateControllerVelocities();
+        ['left', 'right'].forEach((hand) => this.updateVRHover(hand));
+    }
+    updateVRHover(hand) {
+        const rayPose = this.getTargetRayPose(hand);
+        if (!rayPose)
+            return;
+        const target = this.findVRTargetAtRay(rayPose.origin, rayPose.direction);
+        const next = target?.actor ?? null;
+        this.handleHoverTransition(hand, next, target?.rayHit?.hitLocation);
+    }
+    handleHoverTransition(hand, next, point) {
+        const prev = this.hoverActorByHand[hand];
+        if (prev !== next) {
+            if (prev?.onVRHoverEnd)
+                prev.onVRHoverEnd(hand);
+            if (next?.onVRHoverStart && point)
+                next.onVRHoverStart(hand, point);
+            this.hoverActorByHand[hand] = next;
+        }
+        else if (next?.onVRHover && point) {
+            next.onVRHover(hand, point);
+        }
+    }
+    /**
+     * Sets up VR tracking with the provided renderer
+     */
+    setupVRTracking(renderer) {
+        if (!renderer.xr.enabled) {
+            return;
+        }
+        // Store reference to the renderer for teleportation
+        this.xrRenderer = renderer;
+        // Ensure controller manager is created
+        if (!this.controllerManager && this.world) {
+            this.controllerManager = new VRControllerManager(this.world, this.options.controllerOptions);
+            this.setupControllerEventHandlers();
+        }
+        // Set up controller manager with the renderer and direct VR input handling
+        if (this.controllerManager) {
+            this.controllerManager.setupWithRenderer(renderer);
+            this.setupDirectVRInputHandling();
+        }
+        // Listen for session events to forward them
+        renderer.xr.addEventListener('sessionstart', () => {
+            const session = renderer.xr.getSession();
+            if (session) {
+                this.setupReferenceSpaces(session);
+                this.onVRSessionStart.invoke(session);
+            }
+        });
+        renderer.xr.addEventListener('sessionend', () => {
+            this.baseReferenceSpace = null;
+            this.currentReferenceSpace = null;
+            this.onVRSessionEnd.invoke();
+        });
+    }
+    /**
+     * Setup WebXR reference spaces for teleportation
+     */
+    async setupReferenceSpaces(session) {
+        try {
+            // Try to get local-floor reference space first
+            this.baseReferenceSpace = await session.requestReferenceSpace('local-floor');
+        }
+        catch (e) {
+            try {
+                // Fallback to viewer space with floor offset
+                const viewerSpace = await session.requestReferenceSpace('viewer');
+                const floorOffset = new XRRigidTransform({ x: 0, y: -1.5, z: 0 });
+                this.baseReferenceSpace = viewerSpace.getOffsetReferenceSpace(floorOffset);
+            }
+            catch (e2) {
+                console.error('[VRPawn] Failed to create reference space:', e2);
+                return;
+            }
+        }
+        // Initially, current reference space is the same as base
+        this.currentReferenceSpace = this.baseReferenceSpace;
+        // Ensure renderer uses our reference space immediately
+        if (this.xrRenderer) {
+            this.xrRenderer.xr.setReferenceSpace(this.currentReferenceSpace);
+        }
+    }
+    /**
+     * Handle VR button down events
+     */
+    handleVRButtonDown(inputSource, button, value) {
+        for (const handler of this.getOrderedVRHandlers()) {
+            if (handler.handleVRButtonDown && handler.handleVRButtonDown(inputSource, button, value)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    /**
+     * Handle VR button up events
+     */
+    handleVRButtonUp(inputSource, button) {
+        for (const handler of this.getOrderedVRHandlers()) {
+            if (handler.handleVRButtonUp && handler.handleVRButtonUp(inputSource, button)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    /**
+     * Handle VR axis changes for teleportation and snap turning
+     */
+    handleVRAxisChange(inputSource, axis, value) {
+        for (const handler of this.getOrderedVRHandlers()) {
+            if (handler.handleVRAxisChange && handler.handleVRAxisChange(inputSource, axis, value)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    /**
+     * Perform WebXR teleportation by updating reference space
+     */
+    performWebXRTeleportation(session, targetPosition) {
+        if (!this.baseReferenceSpace || !this.xrRenderer) {
+            console.error('[VRPawn] No base reference space available');
+            return;
+        }
+        try {
+            const frame = this.xrRenderer.xr.getFrame();
+            const referenceSpace = this.baseReferenceSpace;
+            if (!frame || !referenceSpace) {
+                console.error('[VRPawn] No frame or reference space available for teleportation');
+                return;
+            }
+            // Get the current viewer pose to understand player's offset from tracking center
+            const viewerPose = frame.getViewerPose(referenceSpace);
+            if (!viewerPose) {
+                console.error('[VRPawn] No viewer pose available for teleportation');
+                return;
+            }
+            // Calculate player's feet position in world space using current heading and origin
+            const localXZ = this.frozenHeadLocalXZ ? this.frozenHeadLocalXZ.clone() : new THREE.Vector3(viewerPose.transform.position.x, 0, viewerPose.transform.position.z);
+            const worldRotation = new THREE.Matrix4().makeRotationY(this.trackingSpaceHeadingDegrees * Math.PI / 180);
+            const rotatedXZ = localXZ.clone().applyMatrix4(worldRotation);
+            const playerInWorldSpaceOld = this.trackingSpaceOriginInWorldSpace.clone().add(rotatedXZ);
+            // Calculate offset from tracking space origin to player's feet (y stays 0)
+            const playerOffsetInWorldSpace = rotatedXZ.clone();
+            // Update tracking space origin so that origin + playerOffset == new target position
+            this.trackingSpaceOriginInWorldSpace.subVectors(targetPosition, playerOffsetInWorldSpace);
+            // Create the new reference space transform based on current heading and new position
+            const invOrientation = new THREE.Quaternion().setFromAxisAngle(new THREE.Vector3(0, 1, 0), -this.trackingSpaceHeadingDegrees * Math.PI / 180);
+            const invPosition = this.trackingSpaceOriginInWorldSpace.clone().negate().applyQuaternion(invOrientation);
+            const teleportTransform = new XRRigidTransform({
+                x: invPosition.x,
+                y: invPosition.y,
+                z: invPosition.z
+            }, {
+                x: invOrientation.x,
+                y: invOrientation.y,
+                z: invOrientation.z,
+                w: invOrientation.w
+            });
+            // Create new offset reference space
+            this.currentReferenceSpace = this.baseReferenceSpace.getOffsetReferenceSpace(teleportTransform);
+            // Update the renderer's reference space
+            this.xrRenderer.xr.setReferenceSpace(this.currentReferenceSpace);
+            // Clear frozen head after applying teleport
+            this.frozenHeadLocalXZ = null;
+        }
+        catch (error) {
+            console.error('[VRPawn] WebXR teleportation failed:', error);
+        }
+    }
+    //====================================================================================================
+    // Public helpers for rotation/teleportation invoked by components
+    //====================================================================================================
+    getSnapTurnAngleDegrees() {
+        return this.options.snapTurnAngle ?? 90;
+    }
+    yawByDegrees(degrees) {
+        if (this.xrRenderer?.xr.isPresenting && this.currentReferenceSpace) {
+            const session = this.xrRenderer.xr.getSession();
+            if (session) {
+                this.performWebXRSnapTurnDegrees(session, degrees);
+                return;
+            }
+        }
+        const radians = (degrees * Math.PI) / 180;
+        this.rootComponent.rotateY(radians);
+    }
+    // Allow components to request a WebXR-relative teleport
+    applyTeleportTo(targetPosition) {
+        if (this.isXRPresenting()) {
+            if (this.isTeleportReady()) {
+                const session = this.xrRenderer.xr.getSession();
+                this.performWebXRTeleportation(session, targetPosition);
+            }
+            else {
+                this.pendingTeleportTarget = targetPosition.clone();
+            }
+            return;
+        }
+        // In VR-only mode, do nothing if XR isn't presenting
+    }
+    /**
+     * Perform WebXR snap turn by an exact degree amount
+     */
+    performWebXRSnapTurnDegrees(session, degrees) {
+        if (!this.baseReferenceSpace || !this.xrRenderer) {
+            console.error('[VRPawn] No base reference space available for snap turn');
+            return;
+        }
+        try {
+            const frame = this.xrRenderer.xr.getFrame();
+            const referenceSpace = this.currentReferenceSpace ?? this.baseReferenceSpace;
+            if (!frame || !referenceSpace) {
+                console.error('[VRPawn] No frame or reference space available for snap turn');
+                return;
+            }
+            const viewerPose = frame.getViewerPose(referenceSpace);
+            if (!viewerPose) {
+                console.error('[VRPawn] No viewer pose available for snap turn');
+                return;
+            }
+            const headPose = { transform: viewerPose.transform };
+            const rotationDelta = degrees;
+            const angleRadians = rotationDelta * Math.PI / 180;
+            const playerInWorldSpaceOld = new THREE.Vector3(headPose.transform.position.x, 0, headPose.transform.position.z);
+            const playerOffsetInWorldSpaceOld = new THREE.Vector3();
+            playerOffsetInWorldSpaceOld.subVectors(playerInWorldSpaceOld, this.trackingSpaceOriginInWorldSpace);
+            const rotationMatrix = new THREE.Matrix4().makeRotationY(angleRadians);
+            const playerOffsetInWorldSpaceNew = playerOffsetInWorldSpaceOld.clone().applyMatrix4(rotationMatrix);
+            this.trackingSpaceHeadingDegrees += rotationDelta;
+            this.trackingSpaceOriginInWorldSpace.subVectors(playerInWorldSpaceOld, playerOffsetInWorldSpaceNew);
+            const invOrientation = new THREE.Quaternion().setFromAxisAngle(new THREE.Vector3(0, 1, 0), -this.trackingSpaceHeadingDegrees * Math.PI / 180);
+            const invPosition = this.trackingSpaceOriginInWorldSpace.clone().negate().applyQuaternion(invOrientation);
+            const snapTurnTransform = new XRRigidTransform({
+                x: invPosition.x,
+                y: invPosition.y,
+                z: invPosition.z
+            }, {
+                x: invOrientation.x,
+                y: invOrientation.y,
+                z: invOrientation.z,
+                w: invOrientation.w
+            });
+            this.currentReferenceSpace = this.baseReferenceSpace.getOffsetReferenceSpace(snapTurnTransform);
+            this.xrRenderer.xr.setReferenceSpace(this.currentReferenceSpace);
+        }
+        catch (error) {
+            console.error('[VRPawn] WebXR snap turn (degrees) failed:', error);
+        }
+    }
+    /**
+     * Get current hover target for a hand (if any)
+     */
+    getHoverTarget(hand) {
+        const rayPose = this.getTargetRayPose(hand);
+        if (!rayPose)
+            return null;
+        const target = this.findVRTargetAtRay(rayPose.origin, rayPose.direction);
+        if (target?.actor) {
+            return { actor: target.actor, rayHit: target.rayHit };
+        }
+        return null;
+    }
+    // Legacy grip press/release removed; handled by external handlers/components
+    /**
+     * Handle WebXR squeeze start events (grab/pinch gestures)
+     */
+    handleSqueezeStart(event) {
+        for (const handler of this.getOrderedVRHandlers()) {
+            if (handler.handleSqueezeStart && handler.handleSqueezeStart(event)) {
+                return;
+            }
+        }
+    }
+    /**
+     * Handle WebXR squeeze events (successful grab/pinch completion)
+     */
+    handleSqueeze(event) {
+        for (const handler of this.getOrderedVRHandlers()) {
+            if (handler.handleSqueeze && handler.handleSqueeze(event)) {
+                return;
+            }
+        }
+    }
+    /**
+     * Handle WebXR squeeze end events (release gestures)
+     */
+    handleSqueezeEnd(event) {
+        for (const handler of this.getOrderedVRHandlers()) {
+            if (handler.handleSqueezeEnd && handler.handleSqueezeEnd(event)) {
+                return;
+            }
+        }
+    }
+    /**
+     * Handle WebXR select start events (trigger/tap start)
+     */
+    handleSelectStart(event) {
+        for (const handler of this.getOrderedVRHandlers()) {
+            if (handler.handleSelectStart && handler.handleSelectStart(event)) {
+                return;
+            }
+        }
+    }
+    /**
+     * Handle WebXR select events (trigger/tap completion)
+     */
+    handleSelect(event) {
+        for (const handler of this.getOrderedVRHandlers()) {
+            if (handler.handleSelect && handler.handleSelect(event)) {
+                return;
+            }
+        }
+    }
+    /**
+     * Handle WebXR select end events (trigger/tap end)
+     */
+    handleSelectEnd(event) {
+        for (const handler of this.getOrderedVRHandlers()) {
+            if (handler.handleSelectEnd && handler.handleSelectEnd(event)) {
+                return;
+            }
+        }
+    }
+    /**
+     * Unified VR target search along a ray. Prefers grabbables; falls back to interactables.
+     */
+    findVRTargetAtRay(origin, direction) {
+        if (!this.world)
+            return null;
+        // 1) Try physics-based hits for interactables (also gives us hit data)
+        const physicsEngine = this.world.getPhysicsEngine();
+        const hitResults = physicsEngine?.performHitTest({
+            origin,
+            direction,
+            maxDistance: 10,
+            stopOnFirstHit: false,
+            collisionProfile: null,
+            ignoredActors: [this],
+            ignoredComponents: []
+        }) ?? [];
+        // Prefer the closest grabbable among hits if any component exists on the actor
+        let bestGrabbable = null;
+        for (const hit of hitResults) {
+            const actor = hit.hitActor;
+            const comp = actor?.getComponent(VRGrabbableComponent);
+            if (comp) {
+                const dist = origin.distanceTo(hit.hitLocation);
+                if (!bestGrabbable || dist < bestGrabbable.distance) {
+                    bestGrabbable = { actor, distance: dist };
+                }
+            }
+        }
+        if (bestGrabbable) {
+            // Recompute rayHit for the chosen actor by using the first hit that matches it
+            const rayHit = hitResults.find(h => h.hitActor === bestGrabbable.actor) ?? hitResults[0];
+            return { type: 'grabbable', actor: bestGrabbable.actor, rayHit };
+        }
+        // 2) Otherwise, return closest interactable in range
+        for (const hit of hitResults) {
+            const actor = hit.hitActor;
+            const comp = actor?.getComponent(VRInteractableComponent);
+            if (!comp)
+                continue;
+            const interactionRange = comp.getVRInteractionRange();
+            if (origin.distanceTo(hit.hitLocation) <= interactionRange) {
+                return { type: 'interactable', actor, rayHit: hit };
+            }
+        }
+        return null;
+    }
+    /**
+     * Get the current controller velocity estimate for a hand, if available
+     */
+    getControllerVelocity(hand) {
+        return this.controllerVelocities.get(hand) ?? null;
+    }
+    /**
+     * Track controller velocities for drop physics
+     */
+    updateControllerVelocities() {
+        if (!this.xrRenderer?.xr.isPresenting)
+            return;
+        const frame = this.xrRenderer.xr.getFrame();
+        const referenceSpace = this.xrRenderer.xr.getReferenceSpace();
+        if (!frame || !referenceSpace)
+            return;
+        for (const hand of ['left', 'right']) {
+            const controller = this.getControllerByHand(hand);
+            if (!controller?.inputSource.gripSpace)
+                continue;
+            const gripPose = frame.getPose(controller.inputSource.gripSpace, referenceSpace);
+            if (!gripPose)
+                continue;
+            const currentPosition = new THREE.Vector3(gripPose.transform.position.x, gripPose.transform.position.y, gripPose.transform.position.z);
+            const previousPosition = this.previousControllerPositions.get(hand);
+            if (previousPosition) {
+                const velocity = currentPosition.clone().sub(previousPosition).multiplyScalar(60);
+                this.controllerVelocities.set(hand, velocity);
+            }
+            this.previousControllerPositions.set(hand, currentPosition.clone());
+        }
+    }
+    /**
+     * Override destroy to clean up teleportation visuals and attachments
+     */
+    destroy() {
+        // Clean up attachments
+        for (const hand of ['left', 'right']) {
+            const grabComps = this.getComponents(THREE.Object3D);
+            const detacher = grabComps.find(c => typeof c.detachActorFromHand === 'function');
+            if (detacher)
+                detacher.detachActorFromHand(hand);
+        }
+        super.destroy();
+    }
+};
+VRPawn = __decorate([
+    EngineClass('VRPawn'),
+    __metadata("design:paramtypes", [Object])
+], VRPawn);
+export { VRPawn };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"VRPawn.js","sourceRoot":"","sources":["../../../src/xr/VRPawn.ts"],"names":[],"mappings":"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"}