@kitware/vtk.js 28.10.2 → 28.11.0

package/Interaction/Manipulators/MouseCameraTrackballRotateManipulator.js

@@ -1,60 +1,60 @@
 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 { w as multiplyScalar, d as dot, k as add, r as radiansFromDegrees, j as cross } from '../../Common/Core/Math/index.js';
 
+// ----------------------------------------------------------------------------
 // vtkMouseCameraTrackballRotateManipulator methods
 // ----------------------------------------------------------------------------
 
 function vtkMouseCameraTrackballRotateManipulator(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkMouseCameraTrackballRotateManipulator');
-  var newCamPos = new Float64Array(3);
-  var newFp = new Float64Array(3);
-  var newViewUp = new Float64Array(3);
-  var trans = new Float64Array(16);
-  var v2 = new Float64Array(3);
-  var centerNeg = new Float64Array(3);
-  var direction = new Float64Array(3);
-
-  publicAPI.onButtonDown = function (interactor, renderer, position) {
+  const newCamPos = new Float64Array(3);
+  const newFp = new Float64Array(3);
+  const newViewUp = new Float64Array(3);
+  const trans = new Float64Array(16);
+  const v2 = new Float64Array(3);
+  const centerNeg = new Float64Array(3);
+  const direction = 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;
     }
-
-    var camera = renderer.getActiveCamera();
-    var cameraPos = camera.getPosition();
-    var cameraFp = camera.getFocalPoint();
+    const camera = renderer.getActiveCamera();
+    const cameraPos = camera.getPosition();
+    const cameraFp = camera.getFocalPoint();
     mat4.identity(trans);
-    var center = model.center,
-        rotationFactor = model.rotationFactor;
-
+    const {
+      center,
+      rotationFactor
+    } = model;
     if (model.useFocalPointAsCenterOfRotation) {
       center[0] = cameraFp[0];
       center[1] = cameraFp[1];
       center[2] = cameraFp[2];
     }
+    const dx = model.previousPosition.x - position.x;
+    const dy = model.previousPosition.y - position.y;
+    const size = interactor.getView().getViewportSize(renderer);
 
-    var dx = model.previousPosition.x - position.x;
-    var dy = model.previousPosition.y - position.y;
-    var size = interactor.getView().getViewportSize(renderer); // Azimuth
-
-    var viewUp = camera.getViewUp();
-
+    // Azimuth
+    const viewUp = camera.getViewUp();
     if (model.useWorldUpVec) {
-      var centerOfRotation = new Float64Array(3);
-      vec3.copy(centerOfRotation, model.worldUpVec); // Compute projection of cameraPos onto worldUpVec
+      const centerOfRotation = new Float64Array(3);
+      vec3.copy(centerOfRotation, model.worldUpVec);
 
+      // Compute projection of cameraPos onto worldUpVec
       multiplyScalar(centerOfRotation, dot(cameraPos, model.worldUpVec) / dot(model.worldUpVec, model.worldUpVec));
       add(center, centerOfRotation, centerOfRotation);
       mat4.translate(trans, trans, centerOfRotation);
-      mat4.rotate(trans, trans, radiansFromDegrees(360.0 * dx / size[0] * rotationFactor), model.worldUpVec); // Translate back
+      mat4.rotate(trans, trans, radiansFromDegrees(360.0 * dx / size[0] * rotationFactor), model.worldUpVec);
 
+      // Translate back
       centerOfRotation[0] = -centerOfRotation[0];
       centerOfRotation[1] = -centerOfRotation[1];
       centerOfRotation[2] = -centerOfRotation[2];
@@ -63,17 +63,19 @@ function vtkMouseCameraTrackballRotateManipulator(publicAPI, model) {
     } else {
       mat4.translate(trans, trans, center);
       mat4.rotate(trans, trans, radiansFromDegrees(360.0 * dx / size[0] * rotationFactor), viewUp);
-    } // Elevation
-
+    }
 
+    // Elevation
     cross(camera.getDirectionOfProjection(), viewUp, v2);
-    mat4.rotate(trans, trans, radiansFromDegrees(-360.0 * dy / size[1] * rotationFactor), v2); // Translate back
+    mat4.rotate(trans, trans, radiansFromDegrees(-360.0 * dy / size[1] * rotationFactor), v2);
 
+    // Translate back
     centerNeg[0] = -center[0];
     centerNeg[1] = -center[1];
     centerNeg[2] = -center[2];
-    mat4.translate(trans, trans, centerNeg); // Apply transformation to camera position, focal point, and view up
+    mat4.translate(trans, trans, centerNeg);
 
+    // Apply transformation to camera position, focal point, and view up
     vec3.transformMat4(newCamPos, cameraPos, trans);
     vec3.transformMat4(newFp, cameraFp, trans);
     direction[0] = viewUp[0] + cameraPos[0];
@@ -85,45 +87,53 @@ function vtkMouseCameraTrackballRotateManipulator(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
 // ----------------------------------------------------------------------------
 
-
-var DEFAULT_VALUES = {
+const DEFAULT_VALUES = {
   useWorldUpVec: false,
   // set WorldUpVector to be y-axis by default
   worldUpVec: [0, 1, 0],
   useFocalPointAsCenterOfRotation: false
-}; // ----------------------------------------------------------------------------
+};
+
+// ----------------------------------------------------------------------------
 
 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); // Create get-set macro
+  vtkCompositeCameraManipulator.extend(publicAPI, model, initialValues);
 
+  // Create get-set macro
   macro.setGet(publicAPI, model, ['useWorldUpVec']);
   macro.setGetArray(publicAPI, model, ['worldUpVec'], 3);
-  macro.setGet(publicAPI, model, ['useFocalPointAsCenterOfRotation']); // Object specific methods
+  macro.setGet(publicAPI, model, ['useFocalPointAsCenterOfRotation']);
 
+  // Object specific methods
   vtkMouseCameraTrackballRotateManipulator(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 
-var newInstance = macro.newInstance(extend, 'vtkMouseCameraTrackballRotateManipulator'); // ----------------------------------------------------------------------------
+const newInstance = macro.newInstance(extend, 'vtkMouseCameraTrackballRotateManipulator');
+
+// ----------------------------------------------------------------------------
 
 var vtkMouseCameraTrackballRotateManipulator$1 = {
-  newInstance: newInstance,
-  extend: extend
+  newInstance,
+  extend
 };
 
 export { vtkMouseCameraTrackballRotateManipulator$1 as default, extend, newInstance };

package/Interaction/Manipulators/MouseCameraTrackballZoomManipulator.js

@@ -1,117 +1,112 @@
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.js';
 import vtkCompositeCameraManipulator from './CompositeCameraManipulator.js';
 import vtkCompositeMouseManipulator from './CompositeMouseManipulator.js';
 
+// ----------------------------------------------------------------------------
 // vtkMouseCameraTrackballZoomManipulator methods
 // ----------------------------------------------------------------------------
 
 function vtkMouseCameraTrackballZoomManipulator(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkMouseCameraTrackballZoomManipulator');
-
-  publicAPI.onButtonDown = function (interactor, renderer, position) {
+  publicAPI.onButtonDown = (interactor, renderer, position) => {
     model.previousPosition = position;
-    var size = interactor.getView().getViewportSize(renderer);
-    var camera = renderer.getActiveCamera();
-    var direction = model.flipDirection ? -1 : 1;
-
+    const size = interactor.getView().getViewportSize(renderer);
+    const camera = renderer.getActiveCamera();
+    const direction = model.flipDirection ? -1 : 1;
     if (camera.getParallelProjection()) {
       model.zoomScale = 1.5 / size[1] * direction;
     } else {
-      var range = camera.getClippingRange();
+      const range = camera.getClippingRange();
       model.zoomScale = 1.5 * (range[1] / size[1]) * direction;
     }
   };
-
-  publicAPI.onMouseMove = function (interactor, renderer, position) {
+  publicAPI.onMouseMove = (interactor, renderer, position) => {
     if (!position) {
       return;
     }
-
-    var dy = model.previousPosition.y - position.y;
-    var camera = renderer.getActiveCamera();
-
+    const dy = model.previousPosition.y - position.y;
+    const camera = renderer.getActiveCamera();
     if (camera.getParallelProjection()) {
-      var k = dy * model.zoomScale;
+      const k = dy * model.zoomScale;
       camera.setParallelScale((1.0 - k) * camera.getParallelScale());
     } else {
-      var cameraPos = camera.getPosition();
-      var cameraFp = camera.getFocalPoint();
-      var norm = camera.getDirectionOfProjection();
-
-      var _k = dy * model.zoomScale;
-
-      var tmp = _k * norm[0];
+      const cameraPos = camera.getPosition();
+      const cameraFp = camera.getFocalPoint();
+      const norm = camera.getDirectionOfProjection();
+      const k = dy * model.zoomScale;
+      let tmp = k * norm[0];
       cameraPos[0] += tmp;
       cameraFp[0] += tmp;
-      tmp = _k * norm[1];
+      tmp = k * norm[1];
       cameraPos[1] += tmp;
       cameraFp[1] += tmp;
-      tmp = _k * norm[2];
+      tmp = k * norm[2];
       cameraPos[2] += tmp;
       cameraFp[2] += tmp;
-
       if (!camera.getFreezeFocalPoint()) {
         camera.setFocalPoint(cameraFp[0], cameraFp[1], cameraFp[2]);
       }
-
       camera.setPosition(cameraPos[0], cameraPos[1], cameraPos[2]);
       renderer.resetCameraClippingRange();
     }
-
     if (interactor.getLightFollowCamera()) {
       renderer.updateLightsGeometryToFollowCamera();
     }
-
     model.previousPosition = position;
   };
-
-  publicAPI.onScroll = function (interactor, renderer, delta) {
+  publicAPI.onScroll = (interactor, renderer, delta) => {
     if (!delta) {
       return;
     }
-
-    var camera = renderer.getActiveCamera();
-    var dyf = 1 - delta / 10;
-
+    const camera = renderer.getActiveCamera();
+    const dyf = 1 - delta / 10;
     if (camera.getParallelProjection()) {
       camera.setParallelScale(camera.getParallelScale() / dyf);
     } else {
       camera.dolly(dyf);
       renderer.resetCameraClippingRange();
     }
-
     if (interactor.getLightFollowCamera()) {
       renderer.updateLightsGeometryToFollowCamera();
     }
   };
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
-
-var DEFAULT_VALUES = {
+const DEFAULT_VALUES = {
   zoomScale: 0.0,
   flipDirection: false
-}; // ----------------------------------------------------------------------------
+};
+
+// ----------------------------------------------------------------------------
 
 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);
-  macro.setGet(publicAPI, model, ['flipDirection']); // Object specific methods
+  macro.setGet(publicAPI, model, ['flipDirection']);
 
+  // Object specific methods
   vtkMouseCameraTrackballZoomManipulator(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
+
+const newInstance = macro.newInstance(extend, 'vtkMouseCameraTrackballZoomManipulator');
 
-var newInstance = macro.newInstance(extend, 'vtkMouseCameraTrackballZoomManipulator'); // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
 
 var vtkMouseCameraTrackballZoomManipulator$1 = {
-  newInstance: newInstance,
-  extend: extend
+  newInstance,
+  extend
 };
 
 export { vtkMouseCameraTrackballZoomManipulator$1 as default, extend, newInstance };

package/Interaction/Manipulators/MouseCameraTrackballZoomToMouseManipulator.js

@@ -1,71 +1,73 @@
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.js';
 import vtkInteractorStyleManipulator from '../Style/InteractorStyleManipulator.js';
 import vtkMouseCameraTrackballZoomManipulator from './MouseCameraTrackballZoomManipulator.js';
 
+// ----------------------------------------------------------------------------
 // vtkMouseCameraTrackballZoomToMouseManipulator methods
 // ----------------------------------------------------------------------------
 
 function vtkMouseCameraTrackballZoomToMouseManipulator(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkMouseCameraTrackballZoomToMouseManipulator');
-  var superOnButtonDown = publicAPI.onButtonDown;
-
-  publicAPI.onButtonDown = function (interactor, renderer, position) {
+  const superOnButtonDown = publicAPI.onButtonDown;
+  publicAPI.onButtonDown = (interactor, renderer, position) => {
     superOnButtonDown(interactor, renderer, position);
     model.zoomPosition = position;
   };
-
-  publicAPI.onMouseMove = function (interactor, renderer, position) {
+  publicAPI.onMouseMove = (interactor, renderer, position) => {
     if (!position) {
       return;
     }
-
-    var dy = model.previousPosition.y - position.y;
-    var k = dy * model.zoomScale;
+    const dy = model.previousPosition.y - position.y;
+    const k = dy * model.zoomScale;
     vtkInteractorStyleManipulator.dollyToPosition(1.0 - k, model.zoomPosition, renderer, interactor);
-
     if (interactor.getLightFollowCamera()) {
       renderer.updateLightsGeometryToFollowCamera();
     }
-
     model.previousPosition = position;
   };
-
-  publicAPI.onScroll = function (interactor, renderer, delta, position) {
+  publicAPI.onScroll = (interactor, renderer, delta, position) => {
     if (!delta || !position) {
       return;
     }
-
-    var dyf = 1 - delta * 0.1;
+    const dyf = 1 - delta * 0.1;
     vtkInteractorStyleManipulator.dollyToPosition(dyf, position, renderer, interactor);
-
     if (interactor.getLightFollowCamera()) {
       renderer.updateLightsGeometryToFollowCamera();
     }
   };
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
-
-var DEFAULT_VALUES = {
+const DEFAULT_VALUES = {
   zoomPosition: 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);
 
-  vtkMouseCameraTrackballZoomManipulator.extend(publicAPI, model, initialValues); // Object specific methods
+  // Inheritance
+  vtkMouseCameraTrackballZoomManipulator.extend(publicAPI, model, initialValues);
 
+  // Object specific methods
   vtkMouseCameraTrackballZoomToMouseManipulator(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
 
-var newInstance = macro.newInstance(extend, 'vtkMouseCameraTrackballZoomToMouseManipulator'); // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+
+const newInstance = macro.newInstance(extend, 'vtkMouseCameraTrackballZoomToMouseManipulator');
+
+// ----------------------------------------------------------------------------
 
 var vtkMouseCameraTrackballZoomToMouseManipulator$1 = {
-  newInstance: newInstance,
-  extend: extend
+  newInstance,
+  extend
 };
 
 export { vtkMouseCameraTrackballZoomToMouseManipulator$1 as default, extend, newInstance };