@kitware/vtk.js 24.15.0 → 24.16.2

package/Rendering/Core/Camera.js

@@ -61,7 +61,6 @@ function vtkCamera(publicAPI, model) {
     model.position[2] = z; // recompute the focal distance
 
     publicAPI.computeDistance();
-    publicAPI.computeCameraLightTransform();
     publicAPI.modified();
   };
 
@@ -75,7 +74,6 @@ function vtkCamera(publicAPI, model) {
     model.focalPoint[2] = z; // recompute the focal distance
 
     publicAPI.computeDistance();
-    publicAPI.computeCameraLightTransform();
     publicAPI.modified();
   };
 
@@ -97,7 +95,6 @@ function vtkCamera(publicAPI, model) {
     model.focalPoint[0] = model.position[0] + vec[0] * model.distance;
     model.focalPoint[1] = model.position[1] + vec[1] * model.distance;
     model.focalPoint[2] = model.position[2] + vec[2] * model.distance;
-    publicAPI.computeCameraLightTransform();
     publicAPI.modified();
   }; //----------------------------------------------------------------------------
   // This method must be called when the focal point or camera position changes

package/Rendering/Core/RenderWindowInteractor.d.ts

@@ -173,6 +173,16 @@ export interface vtkRenderWindowInteractor extends vtkObject {
 	 * 
 	 * @param {IRenderWindowInteractorEvent} callData 
 	 */
+	invokePointerEnter(callData: IRenderWindowInteractorEvent): void;
+
+	/**
+	 *
+	 */
+	invokePointerLeave(callData: IRenderWindowInteractorEvent): void;
+
+	/**
+	 *
+	 */
 	invokeMouseEnter(callData: IRenderWindowInteractorEvent): void;
 
 	/**
@@ -392,6 +402,18 @@ export interface vtkRenderWindowInteractor extends vtkObject {
 	 * @param {InteractorEventCallback} cb The callback to be called.
 	 * @param {Number} [priority] The priority of the event.
 	 */
+	onPointerEnter(cb: InteractorEventCallback, priority?: number): Readonly<vtkSubscription>;
+
+	/**
+	 *
+	 * @param cb The callback to be called
+	 */
+	onPointerLeave(cb: InteractorEventCallback, priority?: number): Readonly<vtkSubscription>;
+
+	/**
+	 *
+	 * @param cb The callback to be called
+	 */
 	onMouseEnter(cb: InteractorEventCallback, priority?: number): Readonly<vtkSubscription>;
 
 	/**
@@ -949,11 +971,35 @@ export interface vtkRenderWindowInteractor extends vtkObject {
 	 */
 	handleKeyUp(event: KeyboardEvent): void;
 
+	/**
+	 * 
+	 * @param {PointerEvent} event 
+	 */
+	handlePointerDown(event: PointerEvent): void;
+
+	/**
+	 * 
+	 * @param {PointerEvent} event 
+	 */
+	handlePointerUp(event: PointerEvent): void;
+
+	/**
+	 * 
+	 * @param {PointerEvent} event 
+	 */
+	handlePointerCancel(event: PointerEvent): void;
+
+	/**
+	 * 
+	 * @param {PointerEvent} event 
+	 */
+	handlePointerMove(event: PointerEvent): void;
+
 	/**
 	 *
-	 * @param {MouseEvent} event 
+	 * @param {PointerEvent} event 
 	 */
-	handleMouseDown(event: MouseEvent): void;
+	handleMouseDown(event: PointerEvent): void;
 
 	/**
 	 *
@@ -1011,9 +1057,9 @@ export interface vtkRenderWindowInteractor extends vtkObject {
 
 	/**
 	 *
-	 * @param {MouseEvent} event 
+	 * @param {PointerEvent} event 
 	 */
-	handleMouseMove(event: MouseEvent): void;
+	handleMouseMove(event: PointerEvent): void;
 
 	/**
 	 *
@@ -1028,39 +1074,39 @@ export interface vtkRenderWindowInteractor extends vtkObject {
 
 	/**
 	 *
-	 * @param {MouseEvent} event 
+	 * @param {PointerEvent} event 
 	 */
-	handleMouseEnter(event: MouseEvent): void;
+	handlePointerEnter(event: PointerEvent): void;
 
 	/**
 	 *
-	 * @param {MouseEvent} event 
+	 * @param {PointerEvent} event 
 	 */
-	handleMouseLeave(event: MouseEvent): void;
+	handlePointerLeave(event: PointerEvent): void;
 
 	/**
 	 *
-	 * @param {MouseEvent} event 
+	 * @param {PointerEvent} event 
 	 */
-	handleMouseUp(event: MouseEvent): void;
+	handleMouseUp(event: PointerEvent): void;
 
 	/**
 	 *
-	 * @param {TouchEvent} event 
+	 * @param {PointerEvent} event 
 	 */
-	handleTouchStart(event: TouchEvent): void;
+	handleTouchStart(event: PointerEvent): void;
 
 	/**
 	 *
-	 * @param {TouchEvent} event 
+	 * @param {PointerEvent} event 
 	 */
-	handleTouchMove(event: TouchEvent): void;
+	handleTouchMove(event: PointerEvent): void;
 
 	/**
 	 *
-	 * @param {TouchEvent} event 
+	 * @param {PointerEvent} event 
 	 */
-	handleTouchEnd(event: TouchEvent): void;
+	handleTouchEnd(event: PointerEvent): void;
 
 	/**
 	 *
@@ -1093,7 +1139,7 @@ export interface vtkRenderWindowInteractor extends vtkObject {
 	 * @param event
 	 * @param positions
 	 */
-	recognizeGesture(event: 'TouchStart' | 'TouchMouve' | 'TouchEnd', positions: IPosition): void;
+	recognizeGesture(event: 'TouchStart' | 'TouchMove' | 'TouchEnd', positions: IPosition): void;
 
 	/**
 	 *

package/Rendering/Core/RenderWindowInteractor.js

@@ -1,3 +1,4 @@
+import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
 import _defineProperty from '@babel/runtime/helpers/defineProperty';
 import macro from '../../macros.js';
 import { A as degreesFromRadians } from '../../Common/Core/Math/index.js';
@@ -15,10 +16,11 @@ var vtkWarningMacro = macro.vtkWarningMacro,
 // Global methods
 // ----------------------------------------------------------------------------
 
+var EMPTY_MOUSE_EVENT = new MouseEvent('');
 var deviceInputMap = {
   'xr-standard': [Input.Trigger, Input.Grip, Input.TrackPad, Input.Thumbstick, Input.A, Input.B]
 };
-var handledEvents = ['StartAnimation', 'Animation', 'EndAnimation', 'MouseEnter', 'MouseLeave', 'StartMouseMove', 'MouseMove', 'EndMouseMove', 'LeftButtonPress', 'LeftButtonRelease', 'MiddleButtonPress', 'MiddleButtonRelease', 'RightButtonPress', 'RightButtonRelease', 'KeyPress', 'KeyDown', 'KeyUp', 'StartMouseWheel', 'MouseWheel', 'EndMouseWheel', 'StartPinch', 'Pinch', 'EndPinch', 'StartPan', 'Pan', 'EndPan', 'StartRotate', 'Rotate', 'EndRotate', 'Button3D', 'Move3D', 'StartPointerLock', 'EndPointerLock', 'StartInteraction', 'Interaction', 'EndInteraction', 'AnimationFrameRateUpdate'];
+var handledEvents = ['StartAnimation', 'Animation', 'EndAnimation', 'PointerEnter', 'PointerLeave', 'MouseEnter', 'MouseLeave', 'StartMouseMove', 'MouseMove', 'EndMouseMove', 'LeftButtonPress', 'LeftButtonRelease', 'MiddleButtonPress', 'MiddleButtonRelease', 'RightButtonPress', 'RightButtonRelease', 'KeyPress', 'KeyDown', 'KeyUp', 'StartMouseWheel', 'MouseWheel', 'EndMouseWheel', 'StartPinch', 'Pinch', 'EndPinch', 'StartPan', 'Pan', 'EndPan', 'StartRotate', 'Rotate', 'EndRotate', 'Button3D', 'Move3D', 'StartPointerLock', 'EndPointerLock', 'StartInteraction', 'Interaction', 'EndInteraction', 'AnimationFrameRateUpdate'];
 
 function preventDefault(event) {
   if (event.cancelable) {
@@ -27,6 +29,16 @@ function preventDefault(event) {
   }
 
   return false;
+}
+
+function pointerCacheToPositions(cache) {
+  var positions = Object.create(null);
+  cache.forEach(function (_ref) {
+    var pointerId = _ref.pointerId,
+        position = _ref.position;
+    positions[pointerId] = position;
+  });
+  return positions;
 } // ----------------------------------------------------------------------------
 // vtkRenderWindowInteractor methods
 // ----------------------------------------------------------------------------
@@ -36,9 +48,9 @@ function vtkRenderWindowInteractor(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkRenderWindowInteractor'); // Initialize list of requesters
 
-  var animationRequesters = new Set(); // track active event listeners to handle simultaneous button tracking
+  var animationRequesters = new Set(); // map from pointerId to { pointerId: number, position: [x, y] }
 
-  var activeListenerCount = 0; // Public API methods
+  var pointerCache = new Map(); // Public API methods
   //----------------------------------------------------------------------
 
   publicAPI.start = function () {
@@ -127,20 +139,13 @@ function vtkRenderWindowInteractor(publicAPI, model) {
       x: scaleX * (source.clientX - bounds.left),
       y: scaleY * (bounds.height - source.clientY + bounds.top),
       z: 0
-    };
-    updateCurrentRenderer(position.x, position.y);
-    return position;
-  }
-
-  function getTouchEventPositionsFor(touches) {
-    var positions = {};
+    }; // if multitouch, do not update the current renderer
 
-    for (var i = 0; i < touches.length; i++) {
-      var touch = touches[i];
-      positions[touch.identifier] = getScreenEventPositionFor(touch);
+    if (pointerCache.size <= 1 || !model.currentRenderer) {
+      updateCurrentRenderer(position.x, position.y);
     }
 
-    return positions;
+    return position;
   }
 
   function getModifierKeysFor(event) {
@@ -162,40 +167,8 @@ function vtkRenderWindowInteractor(publicAPI, model) {
     return keys;
   }
 
-  function interactionRegistration(addListeners) {
-    var force = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
-    var rootElm = document;
-    var method = addListeners ? 'addEventListener' : 'removeEventListener';
-    var invMethod = addListeners ? 'removeEventListener' : 'addEventListener';
-
-    if (!force && !addListeners && activeListenerCount > 0) {
-      --activeListenerCount;
-    } // only add/remove listeners when there are no registered listeners
-
-
-    if (!activeListenerCount || force) {
-      activeListenerCount = 0;
-
-      if (model.container) {
-        model.container[invMethod]('mousemove', publicAPI.handleMouseMove);
-      }
-
-      rootElm[method]('mouseup', publicAPI.handleMouseUp);
-      rootElm[method]('mousemove', publicAPI.handleMouseMove);
-      rootElm[method]('touchend', publicAPI.handleTouchEnd, false);
-      rootElm[method]('touchcancel', publicAPI.handleTouchEnd, {
-        passive: false,
-        capture: false
-      });
-      rootElm[method]('touchmove', publicAPI.handleTouchMove, {
-        passive: false,
-        capture: false
-      });
-    }
-
-    if (!force && addListeners) {
-      ++activeListenerCount;
-    }
+  function getDeviceTypeFor(event) {
+    return event.pointerType || '';
   }
 
   publicAPI.bindEvents = function (container) {
@@ -204,40 +177,50 @@ function vtkRenderWindowInteractor(publicAPI, model) {
 
     container.addEventListener('wheel', publicAPI.handleWheel);
     container.addEventListener('DOMMouseScroll', publicAPI.handleWheel);
-    container.addEventListener('mouseenter', publicAPI.handleMouseEnter);
-    container.addEventListener('mouseleave', publicAPI.handleMouseLeave);
-    container.addEventListener('mousemove', publicAPI.handleMouseMove);
-    container.addEventListener('mousedown', publicAPI.handleMouseDown);
+    container.addEventListener('pointerenter', publicAPI.handlePointerEnter);
+    container.addEventListener('pointerleave', publicAPI.handlePointerLeave);
+    container.addEventListener('pointermove', publicAPI.handlePointerMove, {
+      passive: false
+    });
+    container.addEventListener('pointerdown', publicAPI.handlePointerDown, {
+      passive: false
+    });
+    container.addEventListener('pointerup', publicAPI.handlePointerUp);
+    container.addEventListener('pointercancel', publicAPI.handlePointerCancel);
     document.addEventListener('keypress', publicAPI.handleKeyPress);
     document.addEventListener('keydown', publicAPI.handleKeyDown);
     document.addEventListener('keyup', publicAPI.handleKeyUp);
-    document.addEventListener('pointerlockchange', publicAPI.handlePointerLockChange);
-    container.addEventListener('touchstart', publicAPI.handleTouchStart, {
-      passive: false,
-      capture: false
-    });
+    document.addEventListener('pointerlockchange', publicAPI.handlePointerLockChange); // using touchAction is more performant than preventDefault
+    // in a touchstart handler.
+
+    container.style.touchAction = 'none';
+    container.style.userSelect = 'none'; // disables tap highlight for when cursor is pointer
+
+    container.style.webkitTapHighlightColor = 'rgba(0,0,0,0)';
   };
 
   publicAPI.unbindEvents = function () {
-    // force unbinding listeners
-    interactionRegistration(false, true);
-    model.container.removeEventListener('contextmenu', preventDefault); // model.container.removeEventListener('click', preventDefault); // Avoid stopping event propagation
-
-    model.container.removeEventListener('wheel', publicAPI.handleWheel);
-    model.container.removeEventListener('DOMMouseScroll', publicAPI.handleWheel);
-    model.container.removeEventListener('mouseenter', publicAPI.handleMouseEnter);
-    model.container.removeEventListener('mouseleave', publicAPI.handleMouseLeave);
-    model.container.removeEventListener('mousemove', publicAPI.handleMouseMove);
-    model.container.removeEventListener('mousedown', publicAPI.handleMouseDown);
+    var container = model.container;
+    container.removeEventListener('contextmenu', preventDefault); // model.container.removeEventListener('click', preventDefault); // Avoid stopping event propagation
+
+    container.removeEventListener('wheel', publicAPI.handleWheel);
+    container.removeEventListener('DOMMouseScroll', publicAPI.handleWheel);
+    container.removeEventListener('pointerenter', publicAPI.handlePointerEnter);
+    container.removeEventListener('pointerleave', publicAPI.handlePointerLeave);
+    container.removeEventListener('pointermove', publicAPI.handlePointerMove, {
+      passive: false
+    });
+    container.removeEventListener('pointerdown', publicAPI.handlePointerDown, {
+      passive: false
+    });
+    container.removeEventListener('pointerup', publicAPI.handlePointerUp);
+    container.removeEventListener('pointercancel', publicAPI.handlePointerCancel);
     document.removeEventListener('keypress', publicAPI.handleKeyPress);
     document.removeEventListener('keydown', publicAPI.handleKeyDown);
     document.removeEventListener('keyup', publicAPI.handleKeyUp);
     document.removeEventListener('pointerlockchange', publicAPI.handlePointerLockChange);
-    model.container.removeEventListener('touchstart', publicAPI.handleTouchStart, {
-      passive: false,
-      capture: false
-    });
     model.container = null;
+    pointerCache.clear();
   };
 
   publicAPI.handleKeyPress = function (event) {
@@ -255,19 +238,131 @@ function vtkRenderWindowInteractor(publicAPI, model) {
     publicAPI.keyUpEvent(data);
   };
 
-  publicAPI.handleMouseDown = function (event) {
-    if (event.button > 2) {
+  publicAPI.handlePointerEnter = function (event) {
+    var callData = _objectSpread(_objectSpread({}, getModifierKeysFor(event)), {}, {
+      position: getScreenEventPositionFor(event),
+      deviceType: getDeviceTypeFor(event)
+    });
+
+    publicAPI.pointerEnterEvent(callData);
+
+    if (callData.deviceType === 'mouse') {
+      publicAPI.mouseEnterEvent(callData);
+    }
+  };
+
+  publicAPI.handlePointerLeave = function (event) {
+    var callData = _objectSpread(_objectSpread({}, getModifierKeysFor(event)), {}, {
+      position: getScreenEventPositionFor(event),
+      deviceType: getDeviceTypeFor(event)
+    });
+
+    publicAPI.pointerLeaveEvent(callData);
+
+    if (callData.deviceType === 'mouse') {
+      publicAPI.mouseLeaveEvent(callData);
+    }
+  };
+
+  publicAPI.handlePointerDown = function (event) {
+    if (event.button > 2 || publicAPI.isPointerLocked()) {
       // ignore events from extra mouse buttons such as `back` and `forward`
       return;
     }
 
-    interactionRegistration(true);
     preventDefault(event);
 
-    var callData = _objectSpread(_objectSpread({}, getModifierKeysFor(event)), {}, {
+    if (event.target.hasPointerCapture(event.pointerId)) {
+      event.target.releasePointerCapture(event.pointerId);
+    }
+
+    model.container.setPointerCapture(event.pointerId);
+
+    if (pointerCache.has(event.pointerId)) {
+      vtkWarningMacro('[RenderWindowInteractor] duplicate pointerId detected');
+    }
+
+    pointerCache.set(event.pointerId, {
+      pointerId: event.pointerId,
       position: getScreenEventPositionFor(event)
     });
 
+    switch (event.pointerType) {
+      case 'pen':
+      case 'touch':
+        publicAPI.handleTouchStart(event);
+        break;
+
+      case 'mouse':
+      default:
+        publicAPI.handleMouseDown(event);
+        break;
+    }
+  };
+
+  publicAPI.handlePointerUp = function (event) {
+    if (pointerCache.has(event.pointerId)) {
+      preventDefault(event);
+      pointerCache.delete(event.pointerId);
+      model.container.releasePointerCapture(event.pointerId);
+
+      switch (event.pointerType) {
+        case 'pen':
+        case 'touch':
+          publicAPI.handleTouchEnd(event);
+          break;
+
+        case 'mouse':
+        default:
+          publicAPI.handleMouseUp(event);
+          break;
+      }
+    }
+  };
+
+  publicAPI.handlePointerCancel = function (event) {
+    if (pointerCache.has(event.pointerId)) {
+      pointerCache.delete(event.pointerId);
+
+      switch (event.pointerType) {
+        case 'pen':
+        case 'touch':
+          publicAPI.handleTouchEnd(event);
+          break;
+
+        case 'mouse':
+        default:
+          publicAPI.handleMouseUp(event);
+          break;
+      }
+    }
+  };
+
+  publicAPI.handlePointerMove = function (event) {
+    if (pointerCache.has(event.pointerId)) {
+      var pointer = pointerCache.get(event.pointerId);
+      pointer.position = getScreenEventPositionFor(event);
+    }
+
+    switch (event.pointerType) {
+      case 'pen':
+      case 'touch':
+        publicAPI.handleTouchMove(event);
+        break;
+
+      case 'mouse':
+      default:
+        publicAPI.handleMouseMove(event);
+        break;
+    }
+  };
+
+  publicAPI.handleMouseDown = function (event) {
+    var callData = _objectSpread(_objectSpread({}, getModifierKeysFor(event)), {}, {
+      position: getScreenEventPositionFor(event),
+      deviceType: getDeviceTypeFor(event)
+    });
+
     switch (event.button) {
       case 0:
         publicAPI.leftButtonPressEvent(callData);
@@ -457,10 +552,9 @@ function vtkRenderWindowInteractor(publicAPI, model) {
   };
 
   publicAPI.handleMouseMove = function (event) {
-    // Do not consume event for move
-    // preventDefault(event);
     var callData = _objectSpread(_objectSpread({}, getModifierKeysFor(event)), {}, {
-      position: getScreenEventPositionFor(event)
+      position: getScreenEventPositionFor(event),
+      deviceType: getDeviceTypeFor(event)
     });
 
     if (model.moveTimeoutID === 0) {
@@ -522,7 +616,8 @@ function vtkRenderWindowInteractor(publicAPI, model) {
      */
 
     var callData = _objectSpread(_objectSpread(_objectSpread({}, normalizeWheel(event)), getModifierKeysFor(event)), {}, {
-      position: getScreenEventPositionFor(event)
+      position: getScreenEventPositionFor(event),
+      deviceType: getDeviceTypeFor(event)
     });
 
     if (model.wheelTimeoutID === 0) {
@@ -540,28 +635,10 @@ function vtkRenderWindowInteractor(publicAPI, model) {
     }, 200);
   };
 
-  publicAPI.handleMouseEnter = function (event) {
-    var callData = _objectSpread(_objectSpread({}, getModifierKeysFor(event)), {}, {
-      position: getScreenEventPositionFor(event)
-    });
-
-    publicAPI.mouseEnterEvent(callData);
-  };
-
-  publicAPI.handleMouseLeave = function (event) {
-    var callData = _objectSpread(_objectSpread({}, getModifierKeysFor(event)), {}, {
-      position: getScreenEventPositionFor(event)
-    });
-
-    publicAPI.mouseLeaveEvent(callData);
-  };
-
   publicAPI.handleMouseUp = function (event) {
-    interactionRegistration(false);
-    preventDefault(event);
-
     var callData = _objectSpread(_objectSpread({}, getModifierKeysFor(event)), {}, {
-      position: getScreenEventPositionFor(event)
+      position: getScreenEventPositionFor(event),
+      deviceType: getDeviceTypeFor(event)
     });
 
     switch (event.button) {
@@ -584,107 +661,85 @@ function vtkRenderWindowInteractor(publicAPI, model) {
   };
 
   publicAPI.handleTouchStart = function (event) {
-    interactionRegistration(true);
-    preventDefault(event); // If multitouch
-
-    if (model.recognizeGestures && event.touches.length > 1) {
-      var positions = getTouchEventPositionsFor(event.touches); // did we just transition to multitouch?
-
-      if (event.touches.length === 2) {
-        var touch = event.touches[0];
-        var callData = {
-          position: getScreenEventPositionFor(touch),
-          shiftKey: false,
-          altKey: false,
-          controlKey: false
-        };
+    var pointers = _toConsumableArray(pointerCache.values()); // If multitouch
+
+
+    if (model.recognizeGestures && pointers.length > 1) {
+      var positions = pointerCacheToPositions(pointerCache); // did we just transition to multitouch?
+
+      if (pointers.length === 2) {
+        var callData = _objectSpread(_objectSpread({}, getModifierKeysFor(EMPTY_MOUSE_EVENT)), {}, {
+          position: pointers[0].position,
+          deviceType: getDeviceTypeFor(event)
+        });
+
         publicAPI.leftButtonReleaseEvent(callData);
       } // handle the gesture
 
 
       publicAPI.recognizeGesture('TouchStart', positions);
-    } else {
-      var _touch = event.touches[0];
-      var _callData = {
-        position: getScreenEventPositionFor(_touch),
-        shiftKey: false,
-        altKey: false,
-        controlKey: false
-      };
+    } else if (pointers.length === 1) {
+      var _callData = _objectSpread(_objectSpread({}, getModifierKeysFor(EMPTY_MOUSE_EVENT)), {}, {
+        position: getScreenEventPositionFor(event),
+        deviceType: getDeviceTypeFor(event)
+      });
+
       publicAPI.leftButtonPressEvent(_callData);
     }
   };
 
   publicAPI.handleTouchMove = function (event) {
-    preventDefault(event);
+    var pointers = _toConsumableArray(pointerCache.values());
 
-    if (model.recognizeGestures && event.touches.length > 1) {
-      var positions = getTouchEventPositionsFor(event.touches);
+    if (model.recognizeGestures && pointers.length > 1) {
+      var positions = pointerCacheToPositions(pointerCache);
       publicAPI.recognizeGesture('TouchMove', positions);
-    } else {
-      var touch = event.touches[0];
-      var callData = {
-        position: getScreenEventPositionFor(touch),
-        shiftKey: false,
-        altKey: false,
-        controlKey: false
-      };
+    } else if (pointers.length === 1) {
+      var callData = _objectSpread(_objectSpread({}, getModifierKeysFor(EMPTY_MOUSE_EVENT)), {}, {
+        position: pointers[0].position,
+        deviceType: getDeviceTypeFor(event)
+      });
+
       publicAPI.mouseMoveEvent(callData);
     }
   };
 
   publicAPI.handleTouchEnd = function (event) {
-    preventDefault(event);
+    var pointers = _toConsumableArray(pointerCache.values());
 
     if (model.recognizeGestures) {
       // No more fingers down
-      if (event.touches.length === 0) {
-        // If just one finger released, consider as left button
-        if (event.changedTouches.length === 1) {
-          var touch = event.changedTouches[0];
-          var callData = {
-            position: getScreenEventPositionFor(touch),
-            shiftKey: false,
-            altKey: false,
-            controlKey: false
-          };
-          publicAPI.leftButtonReleaseEvent(callData);
-          interactionRegistration(false);
-        } else {
-          // If more than one finger released, recognize touchend
-          var positions = getTouchEventPositionsFor(event.changedTouches);
-          publicAPI.recognizeGesture('TouchEnd', positions);
-          interactionRegistration(false);
-        }
-      } else if (event.touches.length === 1) {
+      if (pointers.length === 0) {
+        var callData = _objectSpread(_objectSpread({}, getModifierKeysFor(EMPTY_MOUSE_EVENT)), {}, {
+          position: pointers[0].position,
+          deviceType: getDeviceTypeFor(event)
+        });
+
+        publicAPI.leftButtonReleaseEvent(callData);
+      } else if (pointers.length === 1) {
         // If one finger left, end touch and start button press
-        var _positions = getTouchEventPositionsFor(event.changedTouches);
-
-        publicAPI.recognizeGesture('TouchEnd', _positions);
-        var _touch2 = event.touches[0];
-        var _callData2 = {
-          position: getScreenEventPositionFor(_touch2),
-          shiftKey: false,
-          altKey: false,
-          controlKey: false
-        };
+        var positions = pointerCacheToPositions(pointerCache);
+        publicAPI.recognizeGesture('TouchEnd', positions);
+
+        var _callData2 = _objectSpread(_objectSpread({}, getModifierKeysFor(EMPTY_MOUSE_EVENT)), {}, {
+          position: pointers[0].position,
+          deviceType: getDeviceTypeFor(event)
+        });
+
         publicAPI.leftButtonPressEvent(_callData2);
       } else {
         // If more than one finger left, keep touch move
-        var _positions2 = getTouchEventPositionsFor(event.touches);
+        var _positions = pointerCacheToPositions(pointerCache);
 
-        publicAPI.recognizeGesture('TouchMove', _positions2);
+        publicAPI.recognizeGesture('TouchMove', _positions);
       }
-    } else {
-      var _touch3 = event.changedTouches[0];
-      var _callData3 = {
-        position: getScreenEventPositionFor(_touch3),
-        shiftKey: false,
-        altKey: false,
-        controlKey: false
-      };
+    } else if (pointers.length === 1) {
+      var _callData3 = _objectSpread(_objectSpread({}, getModifierKeysFor(EMPTY_MOUSE_EVENT)), {}, {
+        position: pointers[0].position,
+        deviceType: getDeviceTypeFor(event)
+      });
+
       publicAPI.leftButtonReleaseEvent(_callData3);
-      interactionRegistration(false);
     }
   };
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kitware/vtk.js",
-  "version": "24.15.0",
+  "version": "24.16.2",
   "description": "Visualization Toolkit for the Web",
   "keywords": [
     "3d",