@kitware/vtk.js 20.1.2 → 20.2.1

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

package/Rendering/OpenGL/PolyDataMapper.js

@@ -1,7 +1,5 @@
 import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
-import { i as identity, b as mat3 } from '../../vendor/gl-matrix/esm/mat3.js';
-import { i as identity$1, j as transpose, q as mat4 } from '../../vendor/gl-matrix/esm/mat4.js';
-import { t as transformMat4 } from '../../vendor/gl-matrix/esm/vec3.js';
+import { mat3, mat4, vec3 } from 'gl-matrix';
 import { newInstance as newInstance$1, setGet, obj, vtkErrorMacro as vtkErrorMacro$1 } from '../../macros.js';
 import vtkHelper from './Helper.js';
 import vtkMapper from '../Core/Mapper.js';
@@ -426,15 +424,15 @@ function vtkOpenGLPolyDataMapper(publicAPI, model) {
         if (tus && tus.length >= 1) {
           switch (tNumComp) {
             case 1:
-              FSSource = vtkShaderProgram.substitute(FSSource, '//VTK::TCoord::Impl', ['vec4 tcolor = texture2D(texture1, tcoordVCVSOutput);', 'gl_FragData[0] = clamp(gl_FragData[0],0.0,1.0)*', '  vec4(tcolor.r,tcolor.r,tcolor.r,1.0);']).result;
+              FSSource = vtkShaderProgram.substitute(FSSource, '//VTK::TCoord::Impl', ['  vec4 tcolor = texture2D(texture1, tcoordVCVSOutput);', '  ambientColor = ambientColor*tcolor.r;', '  diffuseColor = diffuseColor*tcolor.r;']).result;
               break;
 
             case 2:
-              FSSource = vtkShaderProgram.substitute(FSSource, '//VTK::TCoord::Impl', ['vec4 tcolor = texture2D(texture1, tcoordVCVSOutput);', 'gl_FragData[0] = clamp(gl_FragData[0],0.0,1.0)*', '  vec4(tcolor.r,tcolor.r,tcolor.r,tcolor.g);']).result;
+              FSSource = vtkShaderProgram.substitute(FSSource, '//VTK::TCoord::Impl', ['  vec4 tcolor = texture2D(texture1, tcoordVCVSOutput);', '  ambientColor = ambientColor*tcolor.r;', '  diffuseColor = diffuseColor*tcolor.r;', '  opacity = opacity * tcolor.g;']).result;
               break;
 
             default:
-              FSSource = vtkShaderProgram.substitute(FSSource, '//VTK::TCoord::Impl', 'gl_FragData[0] = clamp(gl_FragData[0],0.0,1.0)*texture2D(texture1, tcoordVCVSOutput.st);').result;
+              FSSource = vtkShaderProgram.substitute(FSSource, '//VTK::TCoord::Impl', ['  vec4 tcolor = texture2D(texture1, tcoordVCVSOutput);', '  ambientColor = ambientColor*tcolor.rgb;', '  diffuseColor = diffuseColor*tcolor.rgb;', '  opacity = opacity * tcolor.a;']).result;
           }
         }
       } else {
@@ -445,15 +443,15 @@ function vtkOpenGLPolyDataMapper(publicAPI, model) {
 
         switch (tNumComp) {
           case 1:
-            FSSource = vtkShaderProgram.substitute(FSSource, '//VTK::TCoord::Impl', ['vec4 tcolor = textureCube(texture1, tcoordVCVSOutput);', 'gl_FragData[0] = clamp(gl_FragData[0],0.0,1.0)*', '  vec4(tcolor.r,tcolor.r,tcolor.r,1.0);']).result;
+            FSSource = vtkShaderProgram.substitute(FSSource, '//VTK::TCoord::Impl', ['  vec4 tcolor = textureCube(texture1, tcoordVCVSOutput);', '  ambientColor = ambientColor*tcolor.r;', '  diffuseColor = diffuseColor*tcolor.r;']).result;
             break;
 
           case 2:
-            FSSource = vtkShaderProgram.substitute(FSSource, '//VTK::TCoord::Impl', ['vec4 tcolor = textureCube(texture1, tcoordVCVSOutput);', 'gl_FragData[0] = clamp(gl_FragData[0],0.0,1.0)*', '  vec4(tcolor.r,tcolor.r,tcolor.r,tcolor.g);']).result;
+            FSSource = vtkShaderProgram.substitute(FSSource, '//VTK::TCoord::Impl', ['  vec4 tcolor = textureCube(texture1, tcoordVCVSOutput);', '  ambientColor = ambientColor*tcolor.r;', '  diffuseColor = diffuseColor*tcolor.r;', '  opacity = opacity * tcolor.g;']).result;
             break;
 
           default:
-            FSSource = vtkShaderProgram.substitute(FSSource, '//VTK::TCoord::Impl', 'gl_FragData[0] = clamp(gl_FragData[0],0.0,1.0)*textureCube(texture1, tcoordVCVSOutput);').result;
+            FSSource = vtkShaderProgram.substitute(FSSource, '//VTK::TCoord::Impl', ['  vec4 tcolor = textureCube(texture1, tcoordVCVSOutput);', '  ambientColor = ambientColor*tcolor.rgb;', '  diffuseColor = diffuseColor*tcolor.rgb;', '  opacity = opacity * tcolor.a;']).result;
         }
       }
 
@@ -834,7 +832,7 @@ function vtkOpenGLPolyDataMapper(publicAPI, model) {
 
     var cam = ren.getActiveCamera();
     var viewTF = cam.getViewMatrix();
-    transpose(viewTF, viewTF);
+    mat4.transpose(viewTF, viewTF);
     numberOfLights = 0;
 
     for (var _index = 0; _index < lights.length; ++_index) {
@@ -846,7 +844,7 @@ function vtkOpenGLPolyDataMapper(publicAPI, model) {
         var lp = _light.getTransformedPosition();
 
         var np = new Float64Array(3);
-        transformMat4(np, lp, viewTF);
+        vec3.transformMat4(np, lp, viewTF);
         program.setUniform3fArray("lightAttenuation".concat(numberOfLights), _light.getAttenuationValuesByReference());
         program.setUniformi("lightPositional".concat(numberOfLights), _light.getPositional());
         program.setUniformf("lightExponent".concat(numberOfLights), _light.getExponent());
@@ -1256,8 +1254,8 @@ function extend(publicAPI, model) {
   vtkReplacementShaderMapper.implementReplaceShaderCoincidentOffset(publicAPI, model, initialValues);
   model.primitives = [];
   model.primTypes = primTypes;
-  model.tmpMat3 = identity(new Float64Array(9));
-  model.tmpMat4 = identity$1(new Float64Array(16));
+  model.tmpMat3 = mat3.identity(new Float64Array(9));
+  model.tmpMat4 = mat4.identity(new Float64Array(16));
 
   for (var i = primTypes.Start; i < primTypes.End; i++) {
     model.primitives[i] = vtkHelper.newInstance();

package/Rendering/OpenGL/RenderWindow.d.ts

@@ -1,5 +1,5 @@
 import { vtkAlgorithm, vtkObject } from '@kitware/vtk.js/interfaces';
-import { Vector3 } from '@kitware/vtk.js/types';
+import { Vector2, Vector3 } from '@kitware/vtk.js/types';
 
 /**
  *
@@ -297,6 +297,42 @@ export interface vtkOpenGLRenderWindow extends vtkOpenGLRenderWindowBase {
 	 * @param stream 
 	 */
 	setViewStream(stream : any): boolean;
+
+	/**
+	 * 
+	 * @param size 
+	 */
+	 setSize(size : Vector2): void;
+
+	/**
+	 * 
+	 * @param x 
+	 * @param y 
+	 */
+	 setSize(x : number, y : number): void;
+
+	/**
+	 * 
+	 */
+	 getSize(): Vector2;
+
+	/**
+	 * 
+	 * @param size 
+	 */
+	 setVrResolution(size : Vector2): void;
+
+	/**
+	 * 
+	 * @param x 
+	 * @param y 
+	 */
+	 setVrResolution(x : number, y : number): void;
+
+	/**
+	 * 
+	 */
+	 getVrResolution(): Vector2;
 }
 
 /**

package/Rendering/OpenGL/ShaderCache.js

@@ -1,4 +1,4 @@
-import { m as md5 } from '../../vendor/blueimp-md5/js/md5.js';
+import md5 from 'blueimp-md5';
 import macro from '../../macros.js';
 import vtkShaderProgram from './ShaderProgram.js';
 

package/Rendering/OpenGL/Skybox.js

@@ -1,3 +1,4 @@
+import { mat3, mat4 } from 'gl-matrix';
 import { newInstance as newInstance$1, obj, setGet, get, vtkErrorMacro as vtkErrorMacro$1 } from '../../macros.js';
 import vtkDataArray from '../../Common/Core/DataArray.js';
 import vtkHelper from './Helper.js';
@@ -5,8 +6,6 @@ import vtkViewNode from '../SceneGraph/ViewNode.js';
 import vtkOpenGLTexture from './Texture.js';
 import { Representation } from '../Core/Property/Constants.js';
 import { registerOverride } from './ViewNodeFactory.js';
-import { i as identity } from '../../vendor/gl-matrix/esm/mat3.js';
-import { i as identity$1, g as invert } from '../../vendor/gl-matrix/esm/mat4.js';
 
 var vtkErrorMacro = vtkErrorMacro$1; // ----------------------------------------------------------------------------
 // vtkOpenGLSkybox methods
@@ -49,7 +48,7 @@ function vtkOpenGLSkybox(publicAPI, model) {
       var ren = model.openGLRenderer.getRenderable();
       var keyMats = model.openGLCamera.getKeyMatrices(ren);
       var imat = new Float64Array(16);
-      invert(imat, keyMats.wcpc);
+      mat4.invert(imat, keyMats.wcpc);
       model.tris.getProgram().setUniformMatrix('IMCPCMatrix', imat);
 
       if (model.lastFormat === 'box') {
@@ -165,8 +164,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/SphereMapper.js

@@ -1,4 +1,5 @@
 import _defineProperty from '@babel/runtime/helpers/defineProperty';
+import { mat4 } from 'gl-matrix';
 import { ObjectType } from './BufferObject/Constants.js';
 import { newInstance as newInstance$1, vtkErrorMacro as vtkErrorMacro$1 } from '../../macros.js';
 import vtkBufferObject from './BufferObject.js';
@@ -8,7 +9,6 @@ import vtkOpenGLPolyDataMapper from './PolyDataMapper.js';
 import { v as vtkSphereMapperVS } from './glsl/vtkSphereMapperVS.glsl.js';
 import { v as vtkPolyDataFS } from './glsl/vtkPolyDataFS.glsl.js';
 import { registerOverride } from './ViewNodeFactory.js';
-import { m as multiply } 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; }
 
@@ -104,7 +104,7 @@ function vtkOpenGLSphereMapper(publicAPI, model) {
       if (!actor.getIsIdentity()) {
         var actMats = model.openGLActor.getKeyMatrices();
         var tmp4 = new Float64Array(16);
-        multiply(tmp4, keyMats.wcvc, actMats.mcwc);
+        mat4.multiply(tmp4, keyMats.wcvc, actMats.mcwc);
         program.setUniformMatrix('MCVCMatrix', tmp4);
       } else {
         program.setUniformMatrix('MCVCMatrix', keyMats.wcvc);

package/Rendering/OpenGL/StickMapper.js

@@ -1,4 +1,5 @@
 import _defineProperty from '@babel/runtime/helpers/defineProperty';
+import { mat4, mat3 } from 'gl-matrix';
 import { ObjectType } from './BufferObject/Constants.js';
 import { newInstance as newInstance$1, vtkErrorMacro as vtkErrorMacro$1 } from '../../macros.js';
 import vtkBufferObject from './BufferObject.js';
@@ -7,8 +8,6 @@ import { v as vtkPolyDataFS } from './glsl/vtkPolyDataFS.glsl.js';
 import vtkShaderProgram from './ShaderProgram.js';
 import vtkOpenGLPolyDataMapper from './PolyDataMapper.js';
 import { registerOverride } from './ViewNodeFactory.js';
-import { m as multiply } from '../../vendor/gl-matrix/esm/mat4.js';
-import { m as multiply$1 } from '../../vendor/gl-matrix/esm/mat3.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; }
 
@@ -119,13 +118,13 @@ function vtkOpenGLStickMapper(publicAPI, model) {
 
       if (program.isUniformUsed('MCVCMatrix')) {
         var tmp4 = new Float64Array(16);
-        multiply(tmp4, keyMats.wcvc, actMats.mcwc);
+        mat4.multiply(tmp4, keyMats.wcvc, actMats.mcwc);
         program.setUniformMatrix('MCVCMatrix', tmp4);
       }
 
       if (program.isUniformUsed('normalMatrix')) {
         var anorms = new Float64Array(9);
-        multiply$1(anorms, keyMats.normalMatrix, actMats.normalMatrix);
+        mat3.multiply(anorms, keyMats.normalMatrix, actMats.normalMatrix);
         program.setUniformMatrix3x3('normalMatrix', anorms);
       }
     } else {

package/Rendering/OpenGL/SurfaceLIC/SurfaceLICInterface.js

@@ -12,7 +12,7 @@ import { v as vtkLineIntegralConvolution2D_quadVS } from './glsl/vtkLineIntegral
 import { v as vtkLineIntegralConvolution2D_SC } from './glsl/vtkLineIntegralConvolution2D_SC.glsl.js';
 import { v as vtkSurfaceLICInterface_DCpy } from './glsl/vtkSurfaceLICInterface_DCpy.glsl.js';
 import { v as vtkSurfaceLICInterface_CE } from './glsl/vtkSurfaceLICInterface_CE.glsl.js';
-import { s as seedrandom } from '../../../vendor/seedrandom/index.js';
+import seedrandom from 'seedrandom';
 import { NoiseType, ContrastEnhanceMode } from '../../Core/SurfaceLICInterface/Constants.js';
 import vtkSurfaceLICInterface from '../../Core/SurfaceLICInterface.js';
 

package/Rendering/OpenGL/Volume.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 } from '../../vendor/gl-matrix/esm/mat4.js';
-import { i as identity, f as fromMat4, a as invert } from '../../vendor/gl-matrix/esm/mat3.js';
 
 // vtkOpenGLVolume methods
 // ----------------------------------------------------------------------------
@@ -62,14 +61,14 @@ function vtkOpenGLVolume(publicAPI, model) {
     // has the actor changed?
     if (model.renderable.getMTime() > model.keyMatrixTime.getMTime()) {
       model.renderable.computeMatrix();
-      copy(model.MCWCMatrix, model.renderable.getMatrix());
-      transpose(model.MCWCMatrix, model.MCWCMatrix);
+      mat4.copy(model.MCWCMatrix, model.renderable.getMatrix());
+      mat4.transpose(model.MCWCMatrix, model.MCWCMatrix);
 
       if (model.renderable.getIsIdentity()) {
-        identity(model.normalMatrix);
+        mat3.identity(model.normalMatrix);
       } else {
-        fromMat4(model.normalMatrix, model.MCWCMatrix);
-        invert(model.normalMatrix, model.normalMatrix);
+        mat3.fromMat4(model.normalMatrix, model.MCWCMatrix);
+        mat3.invert(model.normalMatrix, model.normalMatrix);
       }
 
       model.keyMatrixTime.modified();