@kitware/vtk.js 22.5.1 → 22.5.2

package/Rendering/OpenGL.js

@@ -16,6 +16,7 @@ import vtkOpenGLPolyDataMapper from './OpenGL/PolyDataMapper.js';
 import vtkPolyDataMapper2D from './OpenGL/PolyDataMapper2D.js';
 import vtkRenderer from './OpenGL/Renderer.js';
 import vtkRenderWindow from './OpenGL/RenderWindow.js';
+import './OpenGL/ScalarBarActor.js';
 import vtkShader from './OpenGL/Shader.js';
 import vtkShaderCache from './OpenGL/ShaderCache.js';
 import vtkShaderProgram from './OpenGL/ShaderProgram.js';

package/Rendering/WebGPU/BufferManager/Constants.js

@@ -11,7 +11,8 @@ var BufferUsage = {
   NormalsFromPoints: 9,
   Texture: 10,
   RawVertex: 11,
-  Storage: 12
+  Storage: 12,
+  CellIndex: 13
 };
 var PrimitiveTypes = {
   Start: 0,

package/Rendering/WebGPU/BufferManager.js

@@ -20,15 +20,6 @@ var vtkDebugMacro = vtkDebugMacro$1; // the webgpu constants all show up as unde
 // ----------------------------------------------------------------------------
 
 var STATIC = {};
-
-function requestMatches(req1, req2) {
-  if (req1.time !== req2.time) return false;
-  if (req1.format !== req2.format) return false;
-  if (req1.usage !== req2.usage) return false;
-  if (req1.hash !== req2.hash) return false;
-  return true;
-}
-
 var cellCounters = {
   // easy, every input point becomes an output point
   anythingToPoints: function anythingToPoints(numPoints, cellPts) {
@@ -363,44 +354,10 @@ function generateNormals(cellArray, primType, representation, inArray) {
 
 function vtkWebGPUBufferManager(publicAPI, model) {
   // Set our className
-  model.classHierarchy.push('vtkWebGPUBufferManager'); // is the buffer already present?
-
-  publicAPI.hasBuffer = function (req) {
-    if (req.source) {
-      // if a matching buffer already exists then return true
-      if (model.buffers.has(req.source)) {
-        var dabuffers = model.buffers.get(req.source);
-
-        for (var i = 0; i < dabuffers.length; i++) {
-          if (requestMatches(dabuffers[i].request, req)) {
-            return true;
-          }
-        }
-      }
-    }
-
-    return false;
-  }; // we cache based on the passed in source, when the source is
-  // garbage collected then the cache entry is removed. If a source
-  // is not provided then the buffer is NOT cached and you are on your own
-  // if you want to share it etc
-
-
-  publicAPI.getBuffer = function (req) {
-    if (req.source) {
-      // if a matching buffer already exists then return it
-      if (model.buffers.has(req.source)) {
-        var dabuffers = model.buffers.get(req.source);
-
-        for (var i = 0; i < dabuffers.length; i++) {
-          if (requestMatches(dabuffers[i].request, req)) {
-            return dabuffers[i].buffer;
-          }
-        }
-      }
-    } // if a dataArray is provided set the nativeArray
-
+  model.classHierarchy.push('vtkWebGPUBufferManager');
 
+  function _createBuffer(req) {
+    // if a dataArray is provided set the nativeArray
     if (req.dataArray && !req.nativeArray) {
       req.nativeArray = req.dataArray.getData();
     } // create one
@@ -450,8 +407,7 @@ function vtkWebGPUBufferManager(publicAPI, model) {
         scale: req.scale,
         cellData: req.cellData,
         cellOffset: req.cellOffset
-      }); // console.log(result);
-
+      });
       buffer.createAndWrite(result.nativeArray, gpuUsage);
       buffer.setStrideInBytes(vtkWebGPUTypes.getByteStrideFromBufferFormat(req.format));
       buffer.setArrayInformation([{
@@ -482,29 +438,30 @@ function vtkWebGPUBufferManager(publicAPI, model) {
       }]);
     }
 
-    buffer.setSourceTime(req.time); // cache the buffer if we have a dataArray.
-    // We create a new req that only has the 4 fields required for
-    // a comparison to avoid GC cycles
+    buffer.setSourceTime(req.time);
+    return buffer;
+  } // is the buffer already present?
 
-    if (req.source) {
-      if (!model.buffers.has(req.source)) {
-        model.buffers.set(req.source, []);
-      }
 
-      var _dabuffers = model.buffers.get(req.source);
+  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);
+    }
 
-      _dabuffers.push({
-        request: {
-          time: req.time,
-          format: req.format,
-          usage: req.usage,
-          hash: req.hash
-        },
-        buffer: buffer
-      });
+    return false;
+  };
+
+  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);
     }
 
-    return buffer;
+    return _createBuffer(req);
   };
 
   publicAPI.getFullScreenQuadBuffer = function () {
@@ -538,9 +495,7 @@ function extend(publicAPI, model) {
   var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
   Object.assign(model, DEFAULT_VALUES, initialValues); // Object methods
 
-  obj(publicAPI, model); // this is a cache, and a cache with GC pretty much means WeakMap
-
-  model.buffers = new WeakMap();
+  obj(publicAPI, model);
   setGet(publicAPI, model, ['device']);
   vtkWebGPUBufferManager(publicAPI, model);
 } // ----------------------------------------------------------------------------

package/Rendering/WebGPU/Device.js

@@ -89,6 +89,76 @@ function vtkWebGPUDevice(publicAPI, model) {
 
   publicAPI.onSubmittedWorkDone = function () {
     return model.handle.queue.onSubmittedWorkDone();
+  }; // 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 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.getCachedObject = function (owner, hash, creator) {
+    if (!owner || !hash) {
+      vtkErrorMacro('attempt to cache an object without an owner or 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
+
+
+    for (var _len = arguments.length, args = new Array(_len > 3 ? _len - 3 : 0), _key = 3; _key < _len; _key++) {
+      args[_key - 3] = arguments[_key];
+    }
+
+    var createdObject = creator.apply(void 0, args);
+
+    if (!model.objectCache.has(owner)) {
+      model.objectCache.set(owner, []);
+    }
+
+    var objects = model.objectCache.get(owner);
+    objects.push({
+      hash: hash,
+      object: createdObject
+    });
+    return createdObject;
   };
 } // ----------------------------------------------------------------------------
 // Object factory
@@ -110,7 +180,9 @@ function extend(publicAPI, model) {
 
   obj(publicAPI, model);
   setGet(publicAPI, model, ['handle']);
-  get(publicAPI, model, ['bufferManager', 'shaderCache', 'textureManager']);
+  get(publicAPI, model, ['bufferManager', 'shaderCache', 'textureManager']); // this is a cache, and a cache with GC pretty much means WeakMap
+
+  model.objectCache = new WeakMap();
   model.shaderCache = vtkWebGPUShaderCache.newInstance();
   model.shaderCache.setDevice(publicAPI);
   model.bindGroupLayouts = [];

package/Rendering/WebGPU/ImageMapper.js

@@ -269,7 +269,7 @@ function vtkWebGPUImageMapper(publicAPI, model) {
   publicAPI.updateBuffers = function (device) {
     var treq = {
       imageData: model.currentInput,
-      source: model.currentInput
+      owner: model.currentInput.getPointData().getScalars()
     };
     var newTex = device.getTextureManager().getTexture(treq);
     var tViews = model.helper.getTextureViews();

package/Rendering/WebGPU/PolyDataMapper.js

@@ -262,7 +262,8 @@ function vtkWebGPUPolyDataMapper(publicAPI, model) {
       representation = Representation.WIREFRAME;
     }
 
-    var vertexInput = model.primitives[primType].getVertexInput(); // hash = all things that can change the values on the buffer
+    var vertexInput = model.primitives[primType].getVertexInput();
+    var hash = "R".concat(representation, "P").concat(primType); // 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
@@ -273,24 +274,23 @@ function vtkWebGPUPolyDataMapper(publicAPI, model) {
     // - usage
     // - packExtra - covered by format
     // - prim type (vert/lines/polys/strips) - covered by cells mtime
-
-    var hash = cells.getMTime() + representation; // points
+    // points
 
     var points = pd.getPoints();
 
     if (points) {
       var shift = model.WebGPUActor.getBufferShift(model.WebGPURenderer);
       var buffRequest = {
-        hash: hash + points.getMTime(),
+        owner: points,
+        usage: BufferUsage.PointArray,
+        format: 'float32x4',
+        time: Math.max(points.getMTime(), cells.getMTime(), model.WebGPUActor.getKeyMatricesTime().getMTime()),
+        hash: hash,
         dataArray: points,
-        source: points,
         cells: cells,
         primitiveType: primType,
         representation: representation,
-        time: Math.max(points.getMTime(), cells.getMTime(), model.WebGPUActor.getKeyMatricesTime().getMTime()),
         shift: shift,
-        usage: BufferUsage.PointArray,
-        format: 'float32x4',
         packExtra: true
       };
       var buff = device.getBufferManager().getBuffer(buffRequest);
@@ -305,19 +305,19 @@ function vtkWebGPUPolyDataMapper(publicAPI, model) {
     if (usage === BufferUsage.Triangles || usage === BufferUsage.Strips) {
       var normals = pd.getPointData().getNormals();
       var _buffRequest = {
+        format: 'snorm8x4',
+        hash: hash,
         cells: cells,
         representation: representation,
         primitiveType: primType,
-        format: 'snorm8x4',
         packExtra: true,
         shift: 0,
         scale: 127
       };
 
       if (normals) {
-        _buffRequest.hash = hash + normals.getMTime();
+        _buffRequest.owner = normals;
         _buffRequest.dataArray = normals;
-        _buffRequest.source = normals;
         _buffRequest.time = Math.max(normals.getMTime(), cells.getMTime());
         _buffRequest.usage = BufferUsage.PointArray;
 
@@ -325,9 +325,8 @@ function vtkWebGPUPolyDataMapper(publicAPI, model) {
 
         vertexInput.addBuffer(_buff, ['normalMC']);
       } else if (primType === PrimitiveTypes.Triangles) {
-        _buffRequest.hash = hash + points.getMTime();
+        _buffRequest.owner = points;
         _buffRequest.dataArray = points;
-        _buffRequest.source = points;
         _buffRequest.time = Math.max(points.getMTime(), cells.getMTime());
         _buffRequest.usage = BufferUsage.NormalsFromPoints;
 
@@ -356,15 +355,15 @@ function vtkWebGPUPolyDataMapper(publicAPI, model) {
         }
 
         var _buffRequest2 = {
-          hash: hash + points.getMTime(),
+          owner: c,
+          usage: BufferUsage.PointArray,
+          format: 'unorm8x4',
+          time: Math.max(c.getMTime(), cells.getMTime(), points.getMTime()),
+          hash: hash + haveCellScalars,
           dataArray: c,
-          source: c,
           cells: cells,
           primitiveType: primType,
           representation: representation,
-          time: Math.max(c.getMTime(), cells.getMTime()),
-          usage: BufferUsage.PointArray,
-          format: 'unorm8x4',
           cellData: haveCellScalars,
           cellOffset: 0
         };
@@ -390,15 +389,15 @@ function vtkWebGPUPolyDataMapper(publicAPI, model) {
 
     if (tcoords && !edges) {
       var _buffRequest3 = {
-        hash: hash + tcoords.getMTime(),
+        owner: tcoords,
+        usage: BufferUsage.PointArray,
+        format: 'float32x2',
+        time: Math.max(tcoords.getMTime(), cells.getMTime()),
+        hash: hash,
         dataArray: tcoords,
-        source: tcoords,
         cells: cells,
         primitiveType: primType,
-        representation: representation,
-        time: Math.max(tcoords.getMTime(), cells.getMTime()),
-        usage: BufferUsage.PointArray,
-        format: 'float32x2'
+        representation: representation
       };
 
       var _buff4 = device.getBufferManager().getBuffer(_buffRequest3);
@@ -450,10 +449,10 @@ function vtkWebGPUPolyDataMapper(publicAPI, model) {
 
       if (srcTexture.getInputData()) {
         treq.imageData = srcTexture.getInputData();
-        treq.source = treq.imageData;
+        treq.owner = treq.imageData.getPointData().getScalars();
       } else if (srcTexture.getImage()) {
         treq.image = srcTexture.getImage();
-        treq.source = treq.image;
+        treq.owner = treq.image;
       }
 
       var newTex = model.device.getTextureManager().getTexture(treq);

package/Rendering/WebGPU/RenderEncoder.js

@@ -22,7 +22,7 @@ function vtkWebGPURenderEncoder(publicAPI, model) {
       model.handle.popDebugGroup();
     }
 
-    model.handle.endPass();
+    model.handle.end();
   };
 
   publicAPI.setPipeline = function (pl) {

package/Rendering/WebGPU/SphereMapper.js

@@ -67,8 +67,8 @@ function vtkWebGPUSphereMapper(publicAPI, model) {
     primHelper.setNumberOfVertices(3 * numPoints);
     var vertexInput = model.primitives[i].getVertexInput();
     var buffRequest = {
-      hash: points.getMTime(),
-      source: points,
+      owner: points,
+      hash: 'spm',
       time: points.getMTime(),
       usage: BufferUsage.RawVertex,
       format: 'float32x3'
@@ -110,8 +110,8 @@ function vtkWebGPUSphereMapper(publicAPI, model) {
 
     if (scales || defaultRadius !== model._lastRadius) {
       buffRequest = {
-        hash: scales,
-        source: scales,
+        owner: scales,
+        hash: 'spm',
         time: scales ? pointData.getArray(model.renderable.getScaleArray()).getMTime() : 0,
         usage: BufferUsage.RawVertex,
         format: 'float32x2'
@@ -157,8 +157,8 @@ function vtkWebGPUSphereMapper(publicAPI, model) {
 
       if (c) {
         buffRequest = {
-          hash: c,
-          source: c,
+          owner: c,
+          hash: 'spm',
           time: c.getMTime(),
           usage: BufferUsage.RawVertex,
           format: 'unorm8x4'

package/Rendering/WebGPU/StickMapper.js

@@ -89,8 +89,8 @@ function vtkWebGPUStickMapper(publicAPI, model) {
     primHelper.setNumberOfVertices(12);
     var vertexInput = model.primitives[i].getVertexInput();
     var buffRequest = {
-      hash: points.getMTime(),
-      source: points,
+      owner: points,
+      hash: 'stm',
       time: points.getMTime(),
       usage: BufferUsage.RawVertex,
       format: 'float32x3'
@@ -125,8 +125,8 @@ function vtkWebGPUStickMapper(publicAPI, model) {
 
     if (scales || defaultRadius !== model._lastRadius) {
       buffRequest = {
-        hash: scales,
-        source: scales,
+        owner: scales,
+        hash: 'stm',
         time: scales ? pointData.getArray(model.renderable.getScaleArray()).getMTime() : 0,
         usage: BufferUsage.RawVertex,
         format: 'float32'
@@ -166,8 +166,8 @@ function vtkWebGPUStickMapper(publicAPI, model) {
     }
 
     buffRequest = {
-      hash: scales,
-      source: orientationArray,
+      owner: orientationArray,
+      hash: 'stm',
       time: pointData.getArray(model.renderable.getOrientationArray()).getMTime(),
       usage: BufferUsage.RawVertex,
       format: 'float32x3'
@@ -209,8 +209,8 @@ function vtkWebGPUStickMapper(publicAPI, model) {
 
       if (c) {
         buffRequest = {
-          hash: c,
-          source: c,
+          owner: c,
+          hash: 'stm',
           time: c.getMTime(),
           usage: BufferUsage.RawVertex,
           format: 'unorm8x4'

package/Rendering/WebGPU/TextureManager.js

@@ -5,26 +5,15 @@ import vtkWebGPUTexture from './Texture.js';
 var VtkDataTypes = vtkDataArray.VtkDataTypes; // ----------------------------------------------------------------------------
 // Global methods
 // ----------------------------------------------------------------------------
-
-function requestMatches(req1, req2) {
-  if (req1.time !== req2.time) return false;
-  if (req1.nativeArray !== req2.nativeArray) return false;
-  if (req1.format !== req2.format) return false;
-  return true;
-} // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
 // vtkWebGPUTextureManager methods
 // ----------------------------------------------------------------------------
 
-
 function vtkWebGPUTextureManager(publicAPI, model) {
   // Set our className
-  model.classHierarchy.push('vtkWebGPUTextureManager'); // The keys fields of a request are
-  // - source, this is what owns the data and when it does away
-  //   the data should be freed
-  // - imageData - when provided use as the source of the data
-  //
+  model.classHierarchy.push('vtkWebGPUTextureManager'); // fills in request values based on what is missing/provided
 
-  publicAPI.getTexture = function (req) {
+  function _fillRequest(req) {
     // fill in values based on imageData if the request has it
     if (req.imageData) {
       req.dataArray = req.imageData.getPointData().getScalars();
@@ -81,20 +70,10 @@ function vtkWebGPUTextureManager(publicAPI, model) {
       req.depth = 1;
       req.format = 'rgba8unorm';
     }
+  } // create a texture (used by getTexture)
 
-    if (req.source) {
-      // if a matching texture already exists then return it
-      if (model.textures.has(req.source)) {
-        var dabuffers = model.textures.get(req.source);
-
-        for (var i = 0; i < dabuffers.length; i++) {
-          if (requestMatches(dabuffers[i].request, req)) {
-            return dabuffers[i].texture;
-          }
-        }
-      }
-    }
 
+  function _createTexture(req) {
     var newTex = vtkWebGPUTexture.newInstance();
     newTex.create(model.device, {
       width: req.width,
@@ -105,29 +84,25 @@ function vtkWebGPUTextureManager(publicAPI, model) {
 
     if (req.nativeArray || req.image) {
       newTex.writeImageData(req);
-    } // cache the texture if we have a source
-    // We create a new req that only has the fields required for
-    // a comparison to avoid GC cycles
+    }
 
+    return newTex;
+  } // get a texture or create it if not cached.
+  // this is the main entry point
 
-    if (req.source) {
-      if (!model.textures.has(req.source)) {
-        model.textures.set(req.source, []);
-      }
 
-      var _dabuffers = model.textures.get(req.source);
+  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
 
-      _dabuffers.push({
-        request: {
-          time: req.time,
-          nativeArray: req.nativeArray,
-          format: req.format
-        },
-        texture: newTex
-      });
+
+      var hash = req.time + req.format;
+      return model.device.getCachedObject(req.owner, hash, _createTexture, req);
     }
 
-    return newTex;
+    return _createTexture(req);
   };
 } // ----------------------------------------------------------------------------
 // Object factory
@@ -135,7 +110,6 @@ function vtkWebGPUTextureManager(publicAPI, model) {
 
 
 var DEFAULT_VALUES = {
-  textures: null,
   handle: null,
   device: null
 }; // ----------------------------------------------------------------------------
@@ -144,9 +118,7 @@ function extend(publicAPI, model) {
   var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
   Object.assign(model, DEFAULT_VALUES, initialValues); // Object methods
 
-  macro.obj(publicAPI, model); // this is a cache, and a cache with GC pretty much means WeakMap
-
-  model.textures = new WeakMap();
+  macro.obj(publicAPI, model);
   macro.setGet(publicAPI, model, ['device']);
   vtkWebGPUTextureManager(publicAPI, model);
 } // ----------------------------------------------------------------------------

package/Rendering/WebGPU/VolumePass.js

@@ -259,20 +259,19 @@ function vtkWebGPUVolumePass(publicAPI, model) {
   publicAPI.renderDepthBounds = function (renNode, viewNode) {
     publicAPI.updateDepthPolyData(renNode);
     var pd = model._boundsPoly;
-    var cells = pd.getPolys();
-    var hash = cells.getMTime(); // points
+    var cells = pd.getPolys(); // points
 
     var points = pd.getPoints();
     var buffRequest = {
-      hash: hash + points.getMTime(),
+      owner: points,
+      usage: BufferUsage.PointArray,
+      format: 'float32x4',
+      time: Math.max(points.getMTime(), cells.getMTime()),
+      hash: 'vp',
       dataArray: points,
-      source: points,
       cells: cells,
       primitiveType: PrimitiveTypes.Triangles,
       representation: Representation.SURFACE,
-      time: Math.max(points.getMTime(), cells.getMTime()),
-      usage: BufferUsage.PointArray,
-      format: 'float32x4',
       packExtra: true
     };
     var buff = viewNode.getDevice().getBufferManager().getBuffer(buffRequest);

package/Rendering/WebGPU/VolumePassFSQ.js

@@ -454,7 +454,7 @@ function vtkWebGPUVolumePassFSQ(publicAPI, model) {
 
       var treq = {
         imageData: image,
-        source: image
+        owner: image.getPointData().getScalars()
       };
       var newTex = device.getTextureManager().getTexture(treq);
 

package/Rendering/WebGPU.js

@@ -1,4 +1,20 @@
 import vtkRenderWindow from './WebGPU/RenderWindow.js';
+import './WebGPU/Actor.js';
+import './WebGPU/Camera.js';
+import './WebGPU/ForwardPass.js';
+import './WebGPU/Glyph3DMapper.js';
+import './WebGPU/HardwareSelector.js';
+import './WebGPU/ImageMapper.js';
+import './WebGPU/ImageSlice.js';
+import './WebGPU/PixelSpaceCallbackMapper.js';
+import './WebGPU/PolyDataMapper.js';
+import './WebGPU/Renderer.js';
+import './WebGPU/ScalarBarActor.js';
+import './WebGPU/SphereMapper.js';
+import './WebGPU/StickMapper.js';
+import './WebGPU/Texture.js';
+import './WebGPU/ViewNodeFactory.js';
+import './WebGPU/Volume.js';
 
 var WebGPU = {
   vtkRenderWindow: vtkRenderWindow

package/package.json

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