@kitware/vtk.js 28.10.2 → 28.11.0

package/Rendering/WebGPU/VertexInput.js

@@ -1,142 +1,118 @@
-import { newInstance as newInstance$1, obj, setGet } from '../../macros.js';
+import { n as newInstance$1, o as obj, e as setGet } from '../../macros2.js';
 import vtkWebGPUTypes from './Types.js';
 
 function arraysEqual(a, b) {
   if (a === b) return true;
   if (a == null || b == null) return false;
   if (a.length !== b.length) return false;
-
-  for (var i = 0; i < a.length; ++i) {
+  for (let i = 0; i < a.length; ++i) {
     if (!b.includes(a[i])) return false;
   }
-
   return true;
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // vtkWebGPUVertexInput methods
 // ----------------------------------------------------------------------------
-
-
 function vtkWebGPUVertexInput(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkWebGPUVertexInput');
-
   publicAPI.addBuffer = function (buffer, inames) {
-    var stepMode = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 'vertex';
-    var names = inames;
-
+    let stepMode = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 'vertex';
+    let names = inames;
     if (!Array.isArray(names)) {
       names = [names];
-    } // only add if it is a new setting
-
-
-    for (var i = 0; i < model.inputs.length; i++) {
+    }
+    // only add if it is a new setting
+    for (let i = 0; i < model.inputs.length; i++) {
       if (arraysEqual(model.inputs[i].names, names)) {
         if (model.inputs[i].buffer === buffer) {
           return;
         }
-
         model.inputs[i].buffer = buffer;
         return;
       }
-    } // when adding a new entry, make sure we sort the array
+    }
+
+    // when adding a new entry, make sure we sort the array
     // as the order is important to the shader and must always
     // be the same, so alphabetical is an easy option
-
-
     model.inputs.push({
-      buffer: buffer,
-      stepMode: stepMode,
-      names: names
+      buffer,
+      stepMode,
+      names
     });
-    model.inputs = model.inputs.sort(function (v1, v2) {
+    model.inputs = model.inputs.sort((v1, v2) => {
       if (v1.names[0] < v2.names[0]) {
         return -1;
       }
-
       if (v1.names[0] > v2.names[0]) {
         return 1;
       }
-
       return 0;
     });
   };
-
-  publicAPI.removeBufferIfPresent = function (name) {
-    for (var i = 0; i < model.inputs.length; i++) {
+  publicAPI.removeBufferIfPresent = name => {
+    for (let i = 0; i < model.inputs.length; i++) {
       if (model.inputs[i].names.includes(name)) {
         model.inputs.splice(i, 1);
       }
     }
   };
-
-  publicAPI.getBuffer = function (name) {
-    for (var i = 0; i < model.inputs.length; i++) {
+  publicAPI.getBuffer = name => {
+    for (let i = 0; i < model.inputs.length; i++) {
       if (model.inputs[i].names.includes(name)) {
         return model.inputs[i].buffer;
       }
     }
-
     return null;
   };
-
-  publicAPI.hasAttribute = function (name) {
-    for (var i = 0; i < model.inputs.length; i++) {
+  publicAPI.hasAttribute = name => {
+    for (let i = 0; i < model.inputs.length; i++) {
       if (model.inputs[i].names.includes(name)) {
         return true;
       }
     }
-
     return false;
   };
-
-  publicAPI.getAttributeTime = function (name) {
-    for (var i = 0; i < model.inputs.length; i++) {
+  publicAPI.getAttributeTime = name => {
+    for (let i = 0; i < model.inputs.length; i++) {
       if (model.inputs[i].names.includes(name)) {
         return model.inputs[i].buffer.getSourceTime();
       }
     }
-
     return 0;
   };
-
-  publicAPI.getShaderCode = function () {
-    var result = '';
-    var nameCount = 0;
-
-    for (var i = 0; i < model.inputs.length; i++) {
-      for (var nm = 0; nm < model.inputs[i].names.length; nm++) {
-        var arrayInfo = model.inputs[i].buffer.getArrayInformation()[nm];
-        var type = vtkWebGPUTypes.getShaderTypeFromBufferFormat(arrayInfo.format);
-
+  publicAPI.getShaderCode = () => {
+    let result = '';
+    let nameCount = 0;
+    for (let i = 0; i < model.inputs.length; i++) {
+      for (let nm = 0; nm < model.inputs[i].names.length; nm++) {
+        const arrayInfo = model.inputs[i].buffer.getArrayInformation()[nm];
+        const type = vtkWebGPUTypes.getShaderTypeFromBufferFormat(arrayInfo.format);
         if (nameCount > 0) {
           result += ',\n';
         }
-
-        result = "".concat(result, "  @location(").concat(nameCount, ") ").concat(model.inputs[i].names[nm], " : ").concat(type);
+        result = `${result}  @location(${nameCount}) ${model.inputs[i].names[nm]} : ${type}`;
         nameCount++;
       }
     }
-
     return result;
   };
-
-  publicAPI.getVertexInputInformation = function () {
-    var info = {};
-
+  publicAPI.getVertexInputInformation = () => {
+    const info = {};
     if (model.inputs.length) {
-      var vertexBuffers = [];
-      var nameCount = 0;
-
-      for (var i = 0; i < model.inputs.length; i++) {
-        var buf = model.inputs[i].buffer;
-        var buffer = {
+      const vertexBuffers = [];
+      let nameCount = 0;
+      for (let i = 0; i < model.inputs.length; i++) {
+        const buf = model.inputs[i].buffer;
+        const buffer = {
           arrayStride: buf.getStrideInBytes(),
           stepMode: model.inputs[i].stepMode,
           attributes: []
         };
-        var arrayInfo = buf.getArrayInformation();
-
-        for (var nm = 0; nm < model.inputs[i].names.length; nm++) {
+        const arrayInfo = buf.getArrayInformation();
+        for (let nm = 0; nm < model.inputs[i].names.length; nm++) {
           buffer.attributes.push({
             shaderLocation: nameCount,
             offset: arrayInfo[nm].offset,
@@ -144,66 +120,64 @@ function vtkWebGPUVertexInput(publicAPI, model) {
           });
           nameCount++;
         }
-
         vertexBuffers.push(buffer);
       }
-
       info.buffers = vertexBuffers;
     }
-
     return info;
   };
-
-  publicAPI.bindBuffers = function (renderEncoder) {
-    for (var i = 0; i < model.inputs.length; i++) {
+  publicAPI.bindBuffers = renderEncoder => {
+    for (let i = 0; i < model.inputs.length; i++) {
       renderEncoder.setVertexBuffer(i, model.inputs[i].buffer.getHandle());
     }
-
     if (model.indexBuffer) {
       renderEncoder.setIndexBuffer(model.indexBuffer.getHandle(), model.indexBuffer.getArrayInformation()[0].format);
     }
   };
-
-  publicAPI.getReady = function () {};
-
-  publicAPI.releaseGraphicsResources = function () {
+  publicAPI.getReady = () => {};
+  publicAPI.releaseGraphicsResources = () => {
     if (model.created) {
       model.inputs = [];
       model.bindingDescriptions = [];
       model.attributeDescriptions = [];
     }
   };
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
-
-
-var DEFAULT_VALUES = {
+const DEFAULT_VALUES = {
   inputs: null,
   bindingDescriptions: false,
   attributeDescriptions: null,
   indexBuffer: null
-}; // ----------------------------------------------------------------------------
+};
 
+// ----------------------------------------------------------------------------
 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
   obj(publicAPI, model);
   model.bindingDescriptions = [];
   model.attributeDescriptions = [];
   model.inputs = [];
-  setGet(publicAPI, model, ['created', 'device', 'handle', 'indexBuffer']); // For more macro methods, see "Sources/macros.js"
-  // Object specific methods
+  setGet(publicAPI, model, ['created', 'device', 'handle', 'indexBuffer']);
 
+  // For more macro methods, see "Sources/macros.js"
+  // Object specific methods
   vtkWebGPUVertexInput(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
 
-var newInstance = newInstance$1(extend, 'vtkWebGPUVertexInput'); // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+const newInstance = newInstance$1(extend, 'vtkWebGPUVertexInput');
 
+// ----------------------------------------------------------------------------
 var vtkWebGPUVertexInput$1 = {
-  newInstance: newInstance,
-  extend: extend
+  newInstance,
+  extend
 };
 
 export { vtkWebGPUVertexInput$1 as default, extend, newInstance };

package/Rendering/WebGPU/ViewNodeFactory.js

@@ -1,39 +1,51 @@
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.js';
 import vtkViewNodeFactory from '../SceneGraph/ViewNodeFactory.js';
 
-var CLASS_MAPPING = Object.create(null);
+const CLASS_MAPPING = Object.create(null);
 function registerOverride(className, fn) {
   CLASS_MAPPING[className] = fn;
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // vtkWebGPUViewNodeFactory methods
 // ----------------------------------------------------------------------------
 
 function vtkWebGPUViewNodeFactory(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkWebGPUViewNodeFactory');
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
+const DEFAULT_VALUES = {};
 
-var DEFAULT_VALUES = {}; // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
 
 function extend(publicAPI, model) {
-  var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-  Object.assign(model, DEFAULT_VALUES, initialValues); // Static class mapping shared across instances
+  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  Object.assign(model, DEFAULT_VALUES, initialValues);
 
-  model.overrides = CLASS_MAPPING; // Inheritance
+  // Static class mapping shared across instances
+  model.overrides = CLASS_MAPPING;
 
-  vtkViewNodeFactory.extend(publicAPI, model, initialValues); // Object methods
+  // Inheritance
+  vtkViewNodeFactory.extend(publicAPI, model, initialValues);
 
+  // Object methods
   vtkWebGPUViewNodeFactory(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
 
-var newInstance = macro.newInstance(extend, 'vtkWebGPUViewNodeFactory'); // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+
+const newInstance = macro.newInstance(extend, 'vtkWebGPUViewNodeFactory');
+
+// ----------------------------------------------------------------------------
 
 var vtkWebGPUViewNodeFactory$1 = {
-  newInstance: newInstance,
-  extend: extend
+  newInstance,
+  extend
 };
 
 export { vtkWebGPUViewNodeFactory$1 as default, extend, newInstance, registerOverride };

package/Rendering/WebGPU/Volume.js

@@ -1,74 +1,65 @@
 import { mat4 } from 'gl-matrix';
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.js';
 import vtkViewNode from '../SceneGraph/ViewNode.js';
 import { registerOverride } from './ViewNodeFactory.js';
 
+// ----------------------------------------------------------------------------
 // vtkWebGPUVolume methods
 // ----------------------------------------------------------------------------
 
 function vtkWebGPUVolume(publicAPI, model) {
   // Set our className
-  model.classHierarchy.push('vtkWebGPUVolume'); // Builds myself.
+  model.classHierarchy.push('vtkWebGPUVolume');
 
-  publicAPI.buildPass = function (prepass) {
+  // Builds myself.
+  publicAPI.buildPass = prepass => {
     if (!model.renderable || !model.renderable.getVisibility()) {
       return;
     }
-
     if (prepass) {
       model.WebGPURenderer = publicAPI.getFirstAncestorOfType('vtkWebGPURenderer');
-      model.WebGPURenderWindow = model.WebGPURenderer.getFirstAncestorOfType('vtkWebGPURenderWindow'); // for the future if we support hardware selection of volumes
-
+      model.WebGPURenderWindow = model.WebGPURenderer.getFirstAncestorOfType('vtkWebGPURenderWindow');
+      // for the future if we support hardware selection of volumes
       if (model.propID === undefined) {
         model.propID = model.WebGPURenderWindow.getUniquePropID();
       }
-
       model.renderable.getMapper().update();
     }
   };
-
-  publicAPI.queryPass = function (prepass, renderPass) {
+  publicAPI.queryPass = (prepass, renderPass) => {
     if (prepass) {
       if (!model.renderable || !model.renderable.getVisibility()) {
         return;
-      } // Check for the special case when the mapper's bounds are unknown
-
-
-      var bds = model.renderable.getMapper().getBounds();
+      }
 
+      // Check for the special case when the mapper's bounds are unknown
+      const bds = model.renderable.getMapper().getBounds();
       if (!bds || bds.length !== 6 || bds[0] > bds[1]) {
         return;
       }
-
       renderPass.addVolume(publicAPI);
     }
-  }; // used in the method below
-
-
-  var idx = new Float64Array(3);
-  var vout = new Float64Array(3);
-
-  publicAPI.getBoundingCubePoints = function (result, offset) {
-    var input = model.renderable.getMapper().getInputData();
+  };
 
+  // used in the method below
+  const idx = new Float64Array(3);
+  const vout = new Float64Array(3);
+  publicAPI.getBoundingCubePoints = (result, offset) => {
+    const input = model.renderable.getMapper().getInputData();
     if (!input) {
       return;
     }
-
-    var extent = input.getExtent();
-    var m = model.renderable.getMatrix();
-    var count = 0;
-
-    for (var iz = 4; iz < 6; iz++) {
+    const extent = input.getExtent();
+    const m = model.renderable.getMatrix();
+    let count = 0;
+    for (let iz = 4; iz < 6; iz++) {
       idx[2] = extent[iz];
-
-      for (var iy = 2; iy < 4; iy++) {
+      for (let iy = 2; iy < 4; iy++) {
         idx[1] = extent[iy];
-
-        for (var ix = 0; ix < 2; ix++) {
+        for (let ix = 0; ix < 2; ix++) {
           idx[0] = extent[ix];
           input.indexToWorld(idx, vout);
-          var poffset = offset + count * 3;
+          let poffset = offset + count * 3;
           result[poffset++] = m[0] * vout[0] + m[1] * vout[1] + m[2] * vout[2] + m[3];
           result[poffset++] = m[4] * vout[0] + m[5] * vout[1] + m[6] * vout[2] + m[7];
           result[poffset++] = m[8] * vout[0] + m[9] * vout[1] + m[10] * vout[2] + m[11];
@@ -77,36 +68,40 @@ function vtkWebGPUVolume(publicAPI, model) {
       }
     }
   };
-
-  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
+      const mcwc = model.renderable.getMatrix();
 
-      var center = wgpuRen.getStabilizedCenterByReference();
-      mat4.transpose(model.keyMatrices.bcwc, mcwc); // to get to stabilized we also need the center
+      // compute the net shift
+      const center = wgpuRen.getStabilizedCenterByReference();
+      mat4.transpose(model.keyMatrices.bcwc, mcwc);
 
+      // to get to stabilized we also need the center
       mat4.translate(model.keyMatrices.bcsc, model.keyMatrices.bcwc, [-center[0], -center[1], -center[2]]);
       model.keyMatricesTime.modified();
     }
-
     return model.keyMatrices;
   };
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
-
-var DEFAULT_VALUES = {
+const DEFAULT_VALUES = {
   propID: undefined,
   keyMatricesTime: 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.keyMatricesTime = {};
   macro.obj(model.keyMatricesTime, {
@@ -116,18 +111,24 @@ function extend(publicAPI, model) {
     bcwc: new Float64Array(16),
     bcsc: new Float64Array(16)
   };
-  macro.get(publicAPI, model, ['propID', 'keyMatricesTime']); // Object methods
+  macro.get(publicAPI, model, ['propID', 'keyMatricesTime']);
 
+  // Object methods
   vtkWebGPUVolume(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
 
-var newInstance = macro.newInstance(extend, 'vtkWebGPUVolume'); // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+
+const newInstance = macro.newInstance(extend, 'vtkWebGPUVolume');
+
+// ----------------------------------------------------------------------------
 
 var index = {
-  newInstance: newInstance,
-  extend: extend
-}; // Register ourself to WebGPU backend if imported
+  newInstance,
+  extend
+};
 
+// Register ourself to WebGPU backend if imported
 registerOverride('vtkVolume', newInstance);
 
 export { index as default, extend, newInstance };