@kitware/vtk.js 28.10.2 → 28.11.1

package/Rendering/WebGPU/PolyDataMapper.js

@@ -1,49 +1,45 @@
-import { newInstance as newInstance$1 } from '../../macros.js';
+import { n as newInstance$1 } from '../../macros2.js';
 import vtkWebGPUBufferManager from './BufferManager.js';
 import vtkWebGPUCellArrayMapper from './CellArrayMapper.js';
 import vtkViewNode from '../SceneGraph/ViewNode.js';
 import { registerOverride } from './ViewNodeFactory.js';
 
-var PrimitiveTypes = vtkWebGPUBufferManager.PrimitiveTypes; // ----------------------------------------------------------------------------
+const {
+  PrimitiveTypes
+} = vtkWebGPUBufferManager;
+
+// ----------------------------------------------------------------------------
 // vtkWebGPUPolyDataMapper methods
 // ----------------------------------------------------------------------------
 
 function vtkWebGPUPolyDataMapper(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkWebGPUPolyDataMapper');
-
-  publicAPI.createCellArrayMapper = function () {
-    return vtkWebGPUCellArrayMapper.newInstance();
-  };
-
-  publicAPI.buildPass = function (prepass) {
+  publicAPI.createCellArrayMapper = () => vtkWebGPUCellArrayMapper.newInstance();
+  publicAPI.buildPass = prepass => {
     if (prepass) {
       model.WebGPUActor = publicAPI.getFirstAncestorOfType('vtkWebGPUActor');
-
       if (!model.renderable.getStatic()) {
         model.renderable.update();
       }
-
-      var poly = model.renderable.getInputData();
+      const poly = model.renderable.getInputData();
       model.renderable.mapScalars(poly, 1.0);
       publicAPI.updateCellArrayMappers(poly);
     }
   };
+  publicAPI.updateCellArrayMappers = poly => {
+    const prims = [poly.getVerts(), poly.getLines(), poly.getPolys(), poly.getStrips()];
 
-  publicAPI.updateCellArrayMappers = function (poly) {
-    var prims = [poly.getVerts(), poly.getLines(), poly.getPolys(), poly.getStrips()]; // we instantiate a cell array mapper for each cellArray that has cells
+    // we instantiate a cell array mapper for each cellArray that has cells
     // and they handle the rendering of that cell array
-
-    var cellMappers = [];
-    var cellOffset = 0;
-
-    for (var i = PrimitiveTypes.Points; i <= PrimitiveTypes.Triangles; i++) {
+    const cellMappers = [];
+    let cellOffset = 0;
+    for (let i = PrimitiveTypes.Points; i <= PrimitiveTypes.Triangles; i++) {
       if (prims[i].getNumberOfValues() > 0) {
         if (!model.primitives[i]) {
           model.primitives[i] = publicAPI.createCellArrayMapper();
         }
-
-        var cellMapper = model.primitives[i];
+        const cellMapper = model.primitives[i];
         cellMapper.setCellArray(prims[i]);
         cellMapper.setCurrentInput(poly);
         cellMapper.setCellOffset(cellOffset);
@@ -55,63 +51,64 @@ function vtkWebGPUPolyDataMapper(publicAPI, model) {
         model.primitives[i] = null;
       }
     }
-
     if (model.WebGPUActor.getRenderable().getProperty().getEdgeVisibility()) {
-      for (var _i = PrimitiveTypes.TriangleEdges; _i <= PrimitiveTypes.TriangleStripEdges; _i++) {
-        if (prims[_i - 2].getNumberOfValues() > 0) {
-          if (!model.primitives[_i]) {
-            model.primitives[_i] = publicAPI.createCellArrayMapper();
+      for (let i = PrimitiveTypes.TriangleEdges; i <= PrimitiveTypes.TriangleStripEdges; i++) {
+        if (prims[i - 2].getNumberOfValues() > 0) {
+          if (!model.primitives[i]) {
+            model.primitives[i] = publicAPI.createCellArrayMapper();
           }
-
-          var _cellMapper = model.primitives[_i];
-
-          _cellMapper.setCellArray(prims[_i - 2]);
-
-          _cellMapper.setCurrentInput(poly);
-
-          _cellMapper.setCellOffset(model.primitives[_i - 2].getCellOffset());
-
-          _cellMapper.setPrimitiveType(_i);
-
-          _cellMapper.setRenderable(model.renderable);
-
-          cellMappers.push(_cellMapper);
+          const cellMapper = model.primitives[i];
+          cellMapper.setCellArray(prims[i - 2]);
+          cellMapper.setCurrentInput(poly);
+          cellMapper.setCellOffset(model.primitives[i - 2].getCellOffset());
+          cellMapper.setPrimitiveType(i);
+          cellMapper.setRenderable(model.renderable);
+          cellMappers.push(cellMapper);
         } else {
-          model.primitives[_i] = null;
+          model.primitives[i] = null;
         }
       }
     }
-
     publicAPI.prepareNodes();
     publicAPI.addMissingChildren(cellMappers);
     publicAPI.removeUnusedNodes();
   };
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
-
-var DEFAULT_VALUES = {
+const DEFAULT_VALUES = {
   primitives: 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.primitives = []; // Object methods
+  model.primitives = [];
 
+  // Object methods
   vtkWebGPUPolyDataMapper(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
 
-var newInstance = newInstance$1(extend, 'vtkWebGPUPolyDataMapper'); // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+
+const newInstance = newInstance$1(extend, 'vtkWebGPUPolyDataMapper');
+
+// ----------------------------------------------------------------------------
 
 var vtkWebGPUPolyDataMapper$1 = {
-  newInstance: newInstance,
-  extend: extend
-}; // Register ourself to WebGPU backend if imported
+  newInstance,
+  extend
+};
 
+// Register ourself to WebGPU backend if imported
 registerOverride('vtkMapper', newInstance);
 
 export { vtkWebGPUPolyDataMapper$1 as default, extend, newInstance };

package/Rendering/WebGPU/PolyDataMapper2D.js

@@ -1,53 +1,45 @@
-import _defineProperty from '@babel/runtime/helpers/defineProperty';
-import { newInstance as newInstance$1 } from '../../macros.js';
+import { n as newInstance$1 } from '../../macros2.js';
 import vtkWebGPUBufferManager from './BufferManager.js';
 import vtkWebGPUCellArrayMapper from './CellArrayMapper.js';
 import vtkViewNode from '../SceneGraph/ViewNode.js';
 import { registerOverride } from './ViewNodeFactory.js';
 
-function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+const {
+  PrimitiveTypes
+} = vtkWebGPUBufferManager;
 
-function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
-var PrimitiveTypes = vtkWebGPUBufferManager.PrimitiveTypes; // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
 // vtkWebGPUPolyDataMapper methods
 // ----------------------------------------------------------------------------
 
 function vtkWebGPUPolyDataMapper2D(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkWebGPUPolyDataMapper2D');
-
-  publicAPI.createCellArrayMapper = function () {
-    return vtkWebGPUCellArrayMapper.newInstance();
-  };
-
-  publicAPI.buildPass = function (prepass) {
+  publicAPI.createCellArrayMapper = () => vtkWebGPUCellArrayMapper.newInstance();
+  publicAPI.buildPass = prepass => {
     if (prepass) {
       model.WebGPUActor = publicAPI.getFirstAncestorOfType('vtkWebGPUActor2D');
-
       if (!model.renderable.getStatic()) {
         model.renderable.update();
       }
-
-      var poly = model.renderable.getInputData();
+      const poly = model.renderable.getInputData();
       model.renderable.mapScalars(poly, 1.0);
       publicAPI.updateCellArrayMappers(poly);
     }
   };
+  publicAPI.updateCellArrayMappers = poly => {
+    const prims = [poly.getVerts(), poly.getLines(), poly.getPolys(), poly.getStrips()];
 
-  publicAPI.updateCellArrayMappers = function (poly) {
-    var prims = [poly.getVerts(), poly.getLines(), poly.getPolys(), poly.getStrips()]; // we instantiate a cell array mapper for each cellArray that has cells
+    // we instantiate a cell array mapper for each cellArray that has cells
     // and they handle the rendering of that cell array
-
-    var cellMappers = [];
-    var cellOffset = 0;
-
-    for (var i = PrimitiveTypes.Points; i <= PrimitiveTypes.Triangles; i++) {
+    const cellMappers = [];
+    let cellOffset = 0;
+    for (let i = PrimitiveTypes.Points; i <= PrimitiveTypes.Triangles; i++) {
       if (prims[i].getNumberOfValues() > 0) {
         if (!model.primitives[i]) {
           model.primitives[i] = publicAPI.createCellArrayMapper();
         }
-
-        var cellMapper = model.primitives[i];
+        const cellMapper = model.primitives[i];
         cellMapper.setCellArray(prims[i]);
         cellMapper.setCurrentInput(poly);
         cellMapper.setCellOffset(cellOffset);
@@ -60,40 +52,48 @@ function vtkWebGPUPolyDataMapper2D(publicAPI, model) {
         model.primitives[i] = null;
       }
     }
-
     publicAPI.prepareNodes();
     publicAPI.addMissingChildren(cellMappers);
     publicAPI.removeUnusedNodes();
   };
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
-
 function defaultValues(initialValues) {
-  return _objectSpread({
-    primitives: []
-  }, initialValues);
-} // ----------------------------------------------------------------------------
-
+  return {
+    primitives: [],
+    ...initialValues
+  };
+}
 
+// ----------------------------------------------------------------------------
 function extend(publicAPI, model) {
-  var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-  Object.assign(model, defaultValues(initialValues)); // Inheritance
+  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  Object.assign(model, defaultValues(initialValues));
 
+  // Inheritance
   vtkViewNode.extend(publicAPI, model, initialValues);
-  model.primitives = []; // Object methods
+  model.primitives = [];
 
+  // Object methods
   vtkWebGPUPolyDataMapper2D(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 
-var newInstance = newInstance$1(extend, 'vtkWebGPUPolyDataMapper2D'); // ----------------------------------------------------------------------------
+const newInstance = newInstance$1(extend, 'vtkWebGPUPolyDataMapper2D');
+
+// ----------------------------------------------------------------------------
 
 var index = {
-  newInstance: newInstance,
-  extend: extend
-}; // Register ourself to WebGPU backend if imported
+  newInstance,
+  extend
+};
 
+// Register ourself to WebGPU backend if imported
 registerOverride('vtkMapper2D', newInstance);
 
 export { index as default, extend, newInstance };

package/Rendering/WebGPU/RenderEncoder.js

@@ -1,114 +1,96 @@
-import { newInstance as newInstance$1, obj, get, setGet } from '../../macros.js';
+import { n as newInstance$1, o as obj, g as get, e as setGet } from '../../macros2.js';
 import vtkWebGPUShaderCache from './ShaderCache.js';
 
-var forwarded = ['setBindGroup', 'setIndexBuffer', 'setVertexBuffer', 'draw', 'drawIndexed']; // ----------------------------------------------------------------------------
+// methods we forward to the handle
+const forwarded = ['setBindGroup', 'setIndexBuffer', 'setVertexBuffer', 'draw', 'drawIndexed'];
+
+// ----------------------------------------------------------------------------
 // vtkWebGPURenderEncoder methods
 // ----------------------------------------------------------------------------
-
 function vtkWebGPURenderEncoder(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkWebGPURenderEncoder');
-
-  publicAPI.begin = function (encoder) {
+  publicAPI.begin = encoder => {
     model.drawCallbacks = [];
     model.handle = encoder.beginRenderPass(model.description);
-
     if (model.label) {
       model.handle.pushDebugGroup(model.label);
     }
   };
-
-  publicAPI.end = function () {
+  publicAPI.end = () => {
     // loop over registered pipelines and their callbacks
-    for (var i = 0; i < model.drawCallbacks.length; i++) {
-      var pStruct = model.drawCallbacks[i];
-      var pl = pStruct.pipeline;
+    for (let i = 0; i < model.drawCallbacks.length; i++) {
+      const pStruct = model.drawCallbacks[i];
+      const pl = pStruct.pipeline;
       publicAPI.setPipeline(pl);
-
-      for (var cb = 0; cb < pStruct.callbacks.length; cb++) {
+      for (let cb = 0; cb < pStruct.callbacks.length; cb++) {
         pStruct.callbacks[cb](publicAPI);
       }
     }
-
     if (model.label) {
       model.handle.popDebugGroup();
     }
-
     model.handle.end();
     model.boundPipeline = null;
   };
-
-  publicAPI.setPipeline = function (pl) {
+  publicAPI.setPipeline = pl => {
     if (model.boundPipeline === pl) {
       return;
     }
-
     model.handle.setPipeline(pl.getHandle());
-    var pd = pl.getPipelineDescription(); // check attachment state
+    const pd = pl.getPipelineDescription();
 
+    // check attachment state
     if (model.colorTextureViews.length !== pd.fragment.targets.length) {
-      console.log("mismatched attachment counts on pipeline ".concat(pd.fragment.targets.length, " while encoder has ").concat(model.colorTextureViews.length));
+      console.log(`mismatched attachment counts on pipeline ${pd.fragment.targets.length} while encoder has ${model.colorTextureViews.length}`);
       console.trace();
     } else {
-      for (var i = 0; i < model.colorTextureViews.length; i++) {
-        var _model$colorTextureVi;
-
-        var fmt = (_model$colorTextureVi = model.colorTextureViews[i].getTexture()) === null || _model$colorTextureVi === void 0 ? void 0 : _model$colorTextureVi.getFormat();
-
+      for (let i = 0; i < model.colorTextureViews.length; i++) {
+        const fmt = model.colorTextureViews[i].getTexture()?.getFormat();
         if (fmt && fmt !== pd.fragment.targets[i].format) {
-          console.log("mismatched attachments for attachment ".concat(i, " on pipeline ").concat(pd.fragment.targets[i].format, " while encoder has ").concat(fmt));
+          console.log(`mismatched attachments for attachment ${i} on pipeline ${pd.fragment.targets[i].format} while encoder has ${fmt}`);
           console.trace();
         }
       }
-    } // check depth buffer
-
+    }
 
+    // check depth buffer
     if (!model.depthTextureView !== !('depthStencil' in pd)) {
       console.log('mismatched depth attachments');
       console.trace();
     } else if (model.depthTextureView) {
-      var _model$depthTextureVi;
-
-      var dfmt = (_model$depthTextureVi = model.depthTextureView.getTexture()) === null || _model$depthTextureVi === void 0 ? void 0 : _model$depthTextureVi.getFormat();
-
+      const dfmt = model.depthTextureView.getTexture()?.getFormat();
       if (dfmt && dfmt !== pd.depthStencil.format) {
-        console.log("mismatched depth attachments on pipeline ".concat(pd.depthStencil.format, " while encoder has ").concat(dfmt));
+        console.log(`mismatched depth attachments on pipeline ${pd.depthStencil.format} while encoder has ${dfmt}`);
         console.trace();
       }
     }
-
     model.boundPipeline = pl;
   };
-
-  publicAPI.replaceShaderCode = function (pipeline) {
+  publicAPI.replaceShaderCode = pipeline => {
     model.replaceShaderCodeFunction(pipeline);
   };
-
-  publicAPI.setColorTextureView = function (idx, view) {
+  publicAPI.setColorTextureView = (idx, view) => {
     if (model.colorTextureViews[idx] === view) {
       return;
     }
-
     model.colorTextureViews[idx] = view;
   };
-
-  publicAPI.activateBindGroup = function (bg) {
-    var device = model.boundPipeline.getDevice();
-    var midx = model.boundPipeline.getBindGroupLayoutCount(bg.getLabel());
-    model.handle.setBindGroup(midx, bg.getBindGroup(device)); // verify bind group layout matches
-
-    var bgl1 = device.getBindGroupLayoutDescription(bg.getBindGroupLayout(device));
-    var bgl2 = device.getBindGroupLayoutDescription(model.boundPipeline.getBindGroupLayout(midx));
-
+  publicAPI.activateBindGroup = bg => {
+    const device = model.boundPipeline.getDevice();
+    const midx = model.boundPipeline.getBindGroupLayoutCount(bg.getLabel());
+    model.handle.setBindGroup(midx, bg.getBindGroup(device));
+    // verify bind group layout matches
+    const bgl1 = device.getBindGroupLayoutDescription(bg.getBindGroupLayout(device));
+    const bgl2 = device.getBindGroupLayoutDescription(model.boundPipeline.getBindGroupLayout(midx));
     if (bgl1 !== bgl2) {
-      console.log("renderEncoder ".concat(model.pipelineHash, " mismatched bind group layouts bind group has\n").concat(bgl1, "\n versus pipeline\n").concat(bgl2, "\n"));
+      console.log(`renderEncoder ${model.pipelineHash} mismatched bind group layouts bind group has\n${bgl1}\n versus pipeline\n${bgl2}\n`);
       console.trace();
     }
   };
-
-  publicAPI.attachTextureViews = function () {
+  publicAPI.attachTextureViews = () => {
     // for each texture create a view if we do not already have one
-    for (var i = 0; i < model.colorTextureViews.length; i++) {
+    for (let i = 0; i < model.colorTextureViews.length; i++) {
       if (!model.description.colorAttachments[i]) {
         model.description.colorAttachments[i] = {
           view: model.colorTextureViews[i].getHandle()
@@ -117,46 +99,38 @@ function vtkWebGPURenderEncoder(publicAPI, model) {
         model.description.colorAttachments[i].view = model.colorTextureViews[i].getHandle();
       }
     }
-
     if (model.depthTextureView) {
       model.description.depthStencilAttachment.view = model.depthTextureView.getHandle();
     }
-  }; // register pipeline callbacks from a mapper
-
+  };
 
-  publicAPI.registerDrawCallback = function (pipeline, cb) {
+  // register pipeline callbacks from a mapper
+  publicAPI.registerDrawCallback = (pipeline, cb) => {
     // if there is a matching pipeline just add the cb
-    for (var i = 0; i < model.drawCallbacks.length; i++) {
+    for (let i = 0; i < model.drawCallbacks.length; i++) {
       if (model.drawCallbacks[i].pipeline === pipeline) {
         model.drawCallbacks[i].callbacks.push(cb);
         return;
       }
     }
-
     model.drawCallbacks.push({
-      pipeline: pipeline,
+      pipeline,
       callbacks: [cb]
     });
-  }; // simple forwarders
-
+  };
 
-  var _loop = function _loop(i) {
+  // simple forwarders
+  for (let i = 0; i < forwarded.length; i++) {
     publicAPI[forwarded[i]] = function () {
-      var _model$handle;
-
-      return (_model$handle = model.handle)[forwarded[i]].apply(_model$handle, arguments);
+      return model.handle[forwarded[i]](...arguments);
     };
-  };
-
-  for (var i = 0; i < forwarded.length; i++) {
-    _loop(i);
   }
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
-
-
-var DEFAULT_VALUES = {
+const DEFAULT_VALUES = {
   description: null,
   handle: null,
   boundPipeline: null,
@@ -165,12 +139,14 @@ var DEFAULT_VALUES = {
   replaceShaderCodeFunction: null,
   depthTextureView: null,
   label: 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.description = {
     colorAttachments: [{
@@ -184,17 +160,18 @@ function extend(publicAPI, model) {
       depthClearValue: 0.0,
       depthStoreOp: 'store'
     }
-  }; // default shader code just writes out the computedColor
+  };
 
-  model.replaceShaderCodeFunction = function (pipeline) {
-    var fDesc = pipeline.getShaderDescription('fragment');
+  // default shader code just writes out the computedColor
+  model.replaceShaderCodeFunction = pipeline => {
+    const fDesc = pipeline.getShaderDescription('fragment');
     fDesc.addOutput('vec4<f32>', 'outColor');
-    var code = fDesc.getCode();
+    let code = fDesc.getCode();
     code = vtkWebGPUShaderCache.substitute(code, '//VTK::RenderEncoder::Impl', ['output.outColor = computedColor;']).result;
     fDesc.setCode(code);
-  }; // default pipeline settings
-
+  };
 
+  // default pipeline settings
   model.pipelineSettings = {
     primitive: {
       cullMode: 'none'
@@ -222,17 +199,20 @@ function extend(publicAPI, model) {
   };
   model.colorTextureViews = [];
   get(publicAPI, model, ['boundPipeline', 'colorTextureViews']);
-  setGet(publicAPI, model, ['depthTextureView', 'description', 'handle', 'label', 'pipelineHash', 'pipelineSettings', 'replaceShaderCodeFunction']); // For more macro methods, see "Sources/macros.js"
-  // Object specific methods
+  setGet(publicAPI, model, ['depthTextureView', 'description', 'handle', 'label', 'pipelineHash', 'pipelineSettings', 'replaceShaderCodeFunction']);
 
+  // For more macro methods, see "Sources/macros.js"
+  // Object specific methods
   vtkWebGPURenderEncoder(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
 
-var newInstance = newInstance$1(extend, 'vtkWebGPURenderEncoder'); // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+const newInstance = newInstance$1(extend, 'vtkWebGPURenderEncoder');
 
+// ----------------------------------------------------------------------------
 var vtkWebGPURenderEncoder$1 = {
-  newInstance: newInstance,
-  extend: extend
+  newInstance,
+  extend
 };
 
 export { vtkWebGPURenderEncoder$1 as default, extend, newInstance };