@kitware/vtk.js 28.10.2 → 28.11.1

package/Rendering/Misc/TextureLODsDownloader.js

@@ -1,131 +1,121 @@
-import macro from '../../macros.js';
-
-var vtkErrorMacro = macro.vtkErrorMacro; // ----------------------------------------------------------------------------
-
-var getRemoteFileSize = function getRemoteFileSize(url) {
-  return (// This function only works if the server provides a 'Content-Length'.
-    // For some reason, the 'Content-Length' header does not appear to be
-    // given for CORS HEAD requests on firefox. So this will not work on
-    // firefox if the images do not have the same origin as the html file.
-    // TODO: figure out how to make this work for CORS requests on firefox.
-    new Promise(function (resolve, reject) {
-      var xhr = new XMLHttpRequest();
-      xhr.open('HEAD', url, true);
-
-      xhr.onreadystatechange = function () {
-        if (xhr.readyState === 4) {
-          if (xhr.status === 200) {
-            var size = xhr.getResponseHeader('Content-Length');
-            resolve(size);
-          } else {
-            console.log('Failed to get remote file size of', url);
-            reject(xhr);
-          }
-        }
-      };
+import { m as macro } from '../../macros2.js';
+
+const {
+  vtkErrorMacro
+} = macro;
 
-      xhr.send();
-    })
-  );
-}; // ----------------------------------------------------------------------------
-// vtkTextureLODsDownloader methods
 // ----------------------------------------------------------------------------
 
+const getRemoteFileSize = url =>
+// This function only works if the server provides a 'Content-Length'.
+// For some reason, the 'Content-Length' header does not appear to be
+// given for CORS HEAD requests on firefox. So this will not work on
+// firefox if the images do not have the same origin as the html file.
+// TODO: figure out how to make this work for CORS requests on firefox.
+new Promise((resolve, reject) => {
+  const xhr = new XMLHttpRequest();
+  xhr.open('HEAD', url, true);
+  xhr.onreadystatechange = () => {
+    if (xhr.readyState === 4) {
+      if (xhr.status === 200) {
+        const size = xhr.getResponseHeader('Content-Length');
+        resolve(size);
+      } else {
+        console.log('Failed to get remote file size of', url);
+        reject(xhr);
+      }
+    }
+  };
+  xhr.send();
+});
+
+// ----------------------------------------------------------------------------
+// vtkTextureLODsDownloader methods
+// ----------------------------------------------------------------------------
 
 function vtkTextureLODsDownloader(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkTextureLODsDownloader');
-  var internal = {
+  const internal = {
     downloadStack: []
-  }; //--------------------------------------------------------------------------
+  };
 
-  publicAPI.startDownloads = function () {
+  //--------------------------------------------------------------------------
+
+  publicAPI.startDownloads = () => {
     if (!model.texture) {
       vtkErrorMacro('Texture was not set.');
       return;
     }
-
     if (!model.files || model.files.length === 0) {
       vtkErrorMacro('No files set.');
       return;
     }
-
-    var baseUrl = model.baseUrl;
-
+    let baseUrl = model.baseUrl;
     if (baseUrl && !baseUrl.endsWith('/')) {
       baseUrl += '/';
-    } // Create the download stack
-
+    }
 
+    // Create the download stack
     internal.downloadStack = [];
-    model.files.forEach(function (file) {
-      return internal.downloadStack.push("".concat(baseUrl).concat(file));
-    });
-
-    var downloadNextTexture = function downloadNextTexture() {
+    model.files.forEach(file => internal.downloadStack.push(`${baseUrl}${file}`));
+    const downloadNextTexture = () => {
       if (internal.downloadStack.length === 0) {
         return;
-      } // For later use
-
+      }
 
-      var asyncDownloadNextTexture = function asyncDownloadNextTexture() {
+      // For later use
+      const asyncDownloadNextTexture = () => {
         setTimeout(downloadNextTexture, model.waitTimeBetweenDownloads);
       };
-
-      var img = new Image();
-
+      const img = new Image();
       if (model.crossOrigin) {
         img.crossOrigin = model.crossOrigin;
       }
-
-      var url = internal.downloadStack.shift();
-      getRemoteFileSize(url).then(function (size) {
+      const url = internal.downloadStack.shift();
+      getRemoteFileSize(url).then(size => {
         if (!size || size / 1024 > model.maxTextureLODSize) {
           if (!size) {
             console.log('Failed to get image size');
           } else {
             console.log('Skipping image', url, ', because it is larger', 'than the max texture size:', model.maxTextureLODSize, 'KiB');
           }
-
           asyncDownloadNextTexture();
           return;
         }
-
-        img.src = url; // Decode the image asynchronously in an attempt to prevent a
+        img.src = url;
+        // Decode the image asynchronously in an attempt to prevent a
         // freeze during rendering.
         // In theory, this should help, but my profiling indicates that
         // it does not help much... maybe it is running in the main
         // thread anyways?
-
-        img.decode().then(function () {
+        img.decode().then(() => {
           model.texture.setImage(img);
-
           if (model.stepFinishedCallback) {
             model.stepFinishedCallback();
           }
-
           asyncDownloadNextTexture();
-        }).catch(function (encodingError) {
+        }).catch(encodingError => {
           console.log('Failed to decode image:', img.src);
           console.log('Error is:', encodingError);
           asyncDownloadNextTexture();
         });
-      }).catch(function (xhr) {
+      }).catch(xhr => {
         console.log('Failed to get size of:', url);
         console.log('status was:', xhr.status);
         console.log('statusText was:', xhr.statusText);
         asyncDownloadNextTexture();
       });
     };
-
     setTimeout(downloadNextTexture, model.waitTimeToStart);
   };
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
-
-var DEFAULT_VALUES = {
+const DEFAULT_VALUES = {
   baseUrl: '',
   files: [],
   texture: null,
@@ -136,23 +126,31 @@ var DEFAULT_VALUES = {
   // These are in milliseconds
   waitTimeToStart: 4000,
   waitTimeBetweenDownloads: 0
-}; // ----------------------------------------------------------------------------
+};
+
+// ----------------------------------------------------------------------------
 
 function extend(publicAPI, model) {
-  var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
   Object.assign(model, DEFAULT_VALUES, initialValues);
-  macro.obj(publicAPI, model); // Create get-set macros
+  macro.obj(publicAPI, model);
 
-  macro.setGet(publicAPI, model, ['baseUrl', 'files', 'texture', 'crossOrigin', 'maxTextureLODSize', 'stepFinishedCallback', 'waitTimeToStart', 'waitTimeBetweenDownloads']); // Object specific methods
+  // Create get-set macros
+  macro.setGet(publicAPI, model, ['baseUrl', 'files', 'texture', 'crossOrigin', 'maxTextureLODSize', 'stepFinishedCallback', 'waitTimeToStart', 'waitTimeBetweenDownloads']);
 
+  // Object specific methods
   vtkTextureLODsDownloader(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 
-var newInstance = macro.newInstance(extend, 'vtkTextureLODsDownloader'); // ----------------------------------------------------------------------------
+const newInstance = macro.newInstance(extend, 'vtkTextureLODsDownloader');
+
+// ----------------------------------------------------------------------------
 
 var vtkTextureLODsDownloader$1 = {
-  newInstance: newInstance,
-  extend: extend
+  newInstance,
+  extend
 };
 
 export { vtkTextureLODsDownloader$1 as default, extend, newInstance };

package/Rendering/Misc.js

@@ -7,13 +7,13 @@ import vtkSynchronizableRenderWindow from './Misc/SynchronizableRenderWindow.js'
 import vtkTextureLODsDownloader from './Misc/TextureLODsDownloader.js';
 
 var Misc = {
-  vtkCanvasView: vtkCanvasView,
-  vtkFullScreenRenderWindow: vtkFullScreenRenderWindow,
-  vtkGenericRenderWindow: vtkGenericRenderWindow,
-  vtkRemoteView: vtkRemoteView,
-  vtkRenderWindowWithControlBar: vtkRenderWindowWithControlBar,
-  vtkSynchronizableRenderWindow: vtkSynchronizableRenderWindow,
-  vtkTextureLODsDownloader: vtkTextureLODsDownloader
+  vtkCanvasView,
+  vtkFullScreenRenderWindow,
+  vtkGenericRenderWindow,
+  vtkRemoteView,
+  vtkRenderWindowWithControlBar,
+  vtkSynchronizableRenderWindow,
+  vtkTextureLODsDownloader
 };
 
 export { Misc as default };

package/Rendering/OpenGL/Actor.js

@@ -1,16 +1,18 @@
 import { mat3, mat4 } from 'gl-matrix';
-import { newInstance as newInstance$1, obj, setGet, get } from '../../macros.js';
+import { n as newInstance$1, o as obj, e as setGet, g as get } from '../../macros2.js';
 import vtkViewNode from '../SceneGraph/ViewNode.js';
 import { registerOverride } from './ViewNodeFactory.js';
 
+// ----------------------------------------------------------------------------
 // vtkOpenGLActor methods
 // ----------------------------------------------------------------------------
 
 function vtkOpenGLActor(publicAPI, model) {
   // Set our className
-  model.classHierarchy.push('vtkOpenGLActor'); // Builds myself.
+  model.classHierarchy.push('vtkOpenGLActor');
 
-  publicAPI.buildPass = function (prepass) {
+  // Builds myself.
+  publicAPI.buildPass = prepass => {
     if (prepass) {
       model._openGLRenderWindow = publicAPI.getFirstAncestorOfType('vtkOpenGLRenderWindow');
       model._openGLRenderer = publicAPI.getFirstAncestorOfType('vtkOpenGLRenderer');
@@ -18,89 +20,76 @@ function vtkOpenGLActor(publicAPI, model) {
       publicAPI.prepareNodes();
       publicAPI.addMissingNodes(model.renderable.getTextures());
       publicAPI.addMissingNode(model.renderable.getMapper());
-      publicAPI.removeUnusedNodes(); // we store textures and mapper
+      publicAPI.removeUnusedNodes();
 
+      // we store textures and mapper
       model.ogltextures = null;
       model.activeTextures = null;
-
-      for (var index = 0; index < model.children.length; index++) {
-        var child = model.children[index];
-
+      for (let index = 0; index < model.children.length; index++) {
+        const child = model.children[index];
         if (child.isA('vtkOpenGLTexture')) {
           if (!model.ogltextures) {
             model.ogltextures = [];
           }
-
           model.ogltextures.push(child);
         } else {
           model.oglmapper = child;
         }
       }
     }
-  }; // render both opaque and translucent actors
-
+  };
 
-  publicAPI.traverseZBufferPass = function (renderPass) {
+  // render both opaque and translucent actors
+  publicAPI.traverseZBufferPass = renderPass => {
     if (!model.renderable || !model.renderable.getNestedVisibility() || model._openGLRenderer.getSelector() && !model.renderable.getNestedPickable()) {
       return;
     }
-
     publicAPI.apply(renderPass, true);
     model.oglmapper.traverse(renderPass);
     publicAPI.apply(renderPass, false);
-  }; // only render opaque actors
-
-
-  publicAPI.traverseOpaqueZBufferPass = function (renderPass) {
-    return publicAPI.traverseOpaquePass(renderPass);
-  }; // we draw textures, then mapper, then post pass textures
+  };
 
+  // only render opaque actors
+  publicAPI.traverseOpaqueZBufferPass = renderPass => publicAPI.traverseOpaquePass(renderPass);
 
-  publicAPI.traverseOpaquePass = function (renderPass) {
+  // we draw textures, then mapper, then post pass textures
+  publicAPI.traverseOpaquePass = renderPass => {
     if (!model.renderable || !model.renderable.getNestedVisibility() || !model.renderable.getIsOpaque() || model._openGLRenderer.getSelector() && !model.renderable.getNestedPickable()) {
       return;
     }
-
     publicAPI.apply(renderPass, true);
     model.oglmapper.traverse(renderPass);
     publicAPI.apply(renderPass, false);
-  }; // we draw textures, then mapper, then post pass textures
-
+  };
 
-  publicAPI.traverseTranslucentPass = function (renderPass) {
+  // we draw textures, then mapper, then post pass textures
+  publicAPI.traverseTranslucentPass = renderPass => {
     if (!model.renderable || !model.renderable.getNestedVisibility() || model.renderable.getIsOpaque() || model._openGLRenderer.getSelector() && !model.renderable.getNestedPickable()) {
       return;
     }
-
     publicAPI.apply(renderPass, true);
     model.oglmapper.traverse(renderPass);
     publicAPI.apply(renderPass, false);
   };
-
-  publicAPI.activateTextures = function () {
+  publicAPI.activateTextures = () => {
     // always traverse textures first, then mapper
     if (!model.ogltextures) {
       return;
     }
-
     model.activeTextures = [];
-
-    for (var index = 0; index < model.ogltextures.length; index++) {
-      var child = model.ogltextures[index];
+    for (let index = 0; index < model.ogltextures.length; index++) {
+      const child = model.ogltextures[index];
       child.render();
-
       if (child.getHandle()) {
         model.activeTextures.push(child);
       }
     }
   };
-
-  publicAPI.queryPass = function (prepass, renderPass) {
+  publicAPI.queryPass = (prepass, renderPass) => {
     if (prepass) {
       if (!model.renderable || !model.renderable.getVisibility()) {
         return;
       }
-
       if (model.renderable.getIsOpaque()) {
         renderPass.incrementOpaqueActorCount();
       } else {
@@ -108,45 +97,36 @@ function vtkOpenGLActor(publicAPI, model) {
       }
     }
   };
-
-  publicAPI.zBufferPass = function (prepass, renderPass) {
-    return publicAPI.opaquePass(prepass, renderPass);
-  };
-
-  publicAPI.opaqueZBufferPass = function (prepass, renderPass) {
-    return publicAPI.opaquePass(prepass, renderPass);
-  };
-
-  publicAPI.opaquePass = function (prepass, renderPass) {
+  publicAPI.zBufferPass = (prepass, renderPass) => publicAPI.opaquePass(prepass, renderPass);
+  publicAPI.opaqueZBufferPass = (prepass, renderPass) => publicAPI.opaquePass(prepass, renderPass);
+  publicAPI.opaquePass = (prepass, renderPass) => {
     if (prepass) {
       model.context.depthMask(true);
       publicAPI.activateTextures();
     } else if (model.activeTextures) {
-      for (var index = 0; index < model.activeTextures.length; index++) {
+      for (let index = 0; index < model.activeTextures.length; index++) {
         model.activeTextures[index].deactivate();
       }
     }
-  }; // Renders myself
-
+  };
 
-  publicAPI.translucentPass = function (prepass, renderPass) {
+  // Renders myself
+  publicAPI.translucentPass = (prepass, renderPass) => {
     if (prepass) {
       model.context.depthMask(false);
       publicAPI.activateTextures();
     } else if (model.activeTextures) {
-      for (var index = 0; index < model.activeTextures.length; index++) {
+      for (let index = 0; index < model.activeTextures.length; index++) {
         model.activeTextures[index].deactivate();
       }
     }
   };
-
-  publicAPI.getKeyMatrices = function () {
+  publicAPI.getKeyMatrices = () => {
     // has the actor changed?
     if (model.renderable.getMTime() > model.keyMatrixTime.getMTime()) {
       model.renderable.computeMatrix();
       mat4.copy(model.keyMatrices.mcwc, model.renderable.getMatrix());
       mat4.transpose(model.keyMatrices.mcwc, model.keyMatrices.mcwc);
-
       if (model.renderable.getIsIdentity()) {
         mat3.identity(model.keyMatrices.normalMatrix);
       } else {
@@ -154,28 +134,30 @@ function vtkOpenGLActor(publicAPI, model) {
         mat3.invert(model.keyMatrices.normalMatrix, model.keyMatrices.normalMatrix);
         mat3.transpose(model.keyMatrices.normalMatrix, model.keyMatrices.normalMatrix);
       }
-
       model.keyMatrixTime.modified();
     }
-
     return model.keyMatrices;
   };
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
-
-var DEFAULT_VALUES = {
+const DEFAULT_VALUES = {
   context: null,
   keyMatrixTime: null,
   keyMatrices: null,
   activeTextures: 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);
 
+  // Inheritance
   vtkViewNode.extend(publicAPI, model, initialValues);
   model.keyMatrixTime = {};
   obj(model.keyMatrixTime, {
@@ -184,21 +166,28 @@ function extend(publicAPI, model) {
   model.keyMatrices = {
     normalMatrix: mat3.identity(new Float64Array(9)),
     mcwc: mat4.identity(new Float64Array(16))
-  }; // Build VTK API
+  };
 
+  // Build VTK API
   setGet(publicAPI, model, ['context']);
-  get(publicAPI, model, ['activeTextures']); // Object methods
+  get(publicAPI, model, ['activeTextures']);
 
+  // Object methods
   vtkOpenGLActor(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 
-var newInstance = newInstance$1(extend); // ----------------------------------------------------------------------------
+const newInstance = newInstance$1(extend);
+
+// ----------------------------------------------------------------------------
 
 var vtkActor = {
-  newInstance: newInstance,
-  extend: extend
-}; // Register ourself to OpenGL backend if imported
+  newInstance,
+  extend
+};
 
+// Register ourself to OpenGL backend if imported
 registerOverride('vtkActor', newInstance);
 
 export { vtkActor as default, extend, newInstance };