@kitware/vtk.js 28.10.2 → 28.11.1

package/Interaction/Manipulators/MouseCameraTrackballFirstPersonManipulator.js

@@ -1,36 +1,44 @@
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.js';
 import vtkCompositeCameraManipulator from './CompositeCameraManipulator.js';
 import vtkCompositeMouseManipulator from './CompositeMouseManipulator.js';
 
-var ANIMATION_REQUESTER = 'vtkMouseCameraTrackballFirstPersonManipulator'; // ----------------------------------------------------------------------------
+const ANIMATION_REQUESTER = 'vtkMouseCameraTrackballFirstPersonManipulator';
+
+// ----------------------------------------------------------------------------
 // vtkMouseCameraTrackballFirstPersonManipulator methods
 // ----------------------------------------------------------------------------
 
 function vtkMouseCameraTrackballFirstPersonManipulator(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkMouseCameraTrackballFirstPersonManipulator');
-  var internal = {
+  const internal = {
     interactor: null,
     renderer: null,
     previousPosition: null
-  }; //--------------------------------------------------------------------------
+  };
 
-  publicAPI.onButtonDown = function (interactor, renderer, position) {
-    internal.previousPosition = position;
+  //--------------------------------------------------------------------------
 
+  publicAPI.onButtonDown = (interactor, renderer, position) => {
+    internal.previousPosition = position;
     if (model.usePointerLock && !interactor.isPointerLocked()) {
       Object.assign(internal, {
-        interactor: interactor,
-        renderer: renderer
+        interactor,
+        renderer
       });
       interactor.requestPointerLock();
       publicAPI.startPointerLockInteraction();
     }
-  }; //--------------------------------------------------------------------------
+  };
+
+  //--------------------------------------------------------------------------
 
+  publicAPI.startPointerLockInteraction = () => {
+    const {
+      interactor
+    } = internal;
 
-  publicAPI.startPointerLockInteraction = function () {
-    var interactor = internal.interactor; // TODO: at some point, this should perhaps be done in
+    // TODO: at some point, this should perhaps be done in
     // RenderWindowInteractor instead of here.
     // We need to hook into mousemove directly for two reasons:
     // 1. We need to keep receiving mouse move events after the mouse button
@@ -39,121 +47,128 @@ function vtkMouseCameraTrackballFirstPersonManipulator(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.
-
     document.addEventListener('mousemove', publicAPI.onPointerLockMove);
-    var subscription = null;
-
-    var endInteraction = function endInteraction() {
+    let subscription = null;
+    const endInteraction = () => {
       document.removeEventListener('mousemove', publicAPI.onPointerLockMove);
       subscription.unsubscribe();
     };
-
     subscription = interactor.onEndPointerLock(endInteraction);
-  }; //--------------------------------------------------------------------------
+  };
 
+  //--------------------------------------------------------------------------
 
-  publicAPI.onPointerLockMove = function (e) {
-    var sensitivity = model.sensitivity;
-    var yaw = -1 * e.movementX * sensitivity;
-    var pitch = -1 * e.movementY * sensitivity;
+  publicAPI.onPointerLockMove = e => {
+    const sensitivity = model.sensitivity;
+    const yaw = -1 * e.movementX * sensitivity;
+    const pitch = -1 * e.movementY * sensitivity;
     publicAPI.moveCamera(yaw, pitch);
-  }; //--------------------------------------------------------------------------
+  };
 
+  //--------------------------------------------------------------------------
 
-  publicAPI.onMouseMove = function (interactor, renderer, position) {
+  publicAPI.onMouseMove = (interactor, renderer, position) => {
     // This is currently only being called for non pointer lock mode
     if (!position) {
       return;
     }
-
-    var previousPosition = internal.previousPosition;
-    var sensitivity = model.sensitivity;
-    var yaw = (previousPosition.x - position.x) * sensitivity;
-    var pitch = (position.y - previousPosition.y) * sensitivity;
+    const {
+      previousPosition
+    } = internal;
+    const sensitivity = model.sensitivity;
+    const yaw = (previousPosition.x - position.x) * sensitivity;
+    const pitch = (position.y - previousPosition.y) * sensitivity;
     Object.assign(internal, {
-      interactor: interactor,
-      renderer: renderer
+      interactor,
+      renderer
     });
     publicAPI.moveCamera(yaw, pitch);
     internal.previousPosition = position;
-  }; //--------------------------------------------------------------------------
+  };
 
+  //--------------------------------------------------------------------------
 
-  publicAPI.moveCamera = function (yaw, pitch) {
-    var renderer = internal.renderer,
-        interactor = internal.interactor;
-    var camera = renderer.getActiveCamera(); // We need to pick a number of steps here that is not too few
+  publicAPI.moveCamera = (yaw, pitch) => {
+    const {
+      renderer,
+      interactor
+    } = internal;
+    const camera = renderer.getActiveCamera();
+
+    // We need to pick a number of steps here that is not too few
     // (or the camera will be jittery) and not too many (or the
     // animations will take too long).
     // Perhaps this should be calculated?
-
-    var numSteps = model.numAnimationSteps;
-    var yawStep = yaw / numSteps;
-    var pitchStep = pitch / numSteps;
-    var now = performance.now().toString();
-    var animationRequester = "".concat(ANIMATION_REQUESTER, ".").concat(now);
-    var curStep = 0;
-    var animationSub = null;
-
-    var performStep = function performStep() {
+    const numSteps = model.numAnimationSteps;
+    const yawStep = yaw / numSteps;
+    const pitchStep = pitch / numSteps;
+    const now = performance.now().toString();
+    const animationRequester = `${ANIMATION_REQUESTER}.${now}`;
+    let curStep = 0;
+    let animationSub = null;
+    const performStep = () => {
       camera.yaw(yawStep);
       camera.pitch(pitchStep);
       camera.orthogonalizeViewUp();
       curStep += 1;
-
       if (curStep === numSteps) {
         animationSub.unsubscribe();
         renderer.resetCameraClippingRange();
-
         if (interactor.getLightFollowCamera()) {
           renderer.updateLightsGeometryToFollowCamera();
-        } // This needs to be posted to the event loop so it isn't called
+        }
+
+        // This needs to be posted to the event loop so it isn't called
         // in the `handleAnimation` stack, or else the animation will
         // not be canceled.
-
-
-        var cancelRequest = function cancelRequest() {
+        const cancelRequest = () => {
           internal.interactor.cancelAnimation(animationRequester);
         };
-
         setTimeout(cancelRequest, 0);
       }
     };
-
     interactor.requestAnimation(animationRequester);
-    animationSub = interactor.onAnimation(function () {
-      return performStep();
-    });
+    animationSub = interactor.onAnimation(() => performStep());
   };
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
-
-var DEFAULT_VALUES = {
+const DEFAULT_VALUES = {
   numAnimationSteps: 5,
   sensitivity: 0.05,
   usePointerLock: true
-}; // ----------------------------------------------------------------------------
+};
+
+// ----------------------------------------------------------------------------
 
 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);
   vtkCompositeCameraManipulator.extend(publicAPI, model, initialValues);
-  vtkCompositeMouseManipulator.extend(publicAPI, model, initialValues); // Create get-set macros
+  vtkCompositeMouseManipulator.extend(publicAPI, model, initialValues);
 
-  macro.setGet(publicAPI, model, ['numAnimationSteps', 'sensitivity', 'usePointerLock']); // Object specific methods
+  // Create get-set macros
+  macro.setGet(publicAPI, model, ['numAnimationSteps', 'sensitivity', 'usePointerLock']);
 
+  // Object specific methods
   vtkMouseCameraTrackballFirstPersonManipulator(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
 
-var newInstance = macro.newInstance(extend, 'vtkMouseCameraTrackballFirstPersonManipulator'); // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+
+const newInstance = macro.newInstance(extend, 'vtkMouseCameraTrackballFirstPersonManipulator');
+
+// ----------------------------------------------------------------------------
 
 var vtkMouseCameraTrackballFirstPersonManipulator$1 = {
-  newInstance: newInstance,
-  extend: extend
+  newInstance,
+  extend
 };
 
 export { vtkMouseCameraTrackballFirstPersonManipulator$1 as default, extend, newInstance };

package/Interaction/Manipulators/MouseCameraTrackballMultiRotateManipulator.js

@@ -1,4 +1,4 @@
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.js';
 import vtkCompositeCameraManipulator from './CompositeCameraManipulator.js';
 import vtkCompositeMouseManipulator from './CompositeMouseManipulator.js';
 import vtkMouseCameraTrackballRotateManipulator from './MouseCameraTrackballRotateManipulator.js';
@@ -7,74 +7,78 @@ import vtkMouseCameraTrackballRollManipulator from './MouseCameraTrackballRollMa
 function max(x, y) {
   return x < y ? y : x;
 }
-
 function sqr(x) {
   return x * x;
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // vtkMouseCameraTrackballMultiRotateManipulator methods
 // ----------------------------------------------------------------------------
 
-
 function vtkMouseCameraTrackballMultiRotateManipulator(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkMouseCameraTrackballMultiRotateManipulator');
-  var rotateManipulator = vtkMouseCameraTrackballRotateManipulator.newInstance();
-  var rollManipulator = vtkMouseCameraTrackballRollManipulator.newInstance();
-  var currentManipulator = null;
-
-  publicAPI.onButtonDown = function (interactor, renderer, position) {
-    var viewSize = interactor.getView().getViewportSize(renderer);
-    var viewCenter = [0.5 * viewSize[0], 0.5 * viewSize[1]];
-    var rotateRadius = 0.9 * max(viewCenter[0], viewCenter[1]);
-    var dist2 = sqr(viewCenter[0] - position.x) + sqr(viewCenter[1] - position.y);
-
+  const rotateManipulator = vtkMouseCameraTrackballRotateManipulator.newInstance();
+  const rollManipulator = vtkMouseCameraTrackballRollManipulator.newInstance();
+  let currentManipulator = null;
+  publicAPI.onButtonDown = (interactor, renderer, position) => {
+    const viewSize = interactor.getView().getViewportSize(renderer);
+    const viewCenter = [0.5 * viewSize[0], 0.5 * viewSize[1]];
+    const rotateRadius = 0.9 * max(viewCenter[0], viewCenter[1]);
+    const dist2 = sqr(viewCenter[0] - position.x) + sqr(viewCenter[1] - position.y);
     if (rotateRadius * rotateRadius > dist2) {
       currentManipulator = rotateManipulator;
     } else {
       currentManipulator = rollManipulator;
     }
-
     currentManipulator.setButton(publicAPI.getButton());
     currentManipulator.setShift(publicAPI.getShift());
     currentManipulator.setControl(publicAPI.getControl());
     currentManipulator.setCenter(publicAPI.getCenter());
     currentManipulator.onButtonDown(interactor, position);
   };
-
-  publicAPI.onButtonUp = function (interactor) {
+  publicAPI.onButtonUp = interactor => {
     if (currentManipulator) {
       currentManipulator.onButtonUp(interactor);
     }
   };
-
-  publicAPI.onMouseMove = function (interactor, renderer, position) {
+  publicAPI.onMouseMove = (interactor, renderer, position) => {
     if (currentManipulator) {
       currentManipulator.onMouseMove(interactor, renderer, position);
     }
   };
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // 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);
   vtkCompositeMouseManipulator.extend(publicAPI, model, initialValues);
-  vtkCompositeCameraManipulator.extend(publicAPI, model, initialValues); // Object specific methods
+  vtkCompositeCameraManipulator.extend(publicAPI, model, initialValues);
 
+  // Object specific methods
   vtkMouseCameraTrackballMultiRotateManipulator(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
 
-var newInstance = macro.newInstance(extend, 'vtkMouseCameraTrackballMultiRotateManipulator'); // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+
+const newInstance = macro.newInstance(extend, 'vtkMouseCameraTrackballMultiRotateManipulator');
+
+// ----------------------------------------------------------------------------
 
 var vtkMouseCameraTrackballMultiRotateManipulator$1 = {
-  newInstance: newInstance,
-  extend: extend
+  newInstance,
+  extend
 };
 
 export { vtkMouseCameraTrackballMultiRotateManipulator$1 as default, extend, newInstance };

package/Interaction/Manipulators/MouseCameraTrackballPanManipulator.js

@@ -1,45 +1,43 @@
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.js';
 import vtkCompositeCameraManipulator from './CompositeCameraManipulator.js';
 import vtkCompositeMouseManipulator from './CompositeMouseManipulator.js';
 import { j as cross } from '../../Common/Core/Math/index.js';
 
+// ----------------------------------------------------------------------------
 // vtkMouseCameraTrackballPanManipulator methods
 // ----------------------------------------------------------------------------
 
 function vtkMouseCameraTrackballPanManipulator(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkMouseCameraTrackballPanManipulator');
-
-  publicAPI.onButtonDown = function (interactor, renderer, position) {
+  publicAPI.onButtonDown = (interactor, renderer, position) => {
     model.previousPosition = position;
   };
-
-  publicAPI.onMouseMove = function (interactor, renderer, position) {
+  publicAPI.onMouseMove = (interactor, renderer, position) => {
     if (!position) {
       return;
     }
-
-    var pos = position;
-    var lastPos = model.previousPosition;
+    const pos = position;
+    const lastPos = model.previousPosition;
     model.previousPosition = position;
-    var camera = renderer.getActiveCamera();
-    var camPos = camera.getPosition();
-    var fp = camera.getFocalPoint();
-
+    const camera = renderer.getActiveCamera();
+    const camPos = camera.getPosition();
+    const fp = camera.getFocalPoint();
     if (camera.getParallelProjection()) {
       camera.orthogonalizeViewUp();
-      var up = camera.getViewUp();
-      var vpn = camera.getViewPlaneNormal();
-      var right = [0, 0, 0];
-      cross(vpn, up, right); // These are different because y is flipped.
-
-      var height = interactor.getView().getViewportSize(renderer)[1];
-      var dx = (pos.x - lastPos.x) / height;
-      var dy = (lastPos.y - pos.y) / height;
-      var scale = camera.getParallelScale();
+      const up = camera.getViewUp();
+      const vpn = camera.getViewPlaneNormal();
+      const right = [0, 0, 0];
+      cross(vpn, up, right);
+
+      // These are different because y is flipped.
+      const height = interactor.getView().getViewportSize(renderer)[1];
+      let dx = (pos.x - lastPos.x) / height;
+      let dy = (lastPos.y - pos.y) / height;
+      const scale = camera.getParallelScale();
       dx *= scale * 2.0;
       dy *= scale * 2.0;
-      var tmp = right[0] * dx + up[0] * dy;
+      let tmp = right[0] * dx + up[0] * dy;
       camPos[0] += tmp;
       fp[0] += tmp;
       tmp = right[1] * dx + up[1] * dy;
@@ -51,46 +49,55 @@ function vtkMouseCameraTrackballPanManipulator(publicAPI, model) {
       camera.setPosition(camPos[0], camPos[1], camPos[2]);
       camera.setFocalPoint(fp[0], fp[1], fp[2]);
     } else {
-      var center = model.center;
-      var style = interactor.getInteractorStyle();
-      var focalDepth = style.computeWorldToDisplay(renderer, center[0], center[1], center[2])[2];
-      var worldPoint = style.computeDisplayToWorld(renderer, pos.x, pos.y, focalDepth);
-      var lastWorldPoint = style.computeDisplayToWorld(renderer, lastPos.x, lastPos.y, focalDepth);
-      var newCamPos = [camPos[0] + (lastWorldPoint[0] - worldPoint[0]), camPos[1] + (lastWorldPoint[1] - worldPoint[1]), camPos[2] + (lastWorldPoint[2] - worldPoint[2])];
-      var newFp = [fp[0] + (lastWorldPoint[0] - worldPoint[0]), fp[1] + (lastWorldPoint[1] - worldPoint[1]), fp[2] + (lastWorldPoint[2] - worldPoint[2])];
+      const {
+        center
+      } = model;
+      const style = interactor.getInteractorStyle();
+      const focalDepth = style.computeWorldToDisplay(renderer, center[0], center[1], center[2])[2];
+      const worldPoint = style.computeDisplayToWorld(renderer, pos.x, pos.y, focalDepth);
+      const lastWorldPoint = style.computeDisplayToWorld(renderer, lastPos.x, lastPos.y, focalDepth);
+      const newCamPos = [camPos[0] + (lastWorldPoint[0] - worldPoint[0]), camPos[1] + (lastWorldPoint[1] - worldPoint[1]), camPos[2] + (lastWorldPoint[2] - worldPoint[2])];
+      const newFp = [fp[0] + (lastWorldPoint[0] - worldPoint[0]), fp[1] + (lastWorldPoint[1] - worldPoint[1]), fp[2] + (lastWorldPoint[2] - worldPoint[2])];
       camera.setPosition(newCamPos[0], newCamPos[1], newCamPos[2]);
       camera.setFocalPoint(newFp[0], newFp[1], newFp[2]);
     }
-
     renderer.resetCameraClippingRange();
-
     if (interactor.getLightFollowCamera()) {
       renderer.updateLightsGeometryToFollowCamera();
     }
   };
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // 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);
   vtkCompositeCameraManipulator.extend(publicAPI, model, initialValues);
-  vtkCompositeMouseManipulator.extend(publicAPI, model, initialValues); // Object specific methods
+  vtkCompositeMouseManipulator.extend(publicAPI, model, initialValues);
 
+  // Object specific methods
   vtkMouseCameraTrackballPanManipulator(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
 
-var newInstance = macro.newInstance(extend, 'vtkMouseCameraTrackballPanManipulator'); // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+
+const newInstance = macro.newInstance(extend, 'vtkMouseCameraTrackballPanManipulator');
+
+// ----------------------------------------------------------------------------
 
 var vtkMouseCameraTrackballPanManipulator$1 = {
-  newInstance: newInstance,
-  extend: extend
+  newInstance,
+  extend
 };
 
 export { vtkMouseCameraTrackballPanManipulator$1 as default, extend, newInstance };

package/Interaction/Manipulators/MouseCameraTrackballRollManipulator.js

@@ -1,67 +1,72 @@
 import { mat4, vec3 } from 'gl-matrix';
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.js';
 import vtkCompositeCameraManipulator from './CompositeCameraManipulator.js';
 import vtkCompositeMouseManipulator from './CompositeMouseManipulator.js';
 import { r as radiansFromDegrees, A as degreesFromRadians } from '../../Common/Core/Math/index.js';
 
+// ----------------------------------------------------------------------------
 // vtkMouseCameraTrackballRollManipulator methods
 // ----------------------------------------------------------------------------
 
 function vtkMouseCameraTrackballRollManipulator(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkMouseCameraTrackballRollManipulator');
-  var axis = new Float64Array(3);
-  var direction = new Float64Array(3);
-  var centerNeg = new Float64Array(3);
-  var transform = new Float64Array(16);
-  var newCamPos = new Float64Array(3);
-  var newFp = new Float64Array(3);
-  var newViewUp = new Float64Array(3);
-
-  publicAPI.onButtonDown = function (interactor, renderer, position) {
+  const axis = new Float64Array(3);
+  const direction = new Float64Array(3);
+  const centerNeg = new Float64Array(3);
+  const transform = new Float64Array(16);
+  const newCamPos = new Float64Array(3);
+  const newFp = new Float64Array(3);
+  const newViewUp = new Float64Array(3);
+  publicAPI.onButtonDown = (interactor, renderer, position) => {
     model.previousPosition = position;
   };
-
-  publicAPI.onMouseMove = function (interactor, renderer, position) {
+  publicAPI.onMouseMove = (interactor, renderer, position) => {
     if (!position) {
       return;
     }
+    const camera = renderer.getActiveCamera();
 
-    var camera = renderer.getActiveCamera(); // compute view vector (rotation axis)
-
-    var cameraPos = camera.getPosition();
-    var cameraFp = camera.getFocalPoint();
-    var viewUp = camera.getViewUp();
+    // compute view vector (rotation axis)
+    const cameraPos = camera.getPosition();
+    const cameraFp = camera.getFocalPoint();
+    const viewUp = camera.getViewUp();
     axis[0] = cameraFp[0] - cameraPos[0];
     axis[1] = cameraFp[1] - cameraPos[1];
-    axis[2] = cameraFp[2] - cameraPos[2]; // compute the angle of rotation
-    // - first compute the two vectors (center to mouse)
+    axis[2] = cameraFp[2] - cameraPos[2];
 
+    // compute the angle of rotation
+    // - first compute the two vectors (center to mouse)
     publicAPI.computeDisplayCenter(interactor.getInteractorStyle(), renderer);
-    var x1 = model.previousPosition.x - model.displayCenter[0];
-    var x2 = position.x - model.displayCenter[0];
-    var y1 = model.previousPosition.y - model.displayCenter[1];
-    var y2 = position.y - model.displayCenter[1];
-
+    const x1 = model.previousPosition.x - model.displayCenter[0];
+    const x2 = position.x - model.displayCenter[0];
+    const y1 = model.previousPosition.y - model.displayCenter[1];
+    const y2 = position.y - model.displayCenter[1];
     if (x2 === 0 && y2 === 0 || x1 === 0 && y1 === 0) {
       // don't ever want to divide by zero
       return;
-    } // - divide by magnitudes to get angle
-
+    }
 
-    var angle = degreesFromRadians((x1 * y2 - y1 * x2) / (Math.sqrt(x1 * x1 + y1 * y1) * Math.sqrt(x2 * x2 + y2 * y2)));
-    var center = model.center;
+    // - divide by magnitudes to get angle
+    const angle = degreesFromRadians((x1 * y2 - y1 * x2) / (Math.sqrt(x1 * x1 + y1 * y1) * Math.sqrt(x2 * x2 + y2 * y2)));
+    const {
+      center
+    } = model;
     mat4.identity(transform);
     centerNeg[0] = -center[0];
     centerNeg[1] = -center[1];
-    centerNeg[2] = -center[2]; // Translate to center
+    centerNeg[2] = -center[2];
 
-    mat4.translate(transform, transform, center); // roll
+    // Translate to center
+    mat4.translate(transform, transform, center);
 
-    mat4.rotate(transform, transform, radiansFromDegrees(angle), axis); // Translate back
+    // roll
+    mat4.rotate(transform, transform, radiansFromDegrees(angle), axis);
 
-    mat4.translate(transform, transform, centerNeg); // Apply transformation to camera position, focal point, and view up
+    // Translate back
+    mat4.translate(transform, transform, centerNeg);
 
+    // Apply transformation to camera position, focal point, and view up
     vec3.transformMat4(newCamPos, cameraPos, transform);
     vec3.transformMat4(newFp, cameraFp, transform);
     direction[0] = viewUp[0] + cameraPos[0];
@@ -73,36 +78,43 @@ function vtkMouseCameraTrackballRollManipulator(publicAPI, model) {
     camera.setViewUp(newViewUp[0] - newCamPos[0], newViewUp[1] - newCamPos[1], newViewUp[2] - newCamPos[2]);
     camera.orthogonalizeViewUp();
     renderer.resetCameraClippingRange();
-
     if (interactor.getLightFollowCamera()) {
       renderer.updateLightsGeometryToFollowCamera();
     }
-
     model.previousPosition = position;
   };
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // 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);
   vtkCompositeCameraManipulator.extend(publicAPI, model, initialValues);
-  vtkCompositeMouseManipulator.extend(publicAPI, model, initialValues); // Object specific methods
+  vtkCompositeMouseManipulator.extend(publicAPI, model, initialValues);
 
+  // Object specific methods
   vtkMouseCameraTrackballRollManipulator(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
 
-var newInstance = macro.newInstance(extend, 'vtkMouseCameraTrackballRollManipulator'); // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+
+const newInstance = macro.newInstance(extend, 'vtkMouseCameraTrackballRollManipulator');
+
+// ----------------------------------------------------------------------------
 
 var vtkMouseCameraTrackballRollManipulator$1 = {
-  newInstance: newInstance,
-  extend: extend
+  newInstance,
+  extend
 };
 
 export { vtkMouseCameraTrackballRollManipulator$1 as default, extend, newInstance };