@kitware/vtk.js 28.10.2 → 28.11.1

package/Rendering/WebGPU/Sampler.js

@@ -1,6 +1,7 @@
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.js';
 
 /* eslint-disable no-bitwise */
+
 // ----------------------------------------------------------------------------
 // vtkWebGPUSampler methods
 // ----------------------------------------------------------------------------
@@ -8,9 +9,8 @@ import macro from '../../macros.js';
 function vtkWebGPUSampler(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkWebGPUSampler');
-
   publicAPI.create = function (device) {
-    var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
     model.device = device;
     model.options.addressModeU = options.addressModeU ? options.addressModeU : 'clamp-to-edge';
     model.options.addressModeV = options.addressModeV ? options.addressModeV : 'clamp-to-edge';
@@ -22,42 +22,44 @@ function vtkWebGPUSampler(publicAPI, model) {
     model.handle = model.device.getHandle().createSampler(model.options);
     model.bindGroupTime.modified();
   };
-
-  publicAPI.getShaderCode = function (binding, group) {
-    var result = "@binding(".concat(binding, ") @group(").concat(group, ") var ").concat(model.label, ": sampler;");
+  publicAPI.getShaderCode = (binding, group) => {
+    const result = `@binding(${binding}) @group(${group}) var ${model.label}: sampler;`;
     return result;
   };
-
-  publicAPI.getBindGroupEntry = function () {
-    var foo = {
+  publicAPI.getBindGroupEntry = () => {
+    const foo = {
       resource: model.handle
     };
     return foo;
   };
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
-
-var DEFAULT_VALUES = {
+const DEFAULT_VALUES = {
   device: null,
   handle: null,
   label: null,
   options: null
-}; // ----------------------------------------------------------------------------
+};
+
+// ----------------------------------------------------------------------------
 
 function extend(publicAPI, model) {
-  var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-  Object.assign(model, DEFAULT_VALUES, initialValues); // Object methods
+  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  Object.assign(model, DEFAULT_VALUES, initialValues);
 
+  // Object methods
   macro.obj(publicAPI, model);
   model.options = {};
   model.bindGroupLayoutEntry = {
     /* eslint-disable no-undef */
     visibility: GPUShaderStage.VERTEX | GPUShaderStage.FRAGMENT,
-
     /* eslint-enable no-undef */
-    sampler: {// type: 'filtering',
+    sampler: {
+      // type: 'filtering',
     }
   };
   model.bindGroupTime = {};
@@ -67,13 +69,17 @@ function extend(publicAPI, model) {
   macro.get(publicAPI, model, ['bindGroupTime', 'handle', 'options']);
   macro.setGet(publicAPI, model, ['bindGroupLayoutEntry', 'device', 'label']);
   vtkWebGPUSampler(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
 
-var newInstance = macro.newInstance(extend); // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+
+const newInstance = macro.newInstance(extend);
+
+// ----------------------------------------------------------------------------
 
 var vtkWebGPUSampler$1 = {
-  newInstance: newInstance,
-  extend: extend
+  newInstance,
+  extend
 };
 
 export { vtkWebGPUSampler$1 as default, extend, newInstance };

package/Rendering/WebGPU/ScalarBarActor.js

@@ -1,61 +1,70 @@
-import { newInstance as newInstance$1 } from '../../macros.js';
+import { n as newInstance$1 } from '../../macros2.js';
 import vtkScalarBarActor from '../Core/ScalarBarActor.js';
 import vtkViewNode from '../SceneGraph/ViewNode.js';
 import { registerOverride } from './ViewNodeFactory.js';
 
+// ----------------------------------------------------------------------------
 // vtkWebGPUScalarBarActor methods
 // ----------------------------------------------------------------------------
 
 function vtkWebGPUScalarBarActor(publicAPI, model) {
-  model.classHierarchy.push('vtkWebGPUScalarBarActor'); // Builds myself.
+  model.classHierarchy.push('vtkWebGPUScalarBarActor');
 
-  publicAPI.buildPass = function (prepass) {
+  // Builds myself.
+  publicAPI.buildPass = prepass => {
     if (prepass) {
       model.WebGPURenderer = publicAPI.getFirstAncestorOfType('vtkWebGPURenderer');
       model.WebGPURenderWindow = model.WebGPURenderer.getParent();
-
       if (!model.scalarBarActorHelper.getRenderable()) {
         model.scalarBarActorHelper.setRenderable(model.renderable);
       }
-
       publicAPI.prepareNodes();
       publicAPI.addMissingNode(model.scalarBarActorHelper.getBarActor());
       publicAPI.addMissingNode(model.scalarBarActorHelper.getTmActor());
       publicAPI.removeUnusedNodes();
     }
   };
-
-  publicAPI.opaquePass = function (prepass, renderPass) {
+  publicAPI.opaquePass = (prepass, renderPass) => {
     if (prepass) {
-      var camera = model.WebGPURenderer ? model.WebGPURenderer.getRenderable().getActiveCamera() : null;
-      var tsize = model.WebGPURenderer.getTiledSizeAndOrigin();
+      const camera = model.WebGPURenderer ? model.WebGPURenderer.getRenderable().getActiveCamera() : null;
+      const tsize = model.WebGPURenderer.getTiledSizeAndOrigin();
       model.scalarBarActorHelper.updateAPISpecificData([tsize.usize, tsize.vsize], camera, model.WebGPURenderWindow.getRenderable());
     }
   };
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // 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); // Inheritance
+  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  Object.assign(model, DEFAULT_VALUES, initialValues);
 
+  // Inheritance
   vtkViewNode.extend(publicAPI, model, initialValues);
-  model.scalarBarActorHelper = vtkScalarBarActor.newScalarBarActorHelper(); // Object methods
+  model.scalarBarActorHelper = vtkScalarBarActor.newScalarBarActorHelper();
 
+  // Object methods
   vtkWebGPUScalarBarActor(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 
-var newInstance = newInstance$1(extend, 'vtkWebGPUScalarBarActor'); // ----------------------------------------------------------------------------
+const newInstance = newInstance$1(extend, 'vtkWebGPUScalarBarActor');
+
+// ----------------------------------------------------------------------------
 
 var index = {
-  newInstance: newInstance,
-  extend: extend
-}; // Register ourself to WebGPU backend if imported
+  newInstance,
+  extend
+};
 
+// Register ourself to WebGPU backend if imported
 registerOverride('vtkScalarBarActor', newInstance);
 
 export { index as default, extend, newInstance };

package/Rendering/WebGPU/ShaderCache.js

@@ -1,91 +1,93 @@
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.js';
 import vtkWebGPUShaderModule from './ShaderModule.js';
 
+// perform in place string substitutions, indicate if a substitution was done
 // this is useful for building up shader strings which typically involve
 // lots of string substitutions. Return true if a substitution was done.
-
 function substitute(source, search, replace) {
-  var all = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : true;
-  var replaceStr = Array.isArray(replace) ? replace.join('\n') : replace;
-  var replaced = false;
-
+  let all = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : true;
+  const replaceStr = Array.isArray(replace) ? replace.join('\n') : replace;
+  let replaced = false;
   if (source.search(search) !== -1) {
     replaced = true;
   }
-
-  var gflag = '';
-
+  let gflag = '';
   if (all) {
     gflag = 'g';
   }
-
-  var regex = new RegExp(search, gflag);
-  var resultstr = source.replace(regex, replaceStr);
+  const regex = new RegExp(search, gflag);
+  const resultstr = source.replace(regex, replaceStr);
   return {
     replace: replaced,
     result: resultstr
   };
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // vtkWebGPUShaderCache methods
 // ----------------------------------------------------------------------------
 
-
 function vtkWebGPUShaderCache(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkWebGPUShaderCache');
-
-  publicAPI.getShaderModule = function (shaderDesc) {
+  publicAPI.getShaderModule = shaderDesc => {
     // has it already been created?
-    var sType = shaderDesc.getType();
-    var sHash = shaderDesc.getHash();
-
-    var keys = model._shaderModules.keys();
-
-    for (var i = 0; i < keys.length; i++) {
-      var key = keys[i];
-
+    const sType = shaderDesc.getType();
+    const sHash = shaderDesc.getHash();
+    const keys = model._shaderModules.keys();
+    for (let i = 0; i < keys.length; i++) {
+      const key = keys[i];
       if (key.getHash() === sHash && key.getType() === sType) {
         return model._shaderModules.get(key);
       }
-    } // console.log(JSON.stringify(shaderDesc));
+    }
 
+    // console.log(JSON.stringify(shaderDesc));
 
-    var sm = vtkWebGPUShaderModule.newInstance();
+    const sm = vtkWebGPUShaderModule.newInstance();
     sm.initialize(model.device, shaderDesc);
-
     model._shaderModules.set(shaderDesc, sm);
-
     return sm;
   };
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
-
-var DEFAULT_VALUES = {
+const DEFAULT_VALUES = {
   shaderModules: null,
   device: null,
   window: null
-}; // ----------------------------------------------------------------------------
+};
+
+// ----------------------------------------------------------------------------
 
 function extend(publicAPI, model) {
-  var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-  Object.assign(model, DEFAULT_VALUES, initialValues); // Internal objects
+  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  Object.assign(model, DEFAULT_VALUES, initialValues);
 
-  model._shaderModules = new Map(); // Build VTK API
+  // Internal objects
+  model._shaderModules = new Map();
 
+  // Build VTK API
   macro.obj(publicAPI, model);
-  macro.setGet(publicAPI, model, ['device', 'window']); // Object methods
+  macro.setGet(publicAPI, model, ['device', 'window']);
 
+  // Object methods
   vtkWebGPUShaderCache(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
+
+const newInstance = macro.newInstance(extend, 'vtkWebGPUShaderCache');
 
-var newInstance = macro.newInstance(extend, 'vtkWebGPUShaderCache'); // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
 
 var vtkWebGPUShaderCache$1 = {
-  newInstance: newInstance,
-  extend: extend,
-  substitute: substitute
+  newInstance,
+  extend,
+  substitute
 };
 
 export { vtkWebGPUShaderCache$1 as default, extend, newInstance };

package/Rendering/WebGPU/ShaderDescription.js

@@ -1,117 +1,104 @@
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.js';
 import vtkWebGPUShaderCache from './ShaderCache.js';
 
+// ----------------------------------------------------------------------------
 // vtkWebGPUShaderDescription methods
 // ----------------------------------------------------------------------------
+
 // shader description
 
 function vtkWebGPUShaderDescription(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkWebGPUShaderDescription');
-
-  publicAPI.hasOutput = function (name) {
-    return model.outputNames.includes(name);
-  };
-
+  publicAPI.hasOutput = name => model.outputNames.includes(name);
   publicAPI.addOutput = function (type, name) {
-    var interpolation = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : undefined;
+    let interpolation = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : undefined;
     model.outputTypes.push(type);
     model.outputNames.push(name);
     model.outputInterpolations.push(interpolation);
   };
-
-  publicAPI.addBuiltinOutput = function (type, name) {
+  publicAPI.addBuiltinOutput = (type, name) => {
     model.builtinOutputTypes.push(type);
     model.builtinOutputNames.push(name);
   };
-
-  publicAPI.addBuiltinInput = function (type, name) {
+  publicAPI.addBuiltinInput = (type, name) => {
     model.builtinInputTypes.push(type);
     model.builtinInputNames.push(name);
-  }; // perform shader replacements for the input and outputs
-  // of this shader. That includes vertex inputs if specified
-
-
-  publicAPI.replaceShaderCode = function (priorStage, vertexInput) {
-    var inputImpl = [];
-    var iodec = [];
+  };
 
+  // perform shader replacements for the input and outputs
+  // of this shader. That includes vertex inputs if specified
+  publicAPI.replaceShaderCode = (priorStage, vertexInput) => {
+    const inputImpl = [];
+    let iodec = [];
     if (vertexInput) {
       inputImpl.push(vertexInput.getShaderCode());
     }
-
     if (priorStage || model.builtinInputNames.length) {
-      var inputStruct = [];
-      inputStruct.push("struct ".concat(model.type, "Input\n{"));
-
+      const inputStruct = [];
+      inputStruct.push(`struct ${model.type}Input\n{`);
       if (priorStage) {
-        var inputNames = priorStage.getOutputNamesByReference();
-        var inputTypes = priorStage.getOutputTypesByReference();
-        var inputInterpolations = priorStage.getOutputInterpolationsByReference();
-
-        for (var i = 0; i < inputNames.length; i++) {
+        const inputNames = priorStage.getOutputNamesByReference();
+        const inputTypes = priorStage.getOutputTypesByReference();
+        const inputInterpolations = priorStage.getOutputInterpolationsByReference();
+        for (let i = 0; i < inputNames.length; i++) {
           if (inputInterpolations[i] !== undefined) {
-            inputStruct.push("  @location(".concat(i, ") @interpolate(").concat(inputInterpolations[i], ") ").concat(inputNames[i], " : ").concat(inputTypes[i], ","));
+            inputStruct.push(`  @location(${i}) @interpolate(${inputInterpolations[i]}) ${inputNames[i]} : ${inputTypes[i]},`);
           } else {
-            inputStruct.push("  @location(".concat(i, ") ").concat(inputNames[i], " : ").concat(inputTypes[i], ","));
+            inputStruct.push(`  @location(${i}) ${inputNames[i]} : ${inputTypes[i]},`);
           }
         }
       }
-
-      for (var _i = 0; _i < model.builtinInputNames.length; _i++) {
-        inputStruct.push("  ".concat(model.builtinInputNames[_i], " : ").concat(model.builtinInputTypes[_i], ","));
+      for (let i = 0; i < model.builtinInputNames.length; i++) {
+        inputStruct.push(`  ${model.builtinInputNames[i]} : ${model.builtinInputTypes[i]},`);
       }
-
       if (inputStruct.length > 1) {
         inputStruct.push('};');
         iodec = inputStruct;
         inputImpl[inputImpl.length - 1] += ',';
-        inputImpl.push("input: ".concat(model.type, "Input"));
+        inputImpl.push(`input: ${model.type}Input`);
       }
     }
-
     if (inputImpl.length) {
       model.code = vtkWebGPUShaderCache.substitute(model.code, '//VTK::IOStructs::Input', inputImpl).result;
     }
-
     if (model.outputNames.length + model.builtinOutputNames.length) {
-      var outputStruct = ["struct ".concat(model.type, "Output\n{")];
-
-      for (var _i2 = 0; _i2 < model.outputNames.length; _i2++) {
-        if (model.outputInterpolations[_i2] !== undefined) {
-          outputStruct.push("  @location(".concat(_i2, ") @interpolate(").concat(model.outputInterpolations[_i2], ") ").concat(model.outputNames[_i2], " : ").concat(model.outputTypes[_i2], ","));
+      const outputStruct = [`struct ${model.type}Output\n{`];
+      for (let i = 0; i < model.outputNames.length; i++) {
+        if (model.outputInterpolations[i] !== undefined) {
+          outputStruct.push(`  @location(${i}) @interpolate(${model.outputInterpolations[i]}) ${model.outputNames[i]} : ${model.outputTypes[i]},`);
         } else {
-          outputStruct.push("  @location(".concat(_i2, ") ").concat(model.outputNames[_i2], " : ").concat(model.outputTypes[_i2], ","));
+          outputStruct.push(`  @location(${i}) ${model.outputNames[i]} : ${model.outputTypes[i]},`);
         }
       }
-
-      for (var _i3 = 0; _i3 < model.builtinOutputNames.length; _i3++) {
-        outputStruct.push("  ".concat(model.builtinOutputNames[_i3], " : ").concat(model.builtinOutputTypes[_i3], ","));
+      for (let i = 0; i < model.builtinOutputNames.length; i++) {
+        outputStruct.push(`  ${model.builtinOutputNames[i]} : ${model.builtinOutputTypes[i]},`);
       }
-
       outputStruct.push('};');
       iodec = iodec.concat(outputStruct);
-      model.code = vtkWebGPUShaderCache.substitute(model.code, '//VTK::IOStructs::Output', ["-> ".concat(model.type, "Output")]).result;
+      model.code = vtkWebGPUShaderCache.substitute(model.code, '//VTK::IOStructs::Output', [`-> ${model.type}Output`]).result;
     }
-
     model.code = vtkWebGPUShaderCache.substitute(model.code, '//VTK::IOStructs::Dec', iodec).result;
   };
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
-
-var DEFAULT_VALUES = {
+const DEFAULT_VALUES = {
   type: null,
   // 'vertex' or 'fragment'
   hash: null,
   code: null,
   outputNames: null,
   outputTypes: null
-}; // ----------------------------------------------------------------------------
+};
+
+// ----------------------------------------------------------------------------
 
 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);
   model.outputNames = [];
   model.outputTypes = [];
@@ -119,20 +106,26 @@ function extend(publicAPI, model) {
   model.builtinOutputNames = [];
   model.builtinOutputTypes = [];
   model.builtinInputNames = [];
-  model.builtinInputTypes = []; // Build VTK API
+  model.builtinInputTypes = [];
 
+  // Build VTK API
   macro.obj(publicAPI, model);
   macro.setGet(publicAPI, model, ['type', 'hash', 'code']);
-  macro.getArray(publicAPI, model, ['outputTypes', 'outputNames', 'outputInterpolations']); // Object methods
+  macro.getArray(publicAPI, model, ['outputTypes', 'outputNames', 'outputInterpolations']);
 
+  // Object methods
   vtkWebGPUShaderDescription(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
 
-var newInstance = macro.newInstance(extend, 'vtkWebGPUShaderDescription'); // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+
+const newInstance = macro.newInstance(extend, 'vtkWebGPUShaderDescription');
+
+// ----------------------------------------------------------------------------
 
 var vtkWebGPUShaderDescription$1 = {
-  newInstance: newInstance,
-  extend: extend
+  newInstance,
+  extend
 };
 
 export { vtkWebGPUShaderDescription$1 as default, extend, newInstance };

package/Rendering/WebGPU/ShaderModule.js

@@ -1,49 +1,58 @@
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.js';
 
+// ----------------------------------------------------------------------------
 // vtkWebGPUShaderModule methods
 // ----------------------------------------------------------------------------
 
 function vtkWebGPUShaderModule(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkWebGPUShaderModule');
-
-  publicAPI.initialize = function (device, shaderDesc) {
-    model.device = device; // console.log(shaderDesc.getCode());
-
+  publicAPI.initialize = (device, shaderDesc) => {
+    model.device = device;
+    // console.log(shaderDesc.getCode());
     model.handle = model.device.getHandle().createShaderModule({
       code: shaderDesc.getCode()
     });
-  }; // publicAPI.setLastCameraMTime = (mtime) => {
+  };
+
+  // publicAPI.setLastCameraMTime = (mtime) => {
   //   model.lastCameraMTime = mtime;
   // };
+}
 
-} // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
-
-var DEFAULT_VALUES = {
+const DEFAULT_VALUES = {
   device: null,
   handle: 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
   macro.obj(publicAPI, model);
   macro.get(publicAPI, model, ['lastCameraMTime']);
-  macro.setGet(publicAPI, model, ['device', 'handle']); // Object methods
+  macro.setGet(publicAPI, model, ['device', 'handle']);
 
+  // Object methods
   vtkWebGPUShaderModule(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
 
+// ----------------------------------------------------------------------------
+
+const newInstance = macro.newInstance(extend, 'vtkWebGPUShaderModule');
 
-var newInstance = macro.newInstance(extend, 'vtkWebGPUShaderModule'); // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
 
 var vtkWebGPUShaderModule$1 = {
-  newInstance: newInstance,
-  extend: extend
+  newInstance,
+  extend
 };
 
 export { vtkWebGPUShaderModule$1 as default };