@kitware/vtk.js 28.13.1 → 29.0.0

package/BREAKING_CHANGES.md

@@ -1,3 +1,10 @@
+## From 28.x to 29
+
+- **getOpenGLRenderWindow**: `getOpenGLRenderWindow` has been renamed to `getApiSpecificRenderWindow` in `vtkFullScreenRenderWindow`, `vtkGenericRenderWindow` and `vtkViewProxy` to support WebGL and WebGPU backend. ([#2816](https://github.com/Kitware/vtk-js/pull/2816))
+- **WidgetManager**: Deprecated APIs have been fully removed. ([#2910](https://github.com/Kitware/vtk-js/pull/2910))
+- **OpenGLRenderWindow**: WebXR API has been moved into a WebXR RenderWindowHelper. ([#2924](https://github.com/Kitware/vtk-js/pull/2924))
+- **DistanceWidget**: Removed from vtk.js in favor of vtkLineWidget ([#2945](https://github.com/Kitware/vtk-js/pull/2945))
+
 ## From 27.x to 28
 
 - **vtkManipulator.handleEvent**: Change all `handleEvent` signatures of manipulators. Used to be `handleEvent(callData, glRenderWindow): vec3`, it is now `handleEvent(callData, glRenderWindow): { worldCoords: Nullable<vec3>, worldDirection?: mat3 }`.

package/Proxy/Core/ViewProxy.d.ts

@@ -8,6 +8,7 @@ import { vtkSubscription, vtkObject } from './../../interfaces';
 import vtkRenderer from './../../Rendering/Core/Renderer';
 import vtkRenderWindow from './../../Rendering/Core/RenderWindow';
 import vtkOpenGLRenderWindow from './../../Rendering/OpenGL/RenderWindow';
+import vtkWebGPURenderWindow from './../../Rendering/WebGPU/RenderWindow';
 import { VtkProxy } from './../../macros';
 
 export interface vtkViewProxy extends VtkProxy {
@@ -66,7 +67,7 @@ export interface vtkViewProxy extends VtkProxy {
   getInteractor(): vtkRenderWindowInteractor;
   getInteractorStyle2D(): vtkInteractorStyle;
   getInteractorStyle3D(): vtkInteractorStyle;
-  getOpenGLRenderWindow(): vtkOpenGLRenderWindow;
+  getApiSpecificRenderWindow(): vtkOpenGLRenderWindow|vtkWebGPURenderWindow;
   getOrientationAxesType(): string;
   getPresetToOrientationAxes(): any;
   getRenderer(): vtkRenderer;

package/Rendering/Core/RenderWindow.d.ts

@@ -148,6 +148,7 @@ export interface vtkRenderWindow extends vtkObject {
 	 * Switch the rendering backend between WebGL and WebGPU.
 	 * By default, the WebGL backend is used. To switch, to WebGPU call
 	 * `renderWindow.setDefaultViewAPI('WebGPU')` before calling `render`.
+	 * Must be called before `newAPISpecificView()` is called.
 	 * @param defaultViewAPI (default: 'WebGL')
 	 */
 	setDefaultViewAPI(defaultViewAPI: DEFAULT_VIEW_API): boolean;

package/Rendering/Misc/FullScreenRenderWindow.d.ts

@@ -17,6 +17,7 @@ export interface IFullScreenRenderWindowInitialValues {
 	containerStyle?: object;
 	controlPanelStyle?: object;
 	controllerVisibility?: boolean;
+	defaultViewAPI?: boolean;
 	listenWindowResize?: boolean;
 	resizeCallback?: any;
 }
@@ -42,7 +43,9 @@ export interface vtkFullScreenRenderWindow extends vtkObject {
 	delete(): void;
 
 	/**
-	 * 
+	 * Returns vtkWebGPURenderWindow if ?viewAPI='WebGPU' is in URL, or if
+	 * vtkFullScreenRenderWindow has been created with "defaultViewAPI: 'WebGPU",
+	 * otherwise vtkOpenGLRenderWindow is returned.
 	 */
 	getApiSpecificRenderWindow(): any; // vtkOpenGLRenderWindow || vtkWebGPURenderWindow
 

package/Rendering/Misc/FullScreenRenderWindow.js

@@ -72,7 +72,7 @@ function vtkFullScreenRenderWindow(publicAPI, model) {
   model.renderWindow.addRenderer(model.renderer);
 
   // apiSpecificRenderWindow
-  model.apiSpecificRenderWindow = model.renderWindow.newAPISpecificView(userParams.viewAPI);
+  model.apiSpecificRenderWindow = model.renderWindow.newAPISpecificView(userParams.viewAPI ?? model.defaultViewAPI);
   model.apiSpecificRenderWindow.setContainer(model.container);
   model.renderWindow.addView(model.apiSpecificRenderWindow);
 
@@ -161,6 +161,7 @@ const DEFAULT_VALUES = {
   background: [0.32, 0.34, 0.43],
   containerStyle: null,
   controlPanelStyle: null,
+  // defaultViewAPI: undefined,
   listenWindowResize: true,
   resizeCallback: null,
   controllerVisibility: true

package/Rendering/Misc/GenericRenderWindow.d.ts

@@ -4,6 +4,7 @@ import vtkRenderer from './../Core/Renderer';
 import vtkRenderWindow from './../Core/RenderWindow';
 import vtkRenderWindowInteractor from './../Core/RenderWindowInteractor';
 import vtkOpenGLRenderWindow from './../OpenGL/RenderWindow';
+import vtkWebGPURenderWindow from './../WebGPU/RenderWindow';
 
 
 /**
@@ -33,9 +34,9 @@ export interface vtkGenericRenderWindow extends vtkObject {
 	getInteractor(): vtkRenderWindowInteractor;
 
 	/**
-	 * 
+	 * Get the render back-end specific render window.
 	 */
-	getOpenGLRenderWindow(): vtkOpenGLRenderWindow;
+	getApiSpecificRenderWindow(): vtkOpenGLRenderWindow|vtkWebGPURenderWindow;
 
 	/**
 	 * 

package/Rendering/Misc/GenericRenderWindow.js

@@ -1,15 +1,17 @@
 import { m as macro } from '../../macros2.js';
-import vtkRenderWindow$1 from '../OpenGL/RenderWindow.js';
 import vtkRenderer from '../Core/Renderer.js';
 import vtkRenderWindow from '../Core/RenderWindow.js';
 import vtkRenderWindowInteractor from '../Core/RenderWindowInteractor.js';
 import vtkInteractorStyleTrackballCamera from '../../Interaction/Style/InteractorStyleTrackballCamera.js';
+import vtkURLExtract from '../../Common/Core/URLExtract.js';
 import '../../Common/Core/Points.js';
 import '../../Common/Core/DataArray.js';
 import '../../Common/DataModel/PolyData.js';
 import '../Core/Actor.js';
 import '../Core/Mapper.js';
 
+// Process arguments from URL
+const userParams = vtkURLExtract.extractURLParameters();
 function vtkGenericRenderWindow(publicAPI, model) {
   // Capture resize trigger method to remove from publicAPI
   const invokeResize = publicAPI.invokeResize;
@@ -21,13 +23,13 @@ function vtkGenericRenderWindow(publicAPI, model) {
   model.renderWindow.addRenderer(model.renderer);
 
   // OpenGLRenderWindow
-  model._openGLRenderWindow = vtkRenderWindow$1.newInstance();
-  model.renderWindow.addView(model._openGLRenderWindow);
+  model._apiSpecificRenderWindow = model.renderWindow.newAPISpecificView(userParams.viewAPI ?? model.defaultViewAPI);
+  model.renderWindow.addView(model._apiSpecificRenderWindow);
 
   // Interactor
   model.interactor = vtkRenderWindowInteractor.newInstance();
   model.interactor.setInteractorStyle(vtkInteractorStyleTrackballCamera.newInstance());
-  model.interactor.setView(model._openGLRenderWindow);
+  model.interactor.setView(model._apiSpecificRenderWindow);
   model.interactor.initialize();
 
   // Expose background
@@ -41,7 +43,7 @@ function vtkGenericRenderWindow(publicAPI, model) {
     if (model.container) {
       const dims = model.container.getBoundingClientRect();
       const devicePixelRatio = window.devicePixelRatio || 1;
-      model._openGLRenderWindow.setSize(Math.floor(dims.width * devicePixelRatio), Math.floor(dims.height * devicePixelRatio));
+      model._apiSpecificRenderWindow.setSize(Math.floor(dims.width * devicePixelRatio), Math.floor(dims.height * devicePixelRatio));
       invokeResize();
       model.renderWindow.render();
     }
@@ -55,7 +57,7 @@ function vtkGenericRenderWindow(publicAPI, model) {
 
     // Switch container
     model.container = el;
-    model._openGLRenderWindow.setContainer(model.container);
+    model._apiSpecificRenderWindow.setContainer(model.container);
 
     // Bind to new container
     if (model.container) {
@@ -64,7 +66,7 @@ function vtkGenericRenderWindow(publicAPI, model) {
   };
 
   // Properly release GL context
-  publicAPI.delete = macro.chain(publicAPI.setContainer, model._openGLRenderWindow.delete, publicAPI.delete);
+  publicAPI.delete = macro.chain(publicAPI.setContainer, model._apiSpecificRenderWindow.delete, publicAPI.delete);
 
   // Handle size
   if (model.listenWindowResize) {
@@ -91,8 +93,8 @@ function extend(publicAPI, model) {
 
   // Object methods
   macro.obj(publicAPI, model);
-  macro.get(publicAPI, model, ['renderWindow', 'renderer', '_openGLRenderWindow', 'interactor', 'container']);
-  macro.moveToProtected(publicAPI, model, ['openGLRenderWindow']);
+  macro.get(publicAPI, model, ['renderWindow', 'renderer', '_apiSpecificRenderWindow', 'interactor', 'container']);
+  macro.moveToProtected(publicAPI, model, ['_apiSpecificRenderWindow']);
   macro.event(publicAPI, model, 'resize');
 
   // Object specific methods

package/Rendering/OpenGL/RenderWindow.d.ts

@@ -29,10 +29,6 @@ export interface IOpenGLRenderWindowInitialValues {
 	webgl2?: boolean;
 	defaultToWebgl2?: boolean;
 	activeFramebuffer?: any;
-	xrSession?: any;
-	xrSessionIsAR?: boolean;
-	xrReferenceSpace?: any;
-	xrSupported?: boolean;
 	imageFormat?: 'image/png';
 	useOffScreen?: boolean;
 	useBackgroundImage?: boolean;
@@ -236,36 +232,6 @@ export interface vtkOpenGLRenderWindow extends vtkOpenGLRenderWindowBase {
 	 */
 	get3DContext(options: I3DContextOptions): Nullable<WebGLRenderingContext>;
 
-	/**
-	 * Request an XR session on the user device with WebXR,
-   * typically in response to a user request such as a button press.
-	 */
-	startXR(): 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;
-
-	/**
-	 *
-	 */
-	xrRender(): void;
-
 	/**
 	 *
 	 */

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/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;
 }
 
 /**

package/Widgets/Core/WidgetManager.js

@@ -10,8 +10,7 @@ const {
   CaptureOn
 } = WidgetManagerConst;
 const {
-  vtkErrorMacro,
-  vtkWarningMacro
+  vtkErrorMacro
 } = macro;
 let viewIdCount = 1;
 
@@ -203,15 +202,16 @@ function vtkWidgetManager(publicAPI, model) {
   }
   async function captureBuffers(x1, y1, x2, y2) {
     if (model._captureInProgress) {
+      await model._captureInProgress;
       return;
     }
-    model._captureInProgress = true;
     renderPickingBuffer();
     model._capturedBuffers = null;
-    model._capturedBuffers = await model._selector.getSourceDataAsync(model._renderer, x1, y1, x2, y2);
+    model._captureInProgress = model._selector.getSourceDataAsync(model._renderer, x1, y1, x2, y2);
+    model._capturedBuffers = await model._captureInProgress;
+    model._captureInProgress = null;
     model.previousSelectedData = null;
     renderFrontBuffer();
-    model._captureInProgress = false;
   }
   publicAPI.enablePicking = () => {
     model.pickingEnabled = true;
@@ -343,30 +343,6 @@ function vtkWidgetManager(publicAPI, model) {
     }
     return publicAPI.getSelectedData();
   };
-  publicAPI.updateSelectionFromXY = (x, y) => {
-    vtkWarningMacro('updateSelectionFromXY is deprecated, please use getSelectedDataForXY');
-    if (model.pickingEnabled) {
-      // Then pick regular representations.
-      if (model.captureOn === CaptureOn.MOUSE_MOVE) {
-        captureBuffers(x, y, x, y);
-      }
-    }
-  };
-  publicAPI.updateSelectionFromMouseEvent = event => {
-    vtkWarningMacro('updateSelectionFromMouseEvent is deprecated, please use getSelectedDataForXY');
-    const {
-      pageX,
-      pageY
-    } = event;
-    const {
-      top,
-      left,
-      height
-    } = model._apiSpecificRenderWindow.getCanvas().getBoundingClientRect();
-    const x = pageX - left;
-    const y = height - (pageY - top);
-    publicAPI.updateSelectionFromXY(x, y);
-  };
   publicAPI.getSelectedData = () => {
     if (!model.selections || !model.selections.length) {
       model.previousSelectedData = null;

package/Widgets/Widgets3D.js

@@ -1,5 +1,4 @@
 import vtkAngleWidget from './Widgets3D/AngleWidget.js';
-import vtkDistanceWidget from './Widgets3D/DistanceWidget.js';
 import vtkEllipseWidget from './Widgets3D/EllipseWidget.js';
 import vtkImageCroppingWidget from './Widgets3D/ImageCroppingWidget.js';
 import vtkImplicitPlaneWidget from './Widgets3D/ImplicitPlaneWidget.js';
@@ -16,7 +15,6 @@ import vtkSplineWidget from './Widgets3D/SplineWidget.js';
 
 var Widgets3D = {
   vtkAngleWidget,
-  vtkDistanceWidget,
   vtkEllipseWidget,
   vtkImageCroppingWidget,
   vtkImplicitPlaneWidget,

package/index.d.ts

@@ -205,11 +205,12 @@
 /// <reference path="./Rendering/Misc/TextureLODsDownloader.d.ts" />
 /// <reference path="./Rendering/OpenGL/HardwareSelector/Constants.d.ts" />
 /// <reference path="./Rendering/OpenGL/HardwareSelector.d.ts" />
-/// <reference path="./Rendering/OpenGL/RenderWindow/Constants.d.ts" />
 /// <reference path="./Rendering/OpenGL/RenderWindow.d.ts" />
 /// <reference path="./Rendering/SceneGraph/RenderPass.d.ts" />
 /// <reference path="./Rendering/SceneGraph/ViewNode.d.ts" />
 /// <reference path="./Rendering/SceneGraph/ViewNodeFactory.d.ts" />
+/// <reference path="./Rendering/WebXR/RenderWindowHelper/Constants.d.ts" />
+/// <reference path="./Rendering/WebXR/RenderWindowHelper.d.ts" />
 /// <reference path="./Widgets/Core/AbstractWidget.d.ts" />
 /// <reference path="./Widgets/Core/AbstractWidgetFactory.d.ts" />
 /// <reference path="./Widgets/Core/StateBuilder.d.ts" />

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kitware/vtk.js",
-  "version": "28.13.1",
+  "version": "29.0.0",
   "description": "Visualization Toolkit for the Web",
   "keywords": [
     "3d",
@@ -31,6 +31,7 @@
   "module": "./index.js",
   "dependencies": {
     "@babel/runtime": "7.22.11",
+    "@types/webxr": "^0.5.5",
     "commander": "9.2.0",
     "d3-scale": "4.0.2",
     "fast-deep-equal": "^3.1.3",

package/Widgets/Widgets3D/DistanceWidget/behavior.js

@@ -1,133 +0,0 @@
-import { m as macro } from '../../../macros2.js';
-
-const MAX_POINTS = 2;
-function widgetBehavior(publicAPI, model) {
-  model.classHierarchy.push('vtkDistanceWidgetProp');
-  model._isDragging = false;
-
-  // --------------------------------------------------------------------------
-  // Display 2D
-  // --------------------------------------------------------------------------
-
-  publicAPI.setDisplayCallback = callback => model.representations[0].setDisplayCallback(callback);
-
-  // --------------------------------------------------------------------------
-  // Interactor events
-  // --------------------------------------------------------------------------
-
-  function ignoreKey(e) {
-    return e.altKey || e.controlKey || e.shiftKey;
-  }
-
-  // --------------------------------------------------------------------------
-  // Left press: Select handle to drag
-  // --------------------------------------------------------------------------
-
-  publicAPI.handleLeftButtonPress = e => {
-    if (!model.activeState || !model.activeState.getActive() || !model.pickable || ignoreKey(e)) {
-      return macro.VOID;
-    }
-    const manipulator = model.activeState?.getManipulator?.() ?? model.manipulator;
-    if (model.activeState === model.widgetState.getMoveHandle() && model.widgetState.getHandleList().length < MAX_POINTS && manipulator) {
-      const {
-        worldCoords
-      } = manipulator.handleEvent(e, model._apiSpecificRenderWindow);
-      // Commit handle to location
-      const moveHandle = model.widgetState.getMoveHandle();
-      moveHandle.setOrigin(...worldCoords);
-      const newHandle = model.widgetState.addHandle();
-      newHandle.setOrigin(...moveHandle.getOrigin());
-      newHandle.setColor(moveHandle.getColor());
-      newHandle.setScale1(moveHandle.getScale1());
-      newHandle.setManipulator(manipulator);
-    } else if (model.dragable) {
-      model._isDragging = true;
-      model._apiSpecificRenderWindow.setCursor('grabbing');
-      model._interactor.requestAnimation(publicAPI);
-    }
-    publicAPI.invokeStartInteractionEvent();
-    return macro.EVENT_ABORT;
-  };
-
-  // --------------------------------------------------------------------------
-  // Mouse move: Drag selected handle / Handle follow the mouse
-  // --------------------------------------------------------------------------
-
-  publicAPI.handleMouseMove = callData => {
-    const manipulator = model.activeState?.getManipulator?.() ?? model.manipulator;
-    if (manipulator && model.pickable && model.dragable && model.activeState && model.activeState.getActive() && !ignoreKey(callData)) {
-      const {
-        worldCoords
-      } = manipulator.handleEvent(callData, model._apiSpecificRenderWindow);
-      if (worldCoords.length && (model.activeState === model.widgetState.getMoveHandle() || model._isDragging) && model.activeState.setOrigin // e.g. the line is pickable but not draggable
-      ) {
-        model.activeState.setOrigin(worldCoords);
-        publicAPI.invokeInteractionEvent();
-        return macro.EVENT_ABORT;
-      }
-    }
-    return macro.VOID;
-  };
-
-  // --------------------------------------------------------------------------
-  // Left release: Finish drag / Create new handle
-  // --------------------------------------------------------------------------
-
-  publicAPI.handleLeftButtonRelease = () => {
-    if (!model.activeState || !model.activeState.getActive() || !model.pickable) {
-      return macro.VOID;
-    }
-    if (model.hasFocus && model.widgetState.getHandleList().length === MAX_POINTS) {
-      publicAPI.loseFocus();
-      return macro.VOID;
-    }
-    if (model._isDragging) {
-      model._apiSpecificRenderWindow.setCursor('pointer');
-      model.widgetState.deactivate();
-      model._interactor.cancelAnimation(publicAPI);
-      model._isDragging = false;
-    } else if (model.activeState !== model.widgetState.getMoveHandle()) {
-      model.widgetState.deactivate();
-    }
-    if (model.hasFocus && !model.activeState || model.activeState && !model.activeState.getActive()) {
-      model._widgetManager.enablePicking();
-      model._interactor.render();
-    }
-    publicAPI.invokeEndInteractionEvent();
-    return macro.EVENT_ABORT;
-  };
-
-  // --------------------------------------------------------------------------
-  // Focus API - modeHandle follow mouse when widget has focus
-  // --------------------------------------------------------------------------
-
-  publicAPI.grabFocus = () => {
-    if (!model.hasFocus && model.widgetState.getHandleList().length < MAX_POINTS) {
-      model.activeState = model.widgetState.getMoveHandle();
-      model.activeState.activate();
-      model.activeState.setVisible(true);
-      model._interactor.requestAnimation(publicAPI);
-      publicAPI.invokeStartInteractionEvent();
-    }
-    model.hasFocus = true;
-  };
-
-  // --------------------------------------------------------------------------
-
-  publicAPI.loseFocus = () => {
-    if (model.hasFocus) {
-      model._interactor.cancelAnimation(publicAPI);
-      publicAPI.invokeEndInteractionEvent();
-    }
-    model.widgetState.deactivate();
-    model.widgetState.getMoveHandle().deactivate();
-    model.widgetState.getMoveHandle().setVisible(false);
-    model.widgetState.getMoveHandle().setOrigin(null);
-    model.activeState = null;
-    model.hasFocus = false;
-    model._widgetManager.enablePicking();
-    model._interactor.render();
-  };
-}
-
-export { widgetBehavior as default };

package/Widgets/Widgets3D/DistanceWidget/state.js

@@ -1,22 +0,0 @@
-import vtkStateBuilder from '../../Core/StateBuilder.js';
-
-function generateState() {
-  return vtkStateBuilder.createBuilder().addStateFromMixin({
-    labels: ['moveHandle'],
-    mixins: ['origin', 'color', 'scale1', 'visible', 'manipulator'],
-    name: 'moveHandle',
-    initialValues: {
-      scale1: 30,
-      visible: false
-    }
-  }).addDynamicMixinState({
-    labels: ['handles'],
-    mixins: ['origin', 'color', 'scale1', 'visible', 'manipulator'],
-    name: 'handle',
-    initialValues: {
-      scale1: 30
-    }
-  }).build();
-}
-
-export { generateState as default };

package/Widgets/Widgets3D/DistanceWidget.js

@@ -1,109 +0,0 @@
-import { m as macro } from '../../macros2.js';
-import vtkAbstractWidgetFactory from '../Core/AbstractWidgetFactory.js';
-import vtkPlanePointManipulator from '../Manipulators/PlaneManipulator.js';
-import vtkPolyLineRepresentation from '../Representations/PolyLineRepresentation.js';
-import vtkSphereHandleRepresentation from '../Representations/SphereHandleRepresentation.js';
-import { e as distance2BetweenPoints } from '../../Common/Core/Math/index.js';
-import widgetBehavior from './DistanceWidget/behavior.js';
-import generateState from './DistanceWidget/state.js';
-import { ViewTypes } from '../Core/WidgetManager/Constants.js';
-
-// ----------------------------------------------------------------------------
-// Factory
-// ----------------------------------------------------------------------------
-
-function vtkDistanceWidget(publicAPI, model) {
-  model.classHierarchy.push('vtkDistanceWidget');
-  const superClass = {
-    ...publicAPI
-  };
-
-  // --- Widget Requirement ---------------------------------------------------
-
-  model.methodsToLink = ['activeScaleFactor', 'activeColor', 'useActiveColor', 'glyphResolution', 'defaultScale', 'scaleInPixels'];
-  publicAPI.getRepresentationsForViewType = viewType => {
-    switch (viewType) {
-      case ViewTypes.DEFAULT:
-      case ViewTypes.GEOMETRY:
-      case ViewTypes.SLICE:
-      case ViewTypes.VOLUME:
-      default:
-        return [{
-          builder: vtkSphereHandleRepresentation,
-          labels: ['handles']
-        }, {
-          builder: vtkSphereHandleRepresentation,
-          labels: ['moveHandle']
-        }, {
-          builder: vtkPolyLineRepresentation,
-          labels: ['handles', 'moveHandle']
-        }];
-    }
-  };
-
-  // --- Public methods -------------------------------------------------------
-
-  publicAPI.getDistance = () => {
-    const handles = model.widgetState.getHandleList();
-    if (handles.length !== 2) {
-      return 0;
-    }
-    if (!handles[0].getOrigin() || !handles[1].getOrigin()) {
-      return 0;
-    }
-    return Math.sqrt(distance2BetweenPoints(handles[0].getOrigin(), handles[1].getOrigin()));
-  };
-  publicAPI.setManipulator = manipulator => {
-    superClass.setManipulator(manipulator);
-    model.widgetState.getMoveHandle().setManipulator(manipulator);
-    model.widgetState.getHandleList().forEach(handle => {
-      handle.setManipulator(manipulator);
-    });
-  };
-
-  // --------------------------------------------------------------------------
-  // initialization
-  // --------------------------------------------------------------------------
-
-  model.widgetState.onBoundsChange(bounds => {
-    const center = [(bounds[0] + bounds[1]) * 0.5, (bounds[2] + bounds[3]) * 0.5, (bounds[4] + bounds[5]) * 0.5];
-    model.widgetState.getMoveHandle().setOrigin(center);
-  });
-
-  // Default manipulator
-  publicAPI.setManipulator(model.manipulator || vtkPlanePointManipulator.newInstance({
-    useCameraNormal: true
-  }));
-}
-
-// ----------------------------------------------------------------------------
-
-const defaultValues = initialValues => ({
-  // manipulator: null,
-  behavior: widgetBehavior,
-  widgetState: generateState(),
-  ...initialValues
-});
-
-// ----------------------------------------------------------------------------
-
-function extend(publicAPI, model) {
-  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-  Object.assign(model, defaultValues(initialValues));
-  vtkAbstractWidgetFactory.extend(publicAPI, model, initialValues);
-  macro.setGet(publicAPI, model, ['manipulator']);
-  vtkDistanceWidget(publicAPI, model);
-}
-
-// ----------------------------------------------------------------------------
-
-const newInstance = macro.newInstance(extend, 'vtkDistanceWidget');
-
-// ----------------------------------------------------------------------------
-
-var vtkDistanceWidget$1 = {
-  newInstance,
-  extend
-};
-
-export { vtkDistanceWidget$1 as default, extend, newInstance };