@kitware/vtk.js 20.1.2 → 20.2.1

package/Rendering/Core/Camera.js

@@ -1,10 +1,7 @@
 import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
+import { mat4, vec4, vec3, quat } from 'gl-matrix';
 import macro from '../../macros.js';
 import { r as radiansFromDegrees, k as add, j as cross } from '../../Common/Core/Math/index.js';
-import { i as identity, r as rotate, t as translate, g as invert, j as transpose, s as scale, m as multiply$1, d as copy, l as lookAt, o as ortho, k as fromQuat } from '../../vendor/gl-matrix/esm/mat4.js';
-import { t as transformMat4 } from '../../vendor/gl-matrix/esm/vec4.js';
-import { t as transformMat4$1, s as set, a as subtract, n as normalize } from '../../vendor/gl-matrix/esm/vec3.js';
-import { f as fromValues, c as create, a as conjugate, m as multiply, s as setAxisAngle } from '../../vendor/gl-matrix/esm/quat.js';
 
 var vtkDebugMacro = macro.vtkDebugMacro;
 /* eslint-disable new-cap */
@@ -29,12 +26,12 @@ function vtkCamera(publicAPI, model) {
   var origin = new Float64Array(3);
   var dopbasis = new Float64Array([0.0, 0.0, -1.0]);
   var upbasis = new Float64Array([0.0, 1.0, 0.0]);
-  var tmpMatrix = identity(new Float64Array(16));
+  var tmpMatrix = mat4.identity(new Float64Array(16));
   var tmpvec1 = new Float64Array(3);
   var tmpvec2 = new Float64Array(3);
   var tmpvec3 = new Float64Array(3);
-  var rotateMatrix = identity(new Float64Array(16));
-  var trans = identity(new Float64Array(16));
+  var rotateMatrix = mat4.identity(new Float64Array(16));
+  var trans = mat4.identity(new Float64Array(16));
   var newPosition = new Float64Array(3);
   var newFocalPoint = new Float64Array(3); // Internal Functions that don't need to be public
 
@@ -143,10 +140,10 @@ function vtkCamera(publicAPI, model) {
     var at = model.focalPoint;
     var up = model.viewUp;
     var viewUpVec4 = new Float64Array([up[0], up[1], up[2], 0.0]);
-    identity(rotateMatrix);
+    mat4.identity(rotateMatrix);
     var viewDir = new Float64Array([at[0] - eye[0], at[1] - eye[1], at[2] - eye[2]]);
-    rotate(rotateMatrix, rotateMatrix, radiansFromDegrees(angle), viewDir);
-    transformMat4(viewUpVec4, viewUpVec4, rotateMatrix);
+    mat4.rotate(rotateMatrix, rotateMatrix, radiansFromDegrees(angle), viewDir);
+    vec4.transformMat4(viewUpVec4, viewUpVec4, rotateMatrix);
     model.viewUp[0] = viewUpVec4[0];
     model.viewUp[1] = viewUpVec4[1];
     model.viewUp[2] = viewUpVec4[2];
@@ -155,29 +152,29 @@ function vtkCamera(publicAPI, model) {
 
   publicAPI.azimuth = function (angle) {
     var fp = model.focalPoint;
-    identity(trans); // translate the focal point to the origin,
+    mat4.identity(trans); // translate the focal point to the origin,
     // rotate about view up,
     // translate back again
 
-    translate(trans, trans, fp);
-    rotate(trans, trans, radiansFromDegrees(angle), model.viewUp);
-    translate(trans, trans, [-fp[0], -fp[1], -fp[2]]); // apply the transform to the position
+    mat4.translate(trans, trans, fp);
+    mat4.rotate(trans, trans, radiansFromDegrees(angle), model.viewUp);
+    mat4.translate(trans, trans, [-fp[0], -fp[1], -fp[2]]); // apply the transform to the position
 
-    transformMat4$1(newPosition, model.position, trans);
+    vec3.transformMat4(newPosition, model.position, trans);
     publicAPI.setPosition(newPosition[0], newPosition[1], newPosition[2]);
   };
 
   publicAPI.yaw = function (angle) {
     var position = model.position;
-    identity(trans); // translate the camera to the origin,
+    mat4.identity(trans); // translate the camera to the origin,
     // rotate about axis,
     // translate back again
 
-    translate(trans, trans, position);
-    rotate(trans, trans, radiansFromDegrees(angle), model.viewUp);
-    translate(trans, trans, [-position[0], -position[1], -position[2]]); // apply the transform to the position
+    mat4.translate(trans, trans, position);
+    mat4.rotate(trans, trans, radiansFromDegrees(angle), model.viewUp);
+    mat4.translate(trans, trans, [-position[0], -position[1], -position[2]]); // apply the transform to the position
 
-    transformMat4$1(newFocalPoint, model.focalPoint, trans);
+    vec3.transformMat4(newFocalPoint, model.focalPoint, trans);
     publicAPI.setFocalPoint(newFocalPoint[0], newFocalPoint[1], newFocalPoint[2]);
   };
 
@@ -186,15 +183,15 @@ function vtkCamera(publicAPI, model) {
 
     var vt = publicAPI.getViewMatrix();
     var axis = [-vt[0], -vt[1], -vt[2]];
-    identity(trans); // translate the focal point to the origin,
+    mat4.identity(trans); // translate the focal point to the origin,
     // rotate about view up,
     // translate back again
 
-    translate(trans, trans, fp);
-    rotate(trans, trans, radiansFromDegrees(angle), axis);
-    translate(trans, trans, [-fp[0], -fp[1], -fp[2]]); // apply the transform to the position
+    mat4.translate(trans, trans, fp);
+    mat4.rotate(trans, trans, radiansFromDegrees(angle), axis);
+    mat4.translate(trans, trans, [-fp[0], -fp[1], -fp[2]]); // apply the transform to the position
 
-    transformMat4$1(newPosition, model.position, trans);
+    vec3.transformMat4(newPosition, model.position, trans);
     publicAPI.setPosition(newPosition[0], newPosition[1], newPosition[2]);
   };
 
@@ -202,15 +199,15 @@ function vtkCamera(publicAPI, model) {
     var position = model.position;
     var vt = publicAPI.getViewMatrix();
     var axis = [vt[0], vt[1], vt[2]];
-    identity(trans); // translate the camera to the origin,
+    mat4.identity(trans); // translate the camera to the origin,
     // rotate about axis,
     // translate back again
 
-    translate(trans, trans, position);
-    rotate(trans, trans, radiansFromDegrees(angle), axis);
-    translate(trans, trans, [-position[0], -position[1], -position[2]]); // apply the transform to the focal point
+    mat4.translate(trans, trans, position);
+    mat4.rotate(trans, trans, radiansFromDegrees(angle), axis);
+    mat4.translate(trans, trans, [-position[0], -position[1], -position[2]]); // apply the transform to the focal point
 
-    transformMat4$1(newFocalPoint, model.focalPoint, trans);
+    vec3.transformMat4(newFocalPoint, model.focalPoint, trans);
     publicAPI.setFocalPoint.apply(publicAPI, _toConsumableArray(newFocalPoint));
   };
 
@@ -236,7 +233,7 @@ function vtkCamera(publicAPI, model) {
     publicAPI.modified();
   };
 
-  publicAPI.applyTransform = function (transformMat4$1) {
+  publicAPI.applyTransform = function (transformMat4) {
     var vuOld = [].concat(_toConsumableArray(model.viewUp), [1.0]);
     var posNew = [];
     var fpNew = [];
@@ -244,9 +241,9 @@ function vtkCamera(publicAPI, model) {
     vuOld[0] += model.position[0];
     vuOld[1] += model.position[1];
     vuOld[2] += model.position[2];
-    transformMat4(posNew, [].concat(_toConsumableArray(model.position), [1.0]), transformMat4$1);
-    transformMat4(fpNew, [].concat(_toConsumableArray(model.focalPoint), [1.0]), transformMat4$1);
-    transformMat4(vuNew, vuOld, transformMat4$1);
+    vec4.transformMat4(posNew, [].concat(_toConsumableArray(model.position), [1.0]), transformMat4);
+    vec4.transformMat4(fpNew, [].concat(_toConsumableArray(model.focalPoint), [1.0]), transformMat4);
+    vec4.transformMat4(vuNew, vuOld, transformMat4);
     vuNew[0] -= posNew[0];
     vuNew[1] -= posNew[1];
     vuNew[2] -= posNew[2];
@@ -302,24 +299,24 @@ function vtkCamera(publicAPI, model) {
 
   publicAPI.physicalOrientationToWorldDirection = function (ori) {
     // push the x axis through the orientation quat
-    var oriq = fromValues(ori[0], ori[1], ori[2], ori[3]);
-    var coriq = create();
-    var qdir = fromValues(0.0, 0.0, 1.0, 0.0);
-    conjugate(coriq, oriq); // rotate the z axis by the quat
+    var oriq = quat.fromValues(ori[0], ori[1], ori[2], ori[3]);
+    var coriq = quat.create();
+    var qdir = quat.fromValues(0.0, 0.0, 1.0, 0.0);
+    quat.conjugate(coriq, oriq); // rotate the z axis by the quat
 
-    multiply(qdir, oriq, qdir);
-    multiply(qdir, qdir, coriq); // return the z axis in world coords
+    quat.multiply(qdir, oriq, qdir);
+    quat.multiply(qdir, qdir, coriq); // return the z axis in world coords
 
     return [qdir[0], qdir[1], qdir[2]];
   };
 
   publicAPI.getPhysicalToWorldMatrix = function (result) {
     publicAPI.getWorldToPhysicalMatrix(result);
-    invert(result, result);
+    mat4.invert(result, result);
   };
 
   publicAPI.getWorldToPhysicalMatrix = function (result) {
-    identity(result); // now the physical to vtk world rotation tform
+    mat4.identity(result); // now the physical to vtk world rotation tform
 
     var physVRight = [3];
     cross(model.physicalViewNorth, model.physicalViewUp, physVRight);
@@ -332,15 +329,15 @@ function vtkCamera(publicAPI, model) {
     result[8] = -model.physicalViewNorth[0];
     result[9] = -model.physicalViewNorth[1];
     result[10] = -model.physicalViewNorth[2];
-    transpose(result, result);
-    set(tmpvec1, 1 / model.physicalScale, 1 / model.physicalScale, 1 / model.physicalScale);
-    scale(result, result, tmpvec1);
-    translate(result, result, model.physicalTranslation);
+    mat4.transpose(result, result);
+    vec3.set(tmpvec1, 1 / model.physicalScale, 1 / model.physicalScale, 1 / model.physicalScale);
+    mat4.scale(result, result, tmpvec1);
+    mat4.translate(result, result, model.physicalTranslation);
   };
 
   publicAPI.computeViewParametersFromViewMatrix = function (vmat) {
     // invert to get view to world
-    invert(tmpMatrix, vmat); // note with glmatrix operations happen in
+    mat4.invert(tmpMatrix, vmat); // note with glmatrix operations happen in
     // the reverse order
     // mat.scale
     // mat.translate
@@ -350,18 +347,18 @@ function vtkCamera(publicAPI, model) {
     // then extract the params position, orientation
     // push 0,0,0 through to get a translation
 
-    transformMat4$1(tmpvec1, origin, tmpMatrix);
+    vec3.transformMat4(tmpvec1, origin, tmpMatrix);
     publicAPI.computeDistance();
     var oldDist = model.distance;
     publicAPI.setPosition(tmpvec1[0], tmpvec1[1], tmpvec1[2]); // push basis vectors to get orientation
 
-    transformMat4$1(tmpvec2, dopbasis, tmpMatrix);
-    subtract(tmpvec2, tmpvec2, tmpvec1);
-    normalize(tmpvec2, tmpvec2);
+    vec3.transformMat4(tmpvec2, dopbasis, tmpMatrix);
+    vec3.subtract(tmpvec2, tmpvec2, tmpvec1);
+    vec3.normalize(tmpvec2, tmpvec2);
     publicAPI.setDirectionOfProjection(tmpvec2[0], tmpvec2[1], tmpvec2[2]);
-    transformMat4$1(tmpvec3, upbasis, tmpMatrix);
-    subtract(tmpvec3, tmpvec3, tmpvec1);
-    normalize(tmpvec3, tmpvec3);
+    vec3.transformMat4(tmpvec3, upbasis, tmpMatrix);
+    vec3.subtract(tmpvec3, tmpvec3, tmpvec1);
+    vec3.normalize(tmpvec3, tmpvec3);
     publicAPI.setViewUp(tmpvec3[0], tmpvec3[1], tmpvec3[2]);
     publicAPI.setDistance(oldDist);
   }; // the provided matrix should include
@@ -374,7 +371,7 @@ function vtkCamera(publicAPI, model) {
     publicAPI.getWorldToPhysicalMatrix(tmpMatrix); // first convert the physical -> view matrix to be
     // world -> view
 
-    multiply$1(tmpMatrix, mat, tmpMatrix);
+    mat4.multiply(tmpMatrix, mat, tmpMatrix);
     publicAPI.computeViewParametersFromViewMatrix(tmpMatrix);
   };
 
@@ -382,9 +379,9 @@ function vtkCamera(publicAPI, model) {
     model.viewMatrix = mat;
 
     if (model.viewMatrix) {
-      copy(tmpMatrix, model.viewMatrix);
+      mat4.copy(tmpMatrix, model.viewMatrix);
       publicAPI.computeViewParametersFromViewMatrix(tmpMatrix);
-      transpose(model.viewMatrix, model.viewMatrix);
+      mat4.transpose(model.viewMatrix, model.viewMatrix);
     }
   };
 
@@ -393,13 +390,13 @@ function vtkCamera(publicAPI, model) {
       return model.viewMatrix;
     }
 
-    lookAt(tmpMatrix, model.position, // eye
+    mat4.lookAt(tmpMatrix, model.position, // eye
     model.focalPoint, // at
     model.viewUp // up
     );
-    transpose(tmpMatrix, tmpMatrix);
+    mat4.transpose(tmpMatrix, tmpMatrix);
     var result = new Float64Array(16);
-    copy(result, tmpMatrix);
+    mat4.copy(result, tmpMatrix);
     return result;
   };
 
@@ -409,18 +406,18 @@ function vtkCamera(publicAPI, model) {
 
   publicAPI.getProjectionMatrix = function (aspect, nearz, farz) {
     var result = new Float64Array(16);
-    identity(result);
+    mat4.identity(result);
 
     if (model.projectionMatrix) {
-      var scale$1 = 1 / model.physicalScale;
-      set(tmpvec1, scale$1, scale$1, scale$1);
-      copy(result, model.projectionMatrix);
-      scale(result, result, tmpvec1);
-      transpose(result, result);
+      var scale = 1 / model.physicalScale;
+      vec3.set(tmpvec1, scale, scale, scale);
+      mat4.copy(result, model.projectionMatrix);
+      mat4.scale(result, result, tmpvec1);
+      mat4.transpose(result, result);
       return result;
     }
 
-    identity(tmpMatrix); // FIXME: Not sure what to do about adjust z buffer here
+    mat4.identity(tmpMatrix); // FIXME: Not sure what to do about adjust z buffer here
     // adjust Z-buffer range
     // this->ProjectionTransform->AdjustZBuffer( -1, +1, nearz, farz );
 
@@ -435,8 +432,8 @@ function vtkCamera(publicAPI, model) {
       var xmax = (model.windowCenter[0] + 1.0) * width;
       var ymin = (model.windowCenter[1] - 1.0) * height;
       var ymax = (model.windowCenter[1] + 1.0) * height;
-      ortho(tmpMatrix, xmin, xmax, ymin, ymax, cRange[0], cRange[1]);
-      transpose(tmpMatrix, tmpMatrix);
+      mat4.ortho(tmpMatrix, xmin, xmax, ymin, ymax, cRange[0], cRange[1]);
+      mat4.transpose(tmpMatrix, tmpMatrix);
     } else if (model.useOffAxisProjection) {
       throw new Error('Off-Axis projection is not supported at this time');
     } else {
@@ -474,7 +471,7 @@ function vtkCamera(publicAPI, model) {
       tmpMatrix[15] = 0.0;
     }
 
-    copy(result, tmpMatrix);
+    mat4.copy(result, tmpMatrix);
     return result;
   };
 
@@ -483,7 +480,7 @@ function vtkCamera(publicAPI, model) {
     var pMat = publicAPI.getProjectionMatrix(aspect, nearz, farz); // mats are transposed so the order is A then B
     // we reuse pMat as it is a copy so we can do what we want with it
 
-    multiply$1(pMat, vMat, pMat);
+    mat4.multiply(pMat, vMat, pMat);
     return pMat;
   };
 
@@ -523,35 +520,35 @@ function vtkCamera(publicAPI, model) {
     var physVRight = [3];
     cross(model.physicalViewNorth, model.physicalViewUp, physVRight); // phone to physical coordinates
 
-    var rotmat = identity(new Float64Array(16));
-    rotate(rotmat, rotmat, radiansFromDegrees(alpha), model.physicalViewUp);
-    rotate(rotmat, rotmat, radiansFromDegrees(beta), physVRight);
-    rotate(rotmat, rotmat, radiansFromDegrees(gamma), model.physicalViewNorth);
-    rotate(rotmat, rotmat, radiansFromDegrees(-screen), model.physicalViewUp);
+    var rotmat = mat4.identity(new Float64Array(16));
+    mat4.rotate(rotmat, rotmat, radiansFromDegrees(alpha), model.physicalViewUp);
+    mat4.rotate(rotmat, rotmat, radiansFromDegrees(beta), physVRight);
+    mat4.rotate(rotmat, rotmat, radiansFromDegrees(gamma), model.physicalViewNorth);
+    mat4.rotate(rotmat, rotmat, radiansFromDegrees(-screen), model.physicalViewUp);
     var dop = new Float64Array([-model.physicalViewUp[0], -model.physicalViewUp[1], -model.physicalViewUp[2]]);
     var vup = new Float64Array(model.physicalViewNorth);
-    transformMat4$1(dop, dop, rotmat);
-    transformMat4$1(vup, vup, rotmat);
+    vec3.transformMat4(dop, dop, rotmat);
+    vec3.transformMat4(vup, vup, rotmat);
     publicAPI.setDirectionOfProjection(dop[0], dop[1], dop[2]);
     publicAPI.setViewUp(vup[0], vup[1], vup[2]);
     publicAPI.modified();
   };
 
   publicAPI.setOrientationWXYZ = function (degrees, x, y, z) {
-    var quatMat = identity(new Float64Array(16));
+    var quatMat = mat4.identity(new Float64Array(16));
 
     if (degrees !== 0.0 && (x !== 0.0 || y !== 0.0 || z !== 0.0)) {
       // convert to radians
       var angle = radiansFromDegrees(degrees);
-      var q = create();
-      setAxisAngle(q, [x, y, z], angle);
-      fromQuat(quatMat, q);
+      var q = quat.create();
+      quat.setAxisAngle(q, [x, y, z], angle);
+      mat4.fromQuat(quatMat, q);
     }
 
     var newdop = new Float64Array(3);
-    transformMat4$1(newdop, [0.0, 0.0, -1.0], quatMat);
+    vec3.transformMat4(newdop, [0.0, 0.0, -1.0], quatMat);
     var newvup = new Float64Array(3);
-    transformMat4$1(newvup, [0.0, 1.0, 0.0], quatMat);
+    vec3.transformMat4(newvup, [0.0, 1.0, 0.0], quatMat);
     publicAPI.setDirectionOfProjection.apply(publicAPI, _toConsumableArray(newdop));
     publicAPI.setViewUp.apply(publicAPI, _toConsumableArray(newvup));
     publicAPI.modified();

package/Rendering/Core/CellPicker.js

@@ -4,7 +4,7 @@ import { l as normalize } from '../../Common/Core/Math/index.js';
 import vtkPicker from './Picker.js';
 import vtkPoints from '../../Common/Core/Points.js';
 import vtkTriangle from '../../Common/DataModel/Triangle.js';
-import { t as transformMat4 } from '../../vendor/gl-matrix/esm/vec3.js';
+import { vec3 } from 'gl-matrix';
 
 function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
 
@@ -198,7 +198,7 @@ function vtkCellPicker(publicAPI, model) {
         model.mapperNormal[2] = -plane[2];
       }
 
-      transformMat4(model.pickPosition, model.mapperPosition, model.transformMatrix); // Transform vector
+      vec3.transformMat4(model.pickPosition, model.mapperPosition, model.transformMatrix); // Transform vector
 
       var mat = model.transformMatrix;
       model.mapperNormal[0] = mat[0] * model.pickNormal[0] + mat[4] * model.pickNormal[1] + mat[8] * model.pickNormal[2];

package/Rendering/Core/CubeAxesActor.js

@@ -1,5 +1,7 @@
 import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
 import _defineProperty from '@babel/runtime/helpers/defineProperty';
+import { mat4, vec3 } from 'gl-matrix';
+import * as d3 from 'd3-scale';
 import { K as nearestPowerOfTwo, L as normalize2D } from '../../Common/Core/Math/index.js';
 import macro from '../../macros.js';
 import vtkActor from './Actor.js';
@@ -9,9 +11,6 @@ import vtkMapper from './Mapper.js';
 import vtkPixelSpaceCallbackMapper from './PixelSpaceCallbackMapper.js';
 import vtkPolyData from '../../Common/DataModel/PolyData.js';
 import vtkTexture from './Texture.js';
-import { l as linear } from '../../vendor/d3-scale/src/linear.js';
-import { j as transpose, g as invert } from '../../vendor/gl-matrix/esm/mat4.js';
-import { t as transformMat4, a as subtract, n as normalize, d as dot, b as scale, j as add } from '../../vendor/gl-matrix/esm/vec3.js';
 
 function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
 
@@ -70,7 +69,7 @@ function vtkCubeAxesActor(publicAPI, model) {
 
   publicAPI.computeFacesToDraw = function () {
     var cmat = model.camera.getViewMatrix();
-    transpose(cmat, cmat);
+    mat4.transpose(cmat, cmat);
     var changed = false;
     var length = vtkBoundingBox.getDiagonalLength(model.dataBounds);
     var faceDot = Math.sin(model.faceVisibilityAngle * Math.PI / 180.0);
@@ -86,17 +85,17 @@ function vtkCubeAxesActor(publicAPI, model) {
         ptv3[faceAxis] = model.dataBounds[f] - 0.1 * length * faceNormals[f][faceAxis];
         ptv3[otherAxis1] = 0.5 * (model.dataBounds[otherAxis1 * 2] + model.dataBounds[otherAxis1 * 2 + 1]);
         ptv3[otherAxis2] = 0.5 * (model.dataBounds[otherAxis2 * 2] + model.dataBounds[otherAxis2 * 2 + 1]);
-        transformMat4(tmpv3, ptv3, cmat);
+        vec3.transformMat4(tmpv3, ptv3, cmat);
         ptv3[faceAxis] = model.dataBounds[f];
-        transformMat4(tmp2v3, ptv3, cmat);
-        subtract(tmpv3, tmp2v3, tmpv3);
-        normalize(tmpv3, tmpv3); // tmpv3 now holds the face normal vector
+        vec3.transformMat4(tmp2v3, ptv3, cmat);
+        vec3.subtract(tmpv3, tmp2v3, tmpv3);
+        vec3.normalize(tmpv3, tmpv3); // tmpv3 now holds the face normal vector
 
         drawit = tmpv3[2] > faceDot; // for perspctive we need the view direction to the plane
 
         if (!model.camera.getParallelProjection()) {
-          normalize(tmp2v3, tmp2v3);
-          drawit = dot(tmp2v3, tmpv3) > faceDot;
+          vec3.normalize(tmp2v3, tmp2v3);
+          drawit = vec3.dot(tmp2v3, tmpv3) > faceDot;
         }
       }
 
@@ -327,7 +326,7 @@ function vtkCubeAxesActor(publicAPI, model) {
       var tickStrings = [];
 
       for (var _i = 0; _i < 3; _i++) {
-        var scale = linear().domain([model.dataBounds[_i * 2], model.dataBounds[_i * 2 + 1]]);
+        var scale = d3.scaleLinear().domain([model.dataBounds[_i * 2], model.dataBounds[_i * 2 + 1]]);
         ticks[_i] = scale.ticks(5);
         var format = scale.tickFormat(5);
         tickStrings[_i] = ticks[_i].map(format);
@@ -449,17 +448,17 @@ function vtkCubeAxesActor(publicAPI, model) {
     ptv3[0] = coords[pos * 3];
     ptv3[1] = coords[pos * 3 + 1];
     ptv3[2] = coords[pos * 3 + 2];
-    transformMat4(tmpv3, ptv3, cmat); // moving 0.1 in NDC
+    vec3.transformMat4(tmpv3, ptv3, cmat); // moving 0.1 in NDC
 
     tmpv3[0] += 0.1;
-    transformMat4(pt2v3, tmpv3, imat); // results in WC move of
+    vec3.transformMat4(pt2v3, tmpv3, imat); // results in WC move of
 
-    subtract(xDir, pt2v3, ptv3);
+    vec3.subtract(xDir, pt2v3, ptv3);
     tmpv3[0] -= 0.1;
     tmpv3[1] += 0.1;
-    transformMat4(pt2v3, tmpv3, imat); // results in WC move of
+    vec3.transformMat4(pt2v3, tmpv3, imat); // results in WC move of
 
-    subtract(yDir, pt2v3, ptv3);
+    vec3.subtract(yDir, pt2v3, ptv3);
 
     for (var i = 0; i < 3; i++) {
       xDir[i] /= 0.5 * 0.1 * size[0];
@@ -475,40 +474,40 @@ function vtkCubeAxesActor(publicAPI, model) {
     ptv3[2] = coords[pos * 3 + 2]; // horizontal left, right, or middle alignment based on dir[0]
 
     if (dir[0] < -0.5) {
-      scale(tmpv3, xDir, dir[0] * offset - value.width);
+      vec3.scale(tmpv3, xDir, dir[0] * offset - value.width);
     } else if (dir[0] > 0.5) {
-      scale(tmpv3, xDir, dir[0] * offset);
+      vec3.scale(tmpv3, xDir, dir[0] * offset);
     } else {
-      scale(tmpv3, xDir, dir[0] * offset - value.width / 2.0);
+      vec3.scale(tmpv3, xDir, dir[0] * offset - value.width / 2.0);
     }
 
-    add(ptv3, ptv3, tmpv3);
-    scale(tmpv3, yDir, dir[1] * offset - value.height / 2.0);
-    add(ptv3, ptv3, tmpv3);
+    vec3.add(ptv3, ptv3, tmpv3);
+    vec3.scale(tmpv3, yDir, dir[1] * offset - value.height / 2.0);
+    vec3.add(ptv3, ptv3, tmpv3);
     results.points[ptIdx * 3] = ptv3[0];
     results.points[ptIdx * 3 + 1] = ptv3[1];
     results.points[ptIdx * 3 + 2] = ptv3[2];
     results.tcoords[ptIdx * 2] = value.tcoords[0];
     results.tcoords[ptIdx * 2 + 1] = value.tcoords[1];
     ptIdx++;
-    scale(tmpv3, xDir, value.width);
-    add(ptv3, ptv3, tmpv3);
+    vec3.scale(tmpv3, xDir, value.width);
+    vec3.add(ptv3, ptv3, tmpv3);
     results.points[ptIdx * 3] = ptv3[0];
     results.points[ptIdx * 3 + 1] = ptv3[1];
     results.points[ptIdx * 3 + 2] = ptv3[2];
     results.tcoords[ptIdx * 2] = value.tcoords[2];
     results.tcoords[ptIdx * 2 + 1] = value.tcoords[3];
     ptIdx++;
-    scale(tmpv3, yDir, value.height);
-    add(ptv3, ptv3, tmpv3);
+    vec3.scale(tmpv3, yDir, value.height);
+    vec3.add(ptv3, ptv3, tmpv3);
     results.points[ptIdx * 3] = ptv3[0];
     results.points[ptIdx * 3 + 1] = ptv3[1];
     results.points[ptIdx * 3 + 2] = ptv3[2];
     results.tcoords[ptIdx * 2] = value.tcoords[4];
     results.tcoords[ptIdx * 2 + 1] = value.tcoords[5];
     ptIdx++;
-    scale(tmpv3, xDir, value.width);
-    subtract(ptv3, ptv3, tmpv3);
+    vec3.scale(tmpv3, xDir, value.width);
+    vec3.subtract(ptv3, ptv3, tmpv3);
     results.points[ptIdx * 3] = ptv3[0];
     results.points[ptIdx * 3 + 1] = ptv3[1];
     results.points[ptIdx * 3 + 2] = ptv3[2];
@@ -534,7 +533,7 @@ function vtkCubeAxesActor(publicAPI, model) {
 
   publicAPI.updateTexturePolyData = function () {
     var cmat = model.camera.getCompositeProjectionMatrix(model.lastAspectRatio, -1, 1);
-    transpose(cmat, cmat); // update the polydata
+    mat4.transpose(cmat, cmat); // update the polydata
 
     var numLabels = model.textValues.length;
     var numPts = numLabels * 4;
@@ -542,7 +541,7 @@ function vtkCubeAxesActor(publicAPI, model) {
     var points = new Float64Array(numPts * 3);
     var polys = new Uint16Array(numTris * 4);
     var tcoords = new Float32Array(numPts * 2);
-    invert(invmat, cmat);
+    mat4.invert(invmat, cmat);
     var results = {
       ptIdx: 0,
       cellIdx: 0,
@@ -560,12 +559,12 @@ function vtkCubeAxesActor(publicAPI, model) {
       ptv3[0] = coords[ptIdx * 3];
       ptv3[1] = coords[ptIdx * 3 + 1];
       ptv3[2] = coords[ptIdx * 3 + 2];
-      transformMat4(tmpv3, ptv3, cmat);
+      vec3.transformMat4(tmpv3, ptv3, cmat);
       ptv3[0] = coords[ptIdx * 3 + 3];
       ptv3[1] = coords[ptIdx * 3 + 4];
       ptv3[2] = coords[ptIdx * 3 + 5];
-      transformMat4(tmp2v3, ptv3, cmat);
-      subtract(tmpv3, tmpv3, tmp2v3);
+      vec3.transformMat4(tmp2v3, ptv3, cmat);
+      vec3.subtract(tmpv3, tmpv3, tmp2v3);
       var dir = [tmpv3[0], tmpv3[1]];
       normalize2D(dir); // write the axis label
 

package/Rendering/Core/Follower.js

@@ -1,7 +1,6 @@
 import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
 import _defineProperty from '@babel/runtime/helpers/defineProperty';
-import { i as identity, m as multiply, t as translate, s as scale, j as transpose } from '../../vendor/gl-matrix/esm/mat4.js';
-import { s as set, v as vec3, a as subtract, n as normalize, c as cross } from '../../vendor/gl-matrix/esm/vec3.js';
+import { mat4, vec3 } from 'gl-matrix';
 import macro from '../../macros.js';
 import vtkActor from './Actor.js';
 
@@ -31,43 +30,43 @@ function vtkFollower(publicAPI, model) {
   publicAPI.computeMatrix = function () {
     // check whether or not need to rebuild the matrix
     if (publicAPI.getMTime() > model.matrixMTime.getMTime()) {
-      identity(model.matrix);
+      mat4.identity(model.matrix);
 
       if (model.userMatrix) {
-        multiply(model.matrix, model.matrix, model.userMatrix);
+        mat4.multiply(model.matrix, model.matrix, model.userMatrix);
       }
 
-      translate(model.matrix, model.matrix, model.origin);
-      translate(model.matrix, model.matrix, model.position);
-      multiply(model.matrix, model.matrix, model.rotation);
-      scale(model.matrix, model.matrix, model.scale);
+      mat4.translate(model.matrix, model.matrix, model.origin);
+      mat4.translate(model.matrix, model.matrix, model.position);
+      mat4.multiply(model.matrix, model.matrix, model.rotation);
+      mat4.scale(model.matrix, model.matrix, model.scale);
 
       if (model.camera) {
         // first compute our target viewUp
         var vup = new Float64Array(model.viewUp);
 
         if (!model.useViewUp) {
-          set.apply(vec3, [vup].concat(_toConsumableArray(model.camera.getViewUp())));
+          vec3.set.apply(vec3, [vup].concat(_toConsumableArray(model.camera.getViewUp())));
         } // compute a vpn
 
 
         var vpn = new Float64Array(3);
 
         if (model.camera.getParallelProjection()) {
-          set(vpn, model.camera.getViewPlaneNormal());
+          vec3.set(vpn, model.camera.getViewPlaneNormal());
         } else {
-          set.apply(vec3, [vpn].concat(_toConsumableArray(model.position)));
-          subtract(vpn, model.camera.getPosition(), vpn);
-          normalize(vpn, vpn);
+          vec3.set.apply(vec3, [vpn].concat(_toConsumableArray(model.position)));
+          vec3.subtract(vpn, model.camera.getPosition(), vpn);
+          vec3.normalize(vpn, vpn);
         } // compute vright
 
 
         var vright = new Float64Array(3);
-        cross(vright, vup, vpn);
-        normalize(vright, vright); // now recompute the vpn so that it is orthogonal to vup
+        vec3.cross(vright, vup, vpn);
+        vec3.normalize(vright, vright); // now recompute the vpn so that it is orthogonal to vup
 
-        cross(vpn, vright, vup);
-        normalize(vpn, vpn);
+        vec3.cross(vpn, vright, vup);
+        vec3.normalize(vpn, vpn);
         model.followerMatrix[0] = vright[0];
         model.followerMatrix[1] = vright[1];
         model.followerMatrix[2] = vright[2];
@@ -77,11 +76,11 @@ function vtkFollower(publicAPI, model) {
         model.followerMatrix[8] = vpn[0];
         model.followerMatrix[9] = vpn[1];
         model.followerMatrix[10] = vpn[2];
-        multiply(model.matrix, model.followerMatrix, model.matrix);
+        mat4.multiply(model.matrix, model.followerMatrix, model.matrix);
       }
 
-      translate(model.matrix, model.matrix, [-model.origin[0], -model.origin[1], -model.origin[2]]);
-      transpose(model.matrix, model.matrix); // check for identity
+      mat4.translate(model.matrix, model.matrix, [-model.origin[0], -model.origin[1], -model.origin[2]]);
+      mat4.transpose(model.matrix, model.matrix); // check for identity
 
       model.isIdentity = false;
       model.matrixMTime.modified();
@@ -103,7 +102,7 @@ function extend(publicAPI, model) {
   Object.assign(model, DEFAULT_VALUES, initialValues); // Inheritance
 
   vtkActor.extend(publicAPI, model, initialValues);
-  model.followerMatrix = identity(new Float64Array(16)); // Build VTK API
+  model.followerMatrix = mat4.identity(new Float64Array(16)); // Build VTK API
 
   macro.setGet(publicAPI, model, ['useViewUp', 'camera']);
   macro.setGetArray(publicAPI, model, ['viewUp'], 3); // Object methods