docs and linting

dist/preview release/what's new.md

@@ -22,6 +22,7 @@
 - Added support for sound sprites [Doc](https://doc.babylonjs.com/how_to/playing_sounds_and_music#playing-a-sound-sprite) ([Deltakosh](https://github.com/deltakosh/))
 - Display Oculus Quest controller when using a Quest in WebVR ([TrevorDev](https://github.com/TrevorDev))
 - Added startAndReleaseDragOnPointerEvents property to pointerDragBehavior which can be set to false when using custom drag triggering ([TrevorDev](https://github.com/TrevorDev))
+- WebXR updated to spec as of June 27th ([TrevorDev](https://github.com/TrevorDev))
 
 ### Engine
 - Morph targets now can morph UV channel as well ([Deltakosh](https://github.com/deltakosh/))

src/Cameras/XR/webXRCamera.ts

@@ -67,7 +67,7 @@ export class WebXRCamera extends FreeCamera {
         if (!xrSessionManager.currentFrame || !xrSessionManager.currentFrame.getViewerPose) {
             return false;
         }
-        var pose = xrSessionManager.currentFrame.getViewerPose(xrSessionManager.referenceSpaceType);
+        var pose = xrSessionManager.currentFrame.getViewerPose(xrSessionManager.referenceSpace);
         if (!pose || !pose.transform || !pose.transform.matrix) {
             return false;
         }
@@ -84,7 +84,7 @@ export class WebXRCamera extends FreeCamera {
 
         // Update camera rigs
         this._updateNumberOfRigCameras(pose.views.length);
-        pose.views.forEach((view:any, i:number) => {
+        pose.views.forEach((view: any, i: number) => {
             // Update view/projection matrix
             Matrix.FromFloat32ArrayToRefScaled(view.transform.matrix, 0, 1, this.rigCameras[i]._computedViewMatrix);
             Matrix.FromFloat32ArrayToRefScaled(view.projectionMatrix, 0, 1, this.rigCameras[i]._projectionMatrix);
@@ -94,13 +94,16 @@ export class WebXRCamera extends FreeCamera {
             }
 
             // Update viewport
-            var viewport = xrSessionManager.session.renderState.baseLayer.getViewport(view);
-            var width = xrSessionManager.session.renderState.baseLayer.framebufferWidth;
-            var height = xrSessionManager.session.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;
+            if (xrSessionManager.session.renderState.baseLayer) {
+                var viewport = xrSessionManager.session.renderState.baseLayer.getViewport(view);
+                var width = xrSessionManager.session.renderState.baseLayer.framebufferWidth;
+                var height = xrSessionManager.session.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

@@ -10,13 +10,15 @@ export class WebXREnterExitUIButton {
     /**
      * Creates a WebXREnterExitUIButton
      * @param element button element
-     * @param initializationOptions XR initialization options for the button
+     * @param sessionMode XR initialization session mode
+     * @param referenceSpaceType the type of reference space to be used
      */
     constructor(
         /** button element */
         public element: HTMLElement,
         /** XR initialization options for the button */
         public sessionMode: XRSessionMode,
+        /** Reference space type */
         public referenceSpaceType: XRReferenceSpaceType
     ) { }
     /**
@@ -84,7 +86,7 @@ export class WebXREnterExitUI implements IDisposable {
                             return;
                         } else if (helper.state == WebXRState.NOT_IN_XR) {
                             ui._updateButtons(ui._buttons[i]);
-                            if(options.webXRManagedOutputCanvas){
+                            if (options.webXRManagedOutputCanvas) {
                                 await helper.enterXRAsync(ui._buttons[i].sessionMode, ui._buttons[i].referenceSpaceType, options.webXRManagedOutputCanvas);
                             }
                         }
@@ -110,15 +112,6 @@ export class WebXREnterExitUI implements IDisposable {
                 this.element.style.display = (activeButton === null || activeButton === this) ? "" : "none";
                 this.element.innerText = activeButton === this ? "EXIT" : "HMD";
             };
-
-            // var windowBtn = document.createElement("button");
-            // windowBtn.style.cssText = hmdBtn.style.cssText;
-            // windowBtn.innerText = "Window";
-            // this._buttons.push(new WebXREnterExitUIButton(windowBtn, { immersive: false, environmentIntegration: true, outputContext: options.outputCanvasContext }));
-            // this._buttons[this._buttons.length - 1].update = function(activeButton: WebXREnterExitUIButton) {
-            //     this.element.style.display = (activeButton === null || activeButton === this) ? "" : "none";
-            //     this.element.innerText = activeButton === this ? "EXIT" : "Window";
-            // };
             this._updateButtons(null);
         }
 

src/Cameras/XR/webXRExperienceHelper.ts

@@ -106,6 +106,7 @@ export class WebXRExperienceHelper implements IDisposable {
      * Enters XR mode (This must be done within a user interaction in most browsers eg. button click)
      * @param sessionCreationOptions options for the XR session
      * @param referenceSpaceType frame of reference of the XR session
+     * @param outputCanvas the output canvas that will be used to enter XR mode
      * @returns promise that resolves after xr mode has entered
      */
     public enterXRAsync(sessionCreationOptions: XRSessionMode, referenceSpaceType: XRReferenceSpaceType, outputCanvas: WebXRManagedOutputCanvas) {
@@ -113,15 +114,15 @@ export class WebXRExperienceHelper implements IDisposable {
             throw "XR session not supported by this browser";
         }
         this._setState(WebXRState.ENTERING_XR);
-        return this.sessionManager.initializeSessionAsync(sessionCreationOptions).then(()=>{
-            return this.sessionManager.setReferenceSpaceAsync(referenceSpaceType)
-        }).then(()=>{
+        return this.sessionManager.initializeSessionAsync(sessionCreationOptions).then(() => {
+            return this.sessionManager.setReferenceSpaceAsync(referenceSpaceType);
+        }).then(() => {
             return outputCanvas.initializeXRLayerAsync(this.sessionManager.session);
-        }).then(()=>{
-            return this.sessionManager.updateRenderStateAsync({baseLayer: outputCanvas.xrLayer})
-        }).then(()=>{
+        }).then(() => {
+            return this.sessionManager.updateRenderStateAsync({baseLayer: outputCanvas.xrLayer});
+        }).then(() => {
             return this.sessionManager.startRenderingToXRAsync();
-        }).then(()=>{
+        }).then(() => {
             // Cache pre xr scene settings
             this._originalSceneAutoClear = this.scene.autoClear;
             this._nonVRCamera = this.scene.activeCamera;
@@ -148,9 +149,9 @@ export class WebXRExperienceHelper implements IDisposable {
                 this._setState(WebXRState.NOT_IN_XR);
             });
             this._setState(WebXRState.IN_XR);
-        }).catch((e:any)=>{
-            console.log(e)
-            console.log(e.message)
+        }).catch((e: any) => {
+            console.log(e);
+            console.log(e.message);
         });
     }
 

src/Cameras/XR/webXRInput.ts

@@ -11,7 +11,7 @@ export class WebXRController {
     /**
      * Represents the part of the controller that is held. This may not exist if the controller is the head mounted display itself, if thats the case only the pointer from the head will be availible
      */
-    public grip: AbstractMesh;
+    public grip?: AbstractMesh;
     /**
      * Pointer which can be used to select objects or attach a visible laser to
      */
@@ -23,19 +23,30 @@ export class WebXRController {
      * Creates the controller
      * @see https://doc.babylonjs.com/how_to/webxr
      * @param scene the scene which the controller should be associated to
+     * @param inputSource the underlying input source for the controller
+     * @param parentContainer parent that the controller meshes should be children of
      */
-    constructor(scene: Scene, public inputSource:XRInputSource, parentContainer:Nullable<AbstractMesh> = null) {
+    constructor(
+        private scene: Scene,
+        /** The underlying input source for the controller  */
+        public inputSource: XRInputSource,
+        private parentContainer: Nullable<AbstractMesh> = null)
+    {
         this.pointer = new AbstractMesh("controllerPointer", scene);
-        this.grip = new AbstractMesh("controllerGrip", scene);
-        if(parentContainer){
-            parentContainer.addChild(this.pointer)
-            parentContainer.addChild(this.grip)
+        if (parentContainer) {
+            parentContainer.addChild(this.pointer);
+
         }
     }
 
-    updateFromXRFrame(xrFrame:XRFrame, referenceSpaceType:XRReferenceSpaceType){
-        var pose = xrFrame.getPose(this.inputSource.targetRaySpace, referenceSpaceType)
-        if(pose){
+    /**
+     * Updates the controller pose based on the given XRFrame
+     * @param xrFrame xr frame to update the pose with
+     * @param referenceSpace reference space to use
+     */
+    public updateFromXRFrame(xrFrame: XRFrame, referenceSpace: XRReferenceSpace) {
+        var pose = xrFrame.getPose(this.inputSource.targetRaySpace, referenceSpace);
+        if (pose) {
             Matrix.FromFloat32ArrayToRefScaled(pose.transform.matrix, 0, 1, this._tmpMatrix);
             if (!this.pointer.getScene().useRightHandedSystem) {
                 this._tmpMatrix.toggleModelMatrixHandInPlace();
@@ -46,19 +57,29 @@ export class WebXRController {
             this._tmpMatrix.decompose(this.pointer.scaling, this.pointer.rotationQuaternion!, this.pointer.position);
         }
 
-        var pose = xrFrame.getPose(this.inputSource.gripSpace, referenceSpaceType)
-        if(pose){
-            Matrix.FromFloat32ArrayToRefScaled(pose.transform.matrix, 0, 1, this._tmpMatrix);
-            if (!this.pointer.getScene().useRightHandedSystem) {
-                this._tmpMatrix.toggleModelMatrixHandInPlace();
+        if (this.inputSource.gripSpace) {
+            if (!this.grip) {
+                this.grip = new AbstractMesh("controllerGrip", this.scene);
+                if (this.parentContainer) {
+                    this.parentContainer.addChild(this.grip);
+                }
             }
-            if (!this.grip.rotationQuaternion) {
-                this.grip.rotationQuaternion = new Quaternion();
+
+            var pose = xrFrame.getPose(this.inputSource.gripSpace, referenceSpace);
+            if (pose) {
+                Matrix.FromFloat32ArrayToRefScaled(pose.transform.matrix, 0, 1, this._tmpMatrix);
+                if (!this.grip.getScene().useRightHandedSystem) {
+                    this._tmpMatrix.toggleModelMatrixHandInPlace();
+                }
+                if (!this.grip.rotationQuaternion) {
+                    this.grip.rotationQuaternion = new Quaternion();
+                }
+                this._tmpMatrix.decompose(this.grip.scaling, this.grip.rotationQuaternion!, this.grip.position);
             }
-            this._tmpMatrix.decompose(this.grip.scaling, this.grip.rotationQuaternion!, this.grip.position);
         }
+
     }
-    
+
     /**
      * Disposes of the object
      */
@@ -79,7 +100,13 @@ export class WebXRInput implements IDisposable {
      */
     public controllers: Array<WebXRController> = [];
     private _frameObserver: Nullable<Observer<any>>;
+    /**
+     * Event when a controller has been connected/added
+     */
     public onControllerAddedObservable = new Observable<WebXRController>();
+    /**
+     * Event when a controller has been removed/disconnected
+     */
     public onControllerRemovedObservable = new Observable<WebXRController>();
 
     /**
@@ -93,50 +120,50 @@ export class WebXRInput implements IDisposable {
             }
 
             // Start listing to input add/remove event
-            if(this.controllers.length == 0 && helper.sessionManager.session.inputSources){
+            if (this.controllers.length == 0 && helper.sessionManager.session.inputSources) {
                 this._addAndRemoveControllers(helper.sessionManager.session.inputSources, []);
-                helper.sessionManager.session.addEventListener("inputsourceschange", this._onInputSourcesChange)
+                helper.sessionManager.session.addEventListener("inputsourceschange", this._onInputSourcesChange);
             }
 
             // Update controller pose info
-            this.controllers.forEach((controller)=>{
-                controller.updateFromXRFrame(helper.sessionManager.currentFrame!, helper.sessionManager.referenceSpaceType)
-            })
+            this.controllers.forEach((controller) => {
+                controller.updateFromXRFrame(helper.sessionManager.currentFrame!, helper.sessionManager.referenceSpace);
+            });
 
-        })
+        });
     }
 
-    private _onInputSourcesChange = (event:XRInputSourceChangeEvent )=>{
-        this._addAndRemoveControllers(event.added, event.removed)
+    private _onInputSourcesChange = (event: XRInputSourceChangeEvent) => {
+        this._addAndRemoveControllers(event.added, event.removed);
     }
 
-    private _addAndRemoveControllers(addInputs:Array<XRInputSource>, removeInputs:Array<XRInputSource>){
+    private _addAndRemoveControllers(addInputs: Array<XRInputSource>, removeInputs: Array<XRInputSource>) {
         // Add controllers if they don't already exist
-        var sources = this.controllers.map((c)=>{return c.inputSource});
-        addInputs.forEach((input)=>{
-            if(sources.indexOf(input) === -1){
+        var sources = this.controllers.map((c) => {return c.inputSource; });
+        addInputs.forEach((input) => {
+            if (sources.indexOf(input) === -1) {
                 var controller = new WebXRController(this.helper.camera._scene, input, this.helper.container);
-                this.controllers.push(controller)
-                this.onControllerAddedObservable.notifyObservers(controller)
+                this.controllers.push(controller);
+                this.onControllerAddedObservable.notifyObservers(controller);
             }
-        })
-        
+        });
+
         // Remove and dispose of controllers to be disposed
-        var keepControllers: Array<WebXRController> = []
-        var removedControllers: Array<WebXRController> = []
-        this.controllers.forEach((c)=>{
-            if(removeInputs.indexOf(c.inputSource) === -1){
-                keepControllers.push(c)
-            }else{
+        var keepControllers: Array<WebXRController> = [];
+        var removedControllers: Array<WebXRController> = [];
+        this.controllers.forEach((c) => {
+            if (removeInputs.indexOf(c.inputSource) === -1) {
+                keepControllers.push(c);
+            }else {
                 removedControllers.push(c);
             }
-        })
+        });
         this.controllers = keepControllers;
-        removedControllers.forEach((c)=>{
+        removedControllers.forEach((c) => {
             this.onControllerRemovedObservable.notifyObservers(c);
-            c.dispose()
-        })
-        
+            c.dispose();
+        });
+
     }
 
     /**

src/Cameras/XR/webXRManagedOutputCanvas.ts

@@ -10,10 +10,14 @@ export class WebXRManagedOutputCanvas implements IDisposable {
      * xrpresent context of the canvas which can be used to display/mirror xr content
      */
     public canvasContext: WebGLRenderingContext;
-    public xrLayer:any;
-    
-    public initializeXRLayerAsync(xrSession:any){
-        return (this.canvasContext as any).makeXRCompatible().then(()=>{
+    public xrLayer: any;
+
+    /**
+     * Initializes the xr layer for the session
+     * @param xrSession xr session
+     */
+    public initializeXRLayerAsync(xrSession: any) {
+        return (this.canvasContext as any).makeXRCompatible().then(() => {
             this.xrLayer = new XRWebGLLayer(xrSession, this.canvasContext);
         });
     }
@@ -54,7 +58,7 @@ export class WebXRManagedOutputCanvas implements IDisposable {
         } else {
             this._canvas = canvas;
             this.canvasContext = <any>this._canvas.getContext('webgl');
-            if(!this.canvasContext){
+            if (!this.canvasContext) {
                 this.canvasContext = <any>this._canvas.getContext('webgl2');
             }
         }

src/Cameras/XR/webXRSessionManager.ts

@@ -18,25 +18,25 @@ export class WebXRSessionManager implements IDisposable {
      */
     public onXRSessionEnded: Observable<any> = new Observable<any>();
 
-    /** 
+    /**
      * Underlying xr session
      */
     public session: XRSession;
 
     /**
-     * Type of reference space used when creating the session 
+     * Type of reference space used when creating the session
      */
-    public referenceSpaceType: XRReferenceSpaceType;
-    
+    public referenceSpace: XRReferenceSpace;
+
     /** @hidden */
     public _sessionRenderTargetTexture: Nullable<RenderTargetTexture> = null;
-    
+
     /**
      * Current XR frame
      */
     public currentFrame: Nullable<XRFrame>;
     private _xrNavigator: any;
-    private baseLayer:Nullable<XRWebGLLayer> = null;
+    private baseLayer: Nullable<XRWebGLLayer> = null;
 
     /**
      * Constructs a WebXRSessionManager, this must be initialized within a user action before usage
@@ -61,7 +61,12 @@ export class WebXRSessionManager implements IDisposable {
         return Promise.resolve();
     }
 
-    public initializeSessionAsync(xrSessionMode: XRSessionMode){
+    /**
+     * Initializes an xr session
+     * @param xrSessionMode mode to initialize
+     * @returns a promise which will resolve once the session has been initialized
+     */
+    public initializeSessionAsync(xrSessionMode: XRSessionMode) {
         return this._xrNavigator.xr.requestSession(xrSessionMode).then((session: XRSession) => {
             this.session = session;
 
@@ -81,20 +86,31 @@ export class WebXRSessionManager implements IDisposable {
         });
     }
 
-    public setReferenceSpaceAsync(referenceSpaceOptions: XRReferenceSpaceType){
-        return this.session.requestReferenceSpace(referenceSpaceOptions).then((referenceSpace: any)=>{
-            this.referenceSpaceType = referenceSpace;
-        })
+    /**
+     * Sets the reference space on the xr session
+     * @param referenceSpace space to set
+     */
+    public setReferenceSpaceAsync(referenceSpace: XRReferenceSpaceType) {
+        return this.session.requestReferenceSpace(referenceSpace).then((referenceSpace: XRReferenceSpace) => {
+            this.referenceSpace = referenceSpace;
+        });
     }
 
-    public updateRenderStateAsync(state:any){
-        if(state.baseLayer){
+    /**
+     * Updates the render state of the session
+     * @param state state to set
+     */
+    public updateRenderStateAsync(state: any) {
+        if (state.baseLayer) {
             this.baseLayer = state.baseLayer;
         }
         return this.session.updateRenderState(state);
     }
 
-    public startRenderingToXRAsync(){
+    /**
+     * Starts rendering to the xr layer
+     */
+    public startRenderingToXRAsync() {
         // Tell the engine's render loop to be driven by the xr session's refresh rate and provide xr pose information
         this.scene.getEngine().customAnimationFrameRequester = {
             requestAnimationFrame: this.session.requestAnimationFrame.bind(this.session),
@@ -128,15 +144,15 @@ export class WebXRSessionManager implements IDisposable {
      * @returns true if supported
      */
     public supportsSessionAsync(sessionMode: XRSessionMode) {
-        if(!(navigator as any).xr || !(navigator as any).xr.supportsSession){
+        if (!(navigator as any).xr || !(navigator as any).xr.supportsSession) {
             return Promise.resolve(false);
-        }else{
-            return (navigator as any).xr.supportsSession(sessionMode).then(()=>{
-                return Promise.resolve(true)
-            }).catch((e:any)=>{
-                Logger.Warn(e)
+        }else {
+            return (navigator as any).xr.supportsSession(sessionMode).then(() => {
+                return Promise.resolve(true);
+            }).catch((e: any) => {
+                Logger.Warn(e);
                 return Promise.resolve(false);
-            })
+            });
         }
     }
 
@@ -147,8 +163,8 @@ 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) {
-        if(!baseLayer){
-            throw "no layer"
+        if (!baseLayer) {
+            throw "no layer";
         }
         // Create internal texture
         var internalTexture = new InternalTexture(scene.getEngine(), InternalTexture.DATASOURCE_UNKNOWN, true);

src/LibDeclarations/webxr.d.ts

@@ -1,89 +1,117 @@
 type XRSessionMode =
     | "inline"
     | "immersive-vr"
-    | "immersive-ar"
-
+    | "immersive-ar";
 
 type XRReferenceSpaceType =
     | "viewer"
     | "local"
     | "local-floor"
     | "bounded-floor"
-    | "unbounded"
-
+    | "unbounded";
 
 type XREnvironmentBlendMode =
     | "opaque"
     | "additive"
-    | "alpha-blend"
-
+    | "alpha-blend";
 
 type XRVisibilityState =
     | "visible"
     | "visible-blurred"
-    | "hidden"
-    
+    | "hidden";
+
+type XRHandedness =
+    | "none"
+    | "left"
+    | "right";
+
+type XRTargetRayMode =
+    | "gaze"
+    | "tracked-pointer"
+    | "screen";
+
+type XREye =
+    | "none"
+    | "left"
+    | "right";
+
+interface XRSpace extends EventTarget {
+
+}
+
+interface XRRenderState {
+    depthNear: number ;
+    depthFar: number ;
+    inlineVerticalFieldOfView: number | undefined;
+    baseLayer: XRWebGLLayer | undefined;
+}
+
 interface XRInputSource {
-    handedness:XRHandedness;
-    targetRayMode:XRTargetRayMode;
-    targetRaySpace:XRSpace;
-    gripSpace:XRSpace?;
-    gamepad:Gamepad?;
-    profiles:FrozenArray<DOMString>;
-};
+    handedness: XRHandedness;
+    targetRayMode: XRTargetRayMode;
+    targetRaySpace: XRSpace;
+    gripSpace: XRSpace | undefined;
+    gamepad: Gamepad | undefined;
+    profiles: Array<string>;
+}
 
 interface XRSession {
-    addEventListener: Function
-    requestReferenceSpace(type: XRReferenceSpaceType): Promise<void>;
-    updateRenderState(XRRenderStateInit:any):Promise<void>;
+    addEventListener: Function;
+    requestReferenceSpace(type: XRReferenceSpaceType): Promise<XRReferenceSpace>;
+    updateRenderState(XRRenderStateInit: any): Promise<void>;
     requestAnimationFrame: Function;
-    end():Promise<void>;
-    renderState:XRRenderState;
-    inputSources:Array<XRInputSource>
+    end(): Promise<void>;
+    renderState: XRRenderState;
+    inputSources: Array<XRInputSource>;
 
+}
 
-};
+interface XRReferenceSpace extends XRSpace {
+    getOffsetReferenceSpace(originOffset: XRRigidTransform): XRReferenceSpace;
+    onreset: any;
+}
 
 interface XRFrame {
-    session:XRSession
-    getViewerPose(referenceSpace:XRReferenceSpace):XRViewerPose?;
-    getPose(space:XRSpace, baseSpace:XRSpace):XRPose?;
+    session: XRSession;
+    getViewerPose(referenceSpace: XRReferenceSpace): XRViewerPose | undefined;
+    getPose(space: XRSpace, baseSpace: XRSpace): XRPose | undefined;
 }
 
 interface XRViewerPose extends XRPose {
-    views:FrozenArray<XRView>;
+    views: Array<XRView>;
 }
 
 interface XRPose {
-    transform:XRRigidTransform;
-    emulatedPosition:boolean;
+    transform: XRRigidTransform;
+    emulatedPosition: boolean;
 }
 
 declare var XRWebGLLayer: {
     prototype: XRWebGLLayer;
-    new(session: XRSession, context?: WebGLRenderingContext): XRWebGLLayer;
+    new(session: XRSession, context: WebGLRenderingContext | undefined): XRWebGLLayer;
 };
-interface XRWebGLLayer extends XRLayer {
+interface XRWebGLLayer {
     framebuffer: WebGLFramebuffer;
-    framebufferWidth: number
-    framebufferHeight: number
+    framebufferWidth: number;
+    framebufferHeight: number;
+    getViewport: Function;
 }
 
 interface XRRigidTransform {
-    position:DOMPointReadOnly;
-    orientation:DOMPointReadOnly;
-    matrix:Float32Array;
-    inverse:XRRigidTransform;
-};
+    position: DOMPointReadOnly;
+    orientation: DOMPointReadOnly;
+    matrix: Float32Array;
+    inverse: XRRigidTransform;
+}
 
 interface XRView {
-    eye:XREye;
-    projectionMatrix:Float32Array;
-    transform:XRRigidTransform;
-};
+    eye: XREye;
+    projectionMatrix: Float32Array;
+    transform: XRRigidTransform;
+}
 
 interface XRInputSourceChangeEvent {
-    session:XRSession;
-    removed:Array<XRInputSource>;
-    added:Array<XRInputSource>;
+    session: XRSession;
+    removed: Array<XRInputSource>;
+    added: Array<XRInputSource>;
 }

src/scene.ts

@@ -3526,7 +3526,7 @@ export class Scene extends AbstractScene implements IAnimatable {
             // 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);