@kitware/vtk.js 28.10.2 → 28.11.1

package/Rendering/WebGPU/Actor2D.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 vtkWebGPUActor2D(publicAPI, model) {
   // Set our className
-  model.classHierarchy.push('vtkWebGPUActor2D'); // Builds myself.
+  model.classHierarchy.push('vtkWebGPUActor2D');
 
-  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,59 +65,59 @@ function vtkWebGPUActor2D(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()) {
       // compute the net shift, only apply stabilized coords with world coordinates
       model.bufferShift[0] = 0.0;
       model.bufferShift[1] = 0.0;
       model.bufferShift[2] = 0.0;
-      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.identity(model.keyMatrices.bcwc);
-      mat4.identity(model.keyMatrices.normalMatrix); // only meed the buffer shift to get to world
+      mat4.identity(model.keyMatrices.normalMatrix);
 
-      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 meed 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, {
@@ -134,18 +129,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
   vtkWebGPUActor2D(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('vtkActor2D', newInstance);
 
 export { index as default, extend, newInstance };

package/Rendering/WebGPU/BindGroup.js

@@ -1,103 +1,92 @@
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.js';
 
+// ----------------------------------------------------------------------------
 // vtkWebGPUBindGroup methods
 // ----------------------------------------------------------------------------
 
 function vtkWebGPUBindGroup(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkWebGPUBindGroup');
-
-  publicAPI.setBindables = function (bindables) {
+  publicAPI.setBindables = bindables => {
     // is there a difference between the old and new list?
     if (model.bindables.length === bindables.length) {
-      var allMatch = true;
-
-      for (var i = 0; i < model.bindables.length; i++) {
+      let allMatch = true;
+      for (let i = 0; i < model.bindables.length; i++) {
         if (model.bindables[i] !== bindables[i]) {
           allMatch = false;
         }
       }
-
       if (allMatch) {
         return;
       }
-    } // there is a difference
-
+    }
 
+    // there is a difference
     model.bindables = bindables;
     publicAPI.modified();
   };
-
-  publicAPI.getBindGroupLayout = function (device) {
-    var entries = [];
-
-    for (var i = 0; i < model.bindables.length; i++) {
-      var entry = model.bindables[i].getBindGroupLayoutEntry();
+  publicAPI.getBindGroupLayout = device => {
+    const entries = [];
+    for (let i = 0; i < model.bindables.length; i++) {
+      const entry = model.bindables[i].getBindGroupLayoutEntry();
       entry.binding = i;
       entries.push(entry);
     }
-
     return device.getBindGroupLayout({
-      entries: entries
+      entries
     });
   };
-
-  publicAPI.getBindGroup = function (device) {
+  publicAPI.getBindGroup = device => {
     // check mtime
-    var mtime = publicAPI.getMTime();
-
-    for (var i = 0; i < model.bindables.length; i++) {
-      var tm = model.bindables[i].getBindGroupTime().getMTime();
+    let mtime = publicAPI.getMTime();
+    for (let i = 0; i < model.bindables.length; i++) {
+      const tm = model.bindables[i].getBindGroupTime().getMTime();
       mtime = tm > mtime ? tm : mtime;
     }
-
     if (mtime < model.bindGroupTime.getMTime()) {
       return model.bindGroup;
     }
-
-    var entries = [];
-
-    for (var _i = 0; _i < model.bindables.length; _i++) {
-      var entry = model.bindables[_i].getBindGroupEntry();
-
-      entry.binding = _i;
+    const entries = [];
+    for (let i = 0; i < model.bindables.length; i++) {
+      const entry = model.bindables[i].getBindGroupEntry();
+      entry.binding = i;
       entries.push(entry);
     }
-
     model.bindGroup = device.getHandle().createBindGroup({
       layout: publicAPI.getBindGroupLayout(device),
-      entries: entries,
+      entries,
       label: model.label
     });
     model.bindGroupTime.modified();
     return model.bindGroup;
   };
-
-  publicAPI.getShaderCode = function (pipeline) {
-    var lines = [];
-    var bgroup = pipeline.getBindGroupLayoutCount(model.label);
-
-    for (var i = 0; i < model.bindables.length; i++) {
+  publicAPI.getShaderCode = pipeline => {
+    const lines = [];
+    const bgroup = pipeline.getBindGroupLayoutCount(model.label);
+    for (let i = 0; i < model.bindables.length; i++) {
       lines.push(model.bindables[i].getShaderCode(i, bgroup));
     }
-
     return lines.join('\n');
   };
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
-
-var DEFAULT_VALUES = {
+const DEFAULT_VALUES = {
   device: null,
   handle: null,
   label: 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.bindables = [];
   model.bindGroupTime = {};
@@ -107,13 +96,17 @@ function extend(publicAPI, model) {
   macro.get(publicAPI, model, ['bindGroupTime', 'handle', 'sizeInBytes', 'usage']);
   macro.setGet(publicAPI, model, ['label', 'device', 'arrayInformation']);
   vtkWebGPUBindGroup(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
 
-var newInstance = macro.newInstance(extend); // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+
+const newInstance = macro.newInstance(extend);
+
+// ----------------------------------------------------------------------------
 
 var vtkWebGPUBindGroup$1 = {
-  newInstance: newInstance,
-  extend: extend
+  newInstance,
+  extend
 };
 
 export { vtkWebGPUBindGroup$1 as default, extend, newInstance };

package/Rendering/WebGPU/Buffer.js

@@ -1,89 +1,72 @@
-import _defineProperty from '@babel/runtime/helpers/defineProperty';
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.js';
 import Constants from './BufferManager/Constants.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; }
-
-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 forwarded = ['getMappedRange', 'mapAsync', 'unmap'];
-
+// methods we forward to the handle
+const forwarded = ['getMappedRange', 'mapAsync', 'unmap'];
 function bufferSubData(device, destBuffer, destOffset, srcArrayBuffer) {
-  var byteCount = srcArrayBuffer.byteLength;
-  var srcBuffer = device.createBuffer({
+  const byteCount = srcArrayBuffer.byteLength;
+  const srcBuffer = device.createBuffer({
     size: byteCount,
-
     /* eslint-disable no-undef */
     usage: GPUBufferUsage.COPY_SRC,
-
     /* eslint-enable no-undef */
     mappedAtCreation: true
   });
-  var arrayBuffer = srcBuffer.getMappedRange(0, byteCount);
+  const arrayBuffer = srcBuffer.getMappedRange(0, byteCount);
   new Uint8Array(arrayBuffer).set(new Uint8Array(srcArrayBuffer)); // memcpy
-
   srcBuffer.unmap();
-  var encoder = device.createCommandEncoder();
+  const encoder = device.createCommandEncoder();
   encoder.copyBufferToBuffer(srcBuffer, 0, destBuffer, destOffset, byteCount);
-  var commandBuffer = encoder.finish();
-  var queue = device.queue;
+  const commandBuffer = encoder.finish();
+  const queue = device.queue;
   queue.submit([commandBuffer]);
   srcBuffer.destroy();
-} // ----------------------------------------------------------------------------
+}
+// ----------------------------------------------------------------------------
 // vtkWebGPUBufferManager methods
 // ----------------------------------------------------------------------------
 
-
 function vtkWebGPUBuffer(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkWebGPUBuffer');
-
-  publicAPI.create = function (sizeInBytes, usage) {
+  publicAPI.create = (sizeInBytes, usage) => {
     model.handle = model.device.getHandle().createBuffer({
       size: sizeInBytes,
-      usage: usage,
+      usage,
       label: model.label
     });
     model.sizeInBytes = sizeInBytes;
     model.usage = usage;
   };
-
-  publicAPI.write = function (data) {
+  publicAPI.write = data => {
     bufferSubData(model.device.getHandle(), model.handle, 0, data.buffer);
   };
-
-  publicAPI.createAndWrite = function (data, usage) {
+  publicAPI.createAndWrite = (data, usage) => {
     model.handle = model.device.getHandle().createBuffer({
       size: data.byteLength,
-      usage: usage,
+      usage,
       mappedAtCreation: true,
       label: model.label
     });
     model.sizeInBytes = data.byteLength;
     model.usage = usage;
     new Uint8Array(model.handle.getMappedRange()).set(new Uint8Array(data.buffer)); // memcpy
-
     model.handle.unmap();
-  }; // 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 = {
   device: null,
   handle: null,
   sizeInBytes: 0,
@@ -92,23 +75,31 @@ var DEFAULT_VALUES = {
   usage: null,
   label: null,
   sourceTime: 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);
   macro.get(publicAPI, model, ['handle', 'sizeInBytes', 'usage']);
   macro.setGet(publicAPI, model, ['strideInBytes', 'device', 'arrayInformation', 'label', 'sourceTime']);
   vtkWebGPUBuffer(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
+
+const newInstance = macro.newInstance(extend);
 
-var newInstance = macro.newInstance(extend); // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
 
-var vtkWebGPUBuffer$1 = _objectSpread({
-  newInstance: newInstance,
-  extend: extend
-}, Constants);
+var vtkWebGPUBuffer$1 = {
+  newInstance,
+  extend,
+  ...Constants
+};
 
 export { vtkWebGPUBuffer$1 as default, extend, newInstance };

package/Rendering/WebGPU/BufferManager/Constants.js

@@ -1,4 +1,4 @@
-var BufferUsage = {
+const BufferUsage = {
   Verts: 0,
   Lines: 1,
   Triangles: 2,
@@ -14,7 +14,7 @@ var BufferUsage = {
   Storage: 12,
   Index: 13
 };
-var PrimitiveTypes = {
+const PrimitiveTypes = {
   Start: 0,
   Points: 0,
   Lines: 1,
@@ -25,8 +25,8 @@ var PrimitiveTypes = {
   End: 6
 };
 var Constants = {
-  BufferUsage: BufferUsage,
-  PrimitiveTypes: PrimitiveTypes
+  BufferUsage,
+  PrimitiveTypes
 };
 
 export { BufferUsage, PrimitiveTypes, Constants as default };