@kitware/vtk.js 28.10.2 → 28.11.0

package/Rendering/WebGPU/Texture.js

@@ -1,13 +1,18 @@
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.js';
 import HalfFloat from '../../Common/Core/HalfFloat.js';
 import vtkWebGPUBufferManager from './BufferManager.js';
 import vtkWebGPUTextureView from './TextureView.js';
 import vtkWebGPUTypes from './Types.js';
 import vtkTexture from '../Core/Texture.js';
 
-var BufferUsage = vtkWebGPUBufferManager.BufferUsage; // ----------------------------------------------------------------------------
+const {
+  BufferUsage
+} = vtkWebGPUBufferManager;
+
+// ----------------------------------------------------------------------------
 // Global methods
 // ----------------------------------------------------------------------------
+
 // ----------------------------------------------------------------------------
 // vtkWebGPUTexture methods
 // ----------------------------------------------------------------------------
@@ -15,36 +20,30 @@ var BufferUsage = vtkWebGPUBufferManager.BufferUsage; // -----------------------
 function vtkWebGPUTexture(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkWebGPUTexture');
-
-  publicAPI.create = function (device, options) {
+  publicAPI.create = (device, options) => {
     model.device = device;
     model.width = options.width;
     model.height = options.height;
     model.depth = options.depth ? options.depth : 1;
-    var dimension = model.depth === 1 ? '2d' : '3d';
+    const dimension = model.depth === 1 ? '2d' : '3d';
     model.format = options.format ? options.format : 'rgba8unorm';
     model.mipLevel = options.mipLevel ? options.mipLevel : 0;
     /* eslint-disable no-undef */
-
     /* eslint-disable no-bitwise */
-
     model.usage = options.usage ? options.usage : GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_DST;
     /* eslint-enable no-undef */
-
     /* eslint-enable no-bitwise */
-
     model.handle = model.device.getHandle().createTexture({
       size: [model.width, model.height, model.depth],
       format: model.format,
       // 'rgba8unorm',
       usage: model.usage,
       label: model.label,
-      dimension: dimension,
+      dimension,
       mipLevelCount: model.mipLevel + 1
     });
   };
-
-  publicAPI.assignFromHandle = function (device, handle, options) {
+  publicAPI.assignFromHandle = (device, handle, options) => {
     model.device = device;
     model.handle = handle;
     model.width = options.width;
@@ -52,18 +51,14 @@ function vtkWebGPUTexture(publicAPI, model) {
     model.depth = options.depth ? options.depth : 1;
     model.format = options.format ? options.format : 'rgba8unorm';
     /* eslint-disable no-undef */
-
     /* eslint-disable no-bitwise */
-
     model.usage = options.usage ? options.usage : GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_DST;
     /* eslint-enable no-undef */
-
     /* eslint-enable no-bitwise */
   };
 
-  publicAPI.writeImageData = function (req) {
-    var nativeArray = [];
-
+  publicAPI.writeImageData = req => {
+    let nativeArray = [];
     if (req.canvas) {
       model.device.getHandle().queue.copyExternalImageToTexture({
         source: req.canvas,
@@ -75,7 +70,6 @@ function vtkWebGPUTexture(publicAPI, model) {
       model.ready = true;
       return;
     }
-
     if (req.jsImageData && !req.nativeArray) {
       req.width = req.jsImageData.width;
       req.height = req.jsImageData.height;
@@ -84,79 +78,70 @@ function vtkWebGPUTexture(publicAPI, model) {
       req.flip = true;
       req.nativeArray = req.jsImageData.data;
     }
-
-    var tDetails = vtkWebGPUTypes.getDetailsFromTextureFormat(model.format);
-    var bufferBytesPerRow = model.width * tDetails.stride;
-
-    var fixAll = function fixAll(arr, height, depth) {
+    const tDetails = vtkWebGPUTypes.getDetailsFromTextureFormat(model.format);
+    let bufferBytesPerRow = model.width * tDetails.stride;
+    const fixAll = (arr, height, depth) => {
       // bytesPerRow must be a multiple of 256 so we might need to rebuild
       // the data here before passing to the buffer. e.g. if it is unorm8x4 then
       // we need to have width be a multiple of 64
-      var inWidthInBytes = arr.length / (height * depth) * arr.BYTES_PER_ELEMENT; // is this a half float texture?
+      const inWidthInBytes = arr.length / (height * depth) * arr.BYTES_PER_ELEMENT;
 
-      var halfFloat = tDetails.elementSize === 2 && tDetails.sampleType === 'float'; // if we need to copy the data
+      // is this a half float texture?
+      const halfFloat = tDetails.elementSize === 2 && tDetails.sampleType === 'float';
 
+      // if we need to copy the data
       if (halfFloat || inWidthInBytes % 256) {
-        var inArray = arr;
-        var inWidth = inWidthInBytes / inArray.BYTES_PER_ELEMENT;
-        var outBytesPerElement = tDetails.elementSize;
-        var outWidthInBytes = 256 * Math.floor((inWidth * outBytesPerElement + 255) / 256);
-        var outWidth = outWidthInBytes / outBytesPerElement;
-        var outArray = macro.newTypedArray(halfFloat ? 'Uint16Array' : inArray.constructor.name, outWidth * height * depth);
-
-        for (var v = 0; v < height * depth; v++) {
+        const inArray = arr;
+        const inWidth = inWidthInBytes / inArray.BYTES_PER_ELEMENT;
+        const outBytesPerElement = tDetails.elementSize;
+        const outWidthInBytes = 256 * Math.floor((inWidth * outBytesPerElement + 255) / 256);
+        const outWidth = outWidthInBytes / outBytesPerElement;
+        const outArray = macro.newTypedArray(halfFloat ? 'Uint16Array' : inArray.constructor.name, outWidth * height * depth);
+        for (let v = 0; v < height * depth; v++) {
           if (halfFloat) {
-            for (var i = 0; i < inWidth; i++) {
+            for (let i = 0; i < inWidth; i++) {
               outArray[v * outWidth + i] = HalfFloat.toHalf(inArray[v * inWidth + i]);
             }
           } else {
             outArray.set(inArray.subarray(v * inWidth, (v + 1) * inWidth), v * outWidth);
           }
         }
-
         return [outArray, outWidthInBytes];
       }
-
       return [arr, inWidthInBytes];
     };
-
     if (req.nativeArray) {
       nativeArray = req.nativeArray;
     }
-
     if (req.image) {
-      var canvas = document.createElement('canvas');
+      const canvas = document.createElement('canvas');
       canvas.width = req.image.width;
       canvas.height = req.image.height;
-      var ctx = canvas.getContext('2d');
+      const ctx = canvas.getContext('2d');
       ctx.translate(0, canvas.height);
       ctx.scale(1, -1);
       ctx.drawImage(req.image, 0, 0, req.image.width, req.image.height, 0, 0, canvas.width, canvas.height);
-      var imageData = ctx.getImageData(0, 0, req.image.width, req.image.height);
+      const imageData = ctx.getImageData(0, 0, req.image.width, req.image.height);
       nativeArray = imageData.data;
     }
-
-    var cmdEnc = model.device.createCommandEncoder();
-
+    const cmdEnc = model.device.createCommandEncoder();
     if (publicAPI.getDimensionality() !== 3) {
       // Non-3D, supports mipmaps
-      var mips = vtkTexture.generateMipmaps(nativeArray, model.width, model.height, model.mipLevel);
-      var currentWidth = model.width;
-      var currentHeight = model.height;
-
-      for (var m = 0; m <= model.mipLevel; m++) {
-        var fix = fixAll(mips[m], currentHeight, 1);
+      const mips = vtkTexture.generateMipmaps(nativeArray, model.width, model.height, model.mipLevel);
+      let currentWidth = model.width;
+      let currentHeight = model.height;
+      for (let m = 0; m <= model.mipLevel; m++) {
+        const fix = fixAll(mips[m], currentHeight, 1);
         bufferBytesPerRow = fix[1];
-        var buffRequest = {
+        const buffRequest = {
           dataArray: req.dataArray ? req.dataArray : null,
           nativeArray: fix[0],
-
           /* eslint-disable no-undef */
           usage: BufferUsage.Texture
           /* eslint-enable no-undef */
-
         };
-        var buff = model.device.getBufferManager().getBuffer(buffRequest);
+
+        const buff = model.device.getBufferManager().getBuffer(buffRequest);
         cmdEnc.copyBufferToTexture({
           buffer: buff.getHandle(),
           offset: 0,
@@ -169,28 +154,23 @@ function vtkWebGPUTexture(publicAPI, model) {
         currentWidth /= 2;
         currentHeight /= 2;
       }
-
       model.device.submitCommandEncoder(cmdEnc);
       model.ready = true;
     } else {
       // 3D, no mipmaps
-      var _fix = fixAll(nativeArray, model.height, model.depth);
-
-      bufferBytesPerRow = _fix[1];
-      var _buffRequest = {
+      const fix = fixAll(nativeArray, model.height, model.depth);
+      bufferBytesPerRow = fix[1];
+      const buffRequest = {
         dataArray: req.dataArray ? req.dataArray : null,
-
         /* eslint-disable no-undef */
         usage: BufferUsage.Texture
         /* eslint-enable no-undef */
-
       };
-      _buffRequest.nativeArray = _fix[0];
-
-      var _buff = model.device.getBufferManager().getBuffer(_buffRequest);
 
+      buffRequest.nativeArray = fix[0];
+      const buff = model.device.getBufferManager().getBuffer(buffRequest);
       cmdEnc.copyBufferToTexture({
-        buffer: _buff.getHandle(),
+        buffer: buff.getHandle(),
         offset: 0,
         bytesPerRow: bufferBytesPerRow,
         rowsPerImage: model.height
@@ -200,31 +180,28 @@ function vtkWebGPUTexture(publicAPI, model) {
       model.device.submitCommandEncoder(cmdEnc);
       model.ready = true;
     }
-  }; // when data is pulled out of this texture what scale must be applied to
+  };
+
+  // when data is pulled out of this texture what scale must be applied to
   // get back to the original source data. For formats such as r8unorm we
   // have to multiply by 255.0, for formats such as r16float it is 1.0
-
-
-  publicAPI.getScale = function () {
-    var tDetails = vtkWebGPUTypes.getDetailsFromTextureFormat(model.format);
-    var halfFloat = tDetails.elementSize === 2 && tDetails.sampleType === 'float';
+  publicAPI.getScale = () => {
+    const tDetails = vtkWebGPUTypes.getDetailsFromTextureFormat(model.format);
+    const halfFloat = tDetails.elementSize === 2 && tDetails.sampleType === 'float';
     return halfFloat ? 1.0 : 255.0;
   };
-
-  publicAPI.getNumberOfComponents = function () {
-    var tDetails = vtkWebGPUTypes.getDetailsFromTextureFormat(model.format);
+  publicAPI.getNumberOfComponents = () => {
+    const tDetails = vtkWebGPUTypes.getDetailsFromTextureFormat(model.format);
     return tDetails.numComponents;
   };
-
-  publicAPI.getDimensionality = function () {
-    var dims = 0;
+  publicAPI.getDimensionality = () => {
+    let dims = 0;
     if (model.width > 1) dims++;
     if (model.height > 1) dims++;
     if (model.depth > 1) dims++;
     return dims;
   };
-
-  publicAPI.resizeToMatch = function (tex) {
+  publicAPI.resizeToMatch = tex => {
     if (tex.getWidth() !== model.width || tex.getHeight() !== model.height || tex.getDepth() !== model.depth) {
       model.width = tex.getWidth();
       model.height = tex.getHeight();
@@ -237,10 +214,8 @@ function vtkWebGPUTexture(publicAPI, model) {
       });
     }
   };
-
   publicAPI.resize = function (width, height) {
-    var depth = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 1;
-
+    let depth = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 1;
     if (width !== model.width || height !== model.height || depth !== model.depth) {
       model.width = width;
       model.height = height;
@@ -253,49 +228,54 @@ function vtkWebGPUTexture(publicAPI, model) {
       });
     }
   };
-
   publicAPI.createView = function (label) {
-    var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-
+    let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
     // if options is missing values try to add them in
     if (!options.dimension) {
       options.dimension = model.depth === 1 ? '2d' : '3d';
     }
-
-    var view = vtkWebGPUTextureView.newInstance({
-      label: label
+    const view = vtkWebGPUTextureView.newInstance({
+      label
     });
     view.create(publicAPI, options);
     return view;
   };
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
-
-var DEFAULT_VALUES = {
+const DEFAULT_VALUES = {
   device: null,
   handle: null,
   buffer: null,
   ready: false,
   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);
   macro.get(publicAPI, model, ['handle', 'ready', 'width', 'height', 'depth', 'format', 'usage']);
   macro.setGet(publicAPI, model, ['device', 'label']);
   vtkWebGPUTexture(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
+
+const newInstance = macro.newInstance(extend);
 
-var newInstance = macro.newInstance(extend); // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
 
 var vtkWebGPUTexture$1 = {
-  newInstance: newInstance,
-  extend: extend
+  newInstance,
+  extend
 };
 
 export { vtkWebGPUTexture$1 as default, extend, newInstance };

package/Rendering/WebGPU/TextureManager.js

@@ -1,55 +1,56 @@
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.js';
 import vtkDataArray from '../../Common/Core/DataArray.js';
 import vtkWebGPUTexture from './Texture.js';
 
-var VtkDataTypes = vtkDataArray.VtkDataTypes; // ----------------------------------------------------------------------------
+const {
+  VtkDataTypes
+} = vtkDataArray;
+
+// ----------------------------------------------------------------------------
 // Global methods
 // ----------------------------------------------------------------------------
+
 // ----------------------------------------------------------------------------
 // vtkWebGPUTextureManager methods
 // ----------------------------------------------------------------------------
 
 function vtkWebGPUTextureManager(publicAPI, model) {
   // Set our className
-  model.classHierarchy.push('vtkWebGPUTextureManager'); // fills in request values based on what is missing/provided
+  model.classHierarchy.push('vtkWebGPUTextureManager');
 
+  // fills in request values based on what is missing/provided
   function _fillRequest(req) {
     // fill in values based on imageData if the request has it
     if (req.imageData) {
       req.dataArray = req.imageData.getPointData().getScalars();
       req.time = req.dataArray.getMTime();
       req.nativeArray = req.dataArray.getData();
-      var dims = req.imageData.getDimensions();
+      const dims = req.imageData.getDimensions();
       req.width = dims[0];
       req.height = dims[1];
       req.depth = dims[2];
-      var numComp = req.dataArray.getNumberOfComponents(); // todo fix handling of 3 component
-
+      const numComp = req.dataArray.getNumberOfComponents();
+      // todo fix handling of 3 component
       switch (numComp) {
         case 1:
           req.format = 'r';
           break;
-
         case 2:
           req.format = 'rg';
           break;
-
         case 3:
         case 4:
         default:
           req.format = 'rgba';
           break;
       }
-
-      var dataType = req.dataArray.getDataType();
-
+      const dataType = req.dataArray.getDataType();
       switch (dataType) {
         case VtkDataTypes.UNSIGNED_CHAR:
           req.format += '8unorm';
           break;
         // todo extend to other types that are not filterable
         // as they can be useful
-
         case VtkDataTypes.FLOAT:
         case VtkDataTypes.UNSIGNED_INT:
         case VtkDataTypes.INT:
@@ -60,17 +61,17 @@ function vtkWebGPUTextureManager(publicAPI, model) {
           req.format += '16float';
           break;
       }
-    } // fill in values based on image if the request has it
-
+    }
 
+    // fill in values based on image if the request has it
     if (req.image) {
       req.width = req.image.width;
       req.height = req.image.height;
       req.depth = 1;
       req.format = 'rgba8unorm';
-    } // fill in based on js imageData
-
+    }
 
+    // fill in based on js imageData
     if (req.jsImageData) {
       req.width = req.jsImageData.width;
       req.height = req.jsImageData.height;
@@ -79,7 +80,6 @@ function vtkWebGPUTextureManager(publicAPI, model) {
       req.flip = true;
       req.nativeArray = req.jsImageData.data;
     }
-
     if (req.canvas) {
       req.width = req.canvas.width;
       req.height = req.canvas.height;
@@ -87,19 +87,16 @@ function vtkWebGPUTextureManager(publicAPI, model) {
       req.format = 'rgba8unorm';
       req.flip = true;
       /* eslint-disable no-undef */
-
       /* eslint-disable no-bitwise */
-
       req.usage = GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT;
       /* eslint-enable no-undef */
-
       /* eslint-enable no-bitwise */
     }
-  } // create a texture (used by getTexture)
-
+  }
 
+  // create a texture (used by getTexture)
   function _createTexture(req) {
-    var newTex = vtkWebGPUTexture.newInstance();
+    const newTex = vtkWebGPUTexture.newInstance();
     newTex.create(model.device, {
       width: req.width,
       height: req.height,
@@ -107,44 +104,39 @@ function vtkWebGPUTextureManager(publicAPI, model) {
       format: req.format,
       usage: req.usage,
       mipLevel: req.mipLevel
-    }); // fill the texture if we have data
+    });
 
+    // fill the texture if we have data
     if (req.nativeArray || req.image || req.canvas) {
       newTex.writeImageData(req);
     }
-
     return newTex;
-  } // get a texture or create it if not cached.
-  // this is the main entry point
-
+  }
 
-  publicAPI.getTexture = function (req) {
+  // get a texture or create it if not cached.
+  // this is the main entry point
+  publicAPI.getTexture = req => {
     // if we have a source the get/create/cache the texture
     if (req.hash) {
       // if a matching texture already exists then return it
       return model.device.getCachedObject(req.hash, _createTexture, req);
     }
-
     return _createTexture(req);
   };
-
-  publicAPI.getTextureForImageData = function (imgData) {
-    var treq = {
+  publicAPI.getTextureForImageData = imgData => {
+    const treq = {
       time: imgData.getMTime()
     };
-    treq.imageData = imgData; // fill out the req time and format based on imageData/image
-
+    treq.imageData = imgData;
+    // fill out the req time and format based on imageData/image
     _fillRequest(treq);
-
     treq.hash = treq.time + treq.format + treq.mipLevel;
     return model.device.getTextureManager().getTexture(treq);
   };
-
-  publicAPI.getTextureForVTKTexture = function (srcTexture) {
-    var treq = {
+  publicAPI.getTextureForVTKTexture = srcTexture => {
+    const treq = {
       time: srcTexture.getMTime()
     };
-
     if (srcTexture.getInputData()) {
       treq.imageData = srcTexture.getInputData();
     } else if (srcTexture.getImage()) {
@@ -153,39 +145,45 @@ function vtkWebGPUTextureManager(publicAPI, model) {
       treq.jsImageData = srcTexture.getJsImageData();
     } else if (srcTexture.getCanvas()) {
       treq.canvas = srcTexture.getCanvas();
-    } // fill out the req time and format based on imageData/image
-
-
+    }
+    // fill out the req time and format based on imageData/image
     _fillRequest(treq);
-
     treq.mipLevel = srcTexture.getMipLevel();
     treq.hash = treq.time + treq.format + treq.mipLevel;
     return model.device.getTextureManager().getTexture(treq);
   };
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
-
-var DEFAULT_VALUES = {
+const DEFAULT_VALUES = {
   handle: null,
   device: 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.setGet(publicAPI, model, ['device']);
   vtkWebGPUTextureManager(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 
-var newInstance = macro.newInstance(extend); // ----------------------------------------------------------------------------
+const newInstance = macro.newInstance(extend);
+
+// ----------------------------------------------------------------------------
 
 var vtkWebGPUTextureManager$1 = {
-  newInstance: newInstance,
-  extend: extend
+  newInstance,
+  extend
 };
 
 export { vtkWebGPUTextureManager$1 as default, extend, newInstance };