@kitware/vtk.js 28.10.2 → 28.11.1

package/Rendering/SceneGraph/ViewNode.js

@@ -1,250 +1,221 @@
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.js';
 
-var vtkErrorMacro = macro.vtkErrorMacro;
-var PASS_TYPES = ['Build', 'Render']; // ----------------------------------------------------------------------------
+const {
+  vtkErrorMacro
+} = macro;
+const PASS_TYPES = ['Build', 'Render'];
+
+// ----------------------------------------------------------------------------
 // vtkViewNode methods
 // ----------------------------------------------------------------------------
 
 function vtkViewNode(publicAPI, model) {
   // Set our className
-  model.classHierarchy.push('vtkViewNode'); // Builds myself.
-
-  publicAPI.build = function (prepass) {}; // Renders myself
+  model.classHierarchy.push('vtkViewNode');
 
+  // Builds myself.
+  publicAPI.build = prepass => {};
 
-  publicAPI.render = function (prepass) {};
-
-  publicAPI.traverse = function (renderPass) {
+  // Renders myself
+  publicAPI.render = prepass => {};
+  publicAPI.traverse = renderPass => {
     // we can choose to do special
     // traversal here based on pass
-    var passTraversal = renderPass.getTraverseOperation();
-    var fn = publicAPI[passTraversal];
-
+    const passTraversal = renderPass.getTraverseOperation();
+    const fn = publicAPI[passTraversal];
     if (fn) {
       fn(renderPass);
       return;
-    } // default traversal
-
+    }
 
+    // default traversal
     publicAPI.apply(renderPass, true);
-
-    for (var index = 0; index < model.children.length; index++) {
+    for (let index = 0; index < model.children.length; index++) {
       model.children[index].traverse(renderPass);
     }
-
     publicAPI.apply(renderPass, false);
   };
-
-  publicAPI.apply = function (renderPass, prepass) {
-    var customRenderPass = publicAPI[renderPass.getOperation()];
-
+  publicAPI.apply = (renderPass, prepass) => {
+    const customRenderPass = publicAPI[renderPass.getOperation()];
     if (customRenderPass) {
       customRenderPass(prepass, renderPass);
     }
   };
-
-  publicAPI.getViewNodeFor = function (dataObject) {
+  publicAPI.getViewNodeFor = dataObject => {
     if (model.renderable === dataObject) {
       return publicAPI;
     }
-
-    for (var index = 0; index < model.children.length; ++index) {
-      var child = model.children[index];
-      var vn = child.getViewNodeFor(dataObject);
-
+    for (let index = 0; index < model.children.length; ++index) {
+      const child = model.children[index];
+      const vn = child.getViewNodeFor(dataObject);
       if (vn) {
         return vn;
       }
     }
-
     return undefined;
   };
-
-  publicAPI.getFirstAncestorOfType = function (type) {
+  publicAPI.getFirstAncestorOfType = type => {
     if (!model._parent) {
       return null;
     }
-
     if (model._parent.isA(type)) {
       return model._parent;
     }
-
     return model._parent.getFirstAncestorOfType(type);
-  }; // add a missing node/child for the passed in renderables. This should
-  // be called only in between prepareNodes and removeUnusedNodes
-
+  };
 
-  publicAPI.addMissingNode = function (dobj) {
+  // add a missing node/child for the passed in renderables. This should
+  // be called only in between prepareNodes and removeUnusedNodes
+  publicAPI.addMissingNode = dobj => {
     if (!dobj) {
       return;
     }
-
-    var result = model._renderableChildMap.get(dobj); // if found just mark as visited
-
-
+    const result = model._renderableChildMap.get(dobj);
+    // if found just mark as visited
     if (result !== undefined) {
       result.setVisited(true);
     } else {
       // otherwise create a node
-      var newNode = publicAPI.createViewNode(dobj);
-
+      const newNode = publicAPI.createViewNode(dobj);
       if (newNode) {
         newNode.setParent(publicAPI);
         newNode.setVisited(true);
-
         model._renderableChildMap.set(dobj, newNode);
-
         model.children.push(newNode);
       }
     }
-  }; // add missing nodes/children for the passed in renderables. This should
-  // be called only in between prepareNodes and removeUnusedNodes
-
+  };
 
-  publicAPI.addMissingNodes = function (dataObjs) {
+  // add missing nodes/children for the passed in renderables. This should
+  // be called only in between prepareNodes and removeUnusedNodes
+  publicAPI.addMissingNodes = dataObjs => {
     if (!dataObjs || !dataObjs.length) {
       return;
     }
-
-    for (var index = 0; index < dataObjs.length; ++index) {
-      var dobj = dataObjs[index];
-
-      var result = model._renderableChildMap.get(dobj); // if found just mark as visited
-
-
+    for (let index = 0; index < dataObjs.length; ++index) {
+      const dobj = dataObjs[index];
+      const result = model._renderableChildMap.get(dobj);
+      // if found just mark as visited
       if (result !== undefined) {
         result.setVisited(true);
       } else {
         // otherwise create a node
-        var newNode = publicAPI.createViewNode(dobj);
-
+        const newNode = publicAPI.createViewNode(dobj);
         if (newNode) {
           newNode.setParent(publicAPI);
           newNode.setVisited(true);
-
           model._renderableChildMap.set(dobj, newNode);
-
           model.children.push(newNode);
         }
       }
     }
-  }; // ability to add children that have no renderable use in the same manner
+  };
+
+  // ability to add children that have no renderable use in the same manner
   // as addMissingNodes This case is when a normal viewnode wants to
   // delegate passes to a helper or child that doeasn't map to a clear
   // renderable or any renderable
-
-
-  publicAPI.addMissingChildren = function (children) {
+  publicAPI.addMissingChildren = children => {
     if (!children || !children.length) {
       return;
     }
-
-    for (var index = 0; index < children.length; ++index) {
-      var child = children[index];
-      var cindex = model.children.indexOf(child);
-
+    for (let index = 0; index < children.length; ++index) {
+      const child = children[index];
+      const cindex = model.children.indexOf(child);
       if (cindex === -1) {
         child.setParent(publicAPI);
         model.children.push(child);
       }
-
       child.setVisited(true);
     }
   };
-
-  publicAPI.prepareNodes = function () {
-    for (var index = 0; index < model.children.length; ++index) {
+  publicAPI.prepareNodes = () => {
+    for (let index = 0; index < model.children.length; ++index) {
       model.children[index].setVisited(false);
     }
   };
-
-  publicAPI.setVisited = function (val) {
+  publicAPI.setVisited = val => {
     model.visited = val;
   };
-
-  publicAPI.removeUnusedNodes = function () {
-    var visitedCount = 0;
-
-    for (var index = 0; index < model.children.length; ++index) {
-      var child = model.children[index];
-      var visited = child.getVisited();
-
+  publicAPI.removeUnusedNodes = () => {
+    let visitedCount = 0;
+    for (let index = 0; index < model.children.length; ++index) {
+      const child = model.children[index];
+      const visited = child.getVisited();
       if (visited) {
         model.children[visitedCount++] = child;
         child.setVisited(false);
       } else {
-        var renderable = child.getRenderable();
-
+        const renderable = child.getRenderable();
         if (renderable) {
           model._renderableChildMap.delete(renderable);
         }
-
         child.delete();
       }
     }
-
     model.children.length = visitedCount;
   };
-
-  publicAPI.createViewNode = function (dataObj) {
+  publicAPI.createViewNode = dataObj => {
     if (!model.myFactory) {
       vtkErrorMacro('Cannot create view nodes without my own factory');
       return null;
     }
-
-    var ret = model.myFactory.createNode(dataObj);
-
+    const ret = model.myFactory.createNode(dataObj);
     if (ret) {
       ret.setRenderable(dataObj);
     }
-
     return ret;
   };
-
-  var parentDelete = publicAPI.delete;
-
-  publicAPI.delete = function () {
-    for (var i = 0; i < model.children.length; i++) {
+  const parentDelete = publicAPI.delete;
+  publicAPI.delete = () => {
+    for (let i = 0; i < model.children.length; i++) {
       model.children[i].delete();
     }
-
     parentDelete();
   };
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
-
-var DEFAULT_VALUES = {
+const DEFAULT_VALUES = {
   // _parent: null,
   renderable: null,
   myFactory: null,
   children: [],
   visited: false
-}; // ----------------------------------------------------------------------------
+};
+
+// ----------------------------------------------------------------------------
 
 function extend(publicAPI, model) {
-  var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-  Object.assign(model, DEFAULT_VALUES, initialValues); // Build VTK API
+  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  Object.assign(model, DEFAULT_VALUES, initialValues);
 
+  // Build VTK API
   macro.obj(publicAPI, model);
   macro.event(publicAPI, model, 'event');
   model._renderableChildMap = new Map();
   macro.get(publicAPI, model, ['visited']);
   macro.setGet(publicAPI, model, ['_parent', 'renderable', 'myFactory']);
   macro.getArray(publicAPI, model, ['children']);
-  macro.moveToProtected(publicAPI, model, ['parent']); // Object methods
+  macro.moveToProtected(publicAPI, model, ['parent']);
 
+  // Object methods
   vtkViewNode(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 
+const newInstance = macro.newInstance(extend, 'vtkViewNode');
 
-var newInstance = macro.newInstance(extend, 'vtkViewNode'); // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
 
 var vtkViewNode$1 = {
-  newInstance: newInstance,
-  extend: extend,
-  PASS_TYPES: PASS_TYPES
+  newInstance,
+  extend,
+  PASS_TYPES
 };
 
 export { vtkViewNode$1 as default };

package/Rendering/SceneGraph/ViewNodeFactory.js

@@ -1,5 +1,6 @@
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.js';
 
+// ----------------------------------------------------------------------------
 // vtkViewNodeFactory methods
 // ----------------------------------------------------------------------------
 
@@ -7,21 +8,18 @@ function vtkViewNodeFactory(publicAPI, model) {
   // Make sure our overrides is just for our instance not shared with everyone...
   if (!model.overrides) {
     model.overrides = {};
-  } // Set our className
-
+  }
 
+  // Set our className
   model.classHierarchy.push('vtkViewNodeFactory');
-
-  publicAPI.createNode = function (dataObject) {
+  publicAPI.createNode = dataObject => {
     if (dataObject.isDeleted()) {
       return null;
     }
-
-    var cpt = 0;
-    var className = dataObject.getClassName(cpt++);
-    var isObject = false;
-    var keys = Object.keys(model.overrides);
-
+    let cpt = 0;
+    let className = dataObject.getClassName(cpt++);
+    let isObject = false;
+    const keys = Object.keys(model.overrides);
     while (className && !isObject) {
       if (keys.indexOf(className) !== -1) {
         isObject = true;
@@ -29,41 +27,48 @@ function vtkViewNodeFactory(publicAPI, model) {
         className = dataObject.getClassName(cpt++);
       }
     }
-
     if (!isObject) {
       return null;
     }
-
-    var vn = model.overrides[className]();
+    const vn = model.overrides[className]();
     vn.setMyFactory(publicAPI);
     return vn;
   };
-
-  publicAPI.registerOverride = function (className, func) {
+  publicAPI.registerOverride = (className, func) => {
     model.overrides[className] = func;
   };
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
+const DEFAULT_VALUES = {
+  // overrides: {},
+};
 
-var DEFAULT_VALUES = {// overrides: {},
-}; // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
 
 function extend(publicAPI, model) {
-  var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-  Object.assign(model, DEFAULT_VALUES, initialValues); // Build VTK API
+  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  Object.assign(model, DEFAULT_VALUES, initialValues);
 
-  macro.obj(publicAPI, model); // Object methods
+  // Build VTK API
+  macro.obj(publicAPI, model);
 
+  // Object methods
   vtkViewNodeFactory(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
 
-var newInstance = macro.newInstance(extend, 'vtkViewNodeFactory'); // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+
+const newInstance = macro.newInstance(extend, 'vtkViewNodeFactory');
+
+// ----------------------------------------------------------------------------
 
 var vtkViewNodeFactory$1 = {
-  newInstance: newInstance,
-  extend: extend
+  newInstance,
+  extend
 };
 
 export { vtkViewNodeFactory$1 as default, extend, newInstance };

package/Rendering/SceneGraph.js

@@ -4,10 +4,10 @@ import vtkViewNode from './SceneGraph/ViewNode.js';
 import vtkViewNodeFactory from './SceneGraph/ViewNodeFactory.js';
 
 var SceneGraph = {
-  vtkRenderPass: vtkRenderPass,
-  vtkRenderWindowViewNode: vtkRenderWindowViewNode,
-  vtkViewNode: vtkViewNode,
-  vtkViewNodeFactory: vtkViewNodeFactory
+  vtkRenderPass,
+  vtkRenderWindowViewNode,
+  vtkViewNode,
+  vtkViewNodeFactory
 };
 
 export { SceneGraph as default };

package/Rendering/WebGPU/Actor.js

@@ -1,68 +1,63 @@
 import { mat4 } from 'gl-matrix';
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.js';
 import vtkProp from '../Core/Prop.js';
 import vtkViewNode from '../SceneGraph/ViewNode.js';
 import { registerOverride } from './ViewNodeFactory.js';
 
-var CoordinateSystem = vtkProp.CoordinateSystem; // ----------------------------------------------------------------------------
+const {
+  CoordinateSystem
+} = vtkProp;
+
+// ----------------------------------------------------------------------------
 // vtkWebGPUActor methods
 // ----------------------------------------------------------------------------
 
 function vtkWebGPUActor(publicAPI, model) {
   // Set our className
-  model.classHierarchy.push('vtkWebGPUActor'); // Builds myself.
+  model.classHierarchy.push('vtkWebGPUActor');
 
-  publicAPI.buildPass = function (prepass) {
+  // Builds myself.
+  publicAPI.buildPass = prepass => {
     if (prepass) {
       model.WebGPURenderer = publicAPI.getFirstAncestorOfType('vtkWebGPURenderer');
       model.WebGPURenderWindow = model.WebGPURenderer.getFirstAncestorOfType('vtkWebGPURenderWindow');
-
       if (model.propID === undefined) {
         model.propID = model.WebGPURenderWindow.getUniquePropID();
       }
-
       publicAPI.prepareNodes();
       publicAPI.addMissingNode(model.renderable.getMapper());
       publicAPI.removeUnusedNodes();
     }
-  }; // we draw textures, then mapper, then post pass textures
-
+  };
 
-  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.WebGPURenderer.getSelector() && !model.renderable.getNestedPickable()) {
       return;
     }
-
     publicAPI.apply(renderPass, true);
-
     if (model.children[0]) {
       model.children[0].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.WebGPURenderer.getSelector() && !model.renderable.getNestedPickable()) {
       return;
     }
-
     publicAPI.apply(renderPass, true);
-
     if (model.children[0]) {
       model.children[0].traverse(renderPass);
     }
-
     publicAPI.apply(renderPass, false);
   };
-
-  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 {
@@ -70,74 +65,73 @@ function vtkWebGPUActor(publicAPI, model) {
       }
     }
   };
-
-  publicAPI.getBufferShift = function (wgpuRen) {
+  publicAPI.getBufferShift = wgpuRen => {
     publicAPI.getKeyMatrices(wgpuRen);
     return model.bufferShift;
   };
-
-  publicAPI.getKeyMatrices = function (wgpuRen) {
+  publicAPI.getKeyMatrices = wgpuRen => {
     // has the actor or stabilization center changed?
     if (Math.max(model.renderable.getMTime(), wgpuRen.getStabilizedTime()) > model.keyMatricesTime.getMTime()) {
       model.renderable.computeMatrix();
-      var mcwc = model.renderable.getMatrix(); // compute the net shift, only apply stabilized coords with world coordinates
+      const mcwc = model.renderable.getMatrix();
 
+      // compute the net shift, only apply stabilized coords with world coordinates
       model.bufferShift[0] = mcwc[3];
       model.bufferShift[1] = mcwc[7];
       model.bufferShift[2] = mcwc[11];
-      var center = wgpuRen.getStabilizedCenterByReference();
-
+      const center = wgpuRen.getStabilizedCenterByReference();
       if (model.renderable.getCoordinateSystem() === CoordinateSystem.WORLD) {
         model.bufferShift[0] -= center[0];
         model.bufferShift[1] -= center[1];
         model.bufferShift[2] -= center[2];
       }
-
       mat4.transpose(model.keyMatrices.bcwc, mcwc);
-
       if (model.renderable.getIsIdentity()) {
         mat4.identity(model.keyMatrices.normalMatrix);
       } else {
         // we use bcwc BEFORE the translate below (just to get transposed mcvc)
-        mat4.copy(model.keyMatrices.normalMatrix, model.keyMatrices.bcwc); // zero out translation
-
+        mat4.copy(model.keyMatrices.normalMatrix, model.keyMatrices.bcwc);
+        // zero out translation
         model.keyMatrices.normalMatrix[3] = 0.0;
         model.keyMatrices.normalMatrix[7] = 0.0;
         model.keyMatrices.normalMatrix[11] = 0.0;
         mat4.invert(model.keyMatrices.normalMatrix, model.keyMatrices.normalMatrix);
         mat4.transpose(model.keyMatrices.normalMatrix, model.keyMatrices.normalMatrix);
-      } // only need the buffer shift to get to world
-
+      }
 
-      mat4.translate(model.keyMatrices.bcwc, model.keyMatrices.bcwc, [-model.bufferShift[0], -model.bufferShift[1], -model.bufferShift[2]]); // to get to stabilized we also need the center
+      // only need the buffer shift to get to world
+      mat4.translate(model.keyMatrices.bcwc, model.keyMatrices.bcwc, [-model.bufferShift[0], -model.bufferShift[1], -model.bufferShift[2]]);
 
+      // to get to stabilized we also need the center
       if (model.renderable.getCoordinateSystem() === CoordinateSystem.WORLD) {
         mat4.translate(model.keyMatrices.bcsc, model.keyMatrices.bcwc, [-center[0], -center[1], -center[2]]);
       } else {
         mat4.copy(model.keyMatrices.bcsc, model.keyMatrices.bcwc);
       }
-
       model.keyMatricesTime.modified();
     }
-
     return model.keyMatrices;
   };
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
-
-var DEFAULT_VALUES = {
+const DEFAULT_VALUES = {
   keyMatricesTime: null,
   keyMatrices: null,
   propID: undefined,
   bufferShift: undefined
-}; // ----------------------------------------------------------------------------
+};
+
+// ----------------------------------------------------------------------------
 
 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.keyMatricesTime = {};
   macro.obj(model.keyMatricesTime, {
@@ -149,18 +143,24 @@ function extend(publicAPI, model) {
     bcsc: new Float64Array(16)
   };
   macro.get(publicAPI, model, ['propID', 'keyMatricesTime']);
-  model.bufferShift = [0, 0, 0, 0]; // Object methods
+  model.bufferShift = [0, 0, 0, 0];
 
+  // Object methods
   vtkWebGPUActor(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
 
-var newInstance = macro.newInstance(extend); // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+
+const newInstance = macro.newInstance(extend);
+
+// ----------------------------------------------------------------------------
 
 var index = {
-  newInstance: newInstance,
-  extend: extend
-}; // Register ourself to WebGPU backend if imported
+  newInstance,
+  extend
+};
 
+// Register ourself to WebGPU backend if imported
 registerOverride('vtkActor', newInstance);
 
 export { index as default, extend, newInstance };