working again

src/Cameras/XR/webXRCamera.ts

@@ -64,16 +64,16 @@ export class WebXRCamera extends FreeCamera {
      */
     public updateFromXRSessionManager(xrSessionManager: WebXRSessionManager) {
         // Ensure all frame data is available
-        if (!xrSessionManager._currentXRFrame || !xrSessionManager._currentXRFrame.getDevicePose) {
+        if (!xrSessionManager._currentXRFrame || !xrSessionManager._currentXRFrame.getViewerPose) {
             return false;
         }
-        var pose = xrSessionManager._currentXRFrame.getDevicePose(xrSessionManager._frameOfReference);
-        if (!pose || !pose.poseModelMatrix) {
+        var pose = xrSessionManager._currentXRFrame.getViewerPose(xrSessionManager._frameOfReference);
+        if (!pose || !pose.transform || !pose.transform.matrix) {
             return false;
         }
 
         // Update the parent cameras matrix
-        Matrix.FromFloat32ArrayToRefScaled(pose.poseModelMatrix, 0, 1, WebXRCamera._TmpMatrix);
+        Matrix.FromFloat32ArrayToRefScaled(pose.transform.matrix, 0, 1, WebXRCamera._TmpMatrix);
         if (!this._scene.useRightHandedSystem) {
             WebXRCamera._TmpMatrix.toggleModelMatrixHandInPlace();
         }
@@ -83,10 +83,10 @@ export class WebXRCamera extends FreeCamera {
         this.computeWorldMatrix();
 
         // Update camera rigs
-        this._updateNumberOfRigCameras(xrSessionManager._currentXRFrame.views.length);
-        xrSessionManager._currentXRFrame.views.forEach((view, i) => {
+        this._updateNumberOfRigCameras(pose.views.length);
+        pose.views.forEach((view:any, i:number) => {
             // Update view/projection matrix
-            Matrix.FromFloat32ArrayToRefScaled(pose.getViewMatrix(view), 0, 1, this.rigCameras[i]._computedViewMatrix);
+            Matrix.FromFloat32ArrayToRefScaled(view.transform.matrix, 0, 1, this.rigCameras[i]._computedViewMatrix);
             Matrix.FromFloat32ArrayToRefScaled(view.projectionMatrix, 0, 1, this.rigCameras[i]._projectionMatrix);
             if (!this._scene.useRightHandedSystem) {
                 this.rigCameras[i]._computedViewMatrix.toggleModelMatrixHandInPlace();
@@ -94,14 +94,13 @@ export class WebXRCamera extends FreeCamera {
             }
 
             // Update viewport
-            var viewport = xrSessionManager._xrSession.baseLayer.getViewport(view);
-            var width = xrSessionManager._xrSession.baseLayer.framebufferWidth;
-            var height = xrSessionManager._xrSession.baseLayer.framebufferHeight;
+            var viewport = xrSessionManager._xrSession.renderState.baseLayer.getViewport(view);
+            var width = xrSessionManager._xrSession.renderState.baseLayer.framebufferWidth;
+            var height = xrSessionManager._xrSession.renderState.baseLayer.framebufferHeight;
             this.rigCameras[i].viewport.width = viewport.width / width;
             this.rigCameras[i].viewport.height = viewport.height / height;
             this.rigCameras[i].viewport.x = viewport.x / width;
             this.rigCameras[i].viewport.y = viewport.y / height;
-
             // Set cameras to render to the session's render target
             this.rigCameras[i].outputRenderTarget = xrSessionManager._sessionRenderTargetTexture;
         });

src/Cameras/XR/webXREnterExitUI.ts

@@ -15,7 +15,7 @@ export class WebXREnterExitUIButton {
         /** button element */
         public element: HTMLElement,
         /** XR initialization options for the button */
-        public initializationOptions: XRSessionCreationOptions
+        //public initializationOptions: XRSessionCreationOptions
     ) { }
     /**
      * Overwritable function which can be used to update the button's visuals when the state changes

src/Cameras/XR/webXRExperienceHelper.ts

@@ -3,7 +3,6 @@ import { Observable } from "../../Misc/observable";
 import { IDisposable, Scene } from "../../scene";
 import { Quaternion, Vector3 } from "../../Maths/math";
 import { AbstractMesh } from "../../Meshes/abstractMesh";
-import { Ray } from "../../Culling/ray";
 import { Camera } from "../../Cameras/camera";
 import { WebXRSessionManager } from "./webXRSessionManager";
 import { WebXRCamera } from "./webXRCamera";
@@ -109,22 +108,18 @@ export class WebXRExperienceHelper implements IDisposable {
      * @param frameOfReference frame of reference of the XR session
      * @returns promise that resolves after xr mode has entered
      */
-    public enterXRAsync(sessionCreationOptions: XRSessionCreationOptions, frameOfReference: ReferenceSpaceOptions, outputCanvas: WebXRManagedOutputCanvas) {
+    public enterXRAsync(sessionCreationOptions: XRSessionMode, frameOfReference: XRReferenceSpaceType, outputCanvas: WebXRManagedOutputCanvas) {
         if (!this._supported) {
             throw "XR session not supported by this browser";
         }
         this._setState(WebXRState.ENTERING_XR);
         return this.sessionManager.initializeSessionAsync(sessionCreationOptions).then(()=>{
-            console.log("init session")
             return this.sessionManager.setReferenceSpaceAsync(frameOfReference)
         }).then(()=>{
-            console.log("set ref space")
             return outputCanvas.initializeXRLayerAsync(this.sessionManager._xrSession);
         }).then(()=>{
-            console.log("init xr layer")
-            return this.sessionManager.updateRenderStateAsync({baseLayer: outputCanvas.xrLayer, outputContext: outputCanvas.canvasContext})
+            return this.sessionManager.updateRenderStateAsync({baseLayer: outputCanvas.xrLayer})
         }).then(()=>{
-            console.log("base layer set")
             return this.sessionManager.startRenderingToXRAsync();
         }).then(()=>{
             // Cache pre xr scene settings
@@ -136,7 +131,6 @@ export class WebXRExperienceHelper implements IDisposable {
             this.scene.activeCamera = this.camera;
 
             this.sessionManager.onXRFrameObservable.add(() => {
-                console.log("frame")
                 this.camera.updateFromXRSessionManager(this.sessionManager);
             });
 
@@ -154,24 +148,13 @@ export class WebXRExperienceHelper implements IDisposable {
                 this._setState(WebXRState.NOT_IN_XR);
             });
             this._setState(WebXRState.IN_XR);
-            console.log("started!")
         }).catch((e:any)=>{
-            console.log("FAILUE")
             console.log(e)
             console.log(e.message)
         });
     }
 
     /**
-     * Fires a ray and returns the closest hit in the xr sessions enviornment, useful to place objects in AR
-     * @param ray ray to cast into the environment
-     * @returns Promise which resolves with a collision point in the environment if it exists
-     */
-    public environmentPointHitTestAsync(ray: Ray): Promise<Nullable<Vector3>> {
-        return this.sessionManager.environmentPointHitTestAsync(ray);
-    }
-
-    /**
      * Updates the global position of the camera by moving the camera's container
      * This should be used instead of modifying the camera's position as it will be overwritten by an xrSessions's update frame
      * @param position The desired global position of the camera

src/Cameras/XR/webXRInput.ts

@@ -1,6 +1,5 @@
 import { Nullable } from "../../types";
 import { Observer } from "../../Misc/observable";
-import { Matrix, Quaternion } from "../../Maths/math";
 import { IDisposable, Scene } from "../../scene";
 import { AbstractMesh } from "../../Meshes/abstractMesh";
 import { WebXRExperienceHelper } from "./webXRExperienceHelper";
@@ -44,7 +43,6 @@ export class WebXRInput implements IDisposable {
      * XR controllers being tracked
      */
     public controllers: Array<WebXRController> = [];
-    private _tmpMatrix = new Matrix();
     private _frameObserver: Nullable<Observer<any>>;
 
     /**
@@ -52,49 +50,7 @@ export class WebXRInput implements IDisposable {
      * @param helper experience helper which the input should be created for
      */
     public constructor(private helper: WebXRExperienceHelper) {
-        this._frameObserver = helper.sessionManager.onXRFrameObservable.add(() => {
-            if (!helper.sessionManager._currentXRFrame || !helper.sessionManager._currentXRFrame.getDevicePose) {
-                return;
-            }
-
-            var xrFrame = helper.sessionManager._currentXRFrame;
-            var inputSources = helper.sessionManager._xrSession.getInputSources();
-
-            inputSources.forEach((input, i) => {
-                let inputPose = xrFrame.getInputPose(input, helper.sessionManager._frameOfReference);
-                if (inputPose) {
-                    if (this.controllers.length <= i) {
-                        this.controllers.push(new WebXRController(helper.container.getScene()));
-                    }
-                    var controller = this.controllers[i];
-
-                    // Manage the grip if it exists
-                    if (inputPose.gripMatrix) {
-                        if (!controller.grip) {
-                            controller.grip = new AbstractMesh("controllerGrip", helper.container.getScene());
-                        }
-                        Matrix.FromFloat32ArrayToRefScaled(inputPose.gripMatrix, 0, 1, this._tmpMatrix);
-                        if (!controller.grip.getScene().useRightHandedSystem) {
-                            this._tmpMatrix.toggleModelMatrixHandInPlace();
-                        }
-                        if (!controller.grip.rotationQuaternion) {
-                            controller.grip.rotationQuaternion = new Quaternion();
-                        }
-                        this._tmpMatrix.decompose(controller.grip.scaling, controller.grip.rotationQuaternion, controller.grip.position);
-                    }
-
-                    // Manager pointer of controller
-                    Matrix.FromFloat32ArrayToRefScaled(inputPose.targetRay.transformMatrix, 0, 1, this._tmpMatrix);
-                    if (!controller.pointer.getScene().useRightHandedSystem) {
-                        this._tmpMatrix.toggleModelMatrixHandInPlace();
-                    }
-                    if (!controller.pointer.rotationQuaternion) {
-                        controller.pointer.rotationQuaternion = new Quaternion();
-                    }
-                    this._tmpMatrix.decompose(controller.pointer.scaling, controller.pointer.rotationQuaternion, controller.pointer.position);
-                }
-            });
-        });
+        
     }
     /**
      * Disposes of the object

src/Cameras/XR/webXRManagedOutputCanvas.ts

@@ -26,7 +26,7 @@ export class WebXRManagedOutputCanvas implements IDisposable {
     constructor(helper: WebXRExperienceHelper, canvas?: HTMLCanvasElement) {
         if (!canvas) {
             canvas = document.createElement('canvas');
-            canvas.style.cssText = "position:absolute; bottom:0px;right:0px;z-index:10;width:100%;height:100%;background-color: #000000;";
+            canvas.style.cssText = "position:absolute; bottom:0px;right:0px;z-index:10;width:90%;height:100%;background-color: #000000;";
         }
         this._setManagedOutputCanvas(canvas);
         helper.onStateChangedObservable.add((stateInfo) => {
@@ -53,7 +53,7 @@ export class WebXRManagedOutputCanvas implements IDisposable {
             (this.canvasContext as any) = null;
         } else {
             this._canvas = canvas;
-            this.canvasContext = <any>this._canvas.getContext('webgl');
+            this.canvasContext = <any>this._canvas.getContext('webgl2');
         }
     }
 

src/Cameras/XR/webXRSessionManager.ts

@@ -2,10 +2,8 @@ import { Logger } from "../../Misc/logger";
 import { Observable } from "../../Misc/observable";
 import { Nullable } from "../../types";
 import { IDisposable, Scene } from "../../scene";
-import { Vector3, Matrix } from "../../Maths/math";
 import { InternalTexture } from "../../Materials/Textures/internalTexture";
 import { RenderTargetTexture } from "../../Materials/Textures/renderTargetTexture";
-import { Ray } from "../../Culling/ray";
 /**
  * Manages an XRSession
  * @see https://doc.babylonjs.com/how_to/webxr
@@ -23,13 +21,12 @@ export class WebXRSessionManager implements IDisposable {
     /** @hidden */
     public _xrSession: XRSession;
     /** @hidden */
-    public _frameOfReference: XRFrameOfReference;
+    public _frameOfReference: XRReferenceSpaceType;
     /** @hidden */
     public _sessionRenderTargetTexture: Nullable<RenderTargetTexture> = null;
     /** @hidden */
     public _currentXRFrame: Nullable<XRFrame>;
     private _xrNavigator: any;
-    private _tmpMatrix = new Matrix();
     private baseLayer:Nullable<XRWebGLLayer> = null;
 
     /**
@@ -55,8 +52,8 @@ export class WebXRSessionManager implements IDisposable {
         return Promise.resolve();
     }
 
-    public initializeSessionAsync(sessionCreationOptions: XRSessionCreationOptions){
-        return this._xrNavigator.xr.requestSession(sessionCreationOptions.mode).then((session: XRSession) => {
+    public initializeSessionAsync(xrSessionMode: XRSessionMode){
+        return this._xrNavigator.xr.requestSession(xrSessionMode).then((session: XRSession) => {
             this._xrSession = session;
 
             // handle when the session is ended (By calling session.end or device ends its own session eg. pressing home button on phone)
@@ -75,7 +72,7 @@ export class WebXRSessionManager implements IDisposable {
         });
     }
 
-    public setReferenceSpaceAsync(referenceSpaceOptions: ReferenceSpaceOptions){
+    public setReferenceSpaceAsync(referenceSpaceOptions: XRReferenceSpaceType){
         return this._xrSession.requestReferenceSpace(referenceSpaceOptions).then((referenceSpace: any)=>{
             this._frameOfReference = referenceSpace;
         })
@@ -104,7 +101,6 @@ export class WebXRSessionManager implements IDisposable {
 
         // Stop window's animation frame and trigger sessions animation frame
         window.cancelAnimationFrame(this.scene.getEngine()._frameHandler);
-        debugger;
         this.scene.getEngine()._renderLoop();
         return Promise.resolve();
     }
@@ -118,40 +114,6 @@ export class WebXRSessionManager implements IDisposable {
     }
 
     /**
-     * Fires a ray and returns the closest hit in the xr sessions enviornment, useful to place objects in AR
-     * @param ray ray to cast into the environment
-     * @returns Promise which resolves with a collision point in the environment if it exists
-     */
-    public environmentPointHitTestAsync(ray: Ray): Promise<Nullable<Vector3>> {
-        return new Promise((res) => {
-            // Compute left handed inputs to request hit test
-            var origin = new Float32Array([ray.origin.x, ray.origin.y, ray.origin.z]);
-            var direction = new Float32Array([ray.direction.x, ray.direction.y, ray.direction.z]);
-            if (!this.scene.useRightHandedSystem) {
-                origin[2] *= -1;
-                direction[2] *= -1;
-            }
-
-            // Fire hittest
-            this._xrSession.requestHitTest(origin, direction, this._frameOfReference)
-                .then((hits: any) => {
-                    if (hits.length > 0) {
-                        Matrix.FromFloat32ArrayToRefScaled(hits[0].hitMatrix, 0, 1.0, this._tmpMatrix);
-                        var hitPoint = this._tmpMatrix.getTranslation();
-                        if (!this.scene.useRightHandedSystem) {
-                            hitPoint.z *= -1;
-                        }
-                        res(hitPoint);
-                    } else {
-                        res(null);
-                    }
-                }).catch(() => {
-                    res(null);
-                });
-        });
-    }
-
-    /**
      * Checks if a session would be supported for the creation options specified
      * @param sessionMode session mode to check if supported eg. immersive-vr
      * @returns true if supported
@@ -176,11 +138,9 @@ export class WebXRSessionManager implements IDisposable {
      * @param scene scene the new render target should be created for
      */
     public static _CreateRenderTargetTextureFromSession(session: XRSession, scene: Scene, baseLayer: XRWebGLLayer) {
-        console.log("creating render target")
         if(!baseLayer){
             throw "no layer"
         }
-        //debugger;
         // Create internal texture
         var internalTexture = new InternalTexture(scene.getEngine(), InternalTexture.DATASOURCE_UNKNOWN, true);
         internalTexture.width = baseLayer.framebufferWidth;

src/LibDeclarations/webxr.d.ts

@@ -1,46 +1,122 @@
-interface XRDevice {
-    requestSession(options: XRSessionCreationOptions): Promise<XRSession>;
-    supportsSession(options: XRSessionCreationOptions): Promise<void>;
-}
+enum XRSessionMode {
+    "inline",
+    "immersive-vr",
+    "immersive-ar"
+};
+
+enum XRReferenceSpaceType {
+    "viewer",
+    "local",
+    "local-floor",
+    "bounded-floor",
+    "unbounded"
+};
+
+enum XREnvironmentBlendMode {
+    "opaque",
+    "additive",
+    "alpha-blend",
+};
+
+enum XRVisibilityState {
+    "visible",
+    "visible-blurred",
+    "hidden",
+};
+
 interface XRSession {
-    getInputSources(): Array<any>;
-    baseLayer: XRWebGLLayer;
-    requestReferenceSpace(options: ReferenceSpaceOptions): Promise<void>;
-    requestHitTest(origin: Float32Array, direction: Float32Array, frameOfReference: any): any;
-    end(): Promise<void>;
-    updateRenderState(state:any):Promise<void>;
+    addEventListener: Function
+    requestReferenceSpace(type: XRReferenceSpaceType): Promise<void>;
+    updateRenderState(XRRenderStateInit:any):Promise<void>;
     requestAnimationFrame: Function;
-    addEventListener: Function;
-}
-interface XRSessionCreationOptions {
-    mode?: string;
-}
+    end():Promise<void>;
+    renderState:XRRenderState;
 
-interface ReferenceSpaceOptions {
-    type?: string;
-    subtype?: string;
-}
 
-interface XRLayer {
-    getViewport: Function;
-    framebufferWidth: number;
-    framebufferHeight: number;
-}
-interface XRView {
-    projectionMatrix: Float32Array;
-}
+};
+
 interface XRFrame {
-    getDevicePose: Function;
-    getInputPose: Function;
-    views: Array<XRView>;
-    baseLayer: XRLayer;
+    session:XRSession
+    getViewerPose(referenceSpace:XRReferenceSpace):XRViewerPose?
 }
-interface XRFrameOfReference {
+
+interface XRViewerPose extends XRPose {
+    views:FrozenArray<XRView>;
 }
-interface XRWebGLLayer extends XRLayer {
-    framebuffer: WebGLFramebuffer;
+
+interface XRPose {
+    transform:XRRigidTransform;
+    emulatedPosition:boolean;
 }
+
 declare var XRWebGLLayer: {
     prototype: XRWebGLLayer;
     new(session: XRSession, context?: WebGLRenderingContext): XRWebGLLayer;
-};
+};
+interface XRWebGLLayer extends XRLayer {
+    framebuffer: WebGLFramebuffer;
+    framebufferWidth: number
+    framebufferHeight: number
+}
+
+interface XRRigidTransform {
+    position:DOMPointReadOnly;
+    orientation:DOMPointReadOnly;
+    matrix:Float32Array;
+    inverse:XRRigidTransform;
+};
+
+interface XRView {
+    eye:XREye;
+    projectionMatrix:Float32Array;
+    transform:XRRigidTransform;
+};
+
+// interface XRDevice {
+//     requestSession(options: XRSessionCreationOptions): Promise<XRSession>;
+//     supportsSession(options: XRSessionCreationOptions): Promise<void>;
+// }
+// interface XRSession {
+//     getInputSources(): Array<any>;
+//     renderState: any;
+//     requestReferenceSpace(options: ReferenceSpaceOptions): Promise<void>;
+//     requestHitTest(origin: Float32Array, direction: Float32Array, frameOfReference: any): any;
+//     end(): Promise<void>;
+//     updateRenderState(state:any):Promise<void>;
+//     requestAnimationFrame: Function;
+//     addEventListener: Function;
+// }
+// interface XRSessionCreationOptions {
+//     mode?: string;
+// }
+
+
+
+// interface ReferenceSpaceOptions {
+//     type?: string;
+//     subtype?: string;
+// }
+
+// interface XRLayer {
+//     getViewport: Function;
+//     framebufferWidth: number;
+//     framebufferHeight: number;
+// }
+// interface XRView {
+//     projectionMatrix: Float32Array;
+// }
+// interface XRFrame {
+//     getViewerPose: Function;
+//     getInputPose: Function;
+//     views: Array<XRView>;
+//     baseLayer: XRLayer;
+// }
+// interface XRFrameOfReference {
+// }
+// interface XRWebGLLayer extends XRLayer {
+//     framebuffer: WebGLFramebuffer;
+// }
+// declare var XRWebGLLayer: {
+//     prototype: XRWebGLLayer;
+//     new(session: XRSession, context?: WebGLRenderingContext): XRWebGLLayer;
+// };

src/scene.ts

@@ -3523,10 +3523,10 @@ export class Scene extends AbstractScene implements IAnimatable {
 
             this._intermediateRendering = false;
 
-            // Restore framebuffer after rendering to targets
-            if (needRebind) {
-                this._bindFrameBuffer();
-            }
+            // Bind the frame (this is needed to be done in case a subcamera has an outputRenderTarget)
+            // TODO this undoes the change that addresses this https://github.com/BabylonJS/Babylon.js/issues/6124
+            this._bindFrameBuffer();
+            
         }
 
         this.onAfterRenderTargetsRenderObservable.notifyObservers(this);