@kitware/vtk.js 28.10.2 → 28.11.0

package/Interaction/Manipulators/MouseRangeManipulator.js

@@ -1,41 +1,46 @@
-import macro, { vtkWarningMacro } from '../../macros.js';
+import { m as macro, v as vtkWarningMacro } from '../../macros2.js';
 import vtkCompositeMouseManipulator from './CompositeMouseManipulator.js';
 
+// ----------------------------------------------------------------------------
 // vtkMouseRangeManipulator methods
 // ----------------------------------------------------------------------------
 
 function vtkMouseRangeManipulator(publicAPI, model) {
   // Set our className
-  model.classHierarchy.push('vtkMouseRangeManipulator'); // Keep track of delta that is below the value
+  model.classHierarchy.push('vtkMouseRangeManipulator');
+
+  // Keep track of delta that is below the value
   // of one step to progressively increment it
+  const incrementalDelta = new Map();
 
-  var incrementalDelta = new Map(); // Internal methods
+  // Internal methods
   //-------------------------------------------------------------------------
-
   function scaleDeltaToRange(listener, normalizedDelta) {
     return normalizedDelta * ((listener.max - listener.min) / (listener.step + 1));
-  } //-------------------------------------------------------------------------
-
+  }
 
+  //-------------------------------------------------------------------------
   function processDelta(listener, delta) {
-    var oldValue = listener.getValue(); // if exponential scroll is enabled, we raise our scale to the
+    const oldValue = listener.getValue();
+
+    // if exponential scroll is enabled, we raise our scale to the
     //  exponent of the net delta of the interaction. The further away
     // the user's cursor is from the start of the interaction, the more
     // their movements will effect the value.
+    let scalingFactor = listener.exponentialScroll ? listener.scale ** Math.log2(Math.abs(model.interactionNetDelta) + 2) : listener.scale;
 
-    var scalingFactor = listener.exponentialScroll ? Math.pow(listener.scale, Math.log2(Math.abs(model.interactionNetDelta) + 2)) : listener.scale; // Preserve the sign of scale (which can be used to invert the scrolling direction)
+    // Preserve the sign of scale (which can be used to invert the scrolling direction)
     // after the power operation above (in case of exponentialScroll).
-
     scalingFactor = Math.abs(scalingFactor) * Math.sign(listener.scale);
-    var newDelta = delta * scalingFactor + incrementalDelta.get(listener); // Compute new value based on step
+    const newDelta = delta * scalingFactor + incrementalDelta.get(listener);
+
+    // Compute new value based on step
     // In the following line, Math.abs is required so that the floor function
     // consistently rounds to the lowest absolute integer.
-
-    var stepsToDifference = Math.floor(Math.abs(newDelta / listener.step));
-    var value = oldValue + listener.step * stepsToDifference * Math.sign(newDelta);
+    const stepsToDifference = Math.floor(Math.abs(newDelta / listener.step));
+    let value = oldValue + listener.step * stepsToDifference * Math.sign(newDelta);
     value = Math.max(value, listener.min);
     value = Math.min(value, listener.max);
-
     if (value !== oldValue) {
       // Update value
       listener.setValue(value);
@@ -47,7 +52,10 @@ function vtkMouseRangeManipulator(publicAPI, model) {
       // Store delta for the next iteration
       incrementalDelta.set(listener, newDelta);
     }
-  } // Public API methods
+  }
+
+  // Public API methods
+
   // min:number = minimum allowable value
   // max:number = maximum allowable value
   // step:number = value per step -- smaller = more steps over a given distance, larger = fewer steps over a given distance
@@ -55,125 +63,115 @@ function vtkMouseRangeManipulator(publicAPI, model) {
   // setValue:fn = function to set value
   // scale:number = scale value is applied to mouse event to allow users accelerate or decelerate delta without emitting more events
   //-------------------------------------------------------------------------
-
-
   publicAPI.setHorizontalListener = function (min, max, step, getValue, setValue) {
-    var scale = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : 1;
-    var exponentialScroll = arguments.length > 6 && arguments[6] !== undefined ? arguments[6] : false;
-    var getFn = Number.isFinite(getValue) ? function () {
-      return getValue;
-    } : getValue;
+    let scale = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : 1;
+    let exponentialScroll = arguments.length > 6 && arguments[6] !== undefined ? arguments[6] : false;
+    const getFn = Number.isFinite(getValue) ? () => getValue : getValue;
     model.horizontalListener = {
-      min: min,
-      max: max,
-      step: step,
+      min,
+      max,
+      step,
       getValue: getFn,
-      setValue: setValue,
-      scale: scale,
-      exponentialScroll: exponentialScroll
+      setValue,
+      scale,
+      exponentialScroll
     };
     incrementalDelta.set(model.horizontalListener, 0);
     publicAPI.modified();
-  }; //-------------------------------------------------------------------------
-
+  };
 
+  //-------------------------------------------------------------------------
   publicAPI.setVerticalListener = function (min, max, step, getValue, setValue) {
-    var scale = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : 1;
-    var exponentialScroll = arguments.length > 6 && arguments[6] !== undefined ? arguments[6] : false;
-    var getFn = Number.isFinite(getValue) ? function () {
-      return getValue;
-    } : getValue;
+    let scale = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : 1;
+    let exponentialScroll = arguments.length > 6 && arguments[6] !== undefined ? arguments[6] : false;
+    const getFn = Number.isFinite(getValue) ? () => getValue : getValue;
     model.verticalListener = {
-      min: min,
-      max: max,
-      step: step,
+      min,
+      max,
+      step,
       getValue: getFn,
-      setValue: setValue,
-      scale: scale,
-      exponentialScroll: exponentialScroll
+      setValue,
+      scale,
+      exponentialScroll
     };
     incrementalDelta.set(model.verticalListener, 0);
     publicAPI.modified();
-  }; //-------------------------------------------------------------------------
-
+  };
 
+  //-------------------------------------------------------------------------
   publicAPI.setScrollListener = function (min, max, step, getValue, setValue) {
-    var scale = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : 1;
-    var exponentialScroll = arguments.length > 6 && arguments[6] !== undefined ? arguments[6] : false;
-
+    let scale = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : 1;
+    let exponentialScroll = arguments.length > 6 && arguments[6] !== undefined ? arguments[6] : false;
     if (step < 0) {
       vtkWarningMacro('Value of step cannot be negative. If you want to invert the scrolling direction, use a negative scale value instead.');
     }
-
-    var stepSize = Math.abs(step);
-    var getFn = Number.isFinite(getValue) ? function () {
-      return getValue;
-    } : getValue;
+    const stepSize = Math.abs(step);
+    const getFn = Number.isFinite(getValue) ? () => getValue : getValue;
     model.scrollListener = {
-      min: min,
-      max: max,
+      min,
+      max,
       step: stepSize,
       getValue: getFn,
-      setValue: setValue,
-      scale: scale,
-      exponentialScroll: exponentialScroll
+      setValue,
+      scale,
+      exponentialScroll
     };
     incrementalDelta.set(model.scrollListener, 0);
     publicAPI.modified();
-  }; //-------------------------------------------------------------------------
-
+  };
 
-  publicAPI.removeHorizontalListener = function () {
+  //-------------------------------------------------------------------------
+  publicAPI.removeHorizontalListener = () => {
     if (model.horizontalListener) {
       incrementalDelta.delete(model.horizontalListener);
       delete model.horizontalListener;
       publicAPI.modified();
     }
-  }; //-------------------------------------------------------------------------
-
+  };
 
-  publicAPI.removeVerticalListener = function () {
+  //-------------------------------------------------------------------------
+  publicAPI.removeVerticalListener = () => {
     if (model.verticalListener) {
       incrementalDelta.delete(model.verticalListener);
       delete model.verticalListener;
       publicAPI.modified();
     }
-  }; //-------------------------------------------------------------------------
-
+  };
 
-  publicAPI.removeScrollListener = function () {
+  //-------------------------------------------------------------------------
+  publicAPI.removeScrollListener = () => {
     if (model.scrollListener) {
       incrementalDelta.delete(model.scrollListener);
       delete model.scrollListener;
       publicAPI.modified();
     }
-  }; //-------------------------------------------------------------------------
-
+  };
 
-  publicAPI.removeAllListeners = function () {
+  //-------------------------------------------------------------------------
+  publicAPI.removeAllListeners = () => {
     publicAPI.removeHorizontalListener();
     publicAPI.removeVerticalListener();
     publicAPI.removeScrollListener();
-  }; //-------------------------------------------------------------------------
-
+  };
 
-  publicAPI.onButtonDown = function (interactor, renderer, position) {
+  //-------------------------------------------------------------------------
+  publicAPI.onButtonDown = (interactor, renderer, position) => {
     model.previousPosition = position;
     model.interactionNetDelta = 0;
-    var glRenderWindow = interactor.getView(); // Ratio is the dom size vs renderwindow size
-
-    var ratio = glRenderWindow.getContainerSize()[0] / glRenderWindow.getSize()[0]; // Get proper pixel range used by viewport in rw size space
-
-    var size = glRenderWindow.getViewportSize(renderer); // rescale size to match mouse event position
-
-    model.containerSize = size.map(function (v) {
-      return v * ratio;
-    });
+    const glRenderWindow = interactor.getView();
+    // Ratio is the dom size vs renderwindow size
+    const ratio = glRenderWindow.getContainerSize()[0] / glRenderWindow.getSize()[0];
+    // Get proper pixel range used by viewport in rw size space
+    const size = glRenderWindow.getViewportSize(renderer);
+    // rescale size to match mouse event position
+    model.containerSize = size.map(v => v * ratio);
   };
-
-  publicAPI.onButtonUp = function (interactor) {
+  publicAPI.onButtonUp = interactor => {
     interactor.exitPointerLock();
-  }; //--------------------------------------------------------------------------
+  };
+
+  //--------------------------------------------------------------------------
+
   // TODO: at some point, this should perhaps be done in
   // RenderWindowInteractor instead of here.
   // We need to hook into mousemove directly for two reasons:
@@ -183,117 +181,114 @@ function vtkMouseRangeManipulator(publicAPI, model) {
   // 2. Since the mouse is stationary in pointer lock mode, we need the
   //    event.movementX and event.movementY info, which are not currently
   //    passed via interactor.onMouseMove.
-
-
-  publicAPI.startPointerLockEvent = function (interactor, renderer) {
-    var handlePointerLockMove = function handlePointerLockMove(event) {
+  publicAPI.startPointerLockEvent = (interactor, renderer) => {
+    const handlePointerLockMove = event => {
       publicAPI.onPointerLockMove(interactor, renderer, event);
     };
-
     document.addEventListener('mousemove', handlePointerLockMove);
-    var subscription = null;
-
-    var endInteraction = function endInteraction() {
-      var _subscription;
-
+    let subscription = null;
+    const endInteraction = () => {
       document.removeEventListener('mousemove', handlePointerLockMove);
-      (_subscription = subscription) === null || _subscription === void 0 ? void 0 : _subscription.unsubscribe();
+      subscription?.unsubscribe();
     };
-
-    subscription = interactor === null || interactor === void 0 ? void 0 : interactor.onEndPointerLock(endInteraction);
+    subscription = interactor?.onEndPointerLock(endInteraction);
   };
-
-  publicAPI.onPointerLockMove = function (interactor, renderer, event) {
+  publicAPI.onPointerLockMove = (interactor, renderer, event) => {
     // There is a slight delay between the `onEndPointerLock` call
     // and the last `onMouseMove` event, we must make sure the pointer
     // is still locked before we run this logic otherwise we may
     // get a `onMouseMove` call after the pointer has been unlocked.
-    if (!interactor.isPointerLocked()) return; // previousPosition could be undefined if for some reason the
-    // `startPointerLockEvent` method is called before the `onButtonDown` one.
+    if (!interactor.isPointerLocked()) return;
 
+    // previousPosition could be undefined if for some reason the
+    // `startPointerLockEvent` method is called before the `onButtonDown` one.
     if (model.previousPosition == null) return;
     model.previousPosition.x += event.movementX;
     model.previousPosition.y += event.movementY;
     publicAPI.onMouseMove(interactor, renderer, model.previousPosition);
-  }; //-------------------------------------------------------------------------
-
+  };
 
-  publicAPI.onMouseMove = function (interactor, renderer, position) {
+  //-------------------------------------------------------------------------
+  publicAPI.onMouseMove = (interactor, renderer, position) => {
     if (!model.verticalListener && !model.horizontalListener) {
       return;
-    } // We only want to initialize the pointer lock listener
+    }
+
+    // We only want to initialize the pointer lock listener
     // after the user starts moving their mouse, this way
     // we don't interfere with other events such as doubleClick,
     // for this reason we don't call this from `onButtonDown`
-
-
     if (model.usePointerLock && !interactor.isPointerLocked()) {
       interactor.requestPointerLock();
       publicAPI.startPointerLockEvent(interactor, renderer);
     }
-
     if (!position) {
       return;
     }
-
     if (model.horizontalListener) {
-      var dxNorm = (position.x - model.previousPosition.x) / model.containerSize[0];
-      var dx = scaleDeltaToRange(model.horizontalListener, dxNorm);
+      const dxNorm = (position.x - model.previousPosition.x) / model.containerSize[0];
+      const dx = scaleDeltaToRange(model.horizontalListener, dxNorm);
       model.interactionNetDelta += dx;
       processDelta(model.horizontalListener, dx);
     }
-
     if (model.verticalListener) {
-      var dyNorm = (position.y - model.previousPosition.y) / model.containerSize[1];
-      var dy = scaleDeltaToRange(model.verticalListener, dyNorm);
+      const dyNorm = (position.y - model.previousPosition.y) / model.containerSize[1];
+      const dy = scaleDeltaToRange(model.verticalListener, dyNorm);
       model.interactionNetDelta += dy;
       processDelta(model.verticalListener, dy);
     }
-
     model.previousPosition = position;
-  }; //-------------------------------------------------------------------------
-
+  };
 
-  publicAPI.onScroll = function (interactor, renderer, delta) {
+  //-------------------------------------------------------------------------
+  publicAPI.onScroll = (interactor, renderer, delta) => {
     if (!model.scrollListener || !delta) {
       return;
     }
-
     model.interactionNetDelta += delta * model.scrollListener.step;
     processDelta(model.scrollListener, delta * model.scrollListener.step);
   };
-
-  publicAPI.onStartScroll = function () {
+  publicAPI.onStartScroll = () => {
     model.interactionNetDelta = 0;
   };
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
-
-var DEFAULT_VALUES = {
+const DEFAULT_VALUES = {
   horizontalListener: null,
   verticalListener: null,
   scrollListener: null
-}; // ----------------------------------------------------------------------------
+};
+
+// ----------------------------------------------------------------------------
 
 function extend(publicAPI, model) {
-  var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-  Object.assign(model, DEFAULT_VALUES, initialValues); // Inheritance
+  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  Object.assign(model, DEFAULT_VALUES, initialValues);
 
+  // Inheritance
   macro.obj(publicAPI, model);
-  vtkCompositeMouseManipulator.extend(publicAPI, model, initialValues); // Create get-set macros
+  vtkCompositeMouseManipulator.extend(publicAPI, model, initialValues);
 
-  macro.setGet(publicAPI, model, ['usePointerLock']); // Object specific methods
+  // Create get-set macros
+  macro.setGet(publicAPI, model, ['usePointerLock']);
 
+  // Object specific methods
   vtkMouseRangeManipulator(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
 
-var newInstance = macro.newInstance(extend, 'vtkMouseRangeManipulator'); // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+
+const newInstance = macro.newInstance(extend, 'vtkMouseRangeManipulator');
+
+// ----------------------------------------------------------------------------
 
 var vtkMouseRangeManipulator$1 = {
-  newInstance: newInstance,
-  extend: extend
+  newInstance,
+  extend
 };
 
 export { vtkMouseRangeManipulator$1 as default, extend, newInstance };

package/Interaction/Manipulators/VRButtonPanManipulator.js

@@ -1,64 +1,74 @@
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.js';
 import vtkCompositeVRManipulator from './CompositeVRManipulator.js';
 import { Device, Input } from '../../Rendering/Core/RenderWindowInteractor/Constants.js';
 import { States } from '../../Rendering/Core/InteractorStyle/Constants.js';
 
+// ----------------------------------------------------------------------------
 // vtkVRButtonPanManipulator methods
 // ----------------------------------------------------------------------------
 
 function vtkVRButtonPanManipulator(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkVRButtonPanManipulator');
-
-  publicAPI.onButton3D = function (interactorStyle, renderer, state, device, input, pressed) {
+  publicAPI.onButton3D = (interactorStyle, renderer, state, device, input, pressed) => {
     if (pressed) {
       interactorStyle.startCameraPose();
     } else if (state === States.IS_CAMERA_POSE) {
       interactorStyle.endCameraPose();
     }
   };
-
-  publicAPI.onMove3D = function (interactorStyle, renderer, state, data) {
+  publicAPI.onMove3D = (interactorStyle, renderer, state, data) => {
     if (state !== States.IS_CAMERA_POSE) {
       return;
-    } // move the world in the direction of the
-    // controller
-
+    }
 
-    var camera = renderer.getActiveCamera();
-    var oldTrans = camera.getPhysicalTranslation(); // look at the y axis to determine how fast / what direction to move
+    // move the world in the direction of the
+    // controller
+    const camera = renderer.getActiveCamera();
+    const oldTrans = camera.getPhysicalTranslation();
 
-    var speed = data.gamepad.axes[1]; // 0.05 meters / frame movement
+    // look at the y axis to determine how fast / what direction to move
+    const speed = data.gamepad.axes[1];
 
-    var pscale = speed * 0.05 * camera.getPhysicalScale(); // convert orientation to world coordinate direction
+    // 0.05 meters / frame movement
+    const pscale = speed * 0.05 * camera.getPhysicalScale();
 
-    var dir = camera.physicalOrientationToWorldDirection(data.orientation);
+    // convert orientation to world coordinate direction
+    const dir = camera.physicalOrientationToWorldDirection(data.orientation);
     camera.setPhysicalTranslation(oldTrans[0] + dir[0] * pscale, oldTrans[1] + dir[1] * pscale, oldTrans[2] + dir[2] * pscale);
   };
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
-
-var DEFAULT_VALUES = {
+const DEFAULT_VALUES = {
   device: Device.RightController,
   input: Input.TrackPad
-}; // ----------------------------------------------------------------------------
+};
+
+// ----------------------------------------------------------------------------
 
 function extend(publicAPI, model) {
-  var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
   Object.assign(model, DEFAULT_VALUES, initialValues);
   macro.obj(publicAPI, model);
-  vtkCompositeVRManipulator.extend(publicAPI, model, initialValues); // Object specific methods
+  vtkCompositeVRManipulator.extend(publicAPI, model, initialValues);
 
+  // Object specific methods
   vtkVRButtonPanManipulator(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
 
-var newInstance = macro.newInstance(extend, 'vtkVRButtonPanManipulator'); // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+
+const newInstance = macro.newInstance(extend, 'vtkVRButtonPanManipulator');
+
+// ----------------------------------------------------------------------------
 
 var vtkVRButtonPanManipulator$1 = {
-  newInstance: newInstance,
-  extend: extend
+  newInstance,
+  extend
 };
 
 export { vtkVRButtonPanManipulator$1 as default, extend, newInstance };

package/Interaction/Manipulators.js

@@ -21,27 +21,27 @@ import vtkMouseRangeManipulator from './Manipulators/MouseRangeManipulator.js';
 import vtkVRButtonPanManipulator from './Manipulators/VRButtonPanManipulator.js';
 
 var Manipulators = {
-  vtkCompositeCameraManipulator: vtkCompositeCameraManipulator,
-  vtkCompositeGestureManipulator: vtkCompositeGestureManipulator,
-  vtkCompositeKeyboardManipulator: vtkCompositeKeyboardManipulator,
-  vtkCompositeMouseManipulator: vtkCompositeMouseManipulator,
-  vtkCompositeVRManipulator: vtkCompositeVRManipulator,
-  vtkGestureCameraManipulator: vtkGestureCameraManipulator,
-  vtkKeyboardCameraManipulator: vtkKeyboardCameraManipulator,
-  vtkMouseBoxSelectorManipulator: vtkMouseBoxSelectorManipulator,
-  vtkMouseCameraAxisRotateManipulator: vtkMouseCameraAxisRotateManipulator,
-  vtkMouseCameraSliceManipulator: vtkMouseCameraSliceManipulator,
-  vtkMouseCameraUnicamManipulator: vtkMouseCameraUnicamManipulator,
-  vtkMouseCameraUnicamRotateManipulator: vtkMouseCameraUnicamRotateManipulator,
-  vtkMouseCameraTrackballFirstPersonManipulator: vtkMouseCameraTrackballFirstPersonManipulator,
-  vtkMouseCameraTrackballMultiRotateManipulator: vtkMouseCameraTrackballMultiRotateManipulator,
-  vtkMouseCameraTrackballPanManipulator: vtkMouseCameraTrackballPanManipulator,
-  vtkMouseCameraTrackballRollManipulator: vtkMouseCameraTrackballRollManipulator,
-  vtkMouseCameraTrackballRotateManipulator: vtkMouseCameraTrackballRotateManipulator,
-  vtkMouseCameraTrackballZoomManipulator: vtkMouseCameraTrackballZoomManipulator,
-  vtkMouseCameraTrackballZoomToMouseManipulator: vtkMouseCameraTrackballZoomToMouseManipulator,
-  vtkMouseRangeManipulator: vtkMouseRangeManipulator,
-  vtkVRButtonPanManipulator: vtkVRButtonPanManipulator
+  vtkCompositeCameraManipulator,
+  vtkCompositeGestureManipulator,
+  vtkCompositeKeyboardManipulator,
+  vtkCompositeMouseManipulator,
+  vtkCompositeVRManipulator,
+  vtkGestureCameraManipulator,
+  vtkKeyboardCameraManipulator,
+  vtkMouseBoxSelectorManipulator,
+  vtkMouseCameraAxisRotateManipulator,
+  vtkMouseCameraSliceManipulator,
+  vtkMouseCameraUnicamManipulator,
+  vtkMouseCameraUnicamRotateManipulator,
+  vtkMouseCameraTrackballFirstPersonManipulator,
+  vtkMouseCameraTrackballMultiRotateManipulator,
+  vtkMouseCameraTrackballPanManipulator,
+  vtkMouseCameraTrackballRollManipulator,
+  vtkMouseCameraTrackballRotateManipulator,
+  vtkMouseCameraTrackballZoomManipulator,
+  vtkMouseCameraTrackballZoomToMouseManipulator,
+  vtkMouseRangeManipulator,
+  vtkVRButtonPanManipulator
 };
 
 export { Manipulators as default };