@babylonjs/core 6.24.0 → 6.25.0

package/Cameras/VR/vrExperienceHelper.js

@@ -4,31 +4,23 @@ import { FreeCamera } from "../../Cameras/freeCamera.js";
 import { TargetCamera } from "../../Cameras/targetCamera.js";
 import { DeviceOrientationCamera } from "../../Cameras/deviceOrientationCamera.js";
 import { VRDeviceOrientationFreeCamera } from "../../Cameras/VR/vrDeviceOrientationFreeCamera.js";
-import { WebVRFreeCamera } from "../../Cameras/VR/webVRCamera.js";
 import { PointerEventTypes } from "../../Events/pointerEvents.js";
 import { Quaternion, Matrix, Vector3 } from "../../Maths/math.vector.js";
 import { Color3, Color4 } from "../../Maths/math.color.js";
 import { Gamepad } from "../../Gamepads/gamepad.js";
-import { PoseEnabledController, PoseEnabledControllerType } from "../../Gamepads/Controllers/poseEnabledController.js";
-import { WebVRController } from "../../Gamepads/Controllers/webVRController.js";
 import { Xbox360Button } from "../../Gamepads/xboxGamepad.js";
-import { Mesh } from "../../Meshes/mesh.js";
 import { Ray } from "../../Culling/ray.js";
 import { ImageProcessingConfiguration } from "../../Materials/imageProcessingConfiguration.js";
 import { StandardMaterial } from "../../Materials/standardMaterial.js";
 import { DynamicTexture } from "../../Materials/Textures/dynamicTexture.js";
-import { ImageProcessingPostProcess } from "../../PostProcesses/imageProcessingPostProcess.js";
 import { SineEase, EasingFunction, CircleEase } from "../../Animations/easing.js";
 import { Animation } from "../../Animations/animation.js";
-import { VRCameraMetrics } from "../../Cameras/VR/vrCameraMetrics.js";
 import "../../Gamepads/gamepadSceneComponent.js";
 import "../../Animations/animatable.js";
-import { Axis } from "../../Maths/math.axis.js";
 import { WebXRSessionManager } from "../../XR/webXRSessionManager.js";
 import { WebXRState } from "../../XR/webXRTypes.js";
-import { CreateCylinder } from "../../Meshes/Builders/cylinderBuilder.js";
-import { CreateTorus } from "../../Meshes/Builders/torusBuilder.js";
 import { CreateGround } from "../../Meshes/Builders/groundBuilder.js";
+import { CreateTorus } from "../../Meshes/Builders/torusBuilder.js";
 class VRExperienceHelperGazer {
     constructor(scene, gazeTrackerToClone = null) {
         this.scene = scene;
@@ -112,100 +104,6 @@ class VRExperienceHelperGazer {
     }
 }
 VRExperienceHelperGazer._IdCounter = 0;
-class VRExperienceHelperControllerGazer extends VRExperienceHelperGazer {
-    constructor(webVRController, scene, gazeTrackerToClone) {
-        super(scene, gazeTrackerToClone);
-        this.webVRController = webVRController;
-        // Laser pointer
-        this._laserPointer = CreateCylinder("laserPointer", {
-            updatable: false,
-            height: 1,
-            diameterTop: 0.004,
-            diameterBottom: 0.0002,
-            tessellation: 20,
-            subdivisions: 1,
-        }, scene);
-        const laserPointerMaterial = new StandardMaterial("laserPointerMat", scene);
-        laserPointerMaterial.emissiveColor = new Color3(0.7, 0.7, 0.7);
-        laserPointerMaterial.alpha = 0.6;
-        this._laserPointer.material = laserPointerMaterial;
-        this._laserPointer.rotation.x = Math.PI / 2;
-        this._laserPointer.position.z = -0.5;
-        this._laserPointer.isVisible = false;
-        this._laserPointer.isPickable = false;
-        if (!webVRController.mesh) {
-            // Create an empty mesh that is used prior to loading the high quality model
-            const preloadMesh = new Mesh("preloadControllerMesh", scene);
-            const preloadPointerPose = new Mesh(PoseEnabledController.POINTING_POSE, scene);
-            preloadPointerPose.rotation.x = -0.7;
-            preloadMesh.addChild(preloadPointerPose);
-            webVRController.attachToMesh(preloadMesh);
-        }
-        this._setLaserPointerParent(webVRController.mesh);
-        this._meshAttachedObserver = webVRController._meshAttachedObservable.add((mesh) => {
-            this._setLaserPointerParent(mesh);
-        });
-    }
-    _getForwardRay(length) {
-        return this.webVRController.getForwardRay(length);
-    }
-    /** @internal */
-    _activatePointer() {
-        super._activatePointer();
-        this._laserPointer.isVisible = true;
-    }
-    /** @internal */
-    _deactivatePointer() {
-        super._deactivatePointer();
-        this._laserPointer.isVisible = false;
-    }
-    /**
-     * @internal
-     */
-    _setLaserPointerColor(color) {
-        this._laserPointer.material.emissiveColor = color;
-    }
-    /**
-     * @internal
-     */
-    _setLaserPointerLightingDisabled(disabled) {
-        this._laserPointer.material.disableLighting = disabled;
-    }
-    /**
-     * @internal
-     */
-    _setLaserPointerParent(mesh) {
-        const makeNotPick = (root) => {
-            root.isPickable = false;
-            root.getChildMeshes().forEach((c) => {
-                makeNotPick(c);
-            });
-        };
-        makeNotPick(mesh);
-        const meshChildren = mesh.getChildren(undefined, false);
-        let laserParent = mesh;
-        this.webVRController._pointingPoseNode = null;
-        for (let i = 0; i < meshChildren.length; i++) {
-            if (meshChildren[i].name && meshChildren[i].name.indexOf(PoseEnabledController.POINTING_POSE) >= 0) {
-                laserParent = meshChildren[i];
-                this.webVRController._pointingPoseNode = laserParent;
-                break;
-            }
-        }
-        this._laserPointer.parent = laserParent;
-    }
-    _updatePointerDistance(distance = 100) {
-        this._laserPointer.scaling.y = distance;
-        this._laserPointer.position.z = -distance / 2;
-    }
-    dispose() {
-        super.dispose();
-        this._laserPointer.dispose();
-        if (this._meshAttachedObserver) {
-            this.webVRController._meshAttachedObservable.remove(this._meshAttachedObserver);
-        }
-    }
-}
 class VRExperienceHelperCameraGazer extends VRExperienceHelperGazer {
     constructor(_getCamera, scene) {
         super(scene);
@@ -229,7 +127,7 @@ export class OnAfterEnteringVRObservableEvent {
 /**
  * Helps to quickly add VR support to an existing scene.
  * See https://doc.babylonjs.com/features/featuresDeepDive/cameras/webVRHelper
- * @deprecated
+ * @deprecated Use WebXR instead!
  */
 export class VRExperienceHelper {
     /** Return this.onEnteringVRObservable
@@ -244,12 +142,6 @@ export class VRExperienceHelper {
     get onExitingVR() {
         return this.onExitingVRObservable;
     }
-    /** Return this.onControllerMeshLoadedObservable
-     * Note: This one is for backward compatibility. Please use onControllerMeshLoadedObservable directly
-     */
-    get onControllerMeshLoaded() {
-        return this.onControllerMeshLoadedObservable;
-    }
     /**
      * The mesh used to display where the user is going to teleport.
      */
@@ -280,44 +172,14 @@ export class VRExperienceHelper {
             if (this._cameraGazer._gazeTracker) {
                 this._cameraGazer._gazeTracker.dispose();
             }
-            if (this._leftController && this._leftController._gazeTracker) {
-                this._leftController._gazeTracker.dispose();
-            }
-            if (this._rightController && this._rightController._gazeTracker) {
-                this._rightController._gazeTracker.dispose();
-            }
             // Set and create gaze trackers on head and controllers
             this._cameraGazer._gazeTracker = value;
             this._cameraGazer._gazeTracker.bakeCurrentTransformIntoVertices();
             this._cameraGazer._gazeTracker.isPickable = false;
             this._cameraGazer._gazeTracker.isVisible = false;
             this._cameraGazer._gazeTracker.name = "gazeTracker";
-            if (this._leftController) {
-                this._leftController._gazeTracker = this._cameraGazer._gazeTracker.clone("gazeTracker");
-            }
-            if (this._rightController) {
-                this._rightController._gazeTracker = this._cameraGazer._gazeTracker.clone("gazeTracker");
-            }
         }
     }
-    /**
-     * The gaze tracking mesh corresponding to the left controller
-     */
-    get leftControllerGazeTrackerMesh() {
-        if (this._leftController) {
-            return this._leftController._gazeTracker;
-        }
-        return null;
-    }
-    /**
-     * The gaze tracking mesh corresponding to the right controller
-     */
-    get rightControllerGazeTrackerMesh() {
-        if (this._rightController) {
-            return this._rightController._gazeTracker;
-        }
-        return null;
-    }
     /**
      * If the ray of the gaze should be displayed.
      */
@@ -331,12 +193,6 @@ export class VRExperienceHelper {
         this._displayGaze = value;
         if (!value) {
             this._cameraGazer._gazeTracker.isVisible = false;
-            if (this._leftController) {
-                this._leftController._gazeTracker.isVisible = false;
-            }
-            if (this._rightController) {
-                this._rightController._gazeTracker.isVisible = false;
-            }
         }
     }
     /**
@@ -350,24 +206,6 @@ export class VRExperienceHelper {
      */
     set displayLaserPointer(value) {
         this._displayLaserPointer = value;
-        if (!value) {
-            if (this._rightController) {
-                this._rightController._deactivatePointer();
-                this._rightController._gazeTracker.isVisible = false;
-            }
-            if (this._leftController) {
-                this._leftController._deactivatePointer();
-                this._leftController._gazeTracker.isVisible = false;
-            }
-        }
-        else {
-            if (this._rightController) {
-                this._rightController._activatePointer();
-            }
-            if (this._leftController) {
-                this._leftController._activatePointer();
-            }
-        }
     }
     /**
      * The deviceOrientationCamera used as the camera when not in VR.
@@ -379,18 +217,7 @@ export class VRExperienceHelper {
      * Based on the current WebVR support, returns the current VR camera used.
      */
     get currentVRCamera() {
-        if (this._webVRready) {
-            return this._webVRCamera;
-        }
-        else {
-            return this._scene.activeCamera;
-        }
-    }
-    /**
-     * The webVRCamera which is used when in VR.
-     */
-    get webVRCamera() {
-        return this._webVRCamera;
+        return this._scene.activeCamera;
     }
     /**
      * The deviceOrientationCamera that is used as a fallback when vr device is not connected.
@@ -405,10 +232,7 @@ export class VRExperienceHelper {
         return this._btnVR;
     }
     get _teleportationRequestInitiated() {
-        const result = this._cameraGazer._teleportationRequestInitiated ||
-            (this._leftController !== null && this._leftController._teleportationRequestInitiated) ||
-            (this._rightController !== null && this._rightController._teleportationRequestInitiated);
-        return result;
+        return this._cameraGazer._teleportationRequestInitiated;
     }
     /**
      * Instantiates a VRExperienceHelper.
@@ -420,14 +244,6 @@ export class VRExperienceHelper {
     /** Options to modify the vr experience helper's behavior. */
     webVROptions = {}) {
         this.webVROptions = webVROptions;
-        // Can the system support WebVR, even if a headset isn't plugged in?
-        this._webVRsupported = false;
-        // If WebVR is supported, is a headset plugged in and are we ready to present?
-        this._webVRready = false;
-        // Are we waiting for the requestPresent callback to complete?
-        this._webVRrequesting = false;
-        // Are we presenting to the headset right now? (this is the vrDevice state)
-        this._webVRpresenting = false;
         // Are we presenting in the fullscreen fallback?
         this._fullscreenVRpresenting = false;
         /**
@@ -450,12 +266,7 @@ export class VRExperienceHelper {
          * Observable raised when exiting VR.
          */
         this.onExitingVRObservable = new Observable();
-        /**
-         * Observable raised when controller mesh is loaded.
-         */
-        this.onControllerMeshLoadedObservable = new Observable();
         this._useCustomVRButton = false;
-        this._teleportationRequested = false;
         this._teleportActive = false;
         this._floorMeshesCollection = [];
         this._teleportationMode = VRExperienceHelper.TELEPORTATIONMODE_CONSTANTTIME;
@@ -470,21 +281,12 @@ export class VRExperienceHelper {
         this._haloCenter = new Vector3(0, 0, 0);
         this._padSensibilityUp = 0.65;
         this._padSensibilityDown = 0.35;
-        this._leftController = null;
-        this._rightController = null;
-        this._gazeColor = new Color3(0.7, 0.7, 0.7);
-        this._laserColor = new Color3(0.7, 0.7, 0.7);
         this._pickedLaserColor = new Color3(0.2, 0.2, 1);
         this._pickedGazeColor = new Color3(0, 0, 1);
         /**
          * Observable raised when a new mesh is selected based on meshSelectionPredicate
          */
         this.onNewMeshSelected = new Observable();
-        /**
-         * Observable raised when a new mesh is selected based on meshSelectionPredicate.
-         * This observable will provide the mesh and the controller used to select the mesh
-         */
-        this.onMeshSelectedWithController = new Observable();
         /**
          * Observable raised when a new mesh is picked based on meshSelectionPredicate
          */
@@ -507,7 +309,6 @@ export class VRExperienceHelper {
         this.teleportationEnabled = true;
         this._teleportationInitialized = false;
         this._interactionsEnabled = false;
-        this._interactionsRequested = false;
         this._displayGaze = true;
         this._displayLaserPointer = true;
         /**
@@ -534,9 +335,6 @@ export class VRExperienceHelper {
         this.xrTestDone = false;
         this._onResize = () => {
             this._moveButtonToBottomRight();
-            if (this._fullscreenVRpresenting && this._webVRready) {
-                this.exitVR();
-            }
         };
         this._onFullscreenChange = () => {
             this._fullscreenVRpresenting = !!document.fullscreenElement;
@@ -552,14 +350,8 @@ export class VRExperienceHelper {
         };
         this._cachedAngularSensibility = { angularSensibilityX: null, angularSensibilityY: null, angularSensibility: null };
         this._beforeRender = () => {
-            if (this._leftController && this._leftController._activePointer) {
-                this._castRayAndSelectObject(this._leftController);
-            }
-            if (this._rightController && this._rightController._activePointer) {
-                this._castRayAndSelectObject(this._rightController);
-            }
-            if (this._noControllerIsActive && (this._scene.getEngine().isPointerLock || this.enableGazeEvenWhenNoPointerLock)) {
-                this._castRayAndSelectObject(this._cameraGazer);
+            if (this._scene.getEngine().isPointerLock || this.enableGazeEvenWhenNoPointerLock) {
+                // no-op
             }
             else {
                 this._cameraGazer._gazeTracker.isVisible = false;
@@ -571,11 +363,8 @@ export class VRExperienceHelper {
                     gamepad.onleftstickchanged((stickValues) => {
                         if (this._teleportationInitialized && this.teleportationEnabled) {
                             // Listening to classic/xbox gamepad only if no VR controller is active
-                            if ((!this._leftController && !this._rightController) ||
-                                (this._leftController && !this._leftController._activePointer && this._rightController && !this._rightController._activePointer)) {
-                                this._checkTeleportWithRay(stickValues, this._cameraGazer);
-                                this._checkTeleportBackwards(stickValues, this._cameraGazer);
-                            }
+                            this._checkTeleportWithRay(stickValues, this._cameraGazer);
+                            this._checkTeleportBackwards(stickValues, this._cameraGazer);
                         }
                     });
                 }
@@ -599,38 +388,6 @@ export class VRExperienceHelper {
                     });
                 }
             }
-            else {
-                const webVRController = gamepad;
-                const controller = new VRExperienceHelperControllerGazer(webVRController, this._scene, this._cameraGazer._gazeTracker);
-                if (webVRController.hand === "right" || (this._leftController && this._leftController.webVRController != webVRController)) {
-                    this._rightController = controller;
-                }
-                else {
-                    this._leftController = controller;
-                }
-                this._tryEnableInteractionOnController(controller);
-            }
-        };
-        // This only succeeds if the controller's mesh exists for the controller so this must be called whenever new controller is connected or when mesh is loaded
-        this._tryEnableInteractionOnController = (controller) => {
-            if (this._interactionsRequested && !controller._interactionsEnabled) {
-                this._enableInteractionOnController(controller);
-            }
-            if (this._teleportationRequested && !controller._teleportationEnabled) {
-                this._enableTeleportationOnController(controller);
-            }
-        };
-        this._onNewGamepadDisconnected = (gamepad) => {
-            if (gamepad instanceof WebVRController) {
-                if (gamepad.hand === "left" && this._leftController != null) {
-                    this._leftController.dispose();
-                    this._leftController = null;
-                }
-                if (gamepad.hand === "right" && this._rightController != null) {
-                    this._rightController.dispose();
-                    this._rightController = null;
-                }
-            }
         };
         this._workingVector = Vector3.Zero();
         this._workingQuaternion = Quaternion.Identity();
@@ -654,23 +411,6 @@ export class VRExperienceHelper {
         if (webVROptions.laserToggle === undefined) {
             webVROptions.laserToggle = true;
         }
-        if (webVROptions.defaultHeight === undefined) {
-            webVROptions.defaultHeight = 1.7;
-        }
-        if (webVROptions.useCustomVRButton) {
-            this._useCustomVRButton = true;
-            if (webVROptions.customVRButton) {
-                this._btnVR = webVROptions.customVRButton;
-            }
-        }
-        if (webVROptions.rayLength) {
-            this._rayLength = webVROptions.rayLength;
-        }
-        this._defaultHeight = webVROptions.defaultHeight;
-        if (webVROptions.positionScale) {
-            this._rayLength *= webVROptions.positionScale;
-            this._defaultHeight *= webVROptions.positionScale;
-        }
         this._hasEnteredVR = false;
         // Set position
         if (this._scene.activeCamera) {
@@ -763,17 +503,9 @@ export class VRExperienceHelper {
         this.xrTestDone = true;
         // Create VR cameras
         if (webVROptions.createFallbackVRDeviceOrientationFreeCamera) {
-            if (webVROptions.useMultiview) {
-                if (!webVROptions.vrDeviceOrientationCameraMetrics) {
-                    webVROptions.vrDeviceOrientationCameraMetrics = VRCameraMetrics.GetDefault();
-                }
-                webVROptions.vrDeviceOrientationCameraMetrics.multiviewEnabled = true;
-            }
             this._vrDeviceOrientationCamera = new VRDeviceOrientationFreeCamera("VRDeviceOrientationVRHelper", this._position, this._scene, true, webVROptions.vrDeviceOrientationCameraMetrics);
             this._vrDeviceOrientationCamera.angularSensibility = Number.MAX_VALUE;
         }
-        this._webVRCamera = new WebVRFreeCamera("WebVRHelper", this._position, this._scene, webVROptions);
-        this._webVRCamera.useStandingMatrix();
         this._cameraGazer = new VRExperienceHelperCameraGazer(() => {
             return this.currentVRCamera;
         }, scene);
@@ -805,9 +537,6 @@ export class VRExperienceHelper {
                 if (!this.isInVRMode) {
                     this.enterVR();
                 }
-                else {
-                    this._scene.getEngine().disableVR();
-                }
             });
         }
         // Window events
@@ -821,13 +550,6 @@ export class VRExperienceHelper {
         if (webVROptions.createFallbackVRDeviceOrientationFreeCamera) {
             this._displayVRButton();
         }
-        else {
-            this._scene.getEngine().onVRDisplayChangedObservable.add((e) => {
-                if (e.vrDisplay) {
-                    this._displayVRButton();
-                }
-            });
-        }
         // Exiting VR mode using 'ESC' key on desktop
         this._onKeyDown = (event) => {
             if (event.keyCode === 27 && this.isInVRMode) {
@@ -844,28 +566,9 @@ export class VRExperienceHelper {
                 }
             }
         }, PointerEventTypes.POINTERDOUBLETAP, false);
-        // Listen for WebVR display changes
-        this._onVRDisplayChangedBind = (eventArgs) => this._onVRDisplayChanged(eventArgs);
-        this._onVrDisplayPresentChangeBind = () => this._onVrDisplayPresentChange();
-        this._onVRRequestPresentStart = () => {
-            this._webVRrequesting = true;
-            this._updateButtonVisibility();
-        };
-        this._onVRRequestPresentComplete = () => {
-            this._webVRrequesting = false;
-            this._updateButtonVisibility();
-        };
-        scene.getEngine().onVRDisplayChangedObservable.add(this._onVRDisplayChangedBind);
-        scene.getEngine().onVRRequestPresentStart.add(this._onVRRequestPresentStart);
-        scene.getEngine().onVRRequestPresentComplete.add(this._onVRRequestPresentComplete);
-        hostWindow.addEventListener("vrdisplaypresentchange", this._onVrDisplayPresentChangeBind);
         scene.onDisposeObservable.add(() => {
             this.dispose();
         });
-        // Gamepad connection events
-        this._webVRCamera.onControllerMeshLoadedObservable.add((webVRController) => this._onDefaultMeshLoaded(webVRController));
-        this._scene.gamepadManager.onGamepadConnectedObservable.add(this._onNewGamepadConnected);
-        this._scene.gamepadManager.onGamepadDisconnectedObservable.add(this._onNewGamepadDisconnected);
         this._updateButtonVisibility();
         //create easing functions
         this._circleEase = new CircleEase();
@@ -888,50 +591,11 @@ export class VRExperienceHelper {
             this.enableTeleportation({ floorMeshes: this.webVROptions.floorMeshes });
         }
     }
-    // Raised when one of the controller has loaded successfully its associated default mesh
-    _onDefaultMeshLoaded(webVRController) {
-        if (this._leftController && this._leftController.webVRController == webVRController) {
-            if (webVRController.mesh) {
-                this._leftController._setLaserPointerParent(webVRController.mesh);
-            }
-        }
-        if (this._rightController && this._rightController.webVRController == webVRController) {
-            if (webVRController.mesh) {
-                this._rightController._setLaserPointerParent(webVRController.mesh);
-            }
-        }
-        try {
-            this.onControllerMeshLoadedObservable.notifyObservers(webVRController);
-        }
-        catch (err) {
-            Logger.Warn("Error in your custom logic onControllerMeshLoaded: " + err);
-        }
-    }
     /**
      * Gets a value indicating if we are currently in VR mode.
      */
     get isInVRMode() {
-        return (this.xr && this.webVROptions.useXR && this.xr.baseExperience.state === WebXRState.IN_XR) || this._webVRpresenting || this._fullscreenVRpresenting;
-    }
-    _onVrDisplayPresentChange() {
-        const vrDisplay = this._scene.getEngine().getVRDevice();
-        if (vrDisplay) {
-            const wasPresenting = this._webVRpresenting;
-            this._webVRpresenting = vrDisplay.isPresenting;
-            if (wasPresenting && !this._webVRpresenting) {
-                this.exitVR();
-            }
-        }
-        else {
-            Logger.Warn("Detected VRDisplayPresentChange on an unknown VRDisplay. Did you can enterVR on the vrExperienceHelper?");
-        }
-        this._updateButtonVisibility();
-    }
-    _onVRDisplayChanged(eventArgs) {
-        this._webVRsupported = eventArgs.vrSupported;
-        this._webVRready = !!eventArgs.vrDisplay;
-        this._webVRpresenting = eventArgs.vrDisplay && eventArgs.vrDisplay.isPresenting;
-        this._updateButtonVisibility();
+        return (this.xr && this.webVROptions.useXR && this.xr.baseExperience.state === WebXRState.IN_XR) || this._fullscreenVRpresenting;
     }
     _moveButtonToBottomRight() {
         if (this._inputElement && !this._useCustomVRButton && this._btnVR) {
@@ -954,17 +618,6 @@ export class VRExperienceHelper {
         if (this.isInVRMode) {
             this._btnVR.className += " vrdisplaypresenting";
         }
-        else {
-            if (this._webVRready) {
-                this._btnVR.className += " vrdisplayready";
-            }
-            if (this._webVRsupported) {
-                this._btnVR.className += " vrdisplaysupported";
-            }
-            if (this._webVRrequesting) {
-                this._btnVR.className += " vrdisplayrequesting";
-            }
-        }
     }
     /**
      * Attempt to enter VR. If a headset is connected and ready, will request present on that.
@@ -989,13 +642,6 @@ export class VRExperienceHelper {
                 this.vrDeviceOrientationCamera.rotation = Quaternion.FromRotationMatrix(this._scene.activeCamera.getWorldMatrix().getRotationMatrix()).toEulerAngles();
                 this.vrDeviceOrientationCamera.angularSensibility = 2000;
             }
-            if (this.webVRCamera) {
-                const currentYRotation = this.webVRCamera.deviceRotationQuaternion.toEulerAngles().y;
-                const desiredYRotation = Quaternion.FromRotationMatrix(this._scene.activeCamera.getWorldMatrix().getRotationMatrix()).toEulerAngles().y;
-                const delta = desiredYRotation - currentYRotation;
-                const currentGlobalRotation = this.webVRCamera.rotationQuaternion.toEulerAngles().y;
-                this.webVRCamera.rotationQuaternion = Quaternion.FromEulerAngles(0, currentGlobalRotation + delta, 0);
-            }
             // make sure that we return to the last active camera
             this._existingCamera = this._scene.activeCamera;
             // Remove and cache angular sensability to avoid camera rotation when in VR
@@ -1012,20 +658,8 @@ export class VRExperienceHelper {
                 this._existingCamera.angularSensibility = Number.MAX_VALUE;
             }
         }
-        if (this._webVRrequesting) {
-            return;
-        }
         // If WebVR is supported and a headset is connected
-        if (this._webVRready) {
-            if (!this._webVRpresenting) {
-                this._scene.getEngine().onVRRequestPresentComplete.addOnce((result) => {
-                    this.onAfterEnteringVRObservable.notifyObservers({ success: result });
-                });
-                this._webVRCamera.position = this._position;
-                this._scene.activeCamera = this._webVRCamera;
-            }
-        }
-        else if (this._vrDeviceOrientationCamera) {
+        if (this._vrDeviceOrientationCamera) {
             this._vrDeviceOrientationCamera.position = this._position;
             if (this._scene.activeCamera) {
                 this._vrDeviceOrientationCamera.minZ = this._scene.activeCamera.minZ;
@@ -1043,13 +677,6 @@ export class VRExperienceHelper {
         if (this._interactionsEnabled) {
             this._scene.registerBeforeRender(this._beforeRender);
         }
-        if (this._displayLaserPointer) {
-            [this._leftController, this._rightController].forEach((controller) => {
-                if (controller) {
-                    controller._activatePointer();
-                }
-            });
-        }
         this._hasEnteredVR = true;
     }
     /**
@@ -1069,9 +696,6 @@ export class VRExperienceHelper {
                     Logger.Warn("Error in your custom logic onExitingVR: " + err);
                 }
             }
-            if (this._webVRpresenting) {
-                this._scene.getEngine().disableVR();
-            }
             if (this._scene.activeCamera) {
                 this._position = this._scene.activeCamera.position.clone();
             }
@@ -1119,26 +743,10 @@ export class VRExperienceHelper {
             if (this._interactionsEnabled) {
                 this._scene.unregisterBeforeRender(this._beforeRender);
                 this._cameraGazer._gazeTracker.isVisible = false;
-                if (this._leftController) {
-                    this._leftController._gazeTracker.isVisible = false;
-                }
-                if (this._rightController) {
-                    this._rightController._gazeTracker.isVisible = false;
-                }
             }
             // resize to update width and height when exiting vr exits fullscreen
             this._scene.getEngine().resize();
-            [this._leftController, this._rightController].forEach((controller) => {
-                if (controller) {
-                    controller._deactivatePointer();
-                }
-            });
             this._hasEnteredVR = false;
-            // Update engine state to re enable non-vr camera input
-            const engine = this._scene.getEngine();
-            if (engine._onVrDisplayPresentChange) {
-                engine._onVrDisplayPresentChange();
-            }
         }
     }
     /**
@@ -1161,7 +769,6 @@ export class VRExperienceHelper {
      */
     enableInteractions() {
         if (!this._interactionsEnabled) {
-            this._interactionsRequested = true;
             // in XR it is enabled by default, but just to make sure, re-attach
             if (this.xr) {
                 if (this.xr.baseExperience.state === WebXRState.IN_XR) {
@@ -1169,12 +776,6 @@ export class VRExperienceHelper {
                 }
                 return;
             }
-            if (this._leftController) {
-                this._enableInteractionOnController(this._leftController);
-            }
-            if (this._rightController) {
-                this._enableInteractionOnController(this._rightController);
-            }
             this.raySelectionPredicate = (mesh) => {
                 return mesh.isVisible && (mesh.isPickable || mesh.name === this._floorMeshName);
             };
@@ -1191,9 +792,6 @@ export class VRExperienceHelper {
             this._interactionsEnabled = true;
         }
     }
-    get _noControllerIsActive() {
-        return !(this._leftController && this._leftController._activePointer) && !(this._rightController && this._rightController._activePointer);
-    }
     _isTeleportationFloor(mesh) {
         for (let i = 0; i < this._floorMeshesCollection.length; i++) {
             if (this._floorMeshesCollection[i].id === mesh.id) {
@@ -1237,7 +835,6 @@ export class VRExperienceHelper {
      */
     enableTeleportation(vrTeleportationOptions = {}) {
         if (!this._teleportationInitialized) {
-            this._teleportationRequested = true;
             this.enableInteractions();
             if (this.webVROptions.useXR && (vrTeleportationOptions.floorMeshes || vrTeleportationOptions.floorMeshName)) {
                 const floorMeshes = vrTeleportationOptions.floorMeshes || [];
@@ -1292,66 +889,18 @@ export class VRExperienceHelper {
             if (vrTeleportationOptions.easingFunction !== undefined) {
                 this._teleportationEasing = vrTeleportationOptions.easingFunction;
             }
-            if (this._leftController != null) {
-                this._enableTeleportationOnController(this._leftController);
-            }
-            if (this._rightController != null) {
-                this._enableTeleportationOnController(this._rightController);
-            }
             // Creates an image processing post process for the vignette not relying
             // on the main scene configuration for image processing to reduce setup and spaces
             // (gamma/linear) conflicts.
             const imageProcessingConfiguration = new ImageProcessingConfiguration();
             imageProcessingConfiguration.vignetteColor = new Color4(0, 0, 0, 0);
             imageProcessingConfiguration.vignetteEnabled = true;
-            this._postProcessMove = new ImageProcessingPostProcess("postProcessMove", 1.0, this._webVRCamera, undefined, undefined, undefined, undefined, imageProcessingConfiguration);
-            this._webVRCamera.detachPostProcess(this._postProcessMove);
             this._teleportationInitialized = true;
             if (this._isDefaultTeleportationTarget) {
                 this._createTeleportationCircles();
-                this._teleportationTarget.scaling.scaleInPlace(this._webVRCamera.deviceScaleFactor);
             }
         }
     }
-    _enableInteractionOnController(controller) {
-        const controllerMesh = controller.webVRController.mesh;
-        if (controllerMesh) {
-            controller._interactionsEnabled = true;
-            if (this.isInVRMode && this._displayLaserPointer) {
-                controller._activatePointer();
-            }
-            if (this.webVROptions.laserToggle) {
-                controller.webVRController.onMainButtonStateChangedObservable.add((stateObject) => {
-                    // Enabling / disabling laserPointer
-                    if (this._displayLaserPointer && stateObject.value === 1) {
-                        if (controller._activePointer) {
-                            controller._deactivatePointer();
-                        }
-                        else {
-                            controller._activatePointer();
-                        }
-                        if (this.displayGaze) {
-                            controller._gazeTracker.isVisible = controller._activePointer;
-                        }
-                    }
-                });
-            }
-            controller.webVRController.onTriggerStateChangedObservable.add((stateObject) => {
-                let gazer = controller;
-                if (this._noControllerIsActive) {
-                    gazer = this._cameraGazer;
-                }
-                if (!gazer._pointerDownOnMeshAsked) {
-                    if (stateObject.value > this._padSensibilityUp) {
-                        gazer._selectionPointerDown();
-                    }
-                }
-                else if (stateObject.value < this._padSensibilityDown) {
-                    gazer._selectionPointerUp();
-                }
-            });
-        }
-    }
     _checkTeleportWithRay(stateObject, gazer) {
         // Dont teleport if another gaze already requested teleportation
         if (this._teleportationRequestInitiated && !gazer._teleportationRequestInitiated) {
@@ -1417,13 +966,8 @@ export class VRExperienceHelper {
                     return;
                 }
                 // Get rotation and position of the current camera
-                let rotation = Quaternion.FromRotationMatrix(this.currentVRCamera.getWorldMatrix().getRotationMatrix());
-                let position = this.currentVRCamera.position;
-                // If the camera has device position, use that instead
-                if (this.currentVRCamera.devicePosition && this.currentVRCamera.deviceRotationQuaternion) {
-                    rotation = this.currentVRCamera.deviceRotationQuaternion;
-                    position = this.currentVRCamera.devicePosition;
-                }
+                const rotation = Quaternion.FromRotationMatrix(this.currentVRCamera.getWorldMatrix().getRotationMatrix());
+                const position = this.currentVRCamera.position;
                 // Get matrix with only the y rotation of the device rotation
                 rotation.toEulerAnglesToRef(this._workingVector);
                 this._workingVector.z = 0;
@@ -1445,34 +989,6 @@ export class VRExperienceHelper {
             gazer._teleportationBackRequestInitiated = false;
         }
     }
-    _enableTeleportationOnController(controller) {
-        const controllerMesh = controller.webVRController.mesh;
-        if (controllerMesh) {
-            if (!controller._interactionsEnabled) {
-                this._enableInteractionOnController(controller);
-            }
-            controller._interactionsEnabled = true;
-            controller._teleportationEnabled = true;
-            if (controller.webVRController.controllerType === PoseEnabledControllerType.VIVE) {
-                controller._dpadPressed = false;
-                controller.webVRController.onPadStateChangedObservable.add((stateObject) => {
-                    controller._dpadPressed = stateObject.pressed;
-                    if (!controller._dpadPressed) {
-                        controller._rotationLeftAsked = false;
-                        controller._rotationRightAsked = false;
-                        controller._teleportationBackRequestInitiated = false;
-                    }
-                });
-            }
-            controller.webVRController.onPadValuesChangedObservable.add((stateObject) => {
-                if (this.teleportationEnabled) {
-                    this._checkTeleportBackwards(stateObject, controller);
-                    this._checkTeleportWithRay(stateObject, controller);
-                }
-                this._checkRotate(stateObject, controller);
-            });
-        }
-    }
     _createTeleportationCircles() {
         this._teleportationTarget = CreateGround("teleportationTarget", { width: 2, height: 2, subdivisions: 2 }, this._scene);
         this._teleportationTarget.isPickable = false;
@@ -1526,15 +1042,6 @@ export class VRExperienceHelper {
         this._scene.beginAnimation(torus, 0, 60, true);
         this._hideTeleportationTarget();
     }
-    _displayTeleportationTarget() {
-        this._teleportActive = true;
-        if (this._teleportationInitialized) {
-            this._teleportationTarget.isVisible = true;
-            if (this._isDefaultTeleportationTarget) {
-                this._teleportationTarget.getChildren()[0].isVisible = true;
-            }
-        }
-    }
     _hideTeleportationTarget() {
         this._teleportActive = false;
         if (this._teleportationInitialized) {
@@ -1607,28 +1114,8 @@ export class VRExperienceHelper {
         this._postProcessMove.imageProcessingConfiguration.vignetteWeight = 0;
         this._postProcessMove.imageProcessingConfiguration.vignetteStretch = 0;
         this._postProcessMove.samples = 4;
-        this._webVRCamera.attachPostProcess(this._postProcessMove);
-        this._scene.beginAnimation(this._postProcessMove, 0, 6, false, 1, () => {
-            this._webVRCamera.detachPostProcess(this._postProcessMove);
-        });
         this._scene.beginAnimation(this.currentVRCamera, 0, 6, false, 1);
     }
-    _moveTeleportationSelectorTo(hit, gazer, ray) {
-        if (hit.pickedPoint) {
-            if (gazer._teleportationRequestInitiated) {
-                this._displayTeleportationTarget();
-                this._haloCenter.copyFrom(hit.pickedPoint);
-                this._teleportationTarget.position.copyFrom(hit.pickedPoint);
-            }
-            const pickNormal = this._convertNormalToDirectionOfRay(hit.getNormal(true, false), ray);
-            if (pickNormal) {
-                const axis1 = Vector3.Cross(Axis.Y, pickNormal);
-                const axis2 = Vector3.Cross(pickNormal, axis1);
-                Vector3.RotationFromAxisToRef(axis2, pickNormal, axis1, this._teleportationTarget.rotation);
-            }
-            this._teleportationTarget.position.y += 0.1;
-        }
-    }
     /**
      * Teleports the users feet to the desired location
      * @param location The location where the user's feet should be placed
@@ -1639,17 +1126,10 @@ export class VRExperienceHelper {
         }
         // Teleport the hmd to where the user is looking by moving the anchor to where they are looking minus the
         // offset of the headset from the anchor.
-        if (this.webVRCamera.leftCamera) {
-            this._workingVector.copyFrom(this.webVRCamera.leftCamera.globalPosition);
-            this._workingVector.subtractInPlace(this.webVRCamera.position);
-            location.subtractToRef(this._workingVector, this._workingVector);
-        }
-        else {
-            this._workingVector.copyFrom(location);
-        }
+        this._workingVector.copyFrom(location);
         // Add height to account for user's height offset
         if (this.isInVRMode) {
-            this._workingVector.y += this.webVRCamera.deviceDistanceToRoomGround() * this._webVRCamera.deviceScaleFactor;
+            // no-op
         }
         else {
             this._workingVector.y += this._defaultHeight;
@@ -1721,164 +1201,25 @@ export class VRExperienceHelper {
         this._postProcessMove.animations.push(animationPP2);
         this._postProcessMove.imageProcessingConfiguration.vignetteWeight = 0;
         this._postProcessMove.imageProcessingConfiguration.vignetteStretch = 0;
-        this._webVRCamera.attachPostProcess(this._postProcessMove);
-        this._scene.beginAnimation(this._postProcessMove, 0, lastFrame, false, speedRatio, () => {
-            this._webVRCamera.detachPostProcess(this._postProcessMove);
-        });
         this._scene.beginAnimation(this.currentVRCamera, 0, lastFrame, false, speedRatio, () => {
             this.onAfterCameraTeleport.notifyObservers(this._workingVector);
         });
         this._hideTeleportationTarget();
     }
-    _convertNormalToDirectionOfRay(normal, ray) {
-        if (normal) {
-            const angle = Math.acos(Vector3.Dot(normal, ray.direction));
-            if (angle < Math.PI / 2) {
-                normal.scaleInPlace(-1);
-            }
-        }
-        return normal;
-    }
-    _castRayAndSelectObject(gazer) {
-        if (!(this.currentVRCamera instanceof FreeCamera)) {
-            return;
-        }
-        const ray = gazer._getForwardRay(this._rayLength);
-        const hit = this._scene.pickWithRay(ray, this._raySelectionPredicate);
-        if (hit) {
-            this._scene.simulatePointerMove(hit, { pointerId: gazer._id });
-        }
-        gazer._currentHit = hit;
-        // Moving the gazeTracker on the mesh face targetted
-        if (hit && hit.pickedPoint) {
-            if (this._displayGaze) {
-                let multiplier = 1;
-                gazer._gazeTracker.isVisible = true;
-                if (gazer._isActionableMesh) {
-                    multiplier = 3;
-                }
-                if (this.updateGazeTrackerScale) {
-                    gazer._gazeTracker.scaling.x = hit.distance * multiplier;
-                    gazer._gazeTracker.scaling.y = hit.distance * multiplier;
-                    gazer._gazeTracker.scaling.z = hit.distance * multiplier;
-                }
-                const pickNormal = this._convertNormalToDirectionOfRay(hit.getNormal(), ray);
-                // To avoid z-fighting
-                const deltaFighting = 0.002;
-                if (pickNormal) {
-                    const axis1 = Vector3.Cross(Axis.Y, pickNormal);
-                    const axis2 = Vector3.Cross(pickNormal, axis1);
-                    Vector3.RotationFromAxisToRef(axis2, pickNormal, axis1, gazer._gazeTracker.rotation);
-                }
-                gazer._gazeTracker.position.copyFrom(hit.pickedPoint);
-                if (gazer._gazeTracker.position.x < 0) {
-                    gazer._gazeTracker.position.x += deltaFighting;
-                }
-                else {
-                    gazer._gazeTracker.position.x -= deltaFighting;
-                }
-                if (gazer._gazeTracker.position.y < 0) {
-                    gazer._gazeTracker.position.y += deltaFighting;
-                }
-                else {
-                    gazer._gazeTracker.position.y -= deltaFighting;
-                }
-                if (gazer._gazeTracker.position.z < 0) {
-                    gazer._gazeTracker.position.z += deltaFighting;
-                }
-                else {
-                    gazer._gazeTracker.position.z -= deltaFighting;
-                }
-            }
-            // Changing the size of the laser pointer based on the distance from the targetted point
-            gazer._updatePointerDistance(hit.distance);
-        }
-        else {
-            gazer._updatePointerDistance();
-            gazer._gazeTracker.isVisible = false;
-        }
-        if (hit && hit.pickedMesh) {
-            // The object selected is the floor, we're in a teleportation scenario
-            if (this._teleportationInitialized && this._isTeleportationFloor(hit.pickedMesh) && hit.pickedPoint) {
-                // Moving the teleportation area to this targetted point
-                //Raise onSelectedMeshUnselected observable if ray collided floor mesh/meshes and a non floor mesh was previously selected
-                if (gazer._currentMeshSelected && !this._isTeleportationFloor(gazer._currentMeshSelected)) {
-                    this._notifySelectedMeshUnselected(gazer._currentMeshSelected);
-                }
-                gazer._currentMeshSelected = null;
-                if (gazer._teleportationRequestInitiated) {
-                    this._moveTeleportationSelectorTo(hit, gazer, ray);
-                }
-                return;
-            }
-            // If not, we're in a selection scenario
-            //this._teleportationAllowed = false;
-            if (hit.pickedMesh !== gazer._currentMeshSelected) {
-                if (this.meshSelectionPredicate(hit.pickedMesh)) {
-                    this.onNewMeshPicked.notifyObservers(hit);
-                    gazer._currentMeshSelected = hit.pickedMesh;
-                    if (hit.pickedMesh.isPickable && hit.pickedMesh.actionManager) {
-                        this.changeGazeColor(this._pickedGazeColor);
-                        this.changeLaserColor(this._pickedLaserColor);
-                        gazer._isActionableMesh = true;
-                    }
-                    else {
-                        this.changeGazeColor(this._gazeColor);
-                        this.changeLaserColor(this._laserColor);
-                        gazer._isActionableMesh = false;
-                    }
-                    try {
-                        this.onNewMeshSelected.notifyObservers(hit.pickedMesh);
-                        const gazerAsControllerGazer = gazer;
-                        if (gazerAsControllerGazer.webVRController) {
-                            this.onMeshSelectedWithController.notifyObservers({ mesh: hit.pickedMesh, controller: gazerAsControllerGazer.webVRController });
-                        }
-                    }
-                    catch (err) {
-                        Logger.Warn("Error while raising onNewMeshSelected or onMeshSelectedWithController: " + err);
-                    }
-                }
-                else {
-                    this._notifySelectedMeshUnselected(gazer._currentMeshSelected);
-                    gazer._currentMeshSelected = null;
-                    this.changeGazeColor(this._gazeColor);
-                    this.changeLaserColor(this._laserColor);
-                }
-            }
-        }
-        else {
-            this._notifySelectedMeshUnselected(gazer._currentMeshSelected);
-            gazer._currentMeshSelected = null;
-            //this._teleportationAllowed = false;
-            this.changeGazeColor(this._gazeColor);
-            this.changeLaserColor(this._laserColor);
-        }
-    }
-    _notifySelectedMeshUnselected(mesh) {
-        if (mesh) {
-            this.onSelectedMeshUnselected.notifyObservers(mesh);
-        }
-    }
     /**
      * Permanently set new colors for the laser pointer
      * @param color the new laser color
      * @param pickedColor the new laser color when picked mesh detected
      */
     setLaserColor(color, pickedColor = this._pickedLaserColor) {
-        this._laserColor = color;
         this._pickedLaserColor = pickedColor;
     }
     /**
      * Set lighting enabled / disabled on the laser pointer of both controllers
      * @param enabled should the lighting be enabled on the laser pointer
      */
-    setLaserLightingState(enabled = true) {
-        if (this._leftController) {
-            this._leftController._setLaserPointerLightingDisabled(!enabled);
-        }
-        if (this._rightController) {
-            this._rightController._setLaserPointerLightingDisabled(!enabled);
-        }
+    setLaserLightingState(_enabled = true) {
+        // no-op
     }
     /**
      * Permanently set new colors for the gaze pointer
@@ -1886,23 +1227,16 @@ export class VRExperienceHelper {
      * @param pickedColor the new gaze color when picked mesh detected
      */
     setGazeColor(color, pickedColor = this._pickedGazeColor) {
-        this._gazeColor = color;
         this._pickedGazeColor = pickedColor;
     }
     /**
      * Sets the color of the laser ray from the vr controllers.
      * @param color new color for the ray.
      */
-    changeLaserColor(color) {
+    changeLaserColor(_color) {
         if (!this.updateControllerLaserColor) {
             return;
         }
-        if (this._leftController) {
-            this._leftController._setLaserPointerColor(color);
-        }
-        if (this._rightController) {
-            this._rightController._setLaserPointerColor(color);
-        }
     }
     /**
      * Sets the color of the ray from the vr headsets gaze.
@@ -1916,12 +1250,6 @@ export class VRExperienceHelper {
             return;
         }
         this._cameraGazer._gazeTracker.material.emissiveColor = color;
-        if (this._leftController) {
-            this._leftController._gazeTracker.material.emissiveColor = color;
-        }
-        if (this._rightController) {
-            this._rightController._gazeTracker.material.emissiveColor = color;
-        }
     }
     /**
      * Exits VR and disposes of the vr experience helper
@@ -1933,9 +1261,6 @@ export class VRExperienceHelper {
         if (this._postProcessMove) {
             this._postProcessMove.dispose();
         }
-        if (this._webVRCamera) {
-            this._webVRCamera.dispose();
-        }
         if (this._vrDeviceOrientationCamera) {
             this._vrDeviceOrientationCamera.dispose();
         }
@@ -1948,12 +1273,6 @@ export class VRExperienceHelper {
         if (this._cameraGazer) {
             this._cameraGazer.dispose();
         }
-        if (this._leftController) {
-            this._leftController.dispose();
-        }
-        if (this._rightController) {
-            this._rightController.dispose();
-        }
         if (this._teleportationTarget) {
             this._teleportationTarget.dispose();
         }
@@ -1965,11 +1284,7 @@ export class VRExperienceHelper {
         window.removeEventListener("vrdisplaypresentchange", this._onVrDisplayPresentChangeBind);
         window.removeEventListener("resize", this._onResize);
         document.removeEventListener("fullscreenchange", this._onFullscreenChange);
-        this._scene.getEngine().onVRDisplayChangedObservable.removeCallback(this._onVRDisplayChangedBind);
-        this._scene.getEngine().onVRRequestPresentStart.removeCallback(this._onVRRequestPresentStart);
-        this._scene.getEngine().onVRRequestPresentComplete.removeCallback(this._onVRRequestPresentComplete);
         this._scene.gamepadManager.onGamepadConnectedObservable.removeCallback(this._onNewGamepadConnected);
-        this._scene.gamepadManager.onGamepadDisconnectedObservable.removeCallback(this._onNewGamepadDisconnected);
         this._scene.unregisterBeforeRender(this._beforeRender);
     }
     /**