@kitware/vtk.js 28.10.2 → 28.11.0

package/Rendering/WebGPU/TextureView.js

@@ -1,7 +1,8 @@
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.js';
 import vtkWebGPUSampler from './Sampler.js';
 import vtkWebGPUTypes from './Types.js';
 
+// ----------------------------------------------------------------------------
 // vtkWebGPUTextureView methods
 // ----------------------------------------------------------------------------
 
@@ -10,8 +11,7 @@ import vtkWebGPUTypes from './Types.js';
 function vtkWebGPUTextureView(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkWebGPUTextureView');
-
-  publicAPI.create = function (texture, options) {
+  publicAPI.create = (texture, options) => {
     model.texture = texture;
     model.options = options;
     model.options.dimension = model.options.dimension || '2d';
@@ -19,11 +19,10 @@ function vtkWebGPUTextureView(publicAPI, model) {
     model.textureHandle = texture.getHandle();
     model.handle = model.textureHandle.createView(model.options);
     model.bindGroupLayoutEntry.texture.viewDimension = model.options.dimension;
-    var tDetails = vtkWebGPUTypes.getDetailsFromTextureFormat(model.texture.getFormat());
+    const tDetails = vtkWebGPUTypes.getDetailsFromTextureFormat(model.texture.getFormat());
     model.bindGroupLayoutEntry.texture.sampleType = tDetails.sampleType;
   };
-
-  publicAPI.createFromTextureHandle = function (textureHandle, options) {
+  publicAPI.createFromTextureHandle = (textureHandle, options) => {
     model.texture = null;
     model.options = options;
     model.options.dimension = model.options.dimension || '2d';
@@ -31,93 +30,87 @@ function vtkWebGPUTextureView(publicAPI, model) {
     model.textureHandle = textureHandle;
     model.handle = model.textureHandle.createView(model.options);
     model.bindGroupLayoutEntry.texture.viewDimension = model.options.dimension;
-    var tDetails = vtkWebGPUTypes.getDetailsFromTextureFormat(options.format);
+    const tDetails = vtkWebGPUTypes.getDetailsFromTextureFormat(options.format);
     model.bindGroupLayoutEntry.texture.sampleType = tDetails.sampleType;
     model.bindGroupTime.modified();
   };
-
-  publicAPI.getBindGroupEntry = function () {
-    var foo = {
+  publicAPI.getBindGroupEntry = () => {
+    const foo = {
       resource: publicAPI.getHandle()
     };
     return foo;
   };
-
-  publicAPI.getShaderCode = function (binding, group) {
-    var ttype = 'f32';
-
+  publicAPI.getShaderCode = (binding, group) => {
+    let ttype = 'f32';
     if (model.bindGroupLayoutEntry.texture.sampleType === 'sint') {
       ttype = 'i32';
     } else if (model.bindGroupLayoutEntry.texture.sampleType === 'uint') {
       ttype = 'u32';
     }
-
-    var result = "@binding(".concat(binding, ") @group(").concat(group, ") var ").concat(model.label, ": texture_").concat(model.options.dimension, "<").concat(ttype, ">;");
-
+    let result = `@binding(${binding}) @group(${group}) var ${model.label}: texture_${model.options.dimension}<${ttype}>;`;
     if (model.bindGroupLayoutEntry.texture.sampleType === 'depth') {
-      result = "@binding(".concat(binding, ") @group(").concat(group, ") var ").concat(model.label, ": texture_depth_").concat(model.options.dimension, ";");
+      result = `@binding(${binding}) @group(${group}) var ${model.label}: texture_depth_${model.options.dimension};`;
     }
-
     return result;
   };
-
-  publicAPI.addSampler = function (device, options) {
-    var newSamp = vtkWebGPUSampler.newInstance({
-      label: "".concat(model.label, "Sampler")
+  publicAPI.addSampler = (device, options) => {
+    const newSamp = vtkWebGPUSampler.newInstance({
+      label: `${model.label}Sampler`
     });
     newSamp.create(device, options);
     publicAPI.setSampler(newSamp);
   };
-
-  publicAPI.getBindGroupTime = function () {
+  publicAPI.getBindGroupTime = () => {
     // check if the handle changed
     if (model.texture && model.texture.getHandle() !== model.textureHandle) {
       model.textureHandle = model.texture.getHandle();
       model.handle = model.textureHandle.createView(model.options);
       model.bindGroupTime.modified();
     }
-
     return model.bindGroupTime;
-  }; // if the texture has changed then get a new view
-
+  };
 
-  publicAPI.getHandle = function () {
+  // if the texture has changed then get a new view
+  publicAPI.getHandle = () => {
     if (model.texture && model.texture.getHandle() !== model.textureHandle) {
       model.textureHandle = model.texture.getHandle();
       model.handle = model.textureHandle.createView(model.options);
       model.bindGroupTime.modified();
     }
-
     return model.handle;
   };
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
-
-var DEFAULT_VALUES = {
+const DEFAULT_VALUES = {
   texture: null,
   handle: null,
   sampler: 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.bindGroupLayoutEntry = {
     /* eslint-disable no-undef */
     visibility: GPUShaderStage.VERTEX | GPUShaderStage.FRAGMENT,
-
     /* eslint-enable no-undef */
     texture: {
       sampleType: 'float',
-      viewDimension: '2d' // multisampled: false,
-
+      viewDimension: '2d'
+      // multisampled: false,
     }
   };
+
   model.bindGroupTime = {};
   macro.obj(model.bindGroupTime, {
     mtime: 0
@@ -125,13 +118,17 @@ function extend(publicAPI, model) {
   macro.get(publicAPI, model, ['bindGroupTime', 'texture']);
   macro.setGet(publicAPI, model, ['bindGroupLayoutEntry', 'label', 'sampler']);
   vtkWebGPUTextureView(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
 
-var newInstance = macro.newInstance(extend); // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+
+const newInstance = macro.newInstance(extend);
+
+// ----------------------------------------------------------------------------
 
 var vtkWebGPUTextureView$1 = {
-  newInstance: newInstance,
-  extend: extend
+  newInstance,
+  extend
 };
 
 export { vtkWebGPUTextureView$1 as default, extend, newInstance };

package/Rendering/WebGPU/Types.js

@@ -1,5 +1,6 @@
-import { vtkErrorMacro } from '../../macros.js';
+import { r as vtkErrorMacro } from '../../macros2.js';
 
+// ----------------------------------------------------------------------------
 // vtkWebGPUDevice static functions
 //
 // WebGPU uses types in a many places and calls, and often those types
@@ -10,10 +11,10 @@ import { vtkErrorMacro } from '../../macros.js';
 //  - shader types suchs as vec4<f32>
 //  - texture types such as rgba32float
 // ----------------------------------------------------------------------------
+
 // see https://gpuweb.github.io/gpuweb/#texture-formats
 // for possible formats, there are a lot of them
-
-var textureDetails = {
+const textureDetails = {
   // 8-bit formats
   r8unorm: {
     numComponents: 1,
@@ -305,64 +306,57 @@ var textureDetails = {
     sampleType: 'depth'
   }
 };
-
 function getDetailsFromTextureFormat(format) {
   if (!format || format.length < 6) return 0;
-
   if (format in textureDetails === true) {
     return textureDetails[format];
   }
-
-  vtkErrorMacro("unknown format ".concat(format));
+  vtkErrorMacro(`unknown format ${format}`);
   return null;
-} // see https://gpuweb.github.io/gpuweb/#enumdef-gpuvertexformat
-// for possible formats
-
+}
 
+// see https://gpuweb.github.io/gpuweb/#enumdef-gpuvertexformat
+// for possible formats
 function getByteStrideFromBufferFormat(format) {
-  if (!format || format.length < 5) return 0; // options are x2, x3, x4 or nothing
-
-  var numComp = 1;
+  if (!format || format.length < 5) return 0;
 
+  // options are x2, x3, x4 or nothing
+  let numComp = 1;
   if (format[format.length - 2] === 'x') {
     numComp = Number(format[format.length - 1]);
   }
-
-  var sizeStart = numComp === 1 ? format.length - 1 : format.length - 3; // options are 8, 16, 32 resulting in 8, 6, 2 as the last char
+  const sizeStart = numComp === 1 ? format.length - 1 : format.length - 3;
+  // options are 8, 16, 32 resulting in 8, 6, 2 as the last char
   // plugged into the formula below gives 1, 2, 4 respectively
-
-  var num = Number(format[sizeStart]);
-
+  const num = Number(format[sizeStart]);
   if (Number.isNaN(num)) {
-    vtkErrorMacro("unknown format ".concat(format));
+    vtkErrorMacro(`unknown format ${format}`);
     return 0;
   }
-
-  var typeSize = 5 - num / 2;
+  const typeSize = 5 - num / 2;
   return numComp * typeSize;
-} // see https://gpuweb.github.io/gpuweb/#enumdef-gpuvertexformat
-// for possible formats
-
+}
 
+// see https://gpuweb.github.io/gpuweb/#enumdef-gpuvertexformat
+// for possible formats
 function getNumberOfComponentsFromBufferFormat(format) {
-  if (!format || format.length < 5) return 0; // options are x2, x3, x4 or nothing
-
-  var numComp = 1;
+  if (!format || format.length < 5) return 0;
 
+  // options are x2, x3, x4 or nothing
+  let numComp = 1;
   if (format[format.length - 2] === 'x') {
     numComp = Number(format[format.length - 1]);
   }
-
   return numComp;
-} // see https://gpuweb.github.io/gpuweb/#enumdef-gpuvertexformat
-// for possible formats
-
+}
 
+// see https://gpuweb.github.io/gpuweb/#enumdef-gpuvertexformat
+// for possible formats
 function getNativeTypeFromBufferFormat(format) {
-  if (!format || format.length < 5) return 0; // raw types are Uint Int or Float as follows
-
-  var result;
+  if (!format || format.length < 5) return 0;
 
+  // raw types are Uint Int or Float as follows
+  let result;
   if (format[0] === 'f') {
     result = 'Float';
   } else if (format[0] === 's') {
@@ -370,28 +364,24 @@ function getNativeTypeFromBufferFormat(format) {
   } else if (format[0] === 'u') {
     result = 'Uint';
   } else {
-    vtkErrorMacro("unknown format ".concat(format));
+    vtkErrorMacro(`unknown format ${format}`);
     return undefined;
-  } // options are 8, 16, 32 resulting in 8, 6, 2 as the last char
-  // plugged into the formula below gives 1, 2, 4 respectively
-
-
-  var base = format.split('x')[0];
-  var num = Number(base[base.length - 1]);
+  }
 
+  // options are 8, 16, 32 resulting in 8, 6, 2 as the last char
+  // plugged into the formula below gives 1, 2, 4 respectively
+  const base = format.split('x')[0];
+  const num = Number(base[base.length - 1]);
   if (Number.isNaN(num)) {
-    vtkErrorMacro("unknown format ".concat(format));
+    vtkErrorMacro(`unknown format ${format}`);
     return undefined;
   }
-
   result += 8 * (5 - num / 2);
   result += 'Array';
   return result;
 }
-
 function getShaderTypeFromBufferFormat(format) {
-  var dataType;
-
+  let dataType;
   if (format[0] === 'f' || format[1] === 'n') {
     dataType = 'f32';
   } else if (format[0] === 's' && format[1] === 'i') {
@@ -399,54 +389,47 @@ function getShaderTypeFromBufferFormat(format) {
   } else if (format[0] === 'u' && format[1] === 'i') {
     dataType = 'u32';
   } else {
-    vtkErrorMacro("unknown format ".concat(format));
+    vtkErrorMacro(`unknown format ${format}`);
     return undefined;
-  } // options are x2, x3, x4 or nothing
-
-
-  var numComp = 1;
+  }
 
+  // options are x2, x3, x4 or nothing
+  let numComp = 1;
   if (format[format.length - 2] === 'x') {
     numComp = Number(format[format.length - 1]);
   }
-
-  if (numComp === 4) return "vec4<".concat(dataType, ">");
-  if (numComp === 3) return "vec3<".concat(dataType, ">");
-  if (numComp === 2) return "vec2<".concat(dataType, ">");
+  if (numComp === 4) return `vec4<${dataType}>`;
+  if (numComp === 3) return `vec3<${dataType}>`;
+  if (numComp === 2) return `vec2<${dataType}>`;
   return dataType;
 }
-
 function getByteStrideFromShaderFormat(format) {
   if (!format) return 0;
-  var numComp = 1;
-
+  let numComp = 1;
   if (format.substring(0, 3) === 'vec') {
     numComp = Number(format[3]);
   } else if (format.substring(0, 3) === 'mat') {
     numComp = format[3] * format[5];
   }
-
-  var typeSize = 4;
+  const typeSize = 4;
   return numComp * typeSize;
 }
-
 function getNativeTypeFromShaderFormat(format) {
   if (!format) return undefined;
   if (format.includes('f32')) return 'Float32Array';
   if (format.includes('i32')) return 'Int32Array';
   if (format.includes('u32')) return 'Uint32Array';
-  vtkErrorMacro("unknown format ".concat(format));
+  vtkErrorMacro(`unknown format ${format}`);
   return undefined;
 }
-
 var vtkWebGPUTypes = {
-  getDetailsFromTextureFormat: getDetailsFromTextureFormat,
-  getByteStrideFromBufferFormat: getByteStrideFromBufferFormat,
-  getNumberOfComponentsFromBufferFormat: getNumberOfComponentsFromBufferFormat,
-  getNativeTypeFromBufferFormat: getNativeTypeFromBufferFormat,
-  getShaderTypeFromBufferFormat: getShaderTypeFromBufferFormat,
-  getByteStrideFromShaderFormat: getByteStrideFromShaderFormat,
-  getNativeTypeFromShaderFormat: getNativeTypeFromShaderFormat
+  getDetailsFromTextureFormat,
+  getByteStrideFromBufferFormat,
+  getNumberOfComponentsFromBufferFormat,
+  getNativeTypeFromBufferFormat,
+  getShaderTypeFromBufferFormat,
+  getByteStrideFromShaderFormat,
+  getNativeTypeFromShaderFormat
 };
 
 export { vtkWebGPUTypes as default };