fix naming

src/Cameras/XR/webXRCamera.ts

@@ -64,10 +64,10 @@ export class WebXRCamera extends FreeCamera {
      */
     public updateFromXRSessionManager(xrSessionManager: WebXRSessionManager) {
         // Ensure all frame data is available
-        if (!xrSessionManager._currentXRFrame || !xrSessionManager._currentXRFrame.getViewerPose) {
+        if (!xrSessionManager.currentFrame || !xrSessionManager.currentFrame.getViewerPose) {
             return false;
         }
-        var pose = xrSessionManager._currentXRFrame.getViewerPose(xrSessionManager._frameOfReference);
+        var pose = xrSessionManager.currentFrame.getViewerPose(xrSessionManager.referenceSpaceType);
         if (!pose || !pose.transform || !pose.transform.matrix) {
             return false;
         }
@@ -94,9 +94,9 @@ export class WebXRCamera extends FreeCamera {
             }
 
             // Update viewport
-            var viewport = xrSessionManager._xrSession.renderState.baseLayer.getViewport(view);
-            var width = xrSessionManager._xrSession.renderState.baseLayer.framebufferWidth;
-            var height = xrSessionManager._xrSession.renderState.baseLayer.framebufferHeight;
+            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;

src/Cameras/XR/webXREnterExitUI.ts

@@ -17,7 +17,7 @@ export class WebXREnterExitUIButton {
         public element: HTMLElement,
         /** XR initialization options for the button */
         public sessionMode: XRSessionMode,
-        public frameOfReference: XRReferenceSpaceType
+        public referenceSpaceType: XRReferenceSpaceType
     ) { }
     /**
      * Overwritable function which can be used to update the button's visuals when the state changes
@@ -66,7 +66,7 @@ export class WebXREnterExitUI implements IDisposable {
     public static CreateAsync(scene: Scene, helper: WebXRExperienceHelper, options: WebXREnterExitUIOptions): Promise<WebXREnterExitUI> {
         var ui = new WebXREnterExitUI(scene, options);
         var supportedPromises = ui._buttons.map((btn) => {
-            return helper.sessionManager.supportsSessionModeAsync(btn.sessionMode);
+            return helper.sessionManager.supportsSessionAsync(btn.sessionMode);
         });
         helper.onStateChangedObservable.add((state) => {
             if (state == WebXRState.NOT_IN_XR) {
@@ -85,7 +85,7 @@ export class WebXREnterExitUI implements IDisposable {
                         } else if (helper.state == WebXRState.NOT_IN_XR) {
                             ui._updateButtons(ui._buttons[i]);
                             if(options.webXRManagedOutputCanvas){
-                                await helper.enterXRAsync(ui._buttons[i].sessionMode, ui._buttons[i].frameOfReference, options.webXRManagedOutputCanvas);
+                                await helper.enterXRAsync(ui._buttons[i].sessionMode, ui._buttons[i].referenceSpaceType, options.webXRManagedOutputCanvas);
                             }
                         }
                     };

src/Cameras/XR/webXRExperienceHelper.ts

@@ -105,18 +105,18 @@ 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 frameOfReference frame of reference of the XR session
+     * @param referenceSpaceType frame of reference of the XR session
      * @returns promise that resolves after xr mode has entered
      */
-    public enterXRAsync(sessionCreationOptions: XRSessionMode, frameOfReference: XRReferenceSpaceType, outputCanvas: WebXRManagedOutputCanvas) {
+    public enterXRAsync(sessionCreationOptions: XRSessionMode, referenceSpaceType: 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(()=>{
-            return this.sessionManager.setReferenceSpaceAsync(frameOfReference)
+            return this.sessionManager.setReferenceSpaceAsync(referenceSpaceType)
         }).then(()=>{
-            return outputCanvas.initializeXRLayerAsync(this.sessionManager._xrSession);
+            return outputCanvas.initializeXRLayerAsync(this.sessionManager.session);
         }).then(()=>{
             return this.sessionManager.updateRenderStateAsync({baseLayer: outputCanvas.xrLayer})
         }).then(()=>{

src/Cameras/XR/webXRInput.ts

@@ -33,8 +33,8 @@ export class WebXRController {
         }
     }
 
-    updateFromXRFrame(xrFrame:XRFrame, xrFrameOfReference:XRReferenceSpaceType){
-        var pose = xrFrame.getPose(this.inputSource.targetRaySpace, xrFrameOfReference)
+    updateFromXRFrame(xrFrame:XRFrame, referenceSpaceType:XRReferenceSpaceType){
+        var pose = xrFrame.getPose(this.inputSource.targetRaySpace, referenceSpaceType)
         if(pose){
             Matrix.FromFloat32ArrayToRefScaled(pose.transform.matrix, 0, 1, this._tmpMatrix);
             if (!this.pointer.getScene().useRightHandedSystem) {
@@ -46,7 +46,7 @@ export class WebXRController {
             this._tmpMatrix.decompose(this.pointer.scaling, this.pointer.rotationQuaternion!, this.pointer.position);
         }
 
-        var pose = xrFrame.getPose(this.inputSource.gripSpace, xrFrameOfReference)
+        var pose = xrFrame.getPose(this.inputSource.gripSpace, referenceSpaceType)
         if(pose){
             Matrix.FromFloat32ArrayToRefScaled(pose.transform.matrix, 0, 1, this._tmpMatrix);
             if (!this.pointer.getScene().useRightHandedSystem) {
@@ -88,19 +88,19 @@ export class WebXRInput implements IDisposable {
      */
     public constructor(private helper: WebXRExperienceHelper) {
         this._frameObserver = helper.sessionManager.onXRFrameObservable.add(() => {
-            if (!helper.sessionManager._currentXRFrame) {
+            if (!helper.sessionManager.currentFrame) {
                 return;
             }
 
             // Start listing to input add/remove event
-            if(this.controllers.length == 0 && helper.sessionManager._xrSession.inputSources){
-                this._addAndRemoveControllers(helper.sessionManager._xrSession.inputSources, []);
-                helper.sessionManager._xrSession.addEventListener("inputsourceschange", this._onInputSourcesChange)
+            if(this.controllers.length == 0 && helper.sessionManager.session.inputSources){
+                this._addAndRemoveControllers(helper.sessionManager.session.inputSources, []);
+                helper.sessionManager.session.addEventListener("inputsourceschange", this._onInputSourcesChange)
             }
 
             // Update controller pose info
             this.controllers.forEach((controller)=>{
-                controller.updateFromXRFrame(helper.sessionManager._currentXRFrame!, helper.sessionManager._frameOfReference)
+                controller.updateFromXRFrame(helper.sessionManager.currentFrame!, helper.sessionManager.referenceSpaceType)
             })
 
         })

src/Cameras/XR/webXRSessionManager.ts

@@ -18,14 +18,23 @@ export class WebXRSessionManager implements IDisposable {
      */
     public onXRSessionEnded: Observable<any> = new Observable<any>();
 
-    /** @hidden */
-    public _xrSession: XRSession;
-    /** @hidden */
-    public _frameOfReference: XRReferenceSpaceType;
+    /** 
+     * Underlying xr session
+     */
+    public session: XRSession;
+
+    /**
+     * Type of reference space used when creating the session 
+     */
+    public referenceSpaceType: XRReferenceSpaceType;
+    
     /** @hidden */
     public _sessionRenderTargetTexture: Nullable<RenderTargetTexture> = null;
-    /** @hidden */
-    public _currentXRFrame: Nullable<XRFrame>;
+    
+    /**
+     * Current XR frame
+     */
+    public currentFrame: Nullable<XRFrame>;
     private _xrNavigator: any;
     private baseLayer:Nullable<XRWebGLLayer> = null;
 
@@ -54,10 +63,10 @@ export class WebXRSessionManager implements IDisposable {
 
     public initializeSessionAsync(xrSessionMode: XRSessionMode){
         return this._xrNavigator.xr.requestSession(xrSessionMode).then((session: XRSession) => {
-            this._xrSession = session;
+            this.session = session;
 
             // handle when the session is ended (By calling session.end or device ends its own session eg. pressing home button on phone)
-            this._xrSession.addEventListener("end", () => {
+            this.session.addEventListener("end", () => {
                 // Remove render target texture and notify frame obervers
                 this._sessionRenderTargetTexture = null;
 
@@ -73,8 +82,8 @@ export class WebXRSessionManager implements IDisposable {
     }
 
     public setReferenceSpaceAsync(referenceSpaceOptions: XRReferenceSpaceType){
-        return this._xrSession.requestReferenceSpace(referenceSpaceOptions).then((referenceSpace: any)=>{
-            this._frameOfReference = referenceSpace;
+        return this.session.requestReferenceSpace(referenceSpaceOptions).then((referenceSpace: any)=>{
+            this.referenceSpaceType = referenceSpace;
         })
     }
 
@@ -82,22 +91,22 @@ export class WebXRSessionManager implements IDisposable {
         if(state.baseLayer){
             this.baseLayer = state.baseLayer;
         }
-        return this._xrSession.updateRenderState(state);
+        return this.session.updateRenderState(state);
     }
 
     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._xrSession.requestAnimationFrame.bind(this._xrSession),
+            requestAnimationFrame: this.session.requestAnimationFrame.bind(this.session),
             renderFunction: (timestamp: number, xrFrame: Nullable<XRFrame>) => {
                 // Store the XR frame in the manager to be consumed by the XR camera to update pose
-                this._currentXRFrame = xrFrame;
+                this.currentFrame = xrFrame;
                 this.onXRFrameObservable.notifyObservers(null);
                 this.scene.getEngine()._renderLoop();
             }
         };
         // Create render target texture from xr's webgl render target
-        this._sessionRenderTargetTexture = WebXRSessionManager._CreateRenderTargetTextureFromSession(this._xrSession, this.scene, this.baseLayer!);
+        this._sessionRenderTargetTexture = WebXRSessionManager._CreateRenderTargetTextureFromSession(this.session, this.scene, this.baseLayer!);
 
         // Stop window's animation frame and trigger sessions animation frame
         window.cancelAnimationFrame(this.scene.getEngine()._frameHandler);
@@ -110,7 +119,7 @@ export class WebXRSessionManager implements IDisposable {
      * @returns Promise which resolves after it exits XR
      */
     public exitXRAsync() {
-        return this._xrSession.end();
+        return this.session.end();
     }
 
     /**
@@ -118,7 +127,7 @@ export class WebXRSessionManager implements IDisposable {
      * @param sessionMode session mode to check if supported eg. immersive-vr
      * @returns true if supported
      */
-    public supportsSessionModeAsync(sessionMode: XRSessionMode) {
+    public supportsSessionAsync(sessionMode: XRSessionMode) {
         if(!(navigator as any).xr || !(navigator as any).xr.supportsSession){
             return Promise.resolve(false);
         }else{