@kitware/vtk.js 24.5.4 → 24.6.0

package/Rendering/WebGPU/CellArrayMapper.js

@@ -121,9 +121,11 @@ function vtkWebGPUCellArrayMapper(publicAPI, model) {
   model.shaderReplacements.set('replaceShaderPosition', publicAPI.replaceShaderPosition);
 
   publicAPI.replaceShaderNormal = function (hash, pipeline, vertexInput) {
-    if (vertexInput.hasAttribute('normalMC')) {
+    var normalBuffer = vertexInput.getBuffer('normalMC');
+
+    if (normalBuffer) {
       var vDesc = pipeline.getShaderDescription('vertex');
-      vDesc.addOutput('vec3<f32>', 'normalVC');
+      vDesc.addOutput('vec3<f32>', 'normalVC', normalBuffer.getArrayInformation()[0].interpolation);
       var code = vDesc.getCode();
       code = vtkWebGPUShaderCache.substitute(code, '//VTK::Normal::Impl', ['  output.normalVC = normalize((rendererUBO.WCVCNormals * mapperUBO.MCWCNormals * normalMC).xyz);']).result;
       vDesc.setCode(code);
@@ -165,9 +167,10 @@ function vtkWebGPUCellArrayMapper(publicAPI, model) {
       return;
     }
 
-    if (!vertexInput.hasAttribute('colorVI')) return;
+    var colorBuffer = vertexInput.getBuffer('colorVI');
+    if (!colorBuffer) return;
     var vDesc = pipeline.getShaderDescription('vertex');
-    vDesc.addOutput('vec4<f32>', 'color');
+    vDesc.addOutput('vec4<f32>', 'color', colorBuffer.getArrayInformation()[0].interpolation);
     var code = vDesc.getCode();
     code = vtkWebGPUShaderCache.substitute(code, '//VTK::Color::Impl', ['  output.color = colorVI;']).result;
     vDesc.setCode(code);
@@ -276,37 +279,46 @@ function vtkWebGPUCellArrayMapper(publicAPI, model) {
     }
 
     var vertexInput = model.vertexInput;
-    var hash = "R".concat(representation, "P").concat(primType); // hash = all things that can change the values on the buffer
+    var points = pd.getPoints();
+    var indexBuffer; // get the flat mapping indexBuffer for the cells
+
+    if (cells) {
+      var buffRequest = {
+        hash: "R".concat(representation, "P").concat(primType).concat(cells.getMTime()),
+        usage: BufferUsage.Index,
+        cells: cells,
+        numberOfPoints: points.getNumberOfPoints(),
+        primitiveType: primType,
+        representation: representation
+      };
+      indexBuffer = device.getBufferManager().getBuffer(buffRequest);
+      vertexInput.setIndexBuffer(indexBuffer);
+    } else {
+      vertexInput.setIndexBuffer(null);
+    } // hash = all things that can change the values on the buffer
     // since mtimes are unique we can use
-    // - cells mtime - because cells drive how we pack
-    // - rep (point/wireframe/surface) - again because of packing
+    // - indexBuffer mtime - because cells drive how we pack
     // - relevant dataArray mtime - the source data
     // - shift - not currently captured
     // - scale - not currently captured
     // - format
     // - usage
     // - packExtra - covered by format
-    // - prim type (vert/lines/polys/strips) - covered by cells mtime
     // points
 
-    var points = pd.getPoints();
 
     if (points) {
       var shift = model.WebGPUActor.getBufferShift(model.WebGPURenderer);
-      var buffRequest = {
-        owner: points,
+      var _buffRequest = {
+        hash: "".concat(points.getMTime(), "I").concat(indexBuffer.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,
-        representation: representation,
+        indexBuffer: indexBuffer,
         shift: shift,
         packExtra: true
       };
-      var buff = device.getBufferManager().getBuffer(buffRequest);
+      var buff = device.getBufferManager().getBuffer(_buffRequest);
       vertexInput.addBuffer(buff, ['vertexBC']);
     } else {
       vertexInput.removeBufferIfPresent('vertexBC');
@@ -317,33 +329,29 @@ function vtkWebGPUCellArrayMapper(publicAPI, model) {
 
     if (usage === BufferUsage.Triangles || usage === BufferUsage.Strips) {
       var normals = pd.getPointData().getNormals();
-      var _buffRequest = {
+      var _buffRequest2 = {
         format: 'snorm8x4',
-        hash: hash,
-        cells: cells,
-        representation: representation,
-        primitiveType: primType,
+        indexBuffer: indexBuffer,
         packExtra: true,
         shift: 0,
         scale: 127
       };
 
       if (normals) {
-        _buffRequest.owner = normals;
-        _buffRequest.dataArray = normals;
-        _buffRequest.time = Math.max(normals.getMTime(), cells.getMTime());
-        _buffRequest.usage = BufferUsage.PointArray;
+        _buffRequest2.hash = "".concat(normals.getMTime(), "I").concat(indexBuffer.getMTime(), "snorm8x4");
+        _buffRequest2.dataArray = normals;
+        _buffRequest2.usage = BufferUsage.PointArray;
 
-        var _buff = device.getBufferManager().getBuffer(_buffRequest);
+        var _buff = device.getBufferManager().getBuffer(_buffRequest2);
 
         vertexInput.addBuffer(_buff, ['normalMC']);
       } else if (primType === PrimitiveTypes.Triangles) {
-        _buffRequest.owner = points;
-        _buffRequest.dataArray = points;
-        _buffRequest.time = Math.max(points.getMTime(), cells.getMTime());
-        _buffRequest.usage = BufferUsage.NormalsFromPoints;
+        _buffRequest2.hash = "PFN".concat(points.getMTime(), "I").concat(indexBuffer.getMTime(), "snorm8x4");
+        _buffRequest2.dataArray = points;
+        _buffRequest2.cells = cells;
+        _buffRequest2.usage = BufferUsage.NormalsFromPoints;
 
-        var _buff2 = device.getBufferManager().getBuffer(_buffRequest);
+        var _buff2 = device.getBufferManager().getBuffer(_buffRequest2);
 
         vertexInput.addBuffer(_buff2, ['normalMC']);
       } else {
@@ -367,21 +375,17 @@ function vtkWebGPUCellArrayMapper(publicAPI, model) {
           haveCellScalars = true;
         }
 
-        var _buffRequest2 = {
-          owner: c,
+        var _buffRequest3 = {
           usage: BufferUsage.PointArray,
           format: 'unorm8x4',
-          time: Math.max(c.getMTime(), cells.getMTime(), points.getMTime()),
-          hash: hash + haveCellScalars,
+          hash: "".concat(haveCellScalars).concat(c.getMTime(), "I").concat(indexBuffer.getMTime(), "unorm8x4"),
           dataArray: c,
-          cells: cells,
-          primitiveType: primType,
-          representation: representation,
+          indexBuffer: indexBuffer,
           cellData: haveCellScalars,
           cellOffset: 0
         };
 
-        var _buff3 = device.getBufferManager().getBuffer(_buffRequest2);
+        var _buff3 = device.getBufferManager().getBuffer(_buffRequest3);
 
         vertexInput.addBuffer(_buff3, ['colorVI']);
         haveColors = true;
@@ -401,20 +405,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, vertexInput.getIndexBuffer());
 
       vertexInput.addBuffer(_buff4, ['tcoord']);
     } else {
@@ -459,25 +450,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) {