@kitware/vtk.js 28.13.1 → 29.1.0

package/Rendering/OpenGL/RenderWindow.js

@@ -8,16 +8,12 @@ import vtkTextureUnitManager from './TextureUnitManager.js';
 import vtkViewNodeFactory from './ViewNodeFactory.js';
 import vtkRenderPass from '../SceneGraph/RenderPass.js';
 import vtkRenderWindowViewNode from '../SceneGraph/RenderWindowViewNode.js';
-import Constants from './RenderWindow/Constants.js';
-import { createContextProxyHandler, GET_UNDERLYING_CONTEXT } from './RenderWindow/ContextProxy.js';
+import { createContextProxyHandler } from './RenderWindow/ContextProxy.js';
 
 const {
   vtkDebugMacro,
   vtkErrorMacro
 } = macro;
-const {
-  XrSessionTypes
-} = Constants;
 const SCREENSHOT_PLACEHOLDER = {
   position: 'absolute',
   top: 0,
@@ -25,12 +21,6 @@ const SCREENSHOT_PLACEHOLDER = {
   width: '100%',
   height: '100%'
 };
-const DEFAULT_RESET_FACTORS = {
-  rescaleFactor: 0.25,
-  // isotropic scale factor reduces apparent size of objects
-  translateZ: -1.5 // default translation initializes object in front of camera
-};
-
 function checkRenderTargetSupport(gl, format, type) {
   // create temporary frame buffer and texture
   const framebuffer = gl.createFramebuffer();
@@ -227,168 +217,6 @@ function vtkOpenGLRenderWindow(publicAPI, model) {
     }
     return new Proxy(result, cachingContextHandler);
   };
-
-  // Request an XR session on the user device with WebXR,
-  // typically in response to a user request such as a button press
-  publicAPI.startXR = xrSessionType => {
-    if (navigator.xr === undefined) {
-      throw new Error('WebXR is not available');
-    }
-    model.xrSessionType = xrSessionType !== undefined ? xrSessionType : XrSessionTypes.HmdVR;
-    const isXrSessionAR = [XrSessionTypes.HmdAR, XrSessionTypes.MobileAR].includes(model.xrSessionType);
-    const sessionType = isXrSessionAR ? 'immersive-ar' : 'immersive-vr';
-    if (!navigator.xr.isSessionSupported(sessionType)) {
-      if (isXrSessionAR) {
-        throw new Error('Device does not support AR session');
-      } else {
-        throw new Error('VR display is not available');
-      }
-    }
-    if (model.xrSession === null) {
-      navigator.xr.requestSession(sessionType).then(publicAPI.enterXR, () => {
-        throw new Error('Failed to create XR session!');
-      });
-    } else {
-      throw new Error('XR Session already exists!');
-    }
-  };
-
-  // When an XR session is available, set up the XRWebGLLayer
-  // and request the first animation frame for the device
-  publicAPI.enterXR = async xrSession => {
-    model.xrSession = xrSession;
-    model.oldCanvasSize = model.size.slice();
-    if (model.xrSession !== null) {
-      const gl = publicAPI.get3DContext();
-      await gl.makeXRCompatible();
-      const glLayer = new global.XRWebGLLayer(model.xrSession,
-      // constructor needs unproxied context
-      gl[GET_UNDERLYING_CONTEXT]());
-      publicAPI.setSize(glLayer.framebufferWidth, glLayer.framebufferHeight);
-      model.xrSession.updateRenderState({
-        baseLayer: glLayer
-      });
-      model.xrSession.requestReferenceSpace('local').then(refSpace => {
-        model.xrReferenceSpace = refSpace;
-      });
-
-      // Initialize transparent background for augmented reality session
-      const isXrSessionAR = [XrSessionTypes.HmdAR, XrSessionTypes.MobileAR].includes(model.xrSessionType);
-      if (isXrSessionAR) {
-        const ren = model.renderable.getRenderers()[0];
-        model.preXrSessionBackground = ren.getBackground();
-        ren.setBackground([0, 0, 0, 0]);
-      }
-      publicAPI.resetXRScene();
-      model.renderable.getInteractor().switchToXRAnimation();
-      model.xrSceneFrame = model.xrSession.requestAnimationFrame(publicAPI.xrRender);
-    } else {
-      throw new Error('Failed to enter XR with a null xrSession.');
-    }
-  };
-  publicAPI.resetXRScene = function () {
-    let rescaleFactor = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : DEFAULT_RESET_FACTORS.rescaleFactor;
-    let translateZ = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : DEFAULT_RESET_FACTORS.translateZ;
-    // Adjust world-to-physical parameters for different modalities
-
-    const ren = model.renderable.getRenderers()[0];
-    ren.resetCamera();
-    const camera = ren.getActiveCamera();
-    let physicalScale = camera.getPhysicalScale();
-    const physicalTranslation = camera.getPhysicalTranslation();
-    const rescaledTranslateZ = translateZ * physicalScale;
-    physicalScale /= rescaleFactor;
-    physicalTranslation[2] += rescaledTranslateZ;
-    camera.setPhysicalScale(physicalScale);
-    camera.setPhysicalTranslation(physicalTranslation);
-    // Clip at 0.1m, 100.0m in physical space by default
-    camera.setClippingRange(0.1 * physicalScale, 100.0 * physicalScale);
-  };
-  publicAPI.stopXR = async () => {
-    if (navigator.xr === undefined) {
-      // WebXR polyfill not available so nothing to do
-      return;
-    }
-    if (model.xrSession !== null) {
-      model.xrSession.cancelAnimationFrame(model.xrSceneFrame);
-      model.renderable.getInteractor().returnFromXRAnimation();
-      const gl = publicAPI.get3DContext();
-      gl.bindFramebuffer(gl.FRAMEBUFFER, null);
-      await model.xrSession.end().catch(error => {
-        if (!(error instanceof DOMException)) {
-          throw error;
-        }
-      });
-      model.xrSession = null;
-    }
-    if (model.oldCanvasSize !== undefined) {
-      publicAPI.setSize(...model.oldCanvasSize);
-    }
-
-    // Reset to default canvas
-    const ren = model.renderable.getRenderers()[0];
-    if (model.preXrSessionBackground != null) {
-      ren.setBackground(model.preXrSessionBackground);
-      model.preXrSessionBackground = null;
-    }
-    ren.getActiveCamera().setProjectionMatrix(null);
-    ren.resetCamera();
-    ren.setViewport(0.0, 0, 1.0, 1.0);
-    publicAPI.traverseAllPasses();
-  };
-  publicAPI.xrRender = async (t, frame) => {
-    const xrSession = frame.session;
-    const isXrSessionHMD = [XrSessionTypes.HmdVR, XrSessionTypes.HmdAR].includes(model.xrSessionType);
-    model.renderable.getInteractor().updateXRGamepads(xrSession, frame, model.xrReferenceSpace);
-    model.xrSceneFrame = model.xrSession.requestAnimationFrame(publicAPI.xrRender);
-    const xrPose = frame.getViewerPose(model.xrReferenceSpace);
-    if (xrPose) {
-      const gl = publicAPI.get3DContext();
-      if (model.xrSessionType === XrSessionTypes.MobileAR && model.oldCanvasSize !== undefined) {
-        gl.canvas.width = model.oldCanvasSize[0];
-        gl.canvas.height = model.oldCanvasSize[1];
-      }
-      const glLayer = xrSession.renderState.baseLayer;
-      gl.bindFramebuffer(gl.FRAMEBUFFER, glLayer.framebuffer);
-      gl.clear(gl.COLOR_BUFFER_BIT);
-      gl.clear(gl.DEPTH_BUFFER_BIT);
-      publicAPI.setSize(glLayer.framebufferWidth, glLayer.framebufferHeight);
-
-      // get the first renderer
-      const ren = model.renderable.getRenderers()[0];
-
-      // Do a render pass for each eye
-      xrPose.views.forEach((view, index) => {
-        const viewport = glLayer.getViewport(view);
-        if (isXrSessionHMD) {
-          if (view.eye === 'left') {
-            ren.setViewport(0, 0, 0.5, 1.0);
-          } else if (view.eye === 'right') {
-            ren.setViewport(0.5, 0, 1.0, 1.0);
-          } else {
-            // No handling for non-eye viewport
-            return;
-          }
-        } else if (model.xrSessionType === XrSessionTypes.LookingGlassVR) {
-          const startX = viewport.x / glLayer.framebufferWidth;
-          const startY = viewport.y / glLayer.framebufferHeight;
-          const endX = (viewport.x + viewport.width) / glLayer.framebufferWidth;
-          const endY = (viewport.y + viewport.height) / glLayer.framebufferHeight;
-          ren.setViewport(startX, startY, endX, endY);
-        } else {
-          ren.setViewport(0, 0, 1, 1);
-        }
-        ren.getActiveCamera().computeViewParametersFromPhysicalMatrix(view.transform.inverse.matrix);
-        ren.getActiveCamera().setProjectionMatrix(view.projectionMatrix);
-        publicAPI.traverseAllPasses();
-      });
-
-      // Reset scissorbox before any subsequent rendering to external displays
-      // on frame end, such as rendering to a Looking Glass display.
-      gl.scissor(0, 0, glLayer.framebufferWidth, glLayer.framebufferHeight);
-      gl.disable(gl.SCISSOR_TEST);
-    }
-  };
   publicAPI.restoreContext = () => {
     const rp = vtkRenderPass.newInstance();
     rp.setCurrentOperation('Release');
@@ -855,9 +683,6 @@ const DEFAULT_VALUES = {
   defaultToWebgl2: true,
   // attempt webgl2 on by default
   activeFramebuffer: null,
-  xrSession: null,
-  xrReferenceSpace: null,
-  xrSupported: true,
   imageFormat: 'image/png',
   useOffScreen: false,
   useBackgroundImage: false
@@ -906,7 +731,7 @@ function extend(publicAPI, model) {
   macro.event(publicAPI, model, 'imageReady');
 
   // Build VTK API
-  macro.get(publicAPI, model, ['shaderCache', 'textureUnitManager', 'webgl2', 'vrDisplay', 'useBackgroundImage', 'xrSupported', 'activeFramebuffer']);
+  macro.get(publicAPI, model, ['shaderCache', 'textureUnitManager', 'webgl2', 'useBackgroundImage', 'activeFramebuffer']);
   macro.setGet(publicAPI, model, ['initialized', 'context', 'canvas', 'renderPasses', 'notifyStartCaptureImage', 'defaultToWebgl2', 'cursor', 'useOffScreen']);
   macro.setGetArray(publicAPI, model, ['size'], 2);
   macro.event(publicAPI, model, 'windowResizeEvent');

package/Rendering/OpenGL/Texture.js

@@ -2,7 +2,7 @@ import Constants from './Texture/Constants.js';
 import HalfFloat from '../../Common/Core/HalfFloat.js';
 import { n as newInstance$1, o as obj, s as set, e as setGet, g as get, i as moveToProtected, a as newTypedArray, c as macro } from '../../macros2.js';
 import vtkDataArray from '../../Common/Core/DataArray.js';
-import { R as isPowerOfTwo, N as nearestPowerOfTwo } from '../../Common/Core/Math/index.js';
+import { S as isPowerOfTwo, O as nearestPowerOfTwo } from '../../Common/Core/Math/index.js';
 import vtkViewNode from '../SceneGraph/ViewNode.js';
 import { registerOverride } from './ViewNodeFactory.js';
 

package/Rendering/OpenGL/VolumeMapper.js

@@ -175,8 +175,8 @@ function vtkOpenGLVolumeMapper(publicAPI, model) {
 
     // if we have a ztexture then declare it and use it
     if (model.zBufferTexture !== null) {
-      FSSource = vtkShaderProgram.substitute(FSSource, '//VTK::ZBuffer::Dec', ['uniform sampler2D zBufferTexture;', 'uniform float vpWidth;', 'uniform float vpHeight;']).result;
-      FSSource = vtkShaderProgram.substitute(FSSource, '//VTK::ZBuffer::Impl', ['vec4 depthVec = texture2D(zBufferTexture, vec2(gl_FragCoord.x / vpWidth, gl_FragCoord.y/vpHeight));', 'float zdepth = (depthVec.r*256.0 + depthVec.g)/257.0;', 'zdepth = zdepth * 2.0 - 1.0;', 'if (cameraParallel == 0) {', 'zdepth = -2.0 * camFar * camNear / (zdepth*(camFar-camNear)-(camFar+camNear)) - camNear;}', 'else {', 'zdepth = (zdepth + 1.0) * 0.5 * (camFar - camNear);}\n', 'zdepth = -zdepth/rayDir.z;', 'dists.y = min(zdepth,dists.y);']).result;
+      FSSource = vtkShaderProgram.substitute(FSSource, '//VTK::ZBuffer::Dec', ['uniform sampler2D zBufferTexture;', 'uniform float vpZWidth;', 'uniform float vpZHeight;']).result;
+      FSSource = vtkShaderProgram.substitute(FSSource, '//VTK::ZBuffer::Impl', ['vec4 depthVec = texture2D(zBufferTexture, vec2(gl_FragCoord.x / vpZWidth, gl_FragCoord.y/vpZHeight));', 'float zdepth = (depthVec.r*256.0 + depthVec.g)/257.0;', 'zdepth = zdepth * 2.0 - 1.0;', 'if (cameraParallel == 0) {', 'zdepth = -2.0 * camFar * camNear / (zdepth*(camFar-camNear)-(camFar+camNear)) - camNear;}', 'else {', 'zdepth = (zdepth + 1.0) * 0.5 * (camFar - camNear);}\n', 'zdepth = -zdepth/rayDir.z;', 'dists.y = min(zdepth,dists.y);']).result;
     }
 
     // Set the BlendMode approach
@@ -362,8 +362,8 @@ function vtkOpenGLVolumeMapper(publicAPI, model) {
     if (model.zBufferTexture !== null) {
       program.setUniformi('zBufferTexture', model.zBufferTexture.getTextureUnit());
       const size = model._useSmallViewport ? [model._smallViewportWidth, model._smallViewportHeight] : model._openGLRenderWindow.getFramebufferSize();
-      program.setUniformf('vpWidth', size[0]);
-      program.setUniformf('vpHeight', size[1]);
+      program.setUniformf('vpZWidth', size[0]);
+      program.setUniformf('vpZHeight', size[1]);
     }
   };
   publicAPI.setCameraShaderParameters = (cellBO, ren, actor) => {

package/Rendering/WebGPU/RenderWindow.js

@@ -490,6 +490,17 @@ function vtkWebGPURenderWindow(publicAPI, model) {
     ret.setWebGPURenderWindow(publicAPI);
     return ret;
   };
+  const superSetSize = publicAPI.setSize;
+  publicAPI.setSize = (width, height) => {
+    const modified = superSetSize(width, height);
+    if (modified) {
+      publicAPI.invokeWindowResizeEvent({
+        width,
+        height
+      });
+    }
+    return modified;
+  };
   publicAPI.delete = macro.chain(publicAPI.delete, publicAPI.setViewStream);
 }
 
@@ -555,6 +566,7 @@ function extend(publicAPI, model) {
   macro.get(publicAPI, model, ['commandEncoder', 'device', 'presentationFormat', 'useBackgroundImage', 'xrSupported']);
   macro.setGet(publicAPI, model, ['initialized', 'context', 'canvas', 'device', 'renderPasses', 'notifyStartCaptureImage', 'cursor', 'useOffScreen']);
   macro.setGetArray(publicAPI, model, ['size'], 2);
+  macro.event(publicAPI, model, 'windowResizeEvent');
 
   // Object methods
   vtkWebGPURenderWindow(publicAPI, model);

package/Rendering/{OpenGL/RenderWindow → WebXR/RenderWindowHelper}/Constants.d.ts

@@ -1,7 +1,8 @@
 export declare enum XrSessionTypes {
 	HmdVR = 0,
 	MobileAR = 1,
-  LookingGlassVR = 2
+  	LookingGlassVR = 2,
+	HmdAR = 3
 }
 
 declare const _default: {

package/Rendering/WebXR/RenderWindowHelper.d.ts

@@ -0,0 +1,90 @@
+import { vtkObject } from './../../interfaces';
+import { Nullable } from './../../types';
+import vtkOpenGLRenderWindow from './../OpenGL/RenderWindow';
+
+/**
+ *
+ */
+export interface IWebXRRenderWindowHelperInitialValues {
+    initialized: boolean,
+    initCanvasSize?: [number, number],
+    initBackground?: [number, number, number, number],
+    renderWindow?: Nullable<vtkOpenGLRenderWindow>,
+    xrSession?: Nullable<XRSession>,
+    xrSessionType: number,
+    xrReferenceSpace?: any,
+}
+
+export interface vtkWebXRRenderWindowHelper extends vtkObject {
+
+	/**
+     * Initialize the instance.
+	 */
+	initialize(): void;
+
+	/**
+	 * Request an XR session on the user device with WebXR,
+     * typically in response to a user request such as a button press.
+	 */
+	startXR(xrSessionType: Number): void;
+
+    /**
+     * When an XR session is available, set up the XRWebGLLayer
+     * and request the first animation frame for the device
+     */
+    enterXR(): void;
+
+    /**
+     * Adjust world-to-physical parameters for different viewing modalities
+     *
+     * @param {Number} inputRescaleFactor
+     * @param {Number} inputTranslateZ
+     */
+    resetXRScene(inputRescaleFactor: number, inputTranslateZ: number): void;
+
+	/**
+	 * Request to stop the current XR session
+	 */
+	stopXR(): void;
+
+    /**
+     * Get the underlying render window to drive XR rendering.
+     */
+    getRenderWindow(): Nullable<vtkOpenGLRenderWindow>;
+
+    /**
+     * Set the underlying render window to drive XR rendering.
+     */
+    setRenderWindow(renderWindow:Nullable<vtkOpenGLRenderWindow>);
+
+    /**
+     * Get the active WebXR session.
+     */
+    getXrSession(): Nullable<XRSession>;
+}
+
+/**
+ * Method used to decorate a given object (publicAPI+model) with vtkWebXRRenderWindowHelper characteristics.
+ *
+ * @param publicAPI object on which methods will be bounds (public)
+ * @param model object on which data structure will be bounds (protected)
+ * @param {IWebXRRenderWindowHelperInitialValues} [initialValues] (default: {})
+ */
+export function extend(publicAPI: object, model: object, initialValues?: IWebXRRenderWindowHelperInitialValues): void;
+
+/**
+ * Method used to create a new instance of vtkWebXRRenderWindowHelper.
+ * @param {IWebXRRenderWindowHelperInitialValues} [initialValues] for pre-setting some of its content
+ */
+export function newInstance(initialValues?: IWebXRRenderWindowHelperInitialValues): vtkWebXRRenderWindowHelper;
+
+/**
+ * WebXR rendering helper
+ *
+ * vtkWebXRRenderWindowHelper is designed to wrap a vtkRenderWindow for XR rendering.
+ */
+export declare const vtkWebXRRenderWindowHelper: {
+	newInstance: typeof newInstance,
+	extend: typeof extend,
+};
+export default vtkWebXRRenderWindowHelper;

package/Rendering/WebXR/RenderWindowHelper.js

@@ -0,0 +1,242 @@
+import { m as macro } from '../../macros2.js';
+import Constants from './RenderWindowHelper/Constants.js';
+import { GET_UNDERLYING_CONTEXT } from '../OpenGL/RenderWindow/ContextProxy.js';
+
+const {
+  XrSessionTypes
+} = Constants;
+const DEFAULT_RESET_FACTORS = {
+  rescaleFactor: 0.25,
+  // isotropic scale factor reduces apparent size of objects
+  translateZ: -1.5 // default translation initializes object in front of camera
+};
+
+// ----------------------------------------------------------------------------
+// vtkWebXRRenderWindowHelper methods
+// ----------------------------------------------------------------------------
+
+function vtkWebXRRenderWindowHelper(publicAPI, model) {
+  // Set our className
+  model.classHierarchy.push('vtkWebXRRenderWindowHelper');
+  publicAPI.initialize = renderWindow => {
+    if (!model.initialized) {
+      model.renderWindow = renderWindow;
+      model.initialized = true;
+    }
+  };
+  publicAPI.getXrSupported = () => navigator.xr !== undefined;
+
+  // Request an XR session on the user device with WebXR,
+  // typically in response to a user request such as a button press
+  publicAPI.startXR = xrSessionType => {
+    if (navigator.xr === undefined) {
+      throw new Error('WebXR is not available');
+    }
+    model.xrSessionType = xrSessionType !== undefined ? xrSessionType : XrSessionTypes.HmdVR;
+    const isXrSessionAR = [XrSessionTypes.HmdAR, XrSessionTypes.MobileAR].includes(model.xrSessionType);
+    const sessionType = isXrSessionAR ? 'immersive-ar' : 'immersive-vr';
+    if (!navigator.xr.isSessionSupported(sessionType)) {
+      if (isXrSessionAR) {
+        throw new Error('Device does not support AR session');
+      } else {
+        throw new Error('VR display is not available');
+      }
+    }
+    if (model.xrSession === null) {
+      navigator.xr.requestSession(sessionType).then(publicAPI.enterXR, () => {
+        throw new Error('Failed to create XR session!');
+      });
+    } else {
+      throw new Error('XR Session already exists!');
+    }
+  };
+
+  // When an XR session is available, set up the XRWebGLLayer
+  // and request the first animation frame for the device
+  publicAPI.enterXR = async xrSession => {
+    model.xrSession = xrSession;
+    model.initCanvasSize = model.renderWindow.getSize();
+    if (model.xrSession !== null) {
+      const gl = model.renderWindow.get3DContext();
+      await gl.makeXRCompatible();
+
+      // XRWebGLLayer definition is deferred to here to give any WebXR polyfill
+      // an opportunity to override this definition.
+      const {
+        XRWebGLLayer
+      } = window;
+      const glLayer = new XRWebGLLayer(model.xrSession,
+      // constructor needs unproxied context
+      gl[GET_UNDERLYING_CONTEXT]());
+      model.renderWindow.setSize(glLayer.framebufferWidth, glLayer.framebufferHeight);
+      model.xrSession.updateRenderState({
+        baseLayer: glLayer
+      });
+      model.xrSession.requestReferenceSpace('local').then(refSpace => {
+        model.xrReferenceSpace = refSpace;
+      });
+
+      // Initialize transparent background for augmented reality session
+      const isXrSessionAR = [XrSessionTypes.HmdAR, XrSessionTypes.MobileAR].includes(model.xrSessionType);
+      if (isXrSessionAR) {
+        const ren = model.renderWindow.getRenderable().getRenderers()[0];
+        model.initBackground = ren.getBackground();
+        ren.setBackground([0, 0, 0, 0]);
+      }
+      publicAPI.resetXRScene();
+      model.renderWindow.getRenderable().getInteractor().switchToXRAnimation();
+      model.xrSceneFrame = model.xrSession.requestAnimationFrame(model.xrRender);
+      publicAPI.modified();
+    } else {
+      throw new Error('Failed to enter XR with a null xrSession.');
+    }
+  };
+  publicAPI.resetXRScene = function () {
+    let rescaleFactor = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : DEFAULT_RESET_FACTORS.rescaleFactor;
+    let translateZ = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : DEFAULT_RESET_FACTORS.translateZ;
+    // Adjust world-to-physical parameters for different modalities
+
+    const ren = model.renderWindow.getRenderable().getRenderers()[0];
+    ren.resetCamera();
+    const camera = ren.getActiveCamera();
+    let physicalScale = camera.getPhysicalScale();
+    const physicalTranslation = camera.getPhysicalTranslation();
+    const rescaledTranslateZ = translateZ * physicalScale;
+    physicalScale /= rescaleFactor;
+    physicalTranslation[2] += rescaledTranslateZ;
+    camera.setPhysicalScale(physicalScale);
+    camera.setPhysicalTranslation(physicalTranslation);
+    // Clip at 0.1m, 100.0m in physical space by default
+    camera.setClippingRange(0.1 * physicalScale, 100.0 * physicalScale);
+  };
+  publicAPI.stopXR = async () => {
+    if (navigator.xr === undefined) {
+      // WebXR polyfill not available so nothing to do
+      return;
+    }
+    if (model.xrSession !== null) {
+      model.xrSession.cancelAnimationFrame(model.xrSceneFrame);
+      model.renderWindow.getRenderable().getInteractor().returnFromXRAnimation();
+      const gl = model.renderWindow.get3DContext();
+      gl.bindFramebuffer(gl.FRAMEBUFFER, null);
+      await model.xrSession.end().catch(error => {
+        if (!(error instanceof DOMException)) {
+          throw error;
+        }
+      });
+      model.xrSession = null;
+    }
+    if (model.initCanvasSize !== null) {
+      model.renderWindow.setSize(...model.initCanvasSize);
+    }
+
+    // Reset to default canvas
+    const ren = model.renderWindow.getRenderable().getRenderers()[0];
+    if (model.initBackground != null) {
+      ren.setBackground(model.initBackground);
+      model.initBackground = null;
+    }
+    ren.getActiveCamera().setProjectionMatrix(null);
+    ren.resetCamera();
+    ren.setViewport(0.0, 0, 1.0, 1.0);
+    model.renderWindow.traverseAllPasses();
+    publicAPI.modified();
+  };
+  model.xrRender = async (t, frame) => {
+    const xrSession = frame.session;
+    const isXrSessionHMD = [XrSessionTypes.HmdVR, XrSessionTypes.HmdAR].includes(model.xrSessionType);
+    model.renderWindow.getRenderable().getInteractor().updateXRGamepads(xrSession, frame, model.xrReferenceSpace);
+    model.xrSceneFrame = model.xrSession.requestAnimationFrame(model.xrRender);
+    const xrPose = frame.getViewerPose(model.xrReferenceSpace);
+    if (xrPose) {
+      const gl = model.renderWindow.get3DContext();
+      if (model.xrSessionType === XrSessionTypes.MobileAR && model.initCanvasSize !== null) {
+        gl.canvas.width = model.initCanvasSize[0];
+        gl.canvas.height = model.initCanvasSize[1];
+      }
+      const glLayer = xrSession.renderState.baseLayer;
+      gl.bindFramebuffer(gl.FRAMEBUFFER, glLayer.framebuffer);
+      gl.clear(gl.COLOR_BUFFER_BIT);
+      gl.clear(gl.DEPTH_BUFFER_BIT);
+      model.renderWindow.setSize(glLayer.framebufferWidth, glLayer.framebufferHeight);
+
+      // get the first renderer
+      const ren = model.renderWindow.getRenderable().getRenderers()[0];
+
+      // Do a render pass for each eye
+      xrPose.views.forEach((view, index) => {
+        const viewport = glLayer.getViewport(view);
+        if (isXrSessionHMD) {
+          if (view.eye === 'left') {
+            ren.setViewport(0, 0, 0.5, 1.0);
+          } else if (view.eye === 'right') {
+            ren.setViewport(0.5, 0, 1.0, 1.0);
+          } else {
+            // No handling for non-eye viewport
+            return;
+          }
+        } else if (model.xrSessionType === XrSessionTypes.LookingGlassVR) {
+          const startX = viewport.x / glLayer.framebufferWidth;
+          const startY = viewport.y / glLayer.framebufferHeight;
+          const endX = (viewport.x + viewport.width) / glLayer.framebufferWidth;
+          const endY = (viewport.y + viewport.height) / glLayer.framebufferHeight;
+          ren.setViewport(startX, startY, endX, endY);
+        } else {
+          ren.setViewport(0, 0, 1, 1);
+        }
+        ren.getActiveCamera().computeViewParametersFromPhysicalMatrix(view.transform.inverse.matrix);
+        ren.getActiveCamera().setProjectionMatrix(view.projectionMatrix);
+        model.renderWindow.traverseAllPasses();
+      });
+
+      // Reset scissorbox before any subsequent rendering to external displays
+      // on frame end, such as rendering to a Looking Glass display.
+      gl.scissor(0, 0, glLayer.framebufferWidth, glLayer.framebufferHeight);
+      gl.disable(gl.SCISSOR_TEST);
+    }
+  };
+  publicAPI.delete = macro.chain(publicAPI.delete);
+}
+
+// ----------------------------------------------------------------------------
+// Object factory
+// ----------------------------------------------------------------------------
+
+const DEFAULT_VALUES = {
+  initialized: false,
+  initCanvasSize: null,
+  initBackground: null,
+  renderWindow: null,
+  xrSession: null,
+  xrSessionType: 0,
+  xrReferenceSpace: null
+};
+
+// ----------------------------------------------------------------------------
+
+function extend(publicAPI, model) {
+  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  Object.assign(model, DEFAULT_VALUES, initialValues);
+
+  // Build VTK API
+  macro.obj(publicAPI, model);
+  macro.event(publicAPI, model, 'event');
+  macro.get(publicAPI, model, ['xrSession']);
+  macro.setGet(publicAPI, model, ['renderWindow']);
+
+  // Object methods
+  vtkWebXRRenderWindowHelper(publicAPI, model);
+}
+
+// ----------------------------------------------------------------------------
+
+const newInstance = macro.newInstance(extend, 'vtkWebXRRenderWindowHelper');
+
+// ----------------------------------------------------------------------------
+
+var index = {
+  newInstance,
+  extend
+};
+
+export { index as default, extend, newInstance };

package/Widgets/Core/WidgetManager.d.ts

@@ -99,16 +99,6 @@ export interface vtkWidgetManager extends vtkObject {
    */
   getPickingEnabled(): boolean;
 
-  /**
-   * @deprecated
-   */
-  getUseSvgLayer(): boolean;
-
-  /**
-   * @deprecated
-   */
-  setUseSvgLayer(use: boolean): boolean;
-
   /**
    * Enable the picking.
    */
@@ -165,16 +155,6 @@ export interface vtkWidgetManager extends vtkObject {
    */
   getSelectedDataForXY(x: number, y: number): Promise<ISelectedData>;
 
-  /**
-   * @deprecated
-   */
-  updateSelectionFromXY(x: number, y: number): void;
-
-  /**
-   * @deprecated
-   */
-  updateSelectionFromMouseEvent(event: MouseEvent): void;
-
   /**
    * The all currently selected data.
    */
@@ -197,10 +177,6 @@ export interface IWidgetManagerInitialValues {
   captureOn?: CaptureOn;
   viewType?: ViewTypes;
   pickingEnabled?: boolean;
-  /**
-   * @deprecated
-   */
-  useSvgLayer?: boolean;
 }
 
 /**