@kitware/vtk.js 33.3.0 → 33.3.2

package/IO/Geometry/GLTFImporter/Decoder.js

@@ -1,65 +1,79 @@
 import BinaryHelper from '../../Core/BinaryHelper.js';
-import { BINARY_HEADER_MAGIC, BINARY_CHUNK_TYPES, BINARY_CHUNK_HEADER_INTS, BINARY_HEADER_LENGTH, BINARY_HEADER_INTS } from './Constants.js';
+import { BINARY_HEADER_LENGTH, BINARY_HEADER_MAGIC, BINARY_CHUNK_TYPES, BINARY_CHUNK_HEADER_INTS, BINARY_HEADER_INTS } from './Constants.js';
 
 function getChunkInfo(headerStart, data) {
+  // Cache array view
   const header = new Uint32Array(data, headerStart, BINARY_CHUNK_HEADER_INTS);
   const chunkStart = headerStart + BINARY_CHUNK_HEADER_INTS * 4;
-  const chunkLength = header[0];
-  const chunkType = header[1];
   return {
     start: chunkStart,
-    length: chunkLength,
-    type: chunkType
+    length: header[0],
+    type: header[1]
   };
 }
 function getAllChunkInfos(data) {
-  const infos = [];
+  // Pre-calculate array size
+  const maxChunks = Math.floor((data.byteLength - BINARY_HEADER_LENGTH) / 8);
+  const infos = new Array(maxChunks);
   let chunkStart = BINARY_HEADER_INTS * 4;
+  let chunkCount = 0;
   while (chunkStart < data.byteLength) {
     const chunkInfo = getChunkInfo(chunkStart, data);
-    infos.push(chunkInfo);
+    infos[chunkCount++] = chunkInfo;
     chunkStart += chunkInfo.length + BINARY_CHUNK_HEADER_INTS * 4;
   }
-  return infos;
+
+  // Trim array to actual size
+  return infos.slice(0, chunkCount);
 }
 function getJsonFromChunk(chunkInfo, data) {
-  const chunkLength = chunkInfo.length;
   const jsonStart = (BINARY_HEADER_INTS + BINARY_CHUNK_HEADER_INTS) * 4;
-  const jsonSlice = new Uint8Array(data, jsonStart, chunkLength);
-  const stringBuffer = BinaryHelper.arrayBufferToString(jsonSlice);
-  return JSON.parse(stringBuffer);
+  const jsonView = new Uint8Array(data, jsonStart, chunkInfo.length);
+  const decoder = new TextDecoder('utf-8');
+  const jsonString = decoder.decode(jsonView);
+  return JSON.parse(jsonString);
 }
 function getBufferFromChunk(chunkInfo, data) {
   return data.slice(chunkInfo.start, chunkInfo.start + chunkInfo.length);
 }
 function parseGLB(data) {
-  let json;
-  const buffers = [];
+  if (data.byteLength < BINARY_HEADER_LENGTH) {
+    throw new Error('Invalid GLB: File too small');
+  }
+
+  // Cache DataView
   const headerView = new DataView(data, 0, BINARY_HEADER_LENGTH);
+  const magic = new Uint8Array(data, 0, 4);
   const header = {
-    magic: BinaryHelper.arrayBufferToString(new Uint8Array(data, 0, 4)),
+    magic: BinaryHelper.arrayBufferToString(magic),
     version: headerView.getUint32(4, true),
     length: headerView.getUint32(8, true)
   };
   if (header.magic !== BINARY_HEADER_MAGIC) {
     throw new Error('Unsupported glTF-Binary header.');
-  } else if (header.version < 2.0) {
+  }
+  if (header.version < 2.0) {
     throw new Error('Unsupported legacy binary file detected.');
   }
+  if (header.length > data.byteLength) {
+    throw new Error('Invalid GLB: Declared length exceeds file size');
+  }
   const chunkInfos = getAllChunkInfos(data);
-  chunkInfos.forEach(chunkInfo => {
+  let json = null;
+  const buffers = [];
+
+  // Process chunks sequentially
+  for (let i = 0; i < chunkInfos.length; i++) {
+    const chunkInfo = chunkInfos[i];
     if (chunkInfo.type === BINARY_CHUNK_TYPES.JSON && !json) {
       json = getJsonFromChunk(chunkInfo, data);
     } else if (chunkInfo.type === BINARY_CHUNK_TYPES.BIN) {
       buffers.push(getBufferFromChunk(chunkInfo, data));
     }
-  });
+  }
   if (!json) {
     throw new Error('glTF-Binary: JSON content not found.');
   }
-  if (!buffers) {
-    throw new Error('glTF-Binary: Binary chunk not found.');
-  }
   return {
     json,
     buffers

package/IO/Geometry/GLTFImporter/Parser.js

@@ -210,15 +210,24 @@ class GLTFParser {
     if (accessor.bufferView) {
       const buffer = accessor.bufferView.buffer;
       const {
-        ArrayType,
-        byteLength
+        ArrayType
       } = getAccessorArrayTypeAndLength(accessor, accessor.bufferView);
-      const byteOffset = (accessor.bufferView.byteOffset || 0) + (accessor.byteOffset || 0) + buffer.byteOffset;
-      let slicedBufffer = buffer.arrayBuffer.slice(byteOffset, byteOffset + byteLength);
+      const baseByteOffset = (accessor.bufferView.byteOffset || 0) + buffer.byteOffset;
+      const byteOffset = baseByteOffset + (accessor.byteOffset || 0);
+      let arrayBufferView;
       if (accessor.bufferView.byteStride) {
-        slicedBufffer = this.getValueFromInterleavedBuffer(buffer, byteOffset, accessor.bufferView.byteStride, accessor.bytesPerElement, accessor.count);
+        // Only extract if stride is not equal to element size
+        if (accessor.bufferView.byteStride === accessor.bytesPerElement) {
+          arrayBufferView = new ArrayType(buffer.arrayBuffer, byteOffset, accessor.count * accessor.components);
+        } else {
+          // Interleaved buffer, extract only needed bytes
+          const interleavedBuffer = this.getValueFromInterleavedBuffer(buffer, byteOffset, accessor.bufferView.byteStride, accessor.bytesPerElement, accessor.count);
+          arrayBufferView = new ArrayType(interleavedBuffer);
+        }
+      } else {
+        arrayBufferView = new ArrayType(buffer.arrayBuffer, byteOffset, accessor.count * accessor.components);
       }
-      accessor.value = new ArrayType(slicedBufffer);
+      accessor.value = arrayBufferView;
     }
     return accessor;
   }

package/IO/Geometry/GLTFImporter/Reader.js

@@ -149,6 +149,7 @@ async function createPolyDataFromGLTFMesh(primitive) {
       polyData.setStrips(cells);
       break;
     default:
+      cells.delete();
       vtkWarningMacro('Invalid primitive draw mode. Ignoring connectivity.');
   }
   return polyData;
@@ -198,15 +199,7 @@ async function createPropertyFromGLTFMaterial(model, material, actor) {
       const sampler = tex.sampler;
       const image = await loadImage(tex.source);
       const diffuseTex = createVTKTextureFromGLTFTexture(image, sampler);
-
-      // FIXME: Workaround for textures not showing up in WebGL
-      const viewAPI = model.renderer.getRenderWindow();
-      const isWebGL = viewAPI.getViews()[0].isA('vtkOpenGLRenderWindow');
-      if (isWebGL) {
-        actor.addTexture(diffuseTex);
-      } else {
-        property.setDiffuseTexture(diffuseTex);
-      }
+      property.setDiffuseTexture(diffuseTex);
     }
 
     // Handle metallic-roughness texture (metallicRoughnessTexture)
@@ -224,7 +217,7 @@ async function createPropertyFromGLTFMaterial(model, material, actor) {
       material.occlusionTexture.extensions;
       const tex = material.occlusionTexture.texture;
       const sampler = tex.sampler;
-      const aoImage = await loadImage(tex.source, 'r');
+      const aoImage = await loadImage(tex.source);
       const aoTex = createVTKTextureFromGLTFTexture(aoImage, sampler);
       property.setAmbientOcclusionTexture(aoTex);
     }
@@ -299,6 +292,8 @@ function handlePrimitiveExtensions(nodeId, extensions, model) {
       case 'KHR_materials_variants':
         model.variantMappings.set(nodeId, extension.mappings);
         break;
+      case 'KHR_draco_mesh_compression':
+        break;
       default:
         vtkWarningMacro(`Unhandled extension: ${extensionName}`);
     }
@@ -314,6 +309,7 @@ async function createActorFromGTLFNode(worldMatrix) {
   const actor = vtkActor.newInstance();
   const mapper = vtkMapper.newInstance();
   mapper.setColorModeToDirectScalars();
+  mapper.setInterpolateScalarsBeforeMapping(true);
   actor.setMapper(mapper);
   actor.setUserMatrix(worldMatrix);
   const polydata = vtkPolyData.newInstance();
@@ -330,6 +326,7 @@ async function createActorFromGTLFPrimitive(model, primitive, worldMatrix) {
   const actor = vtkActor.newInstance();
   const mapper = vtkMapper.newInstance();
   mapper.setColorModeToDirectScalars();
+  mapper.setInterpolateScalarsBeforeMapping(true);
   actor.setMapper(mapper);
   actor.setUserMatrix(worldMatrix);
   const polydata = await createPolyDataFromGLTFMesh(primitive);

package/IO/Geometry/GLTFImporter/Utils.js

@@ -1,7 +1,5 @@
-import WebworkerPromise from 'webworker-promise';
 import { m as macro } from '../../../macros2.js';
 import vtkTexture from '../../../Rendering/Core/Texture.js';
-import { W as WorkerFactory } from '../../../_virtual/rollup-plugin-worker-loader__module_Sources/IO/Geometry/GLTFImporter/ORMTexture.worker.js';
 import { ARRAY_TYPES, COMPONENTS, BYTES, GL_SAMPLER } from './Constants.js';
 
 const {
@@ -83,33 +81,18 @@ function resolveUrl(url, originalPath) {
 /**
  * Loads image from buffer or URI
  * @param {*} image
- * @param {*} channel
  * @returns
  */
-async function loadImage(image, channel) {
-  let forceReLoad = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
-  // Initialize cache if it doesn't exist
-  if (!image.cache) {
-    image.cache = {};
-  }
-
-  // Return cached result for the channel if available and not forced to reload
-  if (!forceReLoad && image.cache[channel]) {
-    return image.cache[channel];
-  }
-  const worker = new WebworkerPromise(new WorkerFactory());
+async function loadImage(image) {
   if (image.bufferView) {
-    return worker.postMessage({
-      imageBuffer: image.bufferView.data,
-      mimeType: image.mimeType,
-      channel
-    }).then(result => {
-      // Cache the bitmap based on the channel
-      image.cache[channel] = result.bitmap;
-      return result.bitmap;
-    }).finally(() => {
-      worker.terminate();
+    const blob = new Blob([image.bufferView.data], {
+      type: image.mimeType
+    });
+    const bitmap = await createImageBitmap(blob, {
+      colorSpaceConversion: 'none',
+      imageOrientation: 'flipY'
     });
+    return bitmap;
   }
   if (image.uri) {
     vtkWarningMacro('Falling back to image uri', image.uri);
@@ -117,7 +100,6 @@ async function loadImage(image, channel) {
       const img = new Image();
       img.crossOrigin = 'Anonymous';
       img.onload = () => {
-        image.cache[channel] = img; // Cache the loaded image based on the channel
         resolve(img);
       };
       img.onerror = reject;
@@ -158,7 +140,7 @@ function createVTKTextureFromGLTFTexture(image, sampler, extensions) {
       texture.setEdgeClamp(true);
     }
   }
-  texture.setJsImageData(image);
+  texture.setImageBitmap(image);
   return texture;
 }
 

package/Rendering/WebGPU/CellArrayMapper.js

@@ -629,12 +629,12 @@ function vtkWebGPUCellArrayMapper(publicAPI, model) {
     } else {
       if (roughnessTexture?.getImageLoaded()) {
         if (checkDims(roughnessTexture)) {
-          usedTextures.push('_roughnessMap = textureSample(RoughnessTexture, RoughnessTextureSampler, input.tcoordVS);');
+          usedTextures.push('_roughnessMap = textureSample(RoughnessTexture, RoughnessTextureSampler, input.tcoordVS).ggga;');
         }
       }
       if (metallicTexture?.getImageLoaded()) {
         if (checkDims(metallicTexture)) {
-          usedTextures.push('_metallicMap = textureSample(MetallicTexture, MetallicTextureSampler, input.tcoordVS);');
+          usedTextures.push('_metallicMap = textureSample(MetallicTexture, MetallicTextureSampler, input.tcoordVS).bbba;');
         }
       }
       if (ambientOcclusionTexture?.getImageLoaded()) {
@@ -847,11 +847,11 @@ function vtkWebGPUCellArrayMapper(publicAPI, model) {
     }
     if (idata) {
       model.colorTexture.setInputData(idata);
-      newTextures.push(['Diffuse', model.colorTexture]);
+      newTextures.push(['DiffuseTexture', model.colorTexture]);
     }
     const actor = model.WebGPUActor.getRenderable();
     const renderer = model.WebGPURenderer.getRenderable();
-    const textures = [['Diffuse', actor.getProperty().getDiffuseTexture?.()], ['Diffuse', actor.getTextures()[0]], ['Diffuse', model.colorTexture], ['ORM', actor.getProperty().getORMTexture?.()], ['RM', actor.getProperty().getRMTexture?.()], ['Roughness', actor.getProperty().getRoughnessTexture?.()], ['Metallic', actor.getProperty().getMetallicTexture?.()], ['Normal', actor.getProperty().getNormalTexture?.()], ['AmbientOcclusion', actor.getProperty().getAmbientOcclusionTexture?.()], ['Emission', actor.getProperty().getEmissionTexture?.()], ['Environment', renderer.getEnvironmentTexture?.()]];
+    const textures = [['DiffuseTexture', actor.getProperty().getDiffuseTexture?.()], ['DiffuseTexture', actor.getTextures()[0]], ['DiffuseTexture', model.colorTexture], ['ORMTexture', actor.getProperty().getORMTexture?.()], ['RMTexture', actor.getProperty().getRMTexture?.()], ['RoughnessTexture', actor.getProperty().getRoughnessTexture?.()], ['MetallicTexture', actor.getProperty().getMetallicTexture?.()], ['NormalTexture', actor.getProperty().getNormalTexture?.()], ['AmbientOcclusionTexture', actor.getProperty().getAmbientOcclusionTexture?.()], ['EmissionTexture', actor.getProperty().getEmissionTexture?.()], ['EnvironmentTexture', renderer.getEnvironmentTexture?.()]];
     textures.forEach(_ref => {
       let [name, tex] = _ref;
       if (!tex) return;
@@ -866,7 +866,7 @@ function vtkWebGPUCellArrayMapper(publicAPI, model) {
     // Add textures to manager only if not present
     newTextures.forEach(_ref2 => {
       let [textureName, srcTexture] = _ref2;
-      const newTex = model.device.getTextureManager().getTextureForVTKTexture(srcTexture);
+      const newTex = model.device.getTextureManager().getTextureForVTKTexture(srcTexture, textureName);
       if (!newTex.getReady()) return;
       let found = false;
       for (let t = 0; t < model.textures.length; ++t) {
@@ -878,7 +878,7 @@ function vtkWebGPUCellArrayMapper(publicAPI, model) {
       }
       if (!found) {
         usedTextures[model.textures.length] = true;
-        const tview = newTex.createView(`${textureName}Texture`);
+        const tview = newTex.createView(textureName);
         model.textures.push(newTex);
         model.textureViews.push(tview);
 
@@ -888,24 +888,24 @@ function vtkWebGPUCellArrayMapper(publicAPI, model) {
         if (srcTexture.getEdgeClamp() && srcTexture.getRepeat()) addressMode = 'mirror-repeat';else if (srcTexture.getEdgeClamp()) addressMode = 'clamp-to-edge';else if (srcTexture.getRepeat()) addressMode = 'repeat';
 
         // Handle environment texture separately
-        if (textureName !== 'Environment') {
-          tview.addSampler(model.device, {
-            addressModeU: addressMode,
-            addressModeV: addressMode,
-            addressModeW: addressMode,
-            minFilter: interpolate,
-            magFilter: interpolate
-          });
-        } else {
-          tview.addSampler(model.device, {
+        let options = {
+          addressModeU: addressMode,
+          addressModeV: addressMode,
+          addressModeW: addressMode,
+          minFilter: interpolate,
+          magFilter: interpolate
+        };
+        if (textureName === 'EnvironmentTexture') {
+          options = {
             addressModeU: 'repeat',
             addressModeV: 'clamp-to-edge',
             addressModeW: 'repeat',
             minFilter: interpolate,
             magFilter: interpolate,
             mipmapFilter: 'linear'
-          });
+          };
         }
+        tview.addSampler(model.device, options);
       }
     });
 

package/Rendering/WebGPU/PolyDataMapper.js

@@ -38,7 +38,8 @@ function vtkWebGPUPolyDataMapper(publicAPI, model) {
     // and they handle the rendering of that cell array
     const cellMappers = [];
     let cellOffset = 0;
-    for (let i = PrimitiveTypes.Points; i <= PrimitiveTypes.Triangles; i++) {
+    // Handle all primitive types including strips
+    for (let i = PrimitiveTypes.Points; i <= PrimitiveTypes.TriangleStrips; i++) {
       if (prims[i].getNumberOfValues() > 0) {
         if (!model.primitives[i]) {
           model.primitives[i] = publicAPI.createCellArrayMapper();
@@ -55,22 +56,41 @@ function vtkWebGPUPolyDataMapper(publicAPI, model) {
         model.primitives[i] = null;
       }
     }
+
+    // Handle edge visibility for both triangles and triangle strips
     if (model.WebGPUActor.getRenderable().getProperty().getEdgeVisibility()) {
-      for (let i = PrimitiveTypes.TriangleEdges; i <= PrimitiveTypes.TriangleStripEdges; i++) {
-        if (prims[i - 2].getNumberOfValues() > 0) {
-          if (!model.primitives[i]) {
-            model.primitives[i] = publicAPI.createCellArrayMapper();
-          }
-          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;
+      // Handle triangle edges
+      if (prims[PrimitiveTypes.Triangles].getNumberOfValues() > 0) {
+        const i = PrimitiveTypes.TriangleEdges;
+        if (!model.primitives[i]) {
+          model.primitives[i] = publicAPI.createCellArrayMapper();
+        }
+        const cellMapper = model.primitives[i];
+        cellMapper.setCellArray(prims[PrimitiveTypes.Triangles]);
+        cellMapper.setCurrentInput(poly);
+        cellMapper.setCellOffset(model.primitives[PrimitiveTypes.Triangles].getCellOffset());
+        cellMapper.setPrimitiveType(i);
+        cellMapper.setRenderable(model.renderable);
+        cellMappers.push(cellMapper);
+      } else {
+        model.primitives[PrimitiveTypes.TriangleEdges] = null;
+      }
+
+      // Handle triangle strip edges
+      if (prims[PrimitiveTypes.TriangleStrips].getNumberOfValues() > 0) {
+        const i = PrimitiveTypes.TriangleStripEdges;
+        if (!model.primitives[i]) {
+          model.primitives[i] = publicAPI.createCellArrayMapper();
         }
+        const cellMapper = model.primitives[i];
+        cellMapper.setCellArray(prims[PrimitiveTypes.TriangleStrips]);
+        cellMapper.setCurrentInput(poly);
+        cellMapper.setCellOffset(model.primitives[PrimitiveTypes.TriangleStrips].getCellOffset());
+        cellMapper.setPrimitiveType(i);
+        cellMapper.setRenderable(model.renderable);
+        cellMappers.push(cellMapper);
+      } else {
+        model.primitives[PrimitiveTypes.TriangleStripEdges] = null;
       }
     }
     publicAPI.prepareNodes();

package/Rendering/WebGPU/Renderer.js

@@ -315,7 +315,7 @@ function vtkWebGPURenderer(publicAPI, model) {
       ubo.addEntry('FSQMatrix', 'mat4x4<f32>');
       ubo.addEntry('BackgroundColor', 'vec4<f32>');
       model.clearFSQ.setUBO(ubo);
-      const environmentTextureHash = device.getTextureManager().getTextureForVTKTexture(model.backgroundTex);
+      const environmentTextureHash = device.getTextureManager().getTextureForVTKTexture(model.backgroundTex, 'EnvironmentTexture');
       if (environmentTextureHash.getReady()) {
         const tview = environmentTextureHash.createView(`EnvironmentTexture`);
         model.clearFSQ.setTextureViews([tview]);

package/Rendering/WebGPU/Texture.js

@@ -84,17 +84,27 @@ function vtkWebGPUTexture(publicAPI, model) {
       req.height = req.imageBitmap.height;
       req.depth = 1;
       req.format = 'rgba8unorm';
-      req.flip = false;
+      req.flip = true;
       _copyImageToTexture(req.imageBitmap);
       return;
     }
-    if (req.jsImageData && !req.nativeArray) {
+    if (req.jsImageData) {
       req.width = req.jsImageData.width;
       req.height = req.jsImageData.height;
       req.depth = 1;
       req.format = 'rgba8unorm';
       req.flip = true;
-      req.nativeArray = req.jsImageData.data;
+      _copyImageToTexture(req.jsImageData);
+      return;
+    }
+    if (req.image) {
+      req.width = req.image.width;
+      req.height = req.image.height;
+      req.depth = 1;
+      req.format = 'rgba8unorm';
+      req.flip = true;
+      _copyImageToTexture(req.image);
+      return;
     }
     const tDetails = vtkWebGPUTypes.getDetailsFromTextureFormat(model.format);
     let bufferBytesPerRow = model.width * tDetails.stride;
@@ -154,15 +164,6 @@ function vtkWebGPUTexture(publicAPI, model) {
     if (req.nativeArray) {
       nativeArray = req.nativeArray;
     }
-    if (req.image) {
-      const canvas = new OffscreenCanvas(req.image.width, req.image.height);
-      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);
-      const imageData = ctx.getImageData(0, 0, req.image.width, req.image.height);
-      nativeArray = imageData.data;
-    }
     const is3D = publicAPI.getDimensionality() === 3;
     const alignedTextureData = alignTextureData(nativeArray, model.height, is3D ? model.depth : 1);
     bufferBytesPerRow = alignedTextureData[1];

package/Rendering/WebGPU/TextureManager.js

@@ -69,9 +69,10 @@ function vtkWebGPUTextureManager(publicAPI, model) {
       req.height = req.image.height;
       req.depth = 1;
       req.format = 'rgba8unorm';
+      req.flip = true;
       /* eslint-disable no-undef */
       /* eslint-disable no-bitwise */
-      req.usage = GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING;
+      req.usage = GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.RENDER_ATTACHMENT;
       /* eslint-enable no-undef */
       /* eslint-enable no-bitwise */
     }
@@ -86,7 +87,7 @@ function vtkWebGPUTextureManager(publicAPI, model) {
       req.nativeArray = req.jsImageData.data;
       /* eslint-disable no-undef */
       /* eslint-disable no-bitwise */
-      req.usage = GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING;
+      req.usage = GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.RENDER_ATTACHMENT;
       /* eslint-enable no-undef */
       /* eslint-enable no-bitwise */
     }
@@ -99,7 +100,7 @@ function vtkWebGPUTextureManager(publicAPI, model) {
       req.flip = true;
       /* eslint-disable no-undef */
       /* eslint-disable no-bitwise */
-      req.usage = GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT;
+      req.usage = GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.RENDER_ATTACHMENT;
       /* eslint-enable no-undef */
       /* eslint-enable no-bitwise */
     }
@@ -112,7 +113,7 @@ function vtkWebGPUTextureManager(publicAPI, model) {
       req.flip = true;
       /* eslint-disable no-undef */
       /* eslint-disable no-bitwise */
-      req.usage = GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT;
+      req.usage = GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.RENDER_ATTACHMENT;
       /* eslint-enable no-undef */
       /* eslint-enable no-bitwise */
     }
@@ -120,7 +121,9 @@ function vtkWebGPUTextureManager(publicAPI, model) {
 
   // create a texture (used by getTexture)
   function _createTexture(req) {
-    const newTex = vtkWebGPUTexture.newInstance();
+    const newTex = vtkWebGPUTexture.newInstance({
+      label: req.label
+    });
     newTex.create(model.device, {
       width: req.width,
       height: req.height,
@@ -157,9 +160,11 @@ function vtkWebGPUTextureManager(publicAPI, model) {
     treq.hash = treq.time + treq.format + treq.mipLevel;
     return model.device.getTextureManager().getTexture(treq);
   };
-  publicAPI.getTextureForVTKTexture = srcTexture => {
+  publicAPI.getTextureForVTKTexture = function (srcTexture) {
+    let label = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : undefined;
     const treq = {
-      time: srcTexture.getMTime()
+      time: srcTexture.getMTime(),
+      label
     };
     if (srcTexture.getInputData()) {
       treq.imageData = srcTexture.getInputData();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kitware/vtk.js",
-  "version": "33.3.0",
+  "version": "33.3.2",
   "description": "Visualization Toolkit for the Web",
   "keywords": [
     "3d",

package/IO/Geometry/GLTFImporter/ORMTexture.worker.js

@@ -1,42 +0,0 @@
-import registerWebworker from 'webworker-promise/lib/register';
-
-/**
- *
- * @param {ArrayBuffer} imageBuffer
- * @param {string} mimeType
- * @param {string} channel
- * @returns {Promise<ImageData>}
- */
-registerWebworker(async _ref => {
-  let {
-    imageBuffer,
-    mimeType,
-    channel
-  } = _ref;
-  const channelsMap = {
-    r: 0,
-    g: 1,
-    b: 2
-  };
-  const blob = new Blob([imageBuffer], {
-    type: mimeType
-  });
-  const img = await createImageBitmap(blob);
-  const canvas = new OffscreenCanvas(img.width, img.height);
-  const ctx = canvas.getContext('2d');
-  ctx.drawImage(img, 0, 0, img.width, img.height);
-  const bitmap = ctx.getImageData(0, 0, img.width, img.height);
-  if (channel) {
-    const idx = channelsMap[channel];
-    for (let i = 0; i < bitmap.data.length; i += 4) {
-      const channelValue = bitmap.data[i + idx];
-      bitmap.data[i] = channelValue; // red channel
-      bitmap.data[i + 1] = channelValue; // green channel
-      bitmap.data[i + 2] = channelValue; // blue channel
-    }
-  }
-
-  return {
-    bitmap
-  };
-});

package/_virtual/rollup-plugin-worker-loader__module_Sources/IO/Geometry/GLTFImporter/ORMTexture.worker.js

@@ -1,296 +0,0 @@
-import { c as createInlineWorkerFactory } from '../../../../rollup-plugin-web-worker-loader__helper__browser__createInlineWorkerFactory.js';
-
-var WorkerFactory = createInlineWorkerFactory(/* rollup-plugin-web-worker-loader */function () {
-(function () {
-  '__worker_loader_strict__';
-
-  var register = {exports: {}};
-
-  var _createClass$1 = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
-
-  function _classCallCheck$1(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-  var TinyEmitter$1 = function () {
-    function TinyEmitter() {
-      _classCallCheck$1(this, TinyEmitter);
-
-      Object.defineProperty(this, '__listeners', {
-        value: {},
-        enumerable: false,
-        writable: false
-      });
-    }
-
-    _createClass$1(TinyEmitter, [{
-      key: 'emit',
-      value: function emit(eventName) {
-        if (!this.__listeners[eventName]) return this;
-
-        for (var _len = arguments.length, args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
-          args[_key - 1] = arguments[_key];
-        }
-
-        var _iteratorNormalCompletion = true;
-        var _didIteratorError = false;
-        var _iteratorError = undefined;
-
-        try {
-          for (var _iterator = this.__listeners[eventName][Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
-            var handler = _step.value;
-
-            handler.apply(undefined, args);
-          }
-        } catch (err) {
-          _didIteratorError = true;
-          _iteratorError = err;
-        } finally {
-          try {
-            if (!_iteratorNormalCompletion && _iterator.return) {
-              _iterator.return();
-            }
-          } finally {
-            if (_didIteratorError) {
-              throw _iteratorError;
-            }
-          }
-        }
-
-        return this;
-      }
-    }, {
-      key: 'once',
-      value: function once(eventName, handler) {
-        var _this = this;
-
-        var once = function once() {
-          _this.off(eventName, once);
-          handler.apply(undefined, arguments);
-        };
-
-        return this.on(eventName, once);
-      }
-    }, {
-      key: 'on',
-      value: function on(eventName, handler) {
-        if (!this.__listeners[eventName]) this.__listeners[eventName] = [];
-
-        this.__listeners[eventName].push(handler);
-
-        return this;
-      }
-    }, {
-      key: 'off',
-      value: function off(eventName, handler) {
-        if (handler) this.__listeners[eventName] = this.__listeners[eventName].filter(function (h) {
-          return h !== handler;
-        });else this.__listeners[eventName] = [];
-
-        return this;
-      }
-    }]);
-
-    return TinyEmitter;
-  }();
-
-  var tinyEmitter = TinyEmitter$1;
-
-  var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
-
-  var _get = function get(object, property, receiver) { if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { return get(parent, property, receiver); } } else if ("value" in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } };
-
-  var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
-
-  function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } }
-
-  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-  function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
-
-  function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
-
-  function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
-
-  var TinyEmitter = tinyEmitter;
-
-  var MESSAGE_RESULT = 0;
-  var MESSAGE_EVENT = 1;
-
-  var RESULT_ERROR = 0;
-  var RESULT_SUCCESS = 1;
-
-  var DEFAULT_HANDLER = 'main';
-
-  var isPromise = function isPromise(o) {
-    return (typeof o === 'undefined' ? 'undefined' : _typeof(o)) === 'object' && o !== null && typeof o.then === 'function' && typeof o.catch === 'function';
-  };
-
-  function RegisterPromise(fn) {
-    var handlers = _defineProperty({}, DEFAULT_HANDLER, fn);
-    var sendPostMessage = self.postMessage.bind(self);
-
-    var server = new (function (_TinyEmitter) {
-      _inherits(WorkerRegister, _TinyEmitter);
-
-      function WorkerRegister() {
-        _classCallCheck(this, WorkerRegister);
-
-        return _possibleConstructorReturn(this, (WorkerRegister.__proto__ || Object.getPrototypeOf(WorkerRegister)).apply(this, arguments));
-      }
-
-      _createClass(WorkerRegister, [{
-        key: 'emit',
-        value: function emit(eventName) {
-          for (var _len = arguments.length, args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
-            args[_key - 1] = arguments[_key];
-          }
-
-          if (args.length == 1 && args[0] instanceof TransferableResponse) {
-            sendPostMessage({ eventName: eventName, args: args }, args[0].transferable);
-          } else {
-            sendPostMessage({ eventName: eventName, args: args });
-          }
-          return this;
-        }
-      }, {
-        key: 'emitLocally',
-        value: function emitLocally(eventName) {
-          var _get2;
-
-          for (var _len2 = arguments.length, args = Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
-            args[_key2 - 1] = arguments[_key2];
-          }
-
-          (_get2 = _get(WorkerRegister.prototype.__proto__ || Object.getPrototypeOf(WorkerRegister.prototype), 'emit', this)).call.apply(_get2, [this, eventName].concat(args));
-        }
-      }, {
-        key: 'operation',
-        value: function operation(name, handler) {
-          handlers[name] = handler;
-          return this;
-        }
-      }]);
-
-      return WorkerRegister;
-    }(TinyEmitter))();
-
-    var run = function run(messageId, payload, handlerName) {
-
-      var onSuccess = function onSuccess(result) {
-        if (result && result instanceof TransferableResponse) {
-          sendResult(messageId, RESULT_SUCCESS, result.payload, result.transferable);
-        } else {
-          sendResult(messageId, RESULT_SUCCESS, result);
-        }
-      };
-
-      var onError = function onError(e) {
-        sendResult(messageId, RESULT_ERROR, {
-          message: e.message,
-          stack: e.stack
-        });
-      };
-
-      try {
-        var result = runFn(messageId, payload, handlerName);
-        if (isPromise(result)) {
-          result.then(onSuccess).catch(onError);
-        } else {
-          onSuccess(result);
-        }
-      } catch (e) {
-        onError(e);
-      }
-    };
-
-    var runFn = function runFn(messageId, payload, handlerName) {
-      var handler = handlers[handlerName || DEFAULT_HANDLER];
-      if (!handler) throw new Error('Not found handler for this request');
-
-      return handler(payload, sendEvent.bind(null, messageId));
-    };
-
-    var sendResult = function sendResult(messageId, success, payload) {
-      var transferable = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : [];
-
-      sendPostMessage([MESSAGE_RESULT, messageId, success, payload], transferable);
-    };
-
-    var sendEvent = function sendEvent(messageId, eventName, payload) {
-      if (!eventName) throw new Error('eventName is required');
-
-      if (typeof eventName !== 'string') throw new Error('eventName should be string');
-
-      sendPostMessage([MESSAGE_EVENT, messageId, eventName, payload]);
-    };
-
-    self.addEventListener('message', function (_ref) {
-      var data = _ref.data;
-
-      if (Array.isArray(data)) {
-        run.apply(undefined, _toConsumableArray(data));
-      } else if (data && data.eventName) {
-        server.emitLocally.apply(server, [data.eventName].concat(_toConsumableArray(data.args)));
-      }
-    });
-
-    return server;
-  }
-
-  var TransferableResponse = function TransferableResponse(payload, transferable) {
-    _classCallCheck(this, TransferableResponse);
-
-    this.payload = payload;
-    this.transferable = transferable;
-  };
-
-  register.exports = RegisterPromise;
-  register.exports.TransferableResponse = TransferableResponse;
-
-  var registerWebworker = register.exports;
-
-  /**
-   *
-   * @param {ArrayBuffer} imageBuffer
-   * @param {string} mimeType
-   * @param {string} channel
-   * @returns {Promise<ImageData>}
-   */
-  registerWebworker(async _ref => {
-    let {
-      imageBuffer,
-      mimeType,
-      channel
-    } = _ref;
-    const channelsMap = {
-      r: 0,
-      g: 1,
-      b: 2
-    };
-    const blob = new Blob([imageBuffer], {
-      type: mimeType
-    });
-    const img = await createImageBitmap(blob);
-    const canvas = new OffscreenCanvas(img.width, img.height);
-    const ctx = canvas.getContext('2d');
-    ctx.drawImage(img, 0, 0, img.width, img.height);
-    const bitmap = ctx.getImageData(0, 0, img.width, img.height);
-    if (channel) {
-      const idx = channelsMap[channel];
-      for (let i = 0; i < bitmap.data.length; i += 4) {
-        const channelValue = bitmap.data[i + idx];
-        bitmap.data[i] = channelValue; // red channel
-        bitmap.data[i + 1] = channelValue; // green channel
-        bitmap.data[i + 2] = channelValue; // blue channel
-      }
-    }
-
-    return {
-      bitmap
-    };
-  });
-
-})();
-}, null);
-/* eslint-enable */
-
-export { WorkerFactory as W };