@kitware/vtk.js 20.1.4 → 20.2.3

package/Rendering/Core/Prop3D.js

@@ -1,9 +1,8 @@
+import { mat4, quat } from 'gl-matrix';
 import macro from '../../macros.js';
 import vtkBoundingBox from '../../Common/DataModel/BoundingBox.js';
 import { y as degreesFromRadians, r as radiansFromDegrees } from '../../Common/Core/Math/index.js';
 import vtkProp from './Prop.js';
-import { i as identity, n as getRotation, a as rotateX, b as rotateY, c as rotateZ, k as fromQuat, m as multiply, d as copy, t as translate, s as scale, j as transpose } from '../../vendor/gl-matrix/esm/mat4.js';
-import { c as create, g as getAxisAngle, s as setAxisAngle } from '../../vendor/gl-matrix/esm/quat.js';
 
 // vtkProp3D methods
 // ----------------------------------------------------------------------------
@@ -20,10 +19,10 @@ function vtkProp3D(publicAPI, model) {
   };
 
   publicAPI.getOrientationWXYZ = function () {
-    var q = create();
-    getRotation(q, model.rotation);
+    var q = quat.create();
+    mat4.getRotation(q, model.rotation);
     var oaxis = new Float64Array(3);
-    var w = getAxisAngle(oaxis, q);
+    var w = quat.getAxisAngle(oaxis, q);
     return [degreesFromRadians(w), oaxis[0], oaxis[1], oaxis[2]];
   };
 
@@ -32,7 +31,7 @@ function vtkProp3D(publicAPI, model) {
       return;
     }
 
-    rotateX(model.rotation, model.rotation, radiansFromDegrees(val));
+    mat4.rotateX(model.rotation, model.rotation, radiansFromDegrees(val));
     publicAPI.modified();
   };
 
@@ -41,7 +40,7 @@ function vtkProp3D(publicAPI, model) {
       return;
     }
 
-    rotateY(model.rotation, model.rotation, radiansFromDegrees(val));
+    mat4.rotateY(model.rotation, model.rotation, radiansFromDegrees(val));
     publicAPI.modified();
   };
 
@@ -50,7 +49,7 @@ function vtkProp3D(publicAPI, model) {
       return;
     }
 
-    rotateZ(model.rotation, model.rotation, radiansFromDegrees(val));
+    mat4.rotateZ(model.rotation, model.rotation, radiansFromDegrees(val));
     publicAPI.modified();
   };
 
@@ -61,11 +60,11 @@ function vtkProp3D(publicAPI, model) {
 
 
     var angle = radiansFromDegrees(degrees);
-    var q = create();
-    setAxisAngle(q, [x, y, z], angle);
+    var q = quat.create();
+    quat.setAxisAngle(q, [x, y, z], angle);
     var quatMat = new Float64Array(16);
-    fromQuat(quatMat, q);
-    multiply(model.rotation, model.rotation, quatMat);
+    mat4.fromQuat(quatMat, q);
+    mat4.multiply(model.rotation, model.rotation, quatMat);
     publicAPI.modified();
   };
 
@@ -75,7 +74,7 @@ function vtkProp3D(publicAPI, model) {
     }
 
     model.orientation = [x, y, z];
-    identity(model.rotation);
+    mat4.identity(model.rotation);
     publicAPI.rotateZ(z);
     publicAPI.rotateX(x);
     publicAPI.rotateY(y);
@@ -84,7 +83,7 @@ function vtkProp3D(publicAPI, model) {
   };
 
   publicAPI.setUserMatrix = function (matrix) {
-    copy(model.userMatrix, matrix);
+    mat4.copy(model.userMatrix, matrix);
     publicAPI.modified();
   };
 
@@ -96,18 +95,18 @@ function vtkProp3D(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);
-      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);
+      mat4.translate(model.matrix, model.matrix, model.position);
+      mat4.multiply(model.matrix, model.matrix, model.rotation);
+      mat4.scale(model.matrix, model.matrix, model.scale);
+      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 = true;
 
@@ -183,9 +182,9 @@ function extend(publicAPI, model) {
   macro.getArray(publicAPI, model, ['orientation']);
   macro.setGetArray(publicAPI, model, ['origin', 'position', 'scale'], 3); // Object internal instance
 
-  model.matrix = identity(new Float64Array(16));
-  model.rotation = identity(new Float64Array(16));
-  model.userMatrix = identity(new Float64Array(16));
+  model.matrix = mat4.identity(new Float64Array(16));
+  model.rotation = mat4.identity(new Float64Array(16));
+  model.userMatrix = mat4.identity(new Float64Array(16));
   model.transform = null; // FIXME
   // Object methods
 

package/Rendering/Core/Renderer.js

@@ -1,11 +1,10 @@
+import { mat4, vec3 } from 'gl-matrix';
 import { newInstance as newInstance$1, get, setGet, getArray, setGetArray, vtkDebugMacro as vtkDebugMacro$1, vtkErrorMacro as vtkErrorMacro$1, vtkWarningMacro as vtkWarningMacro$1 } from '../../macros.js';
 import vtkCamera from './Camera.js';
 import vtkLight from './Light.js';
 import { O as areBoundsInitialized, u as uninitializeBounds, r as radiansFromDegrees, d as dot, M as createUninitializedBounds } from '../../Common/Core/Math/index.js';
 import vtkViewport from './Viewport.js';
 import vtkBoundingBox from '../../Common/DataModel/BoundingBox.js';
-import { g as invert, j as transpose } from '../../vendor/gl-matrix/esm/mat4.js';
-import { t as transformMat4 } from '../../vendor/gl-matrix/esm/vec3.js';
 
 var vtkDebugMacro = vtkDebugMacro$1,
     vtkErrorMacro = vtkErrorMacro$1,
@@ -266,11 +265,11 @@ function vtkRenderer(publicAPI, model) {
 
 
     var matrix = model.activeCamera.getViewMatrix();
-    invert(matrix, matrix);
-    transpose(matrix, matrix); // Transform point to world coordinates
+    mat4.invert(matrix, matrix);
+    mat4.transpose(matrix, matrix); // Transform point to world coordinates
 
     var result = new Float64Array([x, y, z]);
-    transformMat4(result, result, matrix);
+    vec3.transformMat4(result, result, matrix);
     return result;
   };
 
@@ -282,11 +281,11 @@ function vtkRenderer(publicAPI, model) {
 
 
     var matrix = model.activeCamera.getProjectionMatrix(aspect, -1.0, 1.0);
-    invert(matrix, matrix);
-    transpose(matrix, matrix); // Transform point to world coordinates
+    mat4.invert(matrix, matrix);
+    mat4.transpose(matrix, matrix); // Transform point to world coordinates
 
     var result = new Float64Array([x, y, z]);
-    transformMat4(result, result, matrix);
+    vec3.transformMat4(result, result, matrix);
     return result;
   }; // Convert world point coordinates to view coordinates.
 
@@ -299,9 +298,9 @@ function vtkRenderer(publicAPI, model) {
 
 
     var matrix = model.activeCamera.getViewMatrix();
-    transpose(matrix, matrix);
+    mat4.transpose(matrix, matrix);
     var result = new Float64Array([x, y, z]);
-    transformMat4(result, result, matrix);
+    vec3.transformMat4(result, result, matrix);
     return result;
   }; // Convert world point coordinates to view coordinates.
   // requires the aspect ratio of the viewport as X/Y
@@ -315,9 +314,9 @@ function vtkRenderer(publicAPI, model) {
 
 
     var matrix = model.activeCamera.getProjectionMatrix(aspect, -1.0, 1.0);
-    transpose(matrix, matrix);
+    mat4.transpose(matrix, matrix);
     var result = new Float64Array([x, y, z]);
-    transformMat4(result, result, matrix);
+    vec3.transformMat4(result, result, matrix);
     return result;
   };
 

package/Rendering/Core/ScalarBarActor.js

@@ -1,5 +1,7 @@
 import _defineProperty from '@babel/runtime/helpers/defineProperty';
 import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
+import { vec3, mat4 } from 'gl-matrix';
+import * as d3 from 'd3-scale';
 import { K as nearestPowerOfTwo } 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 { b as scale, j as add, a as subtract, t as transformMat4 } from '../../vendor/gl-matrix/esm/vec3.js';
-import { j as transpose, g as invert } from '../../vendor/gl-matrix/esm/mat4.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; }
 
@@ -130,7 +129,7 @@ function vtkScalarBarActor(publicAPI, model) {
       model.lastTickBounds = _toConsumableArray(range);
       model.barMapper.setScalarRange(model.lastTickBounds); // compute tick marks for axes (update for log scale)
 
-      var scale = linear().domain([model.lastTickBounds[0], model.lastTickBounds[1]]);
+      var scale = d3.scaleLinear().domain([model.lastTickBounds[0], model.lastTickBounds[1]]);
       model.ticks = scale.ticks(5);
       var format = scale.tickFormat(5);
       model.tickStrings = model.ticks.map(format);
@@ -378,40 +377,40 @@ function vtkScalarBarActor(publicAPI, model) {
     ptv3[2] = pos[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];
@@ -437,25 +436,25 @@ function vtkScalarBarActor(publicAPI, model) {
 
   publicAPI.updatePolyDataForLabels = function () {
     var cmat = model.camera.getCompositeProjectionMatrix(model.lastAspectRatio, -1, 1);
-    transpose(cmat, cmat);
-    invert(invmat, cmat);
+    mat4.transpose(cmat, cmat);
+    mat4.invert(invmat, cmat);
     var size = model.lastSize; // compute pixel to distance factors
 
     tmpv3[0] = 0.0;
     tmpv3[1] = 0.0;
     tmpv3[2] = -0.99; // near plane
 
-    transformMat4(ptv3, tmpv3, invmat); // moving 0.1 in NDC
+    vec3.transformMat4(ptv3, tmpv3, invmat); // moving 0.1 in NDC
 
     tmpv3[0] += 0.1;
-    transformMat4(pt2v3, tmpv3, invmat); // results in WC move of
+    vec3.transformMat4(pt2v3, tmpv3, invmat); // 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, invmat); // results in WC move of
+    vec3.transformMat4(pt2v3, tmpv3, invmat); // 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];
@@ -486,24 +485,24 @@ function vtkScalarBarActor(publicAPI, model) {
       if (model.topTitle) {
         tmpv3[0] = model.boxPosition[0] + 0.5 * model.boxSize[0];
         tmpv3[1] = model.barPosition[1] + model.barSize[1];
-        transformMat4(ptv3, tmpv3, invmat); // write the axis label
+        vec3.transformMat4(ptv3, tmpv3, invmat); // write the axis label
 
         publicAPI.createPolyDataForOneLabel(model.axisLabel, ptv3, xDir, yDir, [0, 1], model.axisTitlePixelOffset, results);
       } else {
         tmpv3[0] = model.barPosition[0] + model.barSize[0];
         tmpv3[1] = model.barPosition[1] + 0.5 * model.barSize[1];
-        transformMat4(ptv3, tmpv3, invmat); // write the axis label
+        vec3.transformMat4(ptv3, tmpv3, invmat); // write the axis label
 
-        scale(xDir, xDir, -1);
+        vec3.scale(xDir, xDir, -1);
         publicAPI.createPolyDataForOneLabel(model.axisLabel, ptv3, yDir, xDir, [0, -1], model.axisTitlePixelOffset, results);
-        scale(xDir, xDir, -1);
+        vec3.scale(xDir, xDir, -1);
       }
 
       dir = [-1, 0];
     } else {
       tmpv3[0] = model.barPosition[0] + 0.5 * model.barSize[0];
       tmpv3[1] = model.barPosition[1] + model.barSize[1];
-      transformMat4(ptv3, tmpv3, invmat);
+      vec3.transformMat4(ptv3, tmpv3, invmat);
       publicAPI.createPolyDataForOneLabel(model.axisLabel, ptv3, xDir, yDir, dir, model.axisTitlePixelOffset, results);
     }
 
@@ -522,7 +521,7 @@ function vtkScalarBarActor(publicAPI, model) {
         tickSeg = seg;
       } else {
         tmp2v3[spacedAxis] = model.barPosition[spacedAxis] + 0.5 * model.barSize[spacedAxis] * (seg.corners[2][spacedAxis] + seg.corners[0][spacedAxis]);
-        transformMat4(ptv3, tmp2v3, invmat);
+        vec3.transformMat4(ptv3, tmp2v3, invmat);
         publicAPI.createPolyDataForOneLabel(seg.title, ptv3, xDir, yDir, dir, model.tickLabelPixelOffset, results);
       }
     } // write the tick labels
@@ -534,7 +533,7 @@ function vtkScalarBarActor(publicAPI, model) {
     for (var t = 0; t < model.ticks.length; t++) {
       var tickPos = (model.ticks[t] - model.lastTickBounds[0]) / (model.lastTickBounds[1] - model.lastTickBounds[0]);
       tmp2v3[spacedAxis] = tickSegmentStart + tickSegmentSize * tickPos;
-      transformMat4(ptv3, tmp2v3, invmat);
+      vec3.transformMat4(ptv3, tmp2v3, invmat);
       publicAPI.createPolyDataForOneLabel(model.tickStrings[t], ptv3, xDir, yDir, dir, model.tickLabelPixelOffset, results);
     }
 
@@ -553,8 +552,8 @@ function vtkScalarBarActor(publicAPI, model) {
 
   publicAPI.updatePolyDataForBarSegments = function () {
     var cmat = model.camera.getCompositeProjectionMatrix(model.lastAspectRatio, -1, 1);
-    transpose(cmat, cmat);
-    invert(invmat, cmat);
+    mat4.transpose(cmat, cmat);
+    mat4.invert(invmat, cmat);
     var haveExtraColors = typeof model.scalarsToColors.getNanColor === 'function' && typeof model.scalarsToColors.getAboveRangeColor === 'function' && typeof model.scalarsToColors.getBelowRangeColor === 'function';
     var numPts = 4 + (haveExtraColors ? 12 : 0);
     var numQuads = numPts; // handle vector component mode
@@ -580,7 +579,7 @@ function vtkScalarBarActor(publicAPI, model) {
       for (var e = 0; e < 4; e++) {
         tmp2v3[0] = model.barPosition[0] + seg.corners[e][0] * model.barSize[0];
         tmp2v3[1] = model.barPosition[1] + seg.corners[e][1] * model.barSize[1];
-        transformMat4(ptv3, tmp2v3, invmat);
+        vec3.transformMat4(ptv3, tmp2v3, invmat);
         points[ptIdx * 3] = ptv3[0];
         points[ptIdx * 3 + 1] = ptv3[1];
         points[ptIdx * 3 + 2] = ptv3[2];
@@ -631,7 +630,11 @@ function vtkScalarBarActor(publicAPI, model) {
     publicAPI.modified();
   };
 
-  publicAPI.setVisibility = macro.chain(publicAPI.setVisibility, model.barActor.setVisibility, model.tmActor.setVisibility);
+  var setVisibility = macro.chain(publicAPI.setVisibility, model.barActor.setVisibility, model.tmActor.setVisibility);
+
+  publicAPI.setVisibility = function () {
+    return setVisibility.apply(void 0, arguments).some(Boolean);
+  };
 
   publicAPI.resetAutoLayoutToDefault = function () {
     model.autoLayout = defaultAutoLayout(publicAPI, model);

package/Rendering/Core/Volume.js

@@ -1,9 +1,8 @@
+import { mat4, vec3 } from 'gl-matrix';
 import macro from '../../macros.js';
 import vtkBoundingBox from '../../Common/DataModel/BoundingBox.js';
 import vtkProp3D from './Prop3D.js';
 import vtkVolumeProperty from './VolumeProperty.js';
-import { j as transpose } from '../../vendor/gl-matrix/esm/mat4.js';
-import { t as transformMat4 } from '../../vendor/gl-matrix/esm/vec3.js';
 
 var vtkDebugMacro = macro.vtkDebugMacro; // ----------------------------------------------------------------------------
 // vtkVolume methods
@@ -72,9 +71,9 @@ function vtkVolume(publicAPI, model) {
       vtkBoundingBox.getCorners(bds, bbox);
       publicAPI.computeMatrix();
       var tmp4 = new Float64Array(16);
-      transpose(tmp4, model.matrix);
+      mat4.transpose(tmp4, model.matrix);
       bbox.forEach(function (pt) {
-        return transformMat4(pt, pt, tmp4);
+        return vec3.transformMat4(pt, pt, tmp4);
       });
       /* eslint-disable no-multi-assign */
 

package/Rendering/OpenGL/Actor.js

@@ -1,8 +1,7 @@
+import { mat3, mat4 } from 'gl-matrix';
 import { newInstance as newInstance$1, obj, setGet, get } from '../../macros.js';
 import vtkViewNode from '../SceneGraph/ViewNode.js';
 import { registerOverride } from './ViewNodeFactory.js';
-import { i as identity, f as fromMat4, a as invert, t as transpose$1 } from '../../vendor/gl-matrix/esm/mat3.js';
-import { i as identity$1, d as copy, j as transpose } from '../../vendor/gl-matrix/esm/mat4.js';
 
 // vtkOpenGLActor methods
 // ----------------------------------------------------------------------------
@@ -135,15 +134,15 @@ function vtkOpenGLActor(publicAPI, model) {
     // has the actor changed?
     if (model.renderable.getMTime() > model.keyMatrixTime.getMTime()) {
       model.renderable.computeMatrix();
-      copy(model.keyMatrices.mcwc, model.renderable.getMatrix());
-      transpose(model.keyMatrices.mcwc, model.keyMatrices.mcwc);
+      mat4.copy(model.keyMatrices.mcwc, model.renderable.getMatrix());
+      mat4.transpose(model.keyMatrices.mcwc, model.keyMatrices.mcwc);
 
       if (model.renderable.getIsIdentity()) {
-        identity(model.keyMatrices.normalMatrix);
+        mat3.identity(model.keyMatrices.normalMatrix);
       } else {
-        fromMat4(model.keyMatrices.normalMatrix, model.keyMatrices.mcwc);
-        invert(model.keyMatrices.normalMatrix, model.keyMatrices.normalMatrix);
-        transpose$1(model.keyMatrices.normalMatrix, model.keyMatrices.normalMatrix);
+        mat3.fromMat4(model.keyMatrices.normalMatrix, model.keyMatrices.mcwc);
+        mat3.invert(model.keyMatrices.normalMatrix, model.keyMatrices.normalMatrix);
+        mat3.transpose(model.keyMatrices.normalMatrix, model.keyMatrices.normalMatrix);
       }
 
       model.keyMatrixTime.modified();
@@ -173,8 +172,8 @@ function extend(publicAPI, model) {
     mtime: 0
   });
   model.keyMatrices = {
-    normalMatrix: identity(new Float64Array(9)),
-    mcwc: identity$1(new Float64Array(16))
+    normalMatrix: mat3.identity(new Float64Array(9)),
+    mcwc: mat4.identity(new Float64Array(16))
   }; // Build VTK API
 
   setGet(publicAPI, model, ['context']);

package/Rendering/OpenGL/Camera.js

@@ -1,8 +1,7 @@
+import { mat4, mat3 } from 'gl-matrix';
 import { newInstance as newInstance$1, obj, setGet } from '../../macros.js';
 import vtkViewNode from '../SceneGraph/ViewNode.js';
 import { registerOverride } from './ViewNodeFactory.js';
-import { d as copy, j as transpose, m as multiply } from '../../vendor/gl-matrix/esm/mat4.js';
-import { f as fromMat4, a as invert } from '../../vendor/gl-matrix/esm/mat3.js';
 
 // vtkOpenGLCamera methods
 // ----------------------------------------------------------------------------
@@ -35,14 +34,14 @@ function vtkOpenGLCamera(publicAPI, model) {
   publicAPI.getKeyMatrices = function (ren) {
     // has the camera changed?
     if (ren !== model.lastRenderer || model.openGLRenderWindow.getMTime() > model.keyMatrixTime.getMTime() || publicAPI.getMTime() > model.keyMatrixTime.getMTime() || ren.getMTime() > model.keyMatrixTime.getMTime() || model.renderable.getMTime() > model.keyMatrixTime.getMTime()) {
-      copy(model.keyMatrices.wcvc, model.renderable.getViewMatrix());
-      fromMat4(model.keyMatrices.normalMatrix, model.keyMatrices.wcvc);
-      invert(model.keyMatrices.normalMatrix, model.keyMatrices.normalMatrix);
-      transpose(model.keyMatrices.wcvc, model.keyMatrices.wcvc);
+      mat4.copy(model.keyMatrices.wcvc, model.renderable.getViewMatrix());
+      mat3.fromMat4(model.keyMatrices.normalMatrix, model.keyMatrices.wcvc);
+      mat3.invert(model.keyMatrices.normalMatrix, model.keyMatrices.normalMatrix);
+      mat4.transpose(model.keyMatrices.wcvc, model.keyMatrices.wcvc);
       var aspectRatio = model.openGLRenderer.getAspectRatio();
-      copy(model.keyMatrices.vcpc, model.renderable.getProjectionMatrix(aspectRatio, -1, 1));
-      transpose(model.keyMatrices.vcpc, model.keyMatrices.vcpc);
-      multiply(model.keyMatrices.wcpc, model.keyMatrices.vcpc, model.keyMatrices.wcvc);
+      mat4.copy(model.keyMatrices.vcpc, model.renderable.getProjectionMatrix(aspectRatio, -1, 1));
+      mat4.transpose(model.keyMatrices.vcpc, model.keyMatrices.vcpc);
+      mat4.multiply(model.keyMatrices.wcpc, model.keyMatrices.vcpc, model.keyMatrices.wcvc);
       model.keyMatrixTime.modified();
       model.lastRenderer = ren;
     }

package/Rendering/OpenGL/CellArrayBufferObject.js

@@ -1,10 +1,8 @@
+import { vec3, mat4, quat } from 'gl-matrix';
 import macro from '../../macros.js';
 import vtkBufferObject from './BufferObject.js';
 import { ObjectType } from './BufferObject/Constants.js';
 import { Representation } from '../Core/Property/Constants.js';
-import { k as equals, m as inverse, g as exactEquals } from '../../vendor/gl-matrix/esm/vec3.js';
-import { p as fromRotationTranslationScale } from '../../vendor/gl-matrix/esm/mat4.js';
-import { c as create } from '../../vendor/gl-matrix/esm/quat.js';
 
 var vtkErrorMacro = macro.vtkErrorMacro; // ----------------------------------------------------------------------------
 // Static functions
@@ -12,9 +10,9 @@ var vtkErrorMacro = macro.vtkErrorMacro; // ------------------------------------
 
 function computeInverseShiftAndScaleMatrix(coordShift, coordScale) {
   var inverseScale = new Float64Array(3);
-  inverse(inverseScale, coordScale);
+  vec3.inverse(inverseScale, coordScale);
   var matrix = new Float64Array(16);
-  fromRotationTranslationScale(matrix, create(), coordShift, inverseScale);
+  mat4.fromRotationTranslationScale(matrix, quat.create(), coordShift, inverseScale);
   return matrix;
 }
 
@@ -23,7 +21,7 @@ function shouldApplyCoordShiftAndScale(coordShift, coordScale) {
     return false;
   }
 
-  return !(exactEquals(coordShift, [0, 0, 0]) && exactEquals(coordScale, [1, 1, 1]));
+  return !(vec3.exactEquals(coordShift, [0, 0, 0]) && vec3.exactEquals(coordScale, [1, 1, 1]));
 } // ----------------------------------------------------------------------------
 // vtkOpenGLCellArrayBufferObject methods
 // ----------------------------------------------------------------------------
@@ -351,11 +349,11 @@ function vtkOpenGLCellArrayBufferObject(publicAPI, model) {
       return;
     }
 
-    if (model.coordShift === null || coordShift === null || !equals(coordShift, model.coordShift)) {
+    if (model.coordShift === null || coordShift === null || !vec3.equals(coordShift, model.coordShift)) {
       model.coordShift = coordShift;
     }
 
-    if (model.coordScale === null || coordScale === null || !equals(coordScale, model.coordScale)) {
+    if (model.coordScale === null || coordScale === null || !vec3.equals(coordScale, model.coordScale)) {
       model.coordScale = coordScale;
     }
 

package/Rendering/OpenGL/Glyph3DMapper.js

@@ -1,4 +1,5 @@
 import _defineProperty from '@babel/runtime/helpers/defineProperty';
+import { mat3, mat4 } from 'gl-matrix';
 import { newInstance as newInstance$1, obj, vtkErrorMacro as vtkErrorMacro$1 } from '../../macros.js';
 import vtkBufferObject from './BufferObject.js';
 import vtkHardwareSelector from './HardwareSelector.js';
@@ -6,8 +7,6 @@ import vtkProperty from '../Core/Property.js';
 import vtkOpenGLPolyDataMapper from './PolyDataMapper.js';
 import vtkShaderProgram from './ShaderProgram.js';
 import { registerOverride } from './ViewNodeFactory.js';
-import { i as identity, m as multiply } from '../../vendor/gl-matrix/esm/mat3.js';
-import { i as identity$1, m as multiply$1 } from '../../vendor/gl-matrix/esm/mat4.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; }
 
@@ -307,9 +306,9 @@ function vtkOpenGLGlyph3DMapper(publicAPI, model) {
     var keyMats = model.openGLCamera.getKeyMatrices(ren);
     var actMats = model.openGLActor.getKeyMatrices(); // precompute the actor+camera mats once
 
-    multiply(model.normalMatrix, keyMats.normalMatrix, actMats.normalMatrix);
-    multiply$1(model.mcpcMatrix, keyMats.wcpc, actMats.mcwc);
-    multiply$1(model.mcvcMatrix, keyMats.wcvc, actMats.mcwc);
+    mat3.multiply(model.normalMatrix, keyMats.normalMatrix, actMats.normalMatrix);
+    mat4.multiply(model.mcpcMatrix, keyMats.wcpc, actMats.mcwc);
+    mat4.multiply(model.mcvcMatrix, keyMats.wcvc, actMats.mcwc);
     var garray = model.renderable.getMatrixArray();
     var narray = model.renderable.getNormalArray();
     var carray = model.renderable.getColorArray();
@@ -479,10 +478,10 @@ function extend(publicAPI, model) {
   Object.assign(model, DEFAULT_VALUES, initialValues); // Inheritance
 
   vtkOpenGLPolyDataMapper.extend(publicAPI, model, initialValues);
-  model.tmpMat3 = identity(new Float64Array(9));
-  model.normalMatrix = identity(new Float64Array(9));
-  model.mcpcMatrix = identity$1(new Float64Array(16));
-  model.mcvcMatrix = identity$1(new Float64Array(16));
+  model.tmpMat3 = mat3.identity(new Float64Array(9));
+  model.normalMatrix = mat3.identity(new Float64Array(9));
+  model.mcpcMatrix = mat4.identity(new Float64Array(16));
+  model.mcvcMatrix = mat4.identity(new Float64Array(16));
   model.tmpColor = [];
   model.glyphBOBuildTime = {};
   obj(model.glyphBOBuildTime, {

package/Rendering/OpenGL/ImageMapper.js

@@ -1,3 +1,4 @@
+import { mat4 } from 'gl-matrix';
 import Constants from '../Core/ImageMapper/Constants.js';
 import { newInstance as newInstance$1, setGet, obj, vtkErrorMacro as vtkErrorMacro$1 } from '../../macros.js';
 import vtkDataArray from '../../Common/Core/DataArray.js';
@@ -14,7 +15,6 @@ import { v as vtkPolyDataVS } from './glsl/vtkPolyDataVS.glsl.js';
 import { v as vtkPolyDataFS } from './glsl/vtkPolyDataFS.glsl.js';
 import vtkReplacementShaderMapper from './ReplacementShaderMapper.js';
 import { registerOverride } from './ViewNodeFactory.js';
-import { i as identity, m as multiply } from '../../vendor/gl-matrix/esm/mat4.js';
 
 var vtkErrorMacro = vtkErrorMacro$1;
 var SlicingMode = Constants.SlicingMode; // ----------------------------------------------------------------------------
@@ -383,7 +383,7 @@ function vtkOpenGLImageMapper(publicAPI, model) {
 
       var image = model.currentInput;
       var w2imat4 = image.getWorldToIndex();
-      multiply(model.imagematinv, w2imat4, actor.getMatrix());
+      mat4.multiply(model.imagematinv, w2imat4, actor.getMatrix());
       var planeEquations = [];
 
       for (var _i3 = 0; _i3 < numClipPlanes; _i3++) {
@@ -405,13 +405,13 @@ function vtkOpenGLImageMapper(publicAPI, model) {
     var actMats = model.openGLImageSlice.getKeyMatrices();
     var image = model.currentInput;
     var i2wmat4 = image.getIndexToWorld();
-    multiply(model.imagemat, actMats.mcwc, i2wmat4);
+    mat4.multiply(model.imagemat, actMats.mcwc, i2wmat4);
     var keyMats = model.openGLCamera.getKeyMatrices(ren);
-    multiply(model.imagemat, keyMats.wcpc, model.imagemat);
+    mat4.multiply(model.imagemat, keyMats.wcpc, model.imagemat);
 
     if (cellBO.getCABO().getCoordShiftAndScaleEnabled()) {
       var inverseShiftScaleMat = cellBO.getCABO().getInverseShiftAndScaleMatrix();
-      multiply(model.imagemat, model.imagemat, inverseShiftScaleMat);
+      mat4.multiply(model.imagemat, model.imagemat, inverseShiftScaleMat);
     }
 
     program.setUniformMatrix('MCPCMatrix', model.imagemat);
@@ -831,8 +831,8 @@ function extend(publicAPI, model) {
   model.openGLTexture = vtkOpenGLTexture.newInstance();
   model.colorTexture = vtkOpenGLTexture.newInstance();
   model.pwfTexture = vtkOpenGLTexture.newInstance();
-  model.imagemat = identity(new Float64Array(16));
-  model.imagematinv = identity(new Float64Array(16)); // Build VTK API
+  model.imagemat = mat4.identity(new Float64Array(16));
+  model.imagematinv = mat4.identity(new Float64Array(16)); // Build VTK API
 
   setGet(publicAPI, model, []);
   model.VBOBuildTime = {};

package/Rendering/OpenGL/ImageSlice.js

@@ -1,7 +1,7 @@
+import { mat4 } from 'gl-matrix';
 import { newInstance as newInstance$1, obj, setGet } from '../../macros.js';
 import vtkViewNode from '../SceneGraph/ViewNode.js';
 import { registerOverride } from './ViewNodeFactory.js';
-import { i as identity, d as copy, j as transpose } from '../../vendor/gl-matrix/esm/mat4.js';
 
 // vtkOpenGLImageSlice methods
 // ----------------------------------------------------------------------------
@@ -96,8 +96,8 @@ function vtkOpenGLImageSlice(publicAPI, model) {
   publicAPI.getKeyMatrices = function () {
     // has the actor changed?
     if (model.renderable.getMTime() > model.keyMatrixTime.getMTime()) {
-      copy(model.keyMatrices.mcwc, model.renderable.getMatrix());
-      transpose(model.keyMatrices.mcwc, model.keyMatrices.mcwc);
+      mat4.copy(model.keyMatrices.mcwc, model.renderable.getMatrix());
+      mat4.transpose(model.keyMatrices.mcwc, model.keyMatrices.mcwc);
       model.keyMatrixTime.modified();
     }
 
@@ -124,7 +124,7 @@ function extend(publicAPI, model) {
     mtime: 0
   });
   model.keyMatrices = {
-    mcwc: identity(new Float64Array(16))
+    mcwc: mat4.identity(new Float64Array(16))
   }; // Build VTK API
 
   setGet(publicAPI, model, ['context']); // Object methods