@kitware/vtk.js 24.5.3 → 24.5.6

package/Rendering/OpenGL/PolyDataMapper2D.js

@@ -163,7 +163,7 @@ function vtkOpenGLPolyDataMapper2D(publicAPI, model) {
     // Note that the actor's mtime includes it's properties mtime
     var vmtime = model.VBOBuildTime.getMTime();
 
-    if (vmtime < publicAPI.getMTime() || vmtime < model.renderable.getMTime() || vmtime < actor.getMTime() || vmtime < model.currentInput.getMTime() || model.renderable.getTransformCoordinate() && vmtime < ren.getMTime()) {
+    if (vmtime < publicAPI.getMTime() || vmtime < model._openGLRenderWindow.getMTime() || vmtime < model.renderable.getMTime() || vmtime < actor.getMTime() || vmtime < model.currentInput.getMTime() || model.renderable.getTransformCoordinate() && vmtime < ren.getMTime()) {
       return true;
     }
 
@@ -197,7 +197,9 @@ function vtkOpenGLPolyDataMapper2D(publicAPI, model) {
     }
 
     var transformCoordinate = model.renderable.getTransformCoordinate();
-    var toString = "".concat(poly.getMTime(), "A").concat(representation, "B").concat(poly.getMTime()) + "C".concat(c ? c.getMTime() : 1) + "D".concat(tcoords ? tcoords.getMTime() : 1) + "E".concat(transformCoordinate ? ren.getMTime() : 1);
+    var view = ren.getRenderWindow().getViews()[0];
+    var vsize = view.getViewportSize(ren);
+    var toString = "".concat(poly.getMTime(), "A").concat(representation, "B").concat(poly.getMTime()) + "C".concat(c ? c.getMTime() : 1) + "D".concat(tcoords ? tcoords.getMTime() : 1) + "E".concat(transformCoordinate ? ren.getMTime() : 1) + "F".concat(vsize);
 
     if (model.VBOBuildString !== toString) {
       // Build the VBOs

package/Rendering/OpenGL/VolumeMapper.js

@@ -368,7 +368,7 @@ function vtkOpenGLVolumeMapper(publicAPI, model) {
 
     if (model.zBufferTexture !== null) {
       program.setUniformi('zBufferTexture', model.zBufferTexture.getTextureUnit());
-      var size = publicAPI.getRenderTargetSize();
+      var size = model._useSmallViewport ? [model._smallViewportWidth, model._smallViewportHeight] : model._openGLRenderWindow.getFramebufferSize();
       program.setUniformf('vpWidth', size[0]);
       program.setUniformf('vpHeight', size[1]);
     }

package/Rendering/WebGPU/BufferManager.js

@@ -1,6 +1,7 @@
 import _defineProperty from '@babel/runtime/helpers/defineProperty';
-import { newInstance as newInstance$1, obj, setGet, newTypedArray, vtkDebugMacro as vtkDebugMacro$1 } from '../../macros.js';
+import { newInstance as newInstance$1, obj, setGet, vtkErrorMacro as vtkErrorMacro$1, newTypedArray, vtkDebugMacro as vtkDebugMacro$1 } from '../../macros.js';
 import { j as cross, l as normalize } from '../../Common/Core/Math/index.js';
+import vtkDataArray from '../../Common/Core/DataArray.js';
 import vtkWebGPUBuffer from './Buffer.js';
 import vtkWebGPUTypes from './Types.js';
 import vtkProperty from '../Core/Property.js';
@@ -12,7 +13,9 @@ function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { va
 var BufferUsage = Constants.BufferUsage,
     PrimitiveTypes = Constants.PrimitiveTypes;
 var Representation = vtkProperty.Representation;
-var vtkDebugMacro = vtkDebugMacro$1; // the webgpu constants all show up as undefined
+var vtkDebugMacro = vtkDebugMacro$1,
+    vtkErrorMacro = vtkErrorMacro$1;
+var VtkDataTypes = vtkDataArray.VtkDataTypes; // the webgpu constants all show up as undefined
 
 /* eslint-disable no-undef */
 // ----------------------------------------------------------------------------
@@ -62,6 +65,65 @@ var cellCounters = {
   }
 };
 
+function _getFormatForDataArray(dataArray) {
+  var format;
+
+  switch (dataArray.getDataType()) {
+    case VtkDataTypes.UNSIGNED_CHAR:
+      format = 'uint8';
+      break;
+
+    case VtkDataTypes.FLOAT:
+      format = 'float32';
+      break;
+
+    case VtkDataTypes.UNSIGNED_INT:
+      format = 'uint32';
+      break;
+
+    case VtkDataTypes.INT:
+      format = 'sint32';
+      break;
+
+    case VtkDataTypes.DOUBLE:
+      format = 'float32';
+      break;
+
+    case VtkDataTypes.UNSIGNED_SHORT:
+      format = 'uint16';
+      break;
+
+    case VtkDataTypes.SHORT:
+      format = 'sin16';
+      break;
+
+    default:
+      format = 'float32';
+      break;
+  }
+
+  switch (dataArray.getNumberOfComponents()) {
+    case 2:
+      format += 'x2';
+      break;
+
+    case 3:
+      // only 32bit types support x3
+      if (!format.contains('32')) {
+        vtkErrorMacro("unsupported x3 type for ".concat(format));
+      }
+
+      format += 'x3';
+      break;
+
+    case 4:
+      format += 'x4';
+      break;
+  }
+
+  return format;
+}
+
 function getPrimitiveName(primType) {
   switch (primType) {
     case PrimitiveTypes.Points:
@@ -443,27 +505,34 @@ function vtkWebGPUBufferManager(publicAPI, model) {
   } // is the buffer already present?
 
 
-  publicAPI.hasBuffer = function (req) {
-    if (req.owner) {
-      // if a matching buffer already exists then return true
-      var hash = req.time + req.format + req.usage + req.hash;
-      return model.device.hasCachedObject(req.owner, hash);
-    }
-
-    return false;
+  publicAPI.hasBuffer = function (hash) {
+    return model.device.hasCachedObject(hash);
   };
 
   publicAPI.getBuffer = function (req) {
     // if we have a source the get/create/cache the buffer
-    if (req.owner) {
-      // if a matching buffer already exists then return it
-      var hash = req.time + req.format + req.usage + req.hash;
-      return model.device.getCachedObject(req.owner, hash, _createBuffer, req);
+    if (req.hash) {
+      return model.device.getCachedObject(req.hash, _createBuffer, req);
     }
 
     return _createBuffer(req);
   };
 
+  publicAPI.getBufferForPointArray = function (dataArray, cells, primitiveType, representation) {
+    var format = _getFormatForDataArray(dataArray);
+
+    var buffRequest = {
+      hash: "PA".concat(representation, "P").concat(primitiveType, "D").concat(dataArray.getMTime(), "C").concat(cells.getMTime()).concat(format),
+      usage: BufferUsage.PointArray,
+      format: format,
+      dataArray: dataArray,
+      cells: cells,
+      primitiveType: primitiveType,
+      representation: representation
+    };
+    return publicAPI.getBuffer(buffRequest);
+  };
+
   publicAPI.getFullScreenQuadBuffer = function () {
     if (model.fullScreenQuadBuffer) {
       return model.fullScreenQuadBuffer;

package/Rendering/WebGPU/CellArrayMapper.js

@@ -294,11 +294,9 @@ function vtkWebGPUCellArrayMapper(publicAPI, model) {
     if (points) {
       var shift = model.WebGPUActor.getBufferShift(model.WebGPURenderer);
       var buffRequest = {
-        owner: points,
+        hash: "".concat(hash).concat(points.getMTime()).concat(cells.getMTime()).concat(shift.join(), "float32x4"),
         usage: BufferUsage.PointArray,
         format: 'float32x4',
-        time: Math.max(points.getMTime(), cells.getMTime(), model.WebGPUActor.getKeyMatricesTime().getMTime()),
-        hash: hash,
         dataArray: points,
         cells: cells,
         primitiveType: primType,
@@ -319,7 +317,6 @@ function vtkWebGPUCellArrayMapper(publicAPI, model) {
       var normals = pd.getPointData().getNormals();
       var _buffRequest = {
         format: 'snorm8x4',
-        hash: hash,
         cells: cells,
         representation: representation,
         primitiveType: primType,
@@ -329,18 +326,16 @@ function vtkWebGPUCellArrayMapper(publicAPI, model) {
       };
 
       if (normals) {
-        _buffRequest.owner = normals;
+        _buffRequest.hash = "".concat(hash).concat(normals.getMTime()).concat(cells.getMTime(), "snorm8x4");
         _buffRequest.dataArray = normals;
-        _buffRequest.time = Math.max(normals.getMTime(), cells.getMTime());
         _buffRequest.usage = BufferUsage.PointArray;
 
         var _buff = device.getBufferManager().getBuffer(_buffRequest);
 
         vertexInput.addBuffer(_buff, ['normalMC']);
       } else if (primType === PrimitiveTypes.Triangles) {
-        _buffRequest.owner = points;
+        _buffRequest.hash = "".concat(hash).concat(points.getMTime()).concat(cells.getMTime(), "snorm8x4");
         _buffRequest.dataArray = points;
-        _buffRequest.time = Math.max(points.getMTime(), cells.getMTime());
         _buffRequest.usage = BufferUsage.NormalsFromPoints;
 
         var _buff2 = device.getBufferManager().getBuffer(_buffRequest);
@@ -368,11 +363,9 @@ function vtkWebGPUCellArrayMapper(publicAPI, model) {
         }
 
         var _buffRequest2 = {
-          owner: c,
           usage: BufferUsage.PointArray,
           format: 'unorm8x4',
-          time: Math.max(c.getMTime(), cells.getMTime(), points.getMTime()),
-          hash: hash + haveCellScalars,
+          hash: "".concat(hash).concat(haveCellScalars).concat(c.getMTime()).concat(cells.getMTime(), "unorm8x4"),
           dataArray: c,
           cells: cells,
           primitiveType: primType,
@@ -401,20 +394,7 @@ function vtkWebGPUCellArrayMapper(publicAPI, model) {
     }
 
     if (tcoords && !edges) {
-      // console.log(`tcoords ${tcoords.getMTime()}`);
-      var _buffRequest3 = {
-        owner: tcoords,
-        usage: BufferUsage.PointArray,
-        format: 'float32x2',
-        time: Math.max(tcoords.getMTime(), cells.getMTime()),
-        hash: hash,
-        dataArray: tcoords,
-        cells: cells,
-        primitiveType: primType,
-        representation: representation
-      };
-
-      var _buff4 = device.getBufferManager().getBuffer(_buffRequest3);
+      var _buff4 = device.getBufferManager().getBufferForPointArray(tcoords, cells, primType, representation);
 
       vertexInput.addBuffer(_buff4, ['tcoord']);
     } else {
@@ -459,25 +439,7 @@ function vtkWebGPUCellArrayMapper(publicAPI, model) {
 
     for (var _i = 0; _i < newTextures.length; _i++) {
       var srcTexture = newTextures[_i];
-      var treq = {
-        time: srcTexture.getMTime()
-      };
-
-      if (srcTexture.getInputData()) {
-        treq.imageData = srcTexture.getInputData();
-        treq.owner = treq.imageData.getPointData().getScalars();
-      } else if (srcTexture.getImage()) {
-        treq.image = srcTexture.getImage();
-        treq.owner = treq.image;
-      } else if (srcTexture.getJsImageData()) {
-        treq.jsImageData = srcTexture.getJsImageData();
-        treq.owner = treq.jsImageData;
-      } else if (srcTexture.getCanvas()) {
-        treq.canvas = srcTexture.getCanvas();
-        treq.owner = treq.canvas;
-      }
-
-      var newTex = model.device.getTextureManager().getTexture(treq);
+      var newTex = model.device.getTextureManager().getTextureForVTKTexture(srcTexture);
 
       if (newTex.getReady()) {
         // is this a new texture

package/Rendering/WebGPU/Device.js

@@ -1,8 +1,83 @@
+import _typeof from '@babel/runtime/helpers/typeof';
+import _classCallCheck from '@babel/runtime/helpers/classCallCheck';
+import _createClass from '@babel/runtime/helpers/createClass';
+import _assertThisInitialized from '@babel/runtime/helpers/assertThisInitialized';
+import _inherits from '@babel/runtime/helpers/inherits';
+import _possibleConstructorReturn from '@babel/runtime/helpers/possibleConstructorReturn';
+import _get from '@babel/runtime/helpers/get';
+import _getPrototypeOf from '@babel/runtime/helpers/getPrototypeOf';
+import _wrapNativeSuper from '@babel/runtime/helpers/wrapNativeSuper';
 import { newInstance as newInstance$1, obj, setGet, get } from '../../macros.js';
 import vtkWebGPUBufferManager from './BufferManager.js';
 import vtkWebGPUShaderCache from './ShaderCache.js';
 import vtkWebGPUTextureManager from './TextureManager.js';
 
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+/**
+ * provide a simple WeakRefMap class to share device objects based on
+ * hash values so that buffers/textures etc can be shared betwen mappers.
+ * This is roughly based on WeakLRUCache but without the actual caching
+ * behavior. This is just a map of key -> WeakRef(value)
+ */
+
+/* eslint-disable no-undef */
+
+var WeakRefMap = /*#__PURE__*/function (_Map) {
+  _inherits(WeakRefMap, _Map);
+
+  var _super = _createSuper(WeakRefMap);
+
+  function WeakRefMap() {
+    var _thisSuper, _thisSuper2, _this;
+
+    _classCallCheck(this, WeakRefMap);
+
+    _this = _super.call(this);
+    _this.registry = new FinalizationRegistry(function (key) {
+      var entry = _get((_thisSuper = _assertThisInitialized(_this), _getPrototypeOf(WeakRefMap.prototype)), "get", _thisSuper).call(_thisSuper, key);
+
+      if (entry && entry.deref && entry.deref() === undefined) _get((_thisSuper2 = _assertThisInitialized(_this), _getPrototypeOf(WeakRefMap.prototype)), "delete", _thisSuper2).call(_thisSuper2, key);
+    });
+    return _this;
+  }
+
+  _createClass(WeakRefMap, [{
+    key: "getValue",
+    value: function getValue(key) {
+      var entry = _get(_getPrototypeOf(WeakRefMap.prototype), "get", this).call(this, key);
+
+      if (entry) {
+        var value = entry.deref();
+        if (value !== undefined) return value;
+
+        _get(_getPrototypeOf(WeakRefMap.prototype), "delete", this).call(this, key);
+      }
+
+      return undefined;
+    }
+  }, {
+    key: "setValue",
+    value: function setValue(key, value) {
+      var entry;
+
+      if (value && _typeof(value) === 'object') {
+        entry = new WeakRef(value);
+        this.registry.register(value, key);
+
+        _get(_getPrototypeOf(WeakRefMap.prototype), "set", this).call(this, key, entry);
+      } // else entry is undefined
+
+
+      return entry;
+    }
+  }]);
+
+  return WeakRefMap;
+}( /*#__PURE__*/_wrapNativeSuper(Map));
+/* eslint-enable no-undef */
+// ----------------------------------------------------------------------------
 // vtkWebGPUDevice methods
 // ----------------------------------------------------------------------------
 
@@ -92,72 +167,34 @@ function vtkWebGPUDevice(publicAPI, model) {
   }; // The Device has an object cache that can be used to cache buffers,
   // textures and other objects that can be shared. The basic approach is to
   // call getCachedObject with a request and a create function. The request
-  // must have two fields a hash and an owner. The owner is what the weak
-  // map uses to hold onto the cached object. When the owner is deleted the
-  // cached object will be freed from the cache. The cache lookup just
-  // returns any entry that has a matching owner and hash. If a match isn't
-  // found then the create function is called with any extra arguments.
-  //
-  // For best memory management it is important that the owner be as close
-  // to the underlying object as possible. For example for a point data buffer
-  // you would want the actual vtkDataArray to be the owner, not the polydata
-  // or even worse the actor. As the points data array could be freed wihtout
-  // the polydata or actor being freed.
+  // is based on a hash. The cache lookup just returns any entry that has a
+  // matching hash. If a match isn't found then the create function is
+  // called with any extra arguments.
   // is the object already cached?
 
 
-  publicAPI.hasCachedObject = function (owner, hash) {
-    if (!owner) {
-      return false;
-    } // if a matching request already exists then return true
-
-
-    if (model.objectCache.has(owner)) {
-      var objects = model.objectCache.get(owner);
-
-      for (var i = 0; i < objects.length; i++) {
-        if (hash === objects[i].hash) {
-          return true;
-        }
-      }
-    }
-
-    return false;
+  publicAPI.hasCachedObject = function (hash) {
+    return model.objectCache.getValue(hash);
   };
 
-  publicAPI.getCachedObject = function (owner, hash, creator) {
-    if (!owner || !hash) {
-      vtkErrorMacro('attempt to cache an object without an owner or hash');
+  publicAPI.getCachedObject = function (hash, creator) {
+    if (!hash) {
+      vtkErrorMacro('attempt to cache an object without a hash');
       return null;
-    } // if a matching request already exists then return the cached object
-
-
-    if (model.objectCache.has(owner)) {
-      var _objects = model.objectCache.get(owner);
-
-      for (var i = 0; i < _objects.length; i++) {
-        if (hash === _objects[i].hash) {
-          return _objects[i].object;
-        }
-      }
-    } // otherwise create the object and cache it
+    }
 
+    var existingValue = model.objectCache.getValue(hash);
 
-    for (var _len = arguments.length, args = new Array(_len > 3 ? _len - 3 : 0), _key = 3; _key < _len; _key++) {
-      args[_key - 3] = arguments[_key];
+    if (existingValue) {
+      return existingValue;
     }
 
-    var createdObject = creator.apply(void 0, args);
-
-    if (!model.objectCache.has(owner)) {
-      model.objectCache.set(owner, []);
+    for (var _len = arguments.length, args = new Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {
+      args[_key - 2] = arguments[_key];
     }
 
-    var objects = model.objectCache.get(owner);
-    objects.push({
-      hash: hash,
-      object: createdObject
-    });
+    var createdObject = creator.apply(void 0, args);
+    model.objectCache.setValue(hash, createdObject);
     return createdObject;
   };
 } // ----------------------------------------------------------------------------
@@ -180,9 +217,12 @@ function extend(publicAPI, model) {
 
   obj(publicAPI, model);
   setGet(publicAPI, model, ['handle']);
-  get(publicAPI, model, ['bufferManager', 'shaderCache', 'textureManager']); // this is a cache, and a cache with GC pretty much means WeakMap
+  get(publicAPI, model, ['bufferManager', 'shaderCache', 'textureManager']); // this is a weak ref cache implementation, we create it without
+  // an expirer (so it is strictly based on garbage collection and
+  // objects are not held if there are no external references)
+  // model.objectCache = new WeakLRUCache({ expirer: false });
 
-  model.objectCache = new WeakMap();
+  model.objectCache = new WeakRefMap();
   model.shaderCache = vtkWebGPUShaderCache.newInstance();
   model.shaderCache.setDevice(publicAPI);
   model.bindGroupLayouts = [];
@@ -203,4 +243,4 @@ var vtkWebGPUDevice$1 = {
   extend: extend
 };
 
-export { vtkWebGPUDevice$1 as default, extend, newInstance };
+export { WeakRefMap, vtkWebGPUDevice$1 as default, extend, newInstance };

package/Rendering/WebGPU/Glyph3DMapper.js

@@ -102,6 +102,8 @@ function vtkWebGPUGlyph3DMapper(publicAPI, model) {
 
   publicAPI.buildPass = function (prepass) {
     if (prepass) {
+      model.WebGPUActor = publicAPI.getFirstAncestorOfType('vtkWebGPUActor');
+
       if (!model.renderable.getStatic()) {
         model.renderable.update();
       }

package/Rendering/WebGPU/ImageMapper.js

@@ -265,11 +265,7 @@ function vtkWebGPUImageMapper(publicAPI, model) {
 
   publicAPI.updateBuffers = function () {
     superClassUpdateBuffers();
-    var treq = {
-      imageData: model.currentInput,
-      owner: model.currentInput.getPointData().getScalars()
-    };
-    var newTex = model.device.getTextureManager().getTexture(treq);
+    var newTex = model.device.getTextureManager().getTextureForImageData(model.currentInput);
     var tViews = model.textureViews;
 
     if (!tViews[0] || tViews[0].getTexture() !== newTex) {

package/Rendering/WebGPU/SphereMapper.js

@@ -74,16 +74,15 @@ function vtkWebGPUSphereMapper(publicAPI, model) {
     publicAPI.setNumberOfInstances(1);
     publicAPI.setNumberOfVertices(3 * numPoints);
     var vertexInput = model.vertexInput;
-    var buffRequest = {
-      owner: points,
-      hash: 'spm',
-      time: points.getMTime(),
-      usage: BufferUsage.RawVertex,
-      format: 'float32x3'
-    };
-
-    if (!model.device.getBufferManager().hasBuffer(buffRequest)) {
-      // xyz v1 v2 v3
+    var hash = "spm".concat(points.getMTime(), "float32x3");
+
+    if (!model.device.getBufferManager().hasBuffer(hash)) {
+      var buffRequest = {
+        hash: hash,
+        usage: BufferUsage.RawVertex,
+        format: 'float32x3'
+      }; // xyz v1 v2 v3
+
       var tmpVBO = new Float32Array(3 * numPoints * 3);
       var pointIdx = 0;
       var vboIdx = 0;
@@ -117,15 +116,15 @@ function vtkWebGPUSphereMapper(publicAPI, model) {
     var defaultRadius = model.renderable.getRadius();
 
     if (scales || defaultRadius !== model._lastRadius) {
-      buffRequest = {
-        owner: scales,
-        hash: 'spm',
-        time: scales ? pointData.getArray(model.renderable.getScaleArray()).getMTime() : 0,
-        usage: BufferUsage.RawVertex,
-        format: 'float32x2'
-      };
+      hash = "spm".concat(scales ? pointData.getArray(model.renderable.getScaleArray()).getMTime() : defaultRadius, "float32x2");
+
+      if (!model.device.getBufferManager().hasBuffer(hash)) {
+        var _buffRequest = {
+          hash: hash,
+          usage: BufferUsage.RawVertex,
+          format: 'float32x2'
+        };
 
-      if (!model.device.getBufferManager().hasBuffer(buffRequest)) {
         var _tmpVBO = new Float32Array(3 * numPoints * 2);
 
         var cos30 = Math.cos(radiansFromDegrees(30.0));
@@ -146,9 +145,9 @@ function vtkWebGPUSphereMapper(publicAPI, model) {
           _tmpVBO[_vboIdx++] = 2.0 * radius;
         }
 
-        buffRequest.nativeArray = _tmpVBO;
+        _buffRequest.nativeArray = _tmpVBO;
 
-        var _buff = model.device.getBufferManager().getBuffer(buffRequest);
+        var _buff = model.device.getBufferManager().getBuffer(_buffRequest);
 
         vertexInput.addBuffer(_buff, ['offsetMC']);
       }
@@ -163,15 +162,14 @@ function vtkWebGPUSphereMapper(publicAPI, model) {
       var c = model.renderable.getColorMapColors();
 
       if (c) {
-        buffRequest = {
-          owner: c,
-          hash: 'spm',
-          time: c.getMTime(),
-          usage: BufferUsage.RawVertex,
-          format: 'unorm8x4'
-        };
-
-        if (!model.device.getBufferManager().hasBuffer(buffRequest)) {
+        hash = "spm".concat(c.getMTime(), "unorm8x4");
+
+        if (!model.device.getBufferManager().hasBuffer(hash)) {
+          var _buffRequest2 = {
+            hash: hash,
+            usage: BufferUsage.RawVertex,
+            format: 'unorm8x4'
+          };
           var colorComponents = c.getNumberOfComponents();
 
           if (colorComponents !== 4) {
@@ -194,9 +192,9 @@ function vtkWebGPUSphereMapper(publicAPI, model) {
             }
           }
 
-          buffRequest.nativeArray = _tmpVBO2;
+          _buffRequest2.nativeArray = _tmpVBO2;
 
-          var _buff2 = model.device.getBufferManager().getBuffer(buffRequest);
+          var _buff2 = model.device.getBufferManager().getBuffer(_buffRequest2);
 
           vertexInput.addBuffer(_buff2, ['colorVI']);
         }

package/Rendering/WebGPU/StickMapper.js

@@ -59,7 +59,7 @@ function vtkWebGPUStickMapper(publicAPI, model) {
     vDesc.addBuiltinInput('u32', '@builtin(vertex_index) vertexIndex');
     var fDesc = pipeline.getShaderDescription('fragment');
     fDesc.addBuiltinOutput('f32', '@builtin(frag_depth) fragDepth');
-    var stickFrag = "\n    // compute the eye position and unit direction\n    var vertexVC: vec4<f32>;\n    var EyePos: vec3<f32>;\n    var EyeDir: vec3<f32>;\n\n    if (rendererUBO.cameraParallel != 0u)\n    {\n      EyePos = vec3<f32>(input.vertexVC.x, input.vertexVC.y, input.vertexVC.z + 3.0*input.radiusVC);\n      EyeDir = vec3<f32>(0.0, 0.0, -1.0);\n    }\n    else\n    {\n      EyeDir = input.vertexVC.xyz;\n      EyePos = vec3<f32>(0.0,0.0,0.0);\n      var lengthED: f32 = length(EyeDir);\n      EyeDir = normalize(EyeDir);\n      // we adjust the EyePos to be closer if it is too far away\n      // to prevent floating point precision noise\n      if (lengthED > input.radiusVC*3.0)\n      {\n        EyePos = input.vertexVC.xyz - EyeDir*3.0*input.radiusVC;\n      }\n    }\n    // translate to Sphere center\n    EyePos = EyePos - input.centerVC;\n\n    // rotate to new basis\n    // base1, base2, orientVC\n    var base1: vec3<f32>;\n    if (abs(input.orientVC.z) < 0.99)\n    {\n      base1 = normalize(cross(input.orientVC,vec3<f32>(0.0,0.0,1.0)));\n    }\n    else\n    {\n      base1 = normalize(cross(input.orientVC,vec3<f32>(0.0,1.0,0.0)));\n    }\n    var base2: vec3<f32> = cross(input.orientVC,base1);\n    EyePos = vec3<f32>(dot(EyePos,base1),dot(EyePos,base2),dot(EyePos,input.orientVC));\n    EyeDir = vec3<f32>(dot(EyeDir,base1),dot(EyeDir,base2),dot(EyeDir,input.orientVC));\n\n    // scale to radius 1.0\n    EyePos = EyePos * (1.0 / input.radiusVC);\n\n    // find the intersection\n    var a: f32 = EyeDir.x*EyeDir.x + EyeDir.y*EyeDir.y;\n    var b: f32 = 2.0*(EyePos.x*EyeDir.x + EyePos.y*EyeDir.y);\n    var c: f32 = EyePos.x*EyePos.x + EyePos.y*EyePos.y - 1.0;\n    var d: f32 = b*b - 4.0*a*c;\n    var normal: vec3<f32> = vec3<f32>(0.0,0.0,1.0);\n    if (d < 0.0) { discard; }\n    else\n    {\n      var t: f32 = (-b - sqrt(d))*(0.5 / a);\n      var tz: f32 = EyePos.z + t*EyeDir.z;\n      var iPoint: vec3<f32> = EyePos + t*EyeDir;\n      if (abs(iPoint.z)*input.radiusVC > input.lengthVC*0.5)\n      {\n        // test for end cap\n        var t2: f32 = (-b + sqrt(d))*(0.5 / a);\n        var tz2: f32 = EyePos.z + t2*EyeDir.z;\n        if (tz2*input.radiusVC > input.lengthVC*0.5 || tz*input.radiusVC < -0.5*input.lengthVC) { discard; }\n        else\n        {\n          normal = input.orientVC;\n          var t3: f32 = (input.lengthVC*0.5/input.radiusVC - EyePos.z)/EyeDir.z;\n          iPoint = EyePos + t3*EyeDir;\n          vertexVC = vec4<f32>(input.radiusVC*(iPoint.x*base1 + iPoint.y*base2 + iPoint.z*input.orientVC) + input.centerVC, 1.0);\n        }\n      }\n      else\n      {\n        // The normal is the iPoint.xy rotated back into VC\n        normal = iPoint.x*base1 + iPoint.y*base2;\n        // rescale rerotate and translate\n        vertexVC = vec4<f32>(input.radiusVC*(normal + iPoint.z*input.orientVC) + input.centerVC, 1.0);\n      }\n      // compute the pixel's depth\n      var pos: vec4<f32> = rendererUBO.VCPCMatrix * vertexVC;\n      output.fragDepth = pos.z / pos.w;\n    }\n    ";
+    var stickFrag = "\n    // compute the eye position and unit direction\n    var vertexVC: vec4<f32>;\n    var EyePos: vec3<f32>;\n    var EyeDir: vec3<f32>;\n\n    if (rendererUBO.cameraParallel != 0u)\n    {\n      EyePos = vec3<f32>(input.vertexVC.x, input.vertexVC.y, input.vertexVC.z + 3.0*input.radiusVC);\n      EyeDir = vec3<f32>(0.0, 0.0, -1.0);\n    }\n    else\n    {\n      EyeDir = input.vertexVC.xyz;\n      EyePos = vec3<f32>(0.0,0.0,0.0);\n      var lengthED: f32 = length(EyeDir);\n      EyeDir = normalize(EyeDir);\n      // we adjust the EyePos to be closer if it is too far away\n      // to prevent floating point precision noise\n      if (lengthED > input.radiusVC*3.0)\n      {\n        EyePos = input.vertexVC.xyz - EyeDir*3.0*input.radiusVC;\n      }\n    }\n    // translate to Sphere center\n    EyePos = EyePos - input.centerVC;\n\n    // rotate to new basis\n    // base1, base2, orientVC\n    var base1: vec3<f32>;\n    if (abs(input.orientVC.z) < 0.99)\n    {\n      base1 = normalize(cross(input.orientVC,vec3<f32>(0.0,0.0,1.0)));\n    }\n    else\n    {\n      base1 = normalize(cross(input.orientVC,vec3<f32>(0.0,1.0,0.0)));\n    }\n    var base2: vec3<f32> = cross(input.orientVC,base1);\n    EyePos = vec3<f32>(dot(EyePos,base1),dot(EyePos,base2),dot(EyePos,input.orientVC));\n    EyeDir = vec3<f32>(dot(EyeDir,base1),dot(EyeDir,base2),dot(EyeDir,input.orientVC));\n\n    // scale to radius 1.0\n    EyePos = EyePos * (1.0 / input.radiusVC);\n\n    // find the intersection\n    var a: f32 = EyeDir.x*EyeDir.x + EyeDir.y*EyeDir.y;\n    var b: f32 = 2.0*(EyePos.x*EyeDir.x + EyePos.y*EyeDir.y);\n    var c: f32 = EyePos.x*EyePos.x + EyePos.y*EyePos.y - 1.0;\n    var d: f32 = b*b - 4.0*a*c;\n    var normal: vec3<f32> = vec3<f32>(0.0,0.0,1.0);\n    if (d < 0.0) { discard; }\n    else\n    {\n      var t: f32 = (-b - sqrt(d))*(0.5 / a);\n      var tz: f32 = EyePos.z + t*EyeDir.z;\n      var iPoint: vec3<f32> = EyePos + t*EyeDir;\n      if (abs(iPoint.z)*input.radiusVC > input.lengthVC*0.5)\n      {\n        // test for end cap\n        var t2: f32 = (-b + sqrt(d))*(0.5 / a);\n        var tz2: f32 = EyePos.z + t2*EyeDir.z;\n        if (tz2*input.radiusVC > input.lengthVC*0.5 || tz*input.radiusVC < -0.5*input.lengthVC) { discard; }\n        else\n        {\n          normal = input.orientVC;\n          var t3: f32 = (input.lengthVC*0.5/input.radiusVC - EyePos.z)/EyeDir.z;\n          iPoint = EyePos + t3*EyeDir;\n          vertexVC = vec4<f32>(input.radiusVC*(iPoint.x*base1 + iPoint.y*base2 + iPoint.z*input.orientVC) + input.centerVC, 1.0);\n        }\n      }\n      else\n      {\n        // The normal is the iPoint.xy rotated back into VC\n        normal = iPoint.x*base1 + iPoint.y*base2;\n        // rescale rerotate and translate\n        vertexVC = vec4<f32>(input.radiusVC*(normal + iPoint.z*input.orientVC) + input.centerVC, 1.0);\n      }\n    }\n    // compute the pixel's depth\n    var pos: vec4<f32> = rendererUBO.VCPCMatrix * vertexVC;\n    output.fragDepth = pos.z / pos.w;\n  ";
     var code = fDesc.getCode();
     code = vtkWebGPUShaderCache.substitute(code, '//VTK::Normal::Impl', [stickFrag]).result;
     fDesc.setCode(code);
@@ -97,16 +97,15 @@ function vtkWebGPUStickMapper(publicAPI, model) {
     publicAPI.setNumberOfInstances(numPoints);
     publicAPI.setNumberOfVertices(12);
     var vertexInput = model.vertexInput;
-    var buffRequest = {
-      owner: points,
-      hash: 'stm',
-      time: points.getMTime(),
-      usage: BufferUsage.RawVertex,
-      format: 'float32x3'
-    };
-
-    if (!device.getBufferManager().hasBuffer(buffRequest)) {
-      // xyz v1 v2 v3
+    var hash = "stm".concat(points.getMTime(), "float32x3");
+
+    if (!device.getBufferManager().hasBuffer(hash)) {
+      var buffRequest = {
+        hash: hash,
+        usage: BufferUsage.RawVertex,
+        format: 'float32x3'
+      }; // xyz v1 v2 v3
+
       var tmpVBO = new Float32Array(numPoints * 3);
       var pointIdx = 0;
       var vboIdx = 0;
@@ -133,15 +132,15 @@ function vtkWebGPUStickMapper(publicAPI, model) {
     var defaultRadius = model.renderable.getRadius();
 
     if (scales || defaultRadius !== model._lastRadius) {
-      buffRequest = {
-        owner: scales,
-        hash: 'stm',
-        time: scales ? pointData.getArray(model.renderable.getScaleArray()).getMTime() : 0,
-        usage: BufferUsage.RawVertex,
-        format: 'float32'
-      };
+      hash = "stm".concat(scales ? pointData.getArray(model.renderable.getScaleArray()).getMTime() : defaultRadius, "float32");
+
+      if (!device.getBufferManager().hasBuffer(hash)) {
+        var _buffRequest = {
+          hash: hash,
+          usage: BufferUsage.RawVertex,
+          format: 'float32'
+        };
 
-      if (!device.getBufferManager().hasBuffer(buffRequest)) {
         var _tmpVBO = new Float32Array(numPoints);
 
         var _vboIdx = 0;
@@ -156,9 +155,9 @@ function vtkWebGPUStickMapper(publicAPI, model) {
           _tmpVBO[_vboIdx++] = radius;
         }
 
-        buffRequest.nativeArray = _tmpVBO;
+        _buffRequest.nativeArray = _tmpVBO;
 
-        var _buff = device.getBufferManager().getBuffer(buffRequest);
+        var _buff = device.getBufferManager().getBuffer(_buffRequest);
 
         vertexInput.addBuffer(_buff, ['radiusMC'], 'instance');
       }
@@ -174,16 +173,15 @@ function vtkWebGPUStickMapper(publicAPI, model) {
       vtkErrorMacro(['Error setting orientationArray.\n', 'You have to specify the stick orientation']);
     }
 
-    buffRequest = {
-      owner: orientationArray,
-      hash: 'stm',
-      time: pointData.getArray(model.renderable.getOrientationArray()).getMTime(),
-      usage: BufferUsage.RawVertex,
-      format: 'float32x3'
-    };
+    hash = "stm".concat(pointData.getArray(model.renderable.getOrientationArray()).getMTime(), "float32x3");
+
+    if (!device.getBufferManager().hasBuffer(hash)) {
+      var _buffRequest2 = {
+        hash: hash,
+        usage: BufferUsage.RawVertex,
+        format: 'float32x3'
+      }; // xyz v1 v2 v3
 
-    if (!device.getBufferManager().hasBuffer(buffRequest)) {
-      // xyz v1 v2 v3
       var _tmpVBO2 = new Float32Array(numPoints * 3);
 
       var _pointIdx = 0;
@@ -202,9 +200,9 @@ function vtkWebGPUStickMapper(publicAPI, model) {
         _tmpVBO2[_vboIdx2++] = orientationArray[_pointIdx + 2] * length;
       }
 
-      buffRequest.nativeArray = _tmpVBO2;
+      _buffRequest2.nativeArray = _tmpVBO2;
 
-      var _buff2 = device.getBufferManager().getBuffer(buffRequest);
+      var _buff2 = device.getBufferManager().getBuffer(_buffRequest2);
 
       vertexInput.addBuffer(_buff2, ['orientMC'], 'instance');
     } // deal with colors but only if modified
@@ -216,15 +214,13 @@ function vtkWebGPUStickMapper(publicAPI, model) {
       var c = model.renderable.getColorMapColors();
 
       if (c) {
-        buffRequest = {
-          owner: c,
-          hash: 'stm',
-          time: c.getMTime(),
-          usage: BufferUsage.RawVertex,
-          format: 'unorm8x4'
-        };
+        hash = "stm".concat(c.getMTime(), "unorm8x4");
 
-        if (!device.getBufferManager().hasBuffer(buffRequest)) {
+        if (!device.getBufferManager().hasBuffer(hash)) {
+          var _buffRequest3 = {
+            usage: BufferUsage.RawVertex,
+            format: 'unorm8x4'
+          };
           var colorComponents = c.getNumberOfComponents();
 
           if (colorComponents !== 4) {
@@ -244,9 +240,9 @@ function vtkWebGPUStickMapper(publicAPI, model) {
             _tmpVBO3[_vboIdx3++] = colorData[colorIdx + 3];
           }
 
-          buffRequest.nativeArray = _tmpVBO3;
+          _buffRequest3.nativeArray = _tmpVBO3;
 
-          var _buff3 = device.getBufferManager().getBuffer(buffRequest);
+          var _buff3 = device.getBufferManager().getBuffer(_buffRequest3);
 
           vertexInput.addBuffer(_buff3, ['colorVI'], 'instance');
         }

package/Rendering/WebGPU/StorageBuffer.js

@@ -40,7 +40,6 @@ function vtkWebGPUStorageBuffer(publicAPI, model) {
     if (!model._buffer) {
       var req = {
         nativeArray: model.Float32Array,
-        time: 0,
         usage: BufferUsage.Storage,
         label: model.label
       };

package/Rendering/WebGPU/Texture.js

@@ -95,7 +95,6 @@ function vtkWebGPUTexture(publicAPI, model) {
 
       if (req.dataArray) {
         buffRequest.dataArray = req.dataArray;
-        buffRequest.time = req.dataArray.getMTime();
       }
 
       buffRequest.nativeArray = req.nativeArray; // bytesPerRow must be a multiple of 256 so we might need to rebuild
@@ -144,7 +143,6 @@ function vtkWebGPUTexture(publicAPI, model) {
 
       var _buffRequest = {
         nativeArray: imageData.data,
-        time: 0,
 
         /* eslint-disable no-undef */
         usage: BufferUsage.Texture,

package/Rendering/WebGPU/TextureManager.js

@@ -119,17 +119,47 @@ function vtkWebGPUTextureManager(publicAPI, model) {
 
   publicAPI.getTexture = function (req) {
     // if we have a source the get/create/cache the texture
-    if (req.owner) {
-      // fill out the req time and format based on imageData/image
-      _fillRequest(req); // if a matching texture already exists then return it
-
-
-      var hash = req.time + req.format;
-      return model.device.getCachedObject(req.owner, hash, _createTexture, req);
+    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 = {
+      time: imgData.getMTime()
+    };
+    treq.imageData = imgData; // fill out the req time and format based on imageData/image
+
+    _fillRequest(treq);
+
+    treq.hash = treq.time + treq.format;
+    return model.device.getTextureManager().getTexture(treq);
+  };
+
+  publicAPI.getTextureForVTKTexture = function (srcTexture) {
+    var treq = {
+      time: srcTexture.getMTime()
+    };
+
+    if (srcTexture.getInputData()) {
+      treq.imageData = srcTexture.getInputData();
+    } else if (srcTexture.getImage()) {
+      treq.image = srcTexture.getImage();
+    } else if (srcTexture.getJsImageData()) {
+      treq.jsImageData = srcTexture.getJsImageData();
+    } else if (srcTexture.getCanvas()) {
+      treq.canvas = srcTexture.getCanvas();
+    } // fill out the req time and format based on imageData/image
+
+
+    _fillRequest(treq);
+
+    treq.hash = treq.time + treq.format;
+    return model.device.getTextureManager().getTexture(treq);
+  };
 } // ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------

package/Rendering/WebGPU/UniformBuffer.js

@@ -206,7 +206,6 @@ function vtkWebGPUUniformBuffer(publicAPI, model) {
     if (!model.UBO) {
       var req = {
         nativeArray: model.Float32Array,
-        time: 0,
         usage: BufferUsage.UniformArray,
         label: model.label
       };

package/Rendering/WebGPU/VolumePass.js

@@ -260,11 +260,9 @@ function vtkWebGPUVolumePass(publicAPI, model) {
 
     var points = pd.getPoints();
     var buffRequest = {
-      owner: points,
       usage: BufferUsage.PointArray,
       format: 'float32x4',
-      time: Math.max(points.getMTime(), cells.getMTime()),
-      hash: 'vp',
+      hash: "vp".concat(points.getMTime()).concat(cells.getMTime()),
       dataArray: points,
       cells: cells,
       primitiveType: PrimitiveTypes.Triangles,

package/Rendering/WebGPU/VolumePassFSQ.js

@@ -455,11 +455,7 @@ function vtkWebGPUVolumePassFSQ(publicAPI, model) {
 
       var image = _volMapr4.getInputData();
 
-      var treq = {
-        imageData: image,
-        owner: image.getPointData().getScalars()
-      };
-      var newTex = model.device.getTextureManager().getTexture(treq);
+      var newTex = model.device.getTextureManager().getTextureForImageData(image);
 
       if (!model.textureViews[vidx + 4] || model.textureViews[vidx + 4].getTexture() !== newTex) {
         var tview = newTex.createView("volTexture".concat(vidx));

package/package.json

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