@needle-tools/engine 3.10.1-beta → 3.10.2-beta

package/src/engine-components/webxr/WebXRController.ts

@@ -18,6 +18,7 @@ import { Rigidbody } from "../RigidBody";
 import { SyncedTransform } from "../SyncedTransform";
 import { UIRaycastUtils } from "../ui/RaycastUtils";
 import { WebXR } from "./WebXR";
+import { XRRig } from "./WebXRRig";
 
 const debug = getParam("debugwebxrcontroller");
 
@@ -165,7 +166,7 @@ export class WebXRController extends Behaviour {
     public grabbed: AttachedObject | null = null;
     public input: XRInputSource | null = null;
     public type: ControllerType = ControllerType.PhysicalDevice;
-    public showRaycastLine : boolean = true;
+    public showRaycastLine: boolean = true;
 
     get isUsingHands(): boolean {
         const r = this.input?.hand;
@@ -353,6 +354,33 @@ export class WebXRController extends Behaviour {
 
     rayRotation: Quaternion = new Quaternion();
 
+    private raycastUpdate(raycastLine: Line, wp: Vector3) {
+        const allowRaycastLineVisible = this.showRaycastLine && this.type !== ControllerType.Touch;
+        if (this.type === ControllerType.Touch) {
+            raycastLine.visible = false;
+        }
+        else if (this.isUsingHands) {
+            raycastLine.visible = !this.grabbed && allowRaycastLineVisible;
+            setWorldPosition(raycastLine, wp);
+            const jnts = this.hand!['joints'];
+            if (jnts) {
+                const wrist = jnts['wrist'];
+                if (wrist && this.grabbed && this.grabbed.isCloseGrab) {
+                    const wr = this.getWristQuaternion();
+                    if (wr)
+                        this.rayRotation.copy(wr);
+                    // this.rayRotation.slerp(wr, this.useSmoothing ? t * 2 : 1);
+                }
+            }
+            setWorldQuaternion(raycastLine, this.rayRotation);
+        }
+        else {
+            raycastLine.visible = allowRaycastLineVisible;
+            setWorldQuaternion(raycastLine, this.rayRotation);
+            setWorldPosition(raycastLine, wp);
+        }
+    }
+
     update(): void {
 
         // TODO: we should wait until we actually have models, this is just a workaround
@@ -381,30 +409,7 @@ export class WebXRController extends Behaviour {
         }
 
         if (this.raycastLine) {
-            const allowRaycastLineVisible = this.showRaycastLine && this.type !== ControllerType.Touch;
-            if (this.type === ControllerType.Touch) {
-                this.raycastLine.visible = false;
-            }
-            else if (this.isUsingHands) {
-                this.raycastLine.visible = !this.grabbed && allowRaycastLineVisible;
-                setWorldPosition(this.raycastLine, wp);
-                const jnts = this.hand!['joints'];
-                if (jnts) {
-                    const wrist = jnts['wrist'];
-                    if (wrist && this.grabbed && this.grabbed.isCloseGrab) {
-                        const wr = this.getWristQuaternion();
-                        if (wr)
-                            this.rayRotation.copy(wr);
-                        // this.rayRotation.slerp(wr, this.useSmoothing ? t * 2 : 1);
-                    }
-                }
-                setWorldQuaternion(this.raycastLine, this.rayRotation);
-            }
-            else {
-                this.raycastLine.visible = allowRaycastLineVisible;
-                setWorldQuaternion(this.raycastLine, this.rayRotation);
-                setWorldPosition(this.raycastLine, wp);
-            }
+            this.raycastUpdate(this.raycastLine, wp);
         }
 
         this.lastHit = this.updateLastHit();
@@ -420,8 +425,6 @@ export class WebXRController extends Behaviour {
         }
     }
 
-    private _pinchStartTime: number | undefined = undefined;
-
     onUpdate(session: XRSession) {
         this.lastHit = null;
 
@@ -446,52 +449,61 @@ export class WebXRController extends Behaviour {
 
         switch (this.input.handedness) {
             case "left":
-                const speedFactor = 3 * WebXRController.MovementSpeedFactor;
-                const powFactor = 2;
-                const speed = Mathf.clamp01(this.joystick.length() * 2);
-
-                const sideDir = this.joystick.x > 0 ? 1 : -1;
-                let side = Math.pow(this.joystick.x, powFactor);
-                side *= sideDir;
-                side *= speed;
-
-
-                const forwardDir = this.joystick.y > 0 ? 1 : -1;
-                let forward = Math.pow(this.joystick.y, powFactor);
-                forward *= forwardDir;
-                side *= speed;
-
-                rig.getWorldQuaternion(this.worldRot);
-                this.movementVector.set(side, 0, forward);
-                this.movementVector.applyQuaternion(this.webXR.TransformOrientation);
-                this.movementVector.y = 0;
-                this.movementVector.applyQuaternion(this.worldRot);
-                this.movementVector.multiplyScalar(speedFactor * this.context.time.deltaTime);
-                rig.position.add(this.movementVector);
-
-                if (this.isUsingHands)
-                    this.runTeleport(rig, buttons);
+                this.movementUpdate(rig, buttons);
                 break;
 
             case "right":
-                const rotate = this.joystick.x;
-                const rotAbs = Math.abs(rotate);
-                if (rotAbs < 0.4) {
-                    this.didRotate = false;
-                }
-                else if (rotAbs > .5 && !this.didRotate) {
-                    const dir = rotate > 0 ? -1 : 1;
-                    rig.rotateY(Mathf.toRadians(30 * dir));
-                    this.didRotate = true;
-                }
+                this.rotationUpdate(rig, buttons);
+                break;
+        }
+    }
 
-                this.runTeleport(rig, buttons);
 
-                break;
+    private movementUpdate(rig: Object3D, buttons?: readonly GamepadButton[]) {
+        const speedFactor = 3 * WebXRController.MovementSpeedFactor;
+        const powFactor = 2;
+        const speed = Mathf.clamp01(this.joystick.length() * 2);
+
+        const sideDir = this.joystick.x > 0 ? 1 : -1;
+        let side = Math.pow(this.joystick.x, powFactor);
+        side *= sideDir;
+        side *= speed;
+
+
+        const forwardDir = this.joystick.y > 0 ? 1 : -1;
+        let forward = Math.pow(this.joystick.y, powFactor);
+        forward *= forwardDir;
+        side *= speed;
+
+        rig.getWorldQuaternion(this.worldRot);
+        this.movementVector.set(side, 0, forward);
+        this.movementVector.applyQuaternion(this.webXR.TransformOrientation);
+        this.movementVector.y = 0;
+        this.movementVector.applyQuaternion(this.worldRot);
+        this.movementVector.multiplyScalar(speedFactor * this.context.time.deltaTime);
+        rig.position.add(this.movementVector);
+
+        if (this.isUsingHands)
+            this.runTeleport(rig, buttons);
+    }
+
+    private rotationUpdate(rig: Object3D, buttons?: readonly GamepadButton[]) {
+        const rotate = this.joystick.x;
+        const rotAbs = Math.abs(rotate);
+        if (rotAbs < 0.4) {
+            this.didRotate = false;
+        }
+        else if (rotAbs > .5 && !this.didRotate) {
+            const dir = rotate > 0 ? -1 : 1;
+            rig.rotateY(Mathf.toRadians(30 * dir));
+            this.didRotate = true;
         }
+
+        this.runTeleport(rig, buttons);
     }
+    private _pinchStartTime: number | undefined = undefined;
 
-    private runTeleport(rig, buttons) {
+    private runTeleport(rig: Object3D, buttons?: readonly GamepadButton[]) {
         let teleport = -this.joystick.y;
         if (this.hand?.visible && !this.grabbed) {
             const pinched = this.handPointerModel.isPinched();
@@ -526,24 +538,10 @@ export class WebXRController extends Behaviour {
                         this.didChangeScale = true;
                         const rig = this.webXR.Rig;
                         if (rig) {
-                            if (!isInMiniatureMode) {
-                                isInMiniatureMode = true;
-                                doTeleport = true;
-                                newRigScale = .1;
-                                WebXRController.MovementSpeedFactor = newRigScale * 2;
-                                const cam = this.context.mainCamera as PerspectiveCamera;
-                                WebXRController.PreviousCameraFarDistance = cam.far;
-                                cam.far /= newRigScale;
-                            }
-                            else {
-                                isInMiniatureMode = false;
-                                rig.scale.set(1, 1, 1);
-                                newRigScale = 1;
-                                WebXRController.MovementSpeedFactor = 1;
-                                const cam = this.context.mainCamera as PerspectiveCamera;
-                                if (WebXRController.PreviousCameraFarDistance)
-                                    cam.far = WebXRController.PreviousCameraFarDistance;
-                            }
+                            let args = this.switchScale(rig, doTeleport, isInMiniatureMode, newRigScale);
+                            doTeleport = args.doTeleport;
+                            isInMiniatureMode = args.isInMiniatureMode;
+                            newRigScale = args.newRigScale;
                         }
                     }
                     else if (!btn.pressed)
@@ -575,10 +573,33 @@ export class WebXRController extends Behaviour {
         }
     }
 
+
     private isValidTeleportTarget(obj: Object3D): boolean {
         return GameObject.getComponentInParent(obj, TeleportTarget) != null;
     }
 
+    private switchScale(rig: Object3D, doTeleport: boolean, isInMiniatureMode: boolean, newRigScale: number | null) {
+        if (!isInMiniatureMode) {
+            isInMiniatureMode = true;
+            doTeleport = true;
+            newRigScale = .1;
+            WebXRController.MovementSpeedFactor = newRigScale * 2;
+            const cam = this.context.mainCamera as PerspectiveCamera;
+            WebXRController.PreviousCameraFarDistance = cam.far;
+            cam.far /= newRigScale;
+        }
+        else {
+            isInMiniatureMode = false;
+            rig.scale.set(1, 1, 1);
+            newRigScale = 1;
+            WebXRController.MovementSpeedFactor = 1;
+            const cam = this.context.mainCamera as PerspectiveCamera;
+            if (WebXRController.PreviousCameraFarDistance)
+                cam.far = WebXRController.PreviousCameraFarDistance;
+        }
+        return { doTeleport, isInMiniatureMode, newRigScale }
+    }
+
     private updateStick(inputSource: XRInputSource) {
         if (!inputSource || !inputSource.gamepad || inputSource.gamepad.axes?.length < 4) return;
         this.joystick.x = inputSource.gamepad.axes[2];