@kitware/vtk.js 28.10.2 → 28.11.0

package/Interaction/Manipulators/CompositeMouseManipulator.js

@@ -1,61 +1,55 @@
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.js';
 
+// ----------------------------------------------------------------------------
 // vtkCompositeMouseManipulator methods
 // ----------------------------------------------------------------------------
 
 function vtkCompositeMouseManipulator(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkCompositeMouseManipulator');
+  publicAPI.startInteraction = () => {};
+  publicAPI.endInteraction = () => {};
+  publicAPI.onButtonDown = (interactor, renderer, position) => {};
+  publicAPI.onButtonUp = interactor => {};
+  publicAPI.onMouseMove = (interactor, renderer, position) => {};
+  publicAPI.onStartScroll = (interactor, renderer, delta) => {};
+  publicAPI.onScroll = (interactor, renderer, delta) => {};
+  publicAPI.onEndScroll = interactor => {};
+  publicAPI.isDragEnabled = () => model.dragEnabled;
+  publicAPI.isScrollEnabled = () => model.scrollEnabled;
+}
 
-  publicAPI.startInteraction = function () {};
-
-  publicAPI.endInteraction = function () {};
-
-  publicAPI.onButtonDown = function (interactor, renderer, position) {};
-
-  publicAPI.onButtonUp = function (interactor) {};
-
-  publicAPI.onMouseMove = function (interactor, renderer, position) {};
-
-  publicAPI.onStartScroll = function (interactor, renderer, delta) {};
-
-  publicAPI.onScroll = function (interactor, renderer, delta) {};
-
-  publicAPI.onEndScroll = function (interactor) {};
-
-  publicAPI.isDragEnabled = function () {
-    return model.dragEnabled;
-  };
-
-  publicAPI.isScrollEnabled = function () {
-    return model.scrollEnabled;
-  };
-} // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
-
-var DEFAULT_VALUES = {
+const DEFAULT_VALUES = {
   button: 1,
   shift: false,
   control: false,
   alt: false,
   dragEnabled: true,
   scrollEnabled: false
-}; // ----------------------------------------------------------------------------
+};
+
+// ----------------------------------------------------------------------------
 
 function extend(publicAPI, model) {
-  var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-  Object.assign(model, DEFAULT_VALUES, initialValues); // Create get-set macros
+  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  Object.assign(model, DEFAULT_VALUES, initialValues);
 
+  // Create get-set macros
   macro.setGet(publicAPI, model, ['button', 'shift', 'control', 'alt']);
-  macro.set(publicAPI, model, ['dragEnabled', 'scrollEnabled']); // Object specific methods
+  macro.set(publicAPI, model, ['dragEnabled', 'scrollEnabled']);
 
+  // Object specific methods
   vtkCompositeMouseManipulator(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 
 var vtkCompositeMouseManipulator$1 = {
-  extend: extend
+  extend
 };
 
 export { vtkCompositeMouseManipulator$1 as default, extend };

package/Interaction/Manipulators/CompositeVRManipulator.js

@@ -1,38 +1,45 @@
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.js';
 import { Device, Input } from '../../Rendering/Core/RenderWindowInteractor/Constants.js';
 
+// ----------------------------------------------------------------------------
 // vtkCompositeVRManipulator methods
 // ----------------------------------------------------------------------------
 
 function vtkCompositeVRManipulator(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkCompositeVRManipulator');
+  publicAPI.onButton3D = (interactor, renderer, state, device, input, pressed) => {};
+  publicAPI.onMove3D = (interactor, renderer, state, device, input, pressed) => {};
+}
 
-  publicAPI.onButton3D = function (interactor, renderer, state, device, input, pressed) {};
-
-  publicAPI.onMove3D = function (interactor, renderer, state, device, input, pressed) {};
-} // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
-
-var DEFAULT_VALUES = {// device: null, // Device.RightController
+const DEFAULT_VALUES = {
+  // device: null, // Device.RightController
   // input: null, // Input.TrackPad
-}; // ----------------------------------------------------------------------------
+};
+
+// ----------------------------------------------------------------------------
 
 function extend(publicAPI, model) {
-  var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-  Object.assign(model, DEFAULT_VALUES, initialValues); // Create get-set macros
+  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  Object.assign(model, DEFAULT_VALUES, initialValues);
 
-  macro.setGet(publicAPI, model, ['device', 'input']); // Object specific methods
+  // Create get-set macros
+  macro.setGet(publicAPI, model, ['device', 'input']);
 
+  // Object specific methods
   vtkCompositeVRManipulator(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 
 var vtkCompositeVRManipulator$1 = {
-  extend: extend,
-  Device: Device,
-  Input: Input
+  extend,
+  Device,
+  Input
 };
 
 export { vtkCompositeVRManipulator$1 as default, extend };

package/Interaction/Manipulators/GestureCameraManipulator.js

@@ -1,97 +1,115 @@
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.js';
 import vtkCompositeCameraManipulator from './CompositeCameraManipulator.js';
 import vtkCompositeGestureManipulator from './CompositeGestureManipulator.js';
 import vtkInteractorStyleManipulator from '../Style/InteractorStyleManipulator.js';
 
+// ----------------------------------------------------------------------------
 // vtkGestureCameraManipulator methods
 // ----------------------------------------------------------------------------
 
 function vtkGestureCameraManipulator(publicAPI, model) {
   // Set our className
-  model.classHierarchy.push('vtkGestureCameraManipulator'); //--------------------------------------------------------------------------
+  model.classHierarchy.push('vtkGestureCameraManipulator');
+
+  //--------------------------------------------------------------------------
 
-  publicAPI.onStartPinch = function (interactor, scale) {
+  publicAPI.onStartPinch = (interactor, scale) => {
     model.previousScale = scale;
-  }; //---------------------------------------------------------------------------
+  };
 
+  //---------------------------------------------------------------------------
 
-  publicAPI.onStartRotate = function (interactor, rotation) {
+  publicAPI.onStartRotate = (interactor, rotation) => {
     model.previousRotation = rotation;
-  }; //---------------------------------------------------------------------------
+  };
 
+  //---------------------------------------------------------------------------
 
-  publicAPI.onStartPan = function (interactor, translation) {
+  publicAPI.onStartPan = (interactor, translation) => {
     model.previousTranslation = translation;
-  }; //---------------------------------------------------------------------------
+  };
 
+  //---------------------------------------------------------------------------
 
-  publicAPI.onPinch = function (interactor, renderer, scale) {
+  publicAPI.onPinch = (interactor, renderer, scale) => {
     vtkInteractorStyleManipulator.dollyByFactor(interactor, renderer, scale / model.previousScale);
     model.previousScale = scale;
-  }; //---------------------------------------------------------------------------
+  };
 
+  //---------------------------------------------------------------------------
 
-  publicAPI.onPan = function (interactor, renderer, translation) {
-    var camera = renderer.getActiveCamera();
-    var style = interactor.getInteractorStyle(); // Calculate the focal depth since we'll be using it a lot
+  publicAPI.onPan = (interactor, renderer, translation) => {
+    const camera = renderer.getActiveCamera();
+    const style = interactor.getInteractorStyle();
 
-    var viewFocus = camera.getFocalPoint();
+    // Calculate the focal depth since we'll be using it a lot
+    let viewFocus = camera.getFocalPoint();
     viewFocus = style.computeWorldToDisplay(renderer, viewFocus[0], viewFocus[1], viewFocus[2]);
-    var focalDepth = viewFocus[2];
-    var trans = translation;
-    var lastTrans = model.previousTranslation;
-    var newPickPoint = style.computeDisplayToWorld(renderer, viewFocus[0] + trans[0] - lastTrans[0], viewFocus[1] + trans[1] - lastTrans[1], focalDepth); // Has to recalc old mouse point since the viewport has moved,
-    // so can't move it outside the loop
+    const focalDepth = viewFocus[2];
+    const trans = translation;
+    const lastTrans = model.previousTranslation;
+    const newPickPoint = style.computeDisplayToWorld(renderer, viewFocus[0] + trans[0] - lastTrans[0], viewFocus[1] + trans[1] - lastTrans[1], focalDepth);
 
-    var oldPickPoint = style.computeDisplayToWorld(renderer, viewFocus[0], viewFocus[1], focalDepth); // Camera motion is reversed
+    // Has to recalc old mouse point since the viewport has moved,
+    // so can't move it outside the loop
+    const oldPickPoint = style.computeDisplayToWorld(renderer, viewFocus[0], viewFocus[1], focalDepth);
 
-    var motionVector = [];
+    // Camera motion is reversed
+    const motionVector = [];
     motionVector[0] = oldPickPoint[0] - newPickPoint[0];
     motionVector[1] = oldPickPoint[1] - newPickPoint[1];
     motionVector[2] = oldPickPoint[2] - newPickPoint[2];
     viewFocus = camera.getFocalPoint();
-    var viewPoint = camera.getPosition();
+    const viewPoint = camera.getPosition();
     camera.setFocalPoint(motionVector[0] + viewFocus[0], motionVector[1] + viewFocus[1], motionVector[2] + viewFocus[2]);
     camera.setPosition(motionVector[0] + viewPoint[0], motionVector[1] + viewPoint[1], motionVector[2] + viewPoint[2]);
-
     if (interactor.getLightFollowCamera()) {
       renderer.updateLightsGeometryToFollowCamera();
     }
-
     camera.orthogonalizeViewUp();
     model.previousTranslation = translation;
-  }; //---------------------------------------------------------------------------
+  };
 
+  //---------------------------------------------------------------------------
 
-  publicAPI.onRotate = function (interactor, renderer, rotation) {
-    var camera = renderer.getActiveCamera();
+  publicAPI.onRotate = (interactor, renderer, rotation) => {
+    const camera = renderer.getActiveCamera();
     camera.roll(rotation - model.previousRotation);
     camera.orthogonalizeViewUp();
     model.previousRotation = rotation;
   };
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
+const DEFAULT_VALUES = {};
 
-var DEFAULT_VALUES = {}; // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
 
 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);
   vtkCompositeGestureManipulator.extend(publicAPI, model, initialValues);
-  vtkCompositeCameraManipulator.extend(publicAPI, model, initialValues); // Object specific methods
+  vtkCompositeCameraManipulator.extend(publicAPI, model, initialValues);
 
+  // Object specific methods
   vtkGestureCameraManipulator(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
 
-var newInstance = macro.newInstance(extend, 'vtkGestureCameraManipulator'); // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+
+const newInstance = macro.newInstance(extend, 'vtkGestureCameraManipulator');
+
+// ----------------------------------------------------------------------------
 
 var vtkGestureCameraManipulator$1 = {
-  newInstance: newInstance,
-  extend: extend
+  newInstance,
+  extend
 };
 
 export { vtkGestureCameraManipulator$1 as default, extend, newInstance };

package/Interaction/Manipulators/KeyboardCameraManipulator.js

@@ -1,223 +1,212 @@
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.js';
 import vtkBoundingBox from '../../Common/DataModel/BoundingBox.js';
 import vtkCompositeKeyboardManipulator from './CompositeKeyboardManipulator.js';
 import { k as add, l as normalize, j as cross } from '../../Common/Core/Math/index.js';
 
-var vtkErrorMacro = macro.vtkErrorMacro;
-var ANIMATION_REQUESTER = 'vtkKeyboardCameraManipulator'; // ----------------------------------------------------------------------------
+const {
+  vtkErrorMacro
+} = macro;
+const ANIMATION_REQUESTER = 'vtkKeyboardCameraManipulator';
+
+// ----------------------------------------------------------------------------
 // vtkKeyboardCameraManipulator methods
 // ----------------------------------------------------------------------------
 
 function vtkKeyboardCameraManipulator(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkKeyboardCameraManipulator');
-  var internal = {
+  const internal = {
     keysDown: [],
     direction: [0, 0, 0],
     skipUpdateDirection: false,
     animationSub: null,
     cameraModifiedSub: null
-  }; //--------------------------------------------------------------------------
+  };
+
+  //--------------------------------------------------------------------------
 
-  publicAPI.inMotion = function () {
-    return internal.animationSub !== null;
-  }; //--------------------------------------------------------------------------
+  publicAPI.inMotion = () => internal.animationSub !== null;
 
+  //--------------------------------------------------------------------------
 
-  publicAPI.resetMovementSpeed = function () {
+  publicAPI.resetMovementSpeed = () => {
     // Reset the movement speed to be proportional to the longest length
     // of the renderer's bounds.
-    var renderer = model.renderer;
-    var bounds = renderer.computeVisiblePropBounds(); // Just a number that seems to work okay for our examples...
+    const {
+      renderer
+    } = model;
+    const bounds = renderer.computeVisiblePropBounds();
 
-    var divisor = 500;
+    // Just a number that seems to work okay for our examples...
+    const divisor = 500;
     model.movementSpeed = vtkBoundingBox.getMaxLength(bounds) / divisor;
-  }; //--------------------------------------------------------------------------
+  };
 
+  //--------------------------------------------------------------------------
 
-  publicAPI.startMovement = function () {
+  publicAPI.startMovement = () => {
     if (publicAPI.inMotion()) {
       vtkErrorMacro('Camera is already in motion!');
       return;
     }
-
     if (model.movementSpeed === null) {
       publicAPI.resetMovementSpeed();
     }
-
-    var interactor = model.interactor,
-        renderer = model.renderer;
-
-    var move = function move() {
+    const {
+      interactor,
+      renderer
+    } = model;
+    const move = () => {
       if (internal.keysDown.length === 0) {
         return;
-      } // No need to update the direction when we move the camera here...
-
+      }
 
+      // No need to update the direction when we move the camera here...
       internal.skipUpdateDirection = true;
       publicAPI.moveCamera(renderer.getActiveCamera(), internal.direction, model.movementSpeed);
       renderer.resetCameraClippingRange();
-
       if (interactor.getLightFollowCamera()) {
         renderer.updateLightsGeometryToFollowCamera();
       }
-
       internal.skipUpdateDirection = false;
     };
-
     publicAPI.calculateCurrentDirection();
-    var camera = renderer.getActiveCamera(); // If the camera gets modified elsewhere, let's update the direction
-
+    const camera = renderer.getActiveCamera();
+    // If the camera gets modified elsewhere, let's update the direction
     internal.cameraModifiedSub = camera.onModified(publicAPI.calculateCurrentDirection);
     interactor.requestAnimation(ANIMATION_REQUESTER);
-    internal.animationSub = interactor.onAnimation(function () {
-      return move();
-    });
-  }; //--------------------------------------------------------------------------
+    internal.animationSub = interactor.onAnimation(() => move());
+  };
 
+  //--------------------------------------------------------------------------
 
-  publicAPI.endMovement = function () {
+  publicAPI.endMovement = () => {
     if (internal.animationSub) {
       internal.animationSub.unsubscribe();
       internal.animationSub = null;
     }
-
     model._interactor.cancelAnimation(ANIMATION_REQUESTER);
-
     if (internal.cameraModifiedSub) {
       internal.cameraModifiedSub.unsubscribe();
       internal.cameraModifiedSub = null;
     }
-  }; //--------------------------------------------------------------------------
+  };
 
+  //--------------------------------------------------------------------------
 
-  publicAPI.calculateCurrentDirection = function () {
+  publicAPI.calculateCurrentDirection = () => {
     if (internal.skipUpdateDirection) {
       return;
-    } // Reset
-
+    }
 
+    // Reset
     internal.direction = [0, 0, 0];
-    var renderer = model.renderer;
-
+    const {
+      renderer
+    } = model;
     if (!renderer) {
       return;
     }
-
-    var camera = renderer.getActiveCamera();
-
+    const camera = renderer.getActiveCamera();
     if (!camera) {
       return;
     }
-
     if (internal.keysDown.length === 0) {
       return;
     }
-
-    var directions = internal.keysDown.map(function (key) {
-      return publicAPI.getDirectionFromKey(key, camera);
-    });
-    directions = directions.filter(function (item) {
-      return item;
-    });
-
+    let directions = internal.keysDown.map(key => publicAPI.getDirectionFromKey(key, camera));
+    directions = directions.filter(item => item);
     if (directions.length === 0) {
       return;
     }
-
-    var netDirection = directions.reduce(function (a, b) {
+    const netDirection = directions.reduce((a, b) => {
       add(a, b, b);
       return b;
     });
     normalize(netDirection);
     internal.direction = netDirection;
-  }; //--------------------------------------------------------------------------
-
+  };
 
-  publicAPI.getDirectionFromKey = function (key, camera) {
-    var direction;
+  //--------------------------------------------------------------------------
 
+  publicAPI.getDirectionFromKey = (key, camera) => {
+    let direction;
     if (model.moveForwardKeys.includes(key)) {
       // Move forward
       direction = camera.getDirectionOfProjection();
     } else if (model.moveLeftKeys.includes(key)) {
       // Move left
-      var dirProj = camera.getDirectionOfProjection();
+      const dirProj = camera.getDirectionOfProjection();
       direction = [0, 0, 0];
       cross(camera.getViewUp(), dirProj, direction);
     } else if (model.moveBackwardKeys.includes(key)) {
       // Move backward
-      direction = camera.getDirectionOfProjection().map(function (e) {
-        return -e;
-      });
+      direction = camera.getDirectionOfProjection().map(e => -e);
     } else if (model.moveRightKeys.includes(key)) {
       // Move right
-      var _dirProj = camera.getDirectionOfProjection();
-
+      const dirProj = camera.getDirectionOfProjection();
       direction = [0, 0, 0];
-      cross(_dirProj, camera.getViewUp(), direction);
+      cross(dirProj, camera.getViewUp(), direction);
     } else if (model.moveUpKeys.includes(key)) {
       // Move up
       direction = camera.getViewUp();
     } else if (model.moveDownKeys.includes(key)) {
       // Move down
-      direction = camera.getViewUp().map(function (e) {
-        return -e;
-      });
+      direction = camera.getViewUp().map(e => -e);
     } else {
       return undefined;
     }
-
     normalize(direction);
     return direction;
-  }; //--------------------------------------------------------------------------
+  };
 
+  //--------------------------------------------------------------------------
 
-  publicAPI.moveCamera = function (camera, direction, speed) {
-    var position = camera.getPosition();
-    var focalPoint = camera.getFocalPoint();
+  publicAPI.moveCamera = (camera, direction, speed) => {
+    const position = camera.getPosition();
+    const focalPoint = camera.getFocalPoint();
     camera.setFocalPoint(focalPoint[0] + direction[0] * speed, focalPoint[1] + direction[1] * speed, focalPoint[2] + direction[2] * speed);
     camera.setPosition(position[0] + direction[0] * speed, position[1] + direction[1] * speed, position[2] + direction[2] * speed);
-  }; //--------------------------------------------------------------------------
+  };
 
+  //--------------------------------------------------------------------------
 
-  publicAPI.onKeyPress = function (interactor, renderer, key) {}; //--------------------------------------------------------------------------
+  publicAPI.onKeyPress = (interactor, renderer, key) => {};
 
+  //--------------------------------------------------------------------------
 
-  publicAPI.onKeyDown = function (interactor, renderer, key) {
+  publicAPI.onKeyDown = (interactor, renderer, key) => {
     if (!internal.keysDown.includes(key)) {
       internal.keysDown.push(key);
       publicAPI.calculateCurrentDirection();
     }
-
     if (!publicAPI.inMotion()) {
       Object.assign(model, {
-        interactor: interactor,
-        renderer: renderer
+        interactor,
+        renderer
       });
       publicAPI.startMovement();
     }
-  }; //--------------------------------------------------------------------------
+  };
 
+  //--------------------------------------------------------------------------
 
-  publicAPI.onKeyUp = function (interactor, renderer, key) {
+  publicAPI.onKeyUp = (interactor, renderer, key) => {
     // The following is case insensitive for when the user
     // presses/releases the shift key while this key is down.
-    internal.keysDown = internal.keysDown.filter(function (item) {
-      return item.toUpperCase() !== key.toUpperCase();
-    });
+    internal.keysDown = internal.keysDown.filter(item => item.toUpperCase() !== key.toUpperCase());
     publicAPI.calculateCurrentDirection();
-
     if (internal.keysDown.length === 0) {
       publicAPI.endMovement();
     }
   };
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
-
-var DEFAULT_VALUES = {
+const DEFAULT_VALUES = {
   // The movementSpeed is the magnitude of the camera translation
   // for each animation frame (which occur each 1/60 second)
   // If null, publicAPI.resetMovementSpeed() will be called when
@@ -231,25 +220,34 @@ var DEFAULT_VALUES = {
   moveDownKeys: ['Shift'],
   interactor: null,
   renderer: 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);
-  vtkCompositeKeyboardManipulator.extend(publicAPI, model, initialValues); // Create get-set macros
+  vtkCompositeKeyboardManipulator.extend(publicAPI, model, initialValues);
 
-  macro.setGet(publicAPI, model, ['movementSpeed', 'moveForwardKeys', 'moveLeftKeys', 'moveBackwardKeys', 'moveRightKeys', 'moveUpKeys', 'moveDownKeys', 'interactor', 'renderer']); // Object specific methods
+  // Create get-set macros
+  macro.setGet(publicAPI, model, ['movementSpeed', 'moveForwardKeys', 'moveLeftKeys', 'moveBackwardKeys', 'moveRightKeys', 'moveUpKeys', 'moveDownKeys', 'interactor', 'renderer']);
 
+  // Object specific methods
   vtkKeyboardCameraManipulator(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
+
+const newInstance = macro.newInstance(extend, 'vtkKeyboardCameraManipulator');
 
-var newInstance = macro.newInstance(extend, 'vtkKeyboardCameraManipulator'); // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
 
 var vtkKeyboardCameraManipulator$1 = {
-  newInstance: newInstance,
-  extend: extend
+  newInstance,
+  extend
 };
 
 export { vtkKeyboardCameraManipulator$1 as default, extend, newInstance };