@kitware/vtk.js 24.5.4 → 24.6.0

package/Rendering/WebGPU/IndexBuffer.js

@@ -0,0 +1,397 @@
+import _defineProperty from '@babel/runtime/helpers/defineProperty';
+import _classCallCheck from '@babel/runtime/helpers/classCallCheck';
+import _createClass from '@babel/runtime/helpers/createClass';
+import macro from '../../macros.js';
+import Constants from './BufferManager/Constants.js';
+import vtkProperty from '../Core/Property.js';
+import vtkWebGPUBuffer from './Buffer.js';
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+var Representation = vtkProperty.Representation;
+var PrimitiveTypes = Constants.PrimitiveTypes; // Simulate a small map of pointId to flatId for a cell. The original code
+// used a map and was 2.6x slower (4.7 to 1.9 seconds). Using two fixed
+// length arrays with a count is so much faster even with the required for
+// loops and if statements. This only works as we know the usage is
+// restricted to clear(), set() get() and has() so the count is always
+// incrmenting except for clear where it goes back to 0. Performance
+// improvement is probably due to this appoach not hitting the heap but wow
+// it is so much faster. Code that adds to these vectors checks against 9 to
+// make sure there is room. Switching to test against vec.length -1 results
+// in a small performance hit, so if you change 10, search for 9 in this
+// small class and change those as well.
+
+var _LimitedMap = /*#__PURE__*/function () {
+  function _LimitedMap() {
+    _classCallCheck(this, _LimitedMap);
+
+    this.keys = new Uint32Array(10);
+    this.values = new Uint32Array(10);
+    this.count = 0;
+  }
+
+  _createClass(_LimitedMap, [{
+    key: "clear",
+    value: function clear() {
+      this.count = 0;
+    }
+  }, {
+    key: "has",
+    value: function has(key) {
+      for (var i = 0; i < this.count; i++) {
+        if (this.keys[i] === key) {
+          return true;
+        }
+      }
+
+      return undefined;
+    }
+  }, {
+    key: "get",
+    value: function get(key) {
+      for (var i = 0; i < this.count; i++) {
+        if (this.keys[i] === key) {
+          return this.values[i];
+        }
+      }
+
+      return undefined;
+    }
+  }, {
+    key: "set",
+    value: function set(key, value) {
+      if (this.count < 9) {
+        this.keys[this.count] = key;
+        this.values[this.count++] = value;
+      }
+    }
+  }]);
+
+  return _LimitedMap;
+}();
+
+function getPrimitiveName(primType) {
+  switch (primType) {
+    case PrimitiveTypes.Points:
+      return 'points';
+
+    case PrimitiveTypes.Lines:
+      return 'lines';
+
+    case PrimitiveTypes.Triangles:
+    case PrimitiveTypes.TriangleEdges:
+      return 'polys';
+
+    case PrimitiveTypes.TriangleStripEdges:
+    case PrimitiveTypes.TriangleStrips:
+      return 'strips';
+
+    default:
+      return '';
+  }
+}
+
+function _getOrAddFlatId(state, ptId, cellId) {
+  var flatId = state.pointIdToFlatId[ptId];
+
+  if (flatId < 0) {
+    flatId = state.flatId;
+    state.pointIdToFlatId[ptId] = flatId;
+    state.flatIdToPointId[state.flatId] = ptId;
+    state.flatIdToCellId[state.flatId] = cellId;
+    state.flatId++;
+  }
+
+  return flatId;
+}
+
+function fillCell(ptIds, cellId, state) {
+  var numPtIds = ptIds.length; // are any points already marked for this cell? If so use that as the provoking point
+
+  for (var ptIdx = 0; ptIdx < numPtIds; ptIdx++) {
+    var _ptId = ptIds[ptIdx];
+
+    if (state.cellProvokedMap.has(_ptId)) {
+      state.ibo[state.iboId++] = state.cellProvokedMap.get(_ptId); // insert remaining ptIds (they do not need to provoke)
+
+      for (var ptIdx2 = ptIdx + 1; ptIdx2 < ptIdx + numPtIds; ptIdx2++) {
+        _ptId = ptIds[ptIdx2 % numPtIds];
+
+        var _flatId = _getOrAddFlatId(state, _ptId, cellId); // add to ibo
+
+
+        state.ibo[state.iboId++] = _flatId;
+      } // all done now
+
+
+      return;
+    }
+  } // else have any of the points not been used yet? (not in provokedPointIds)
+
+
+  for (var _ptIdx = 0; _ptIdx < numPtIds; _ptIdx++) {
+    var _ptId2 = ptIds[_ptIdx];
+
+    if (!state.provokedPointIds[_ptId2]) {
+      var _flatId2 = _getOrAddFlatId(state, _ptId2, cellId); // mark provoking and add to ibo
+
+
+      state.provokedPointIds[_ptId2] = 1;
+      state.cellProvokedMap.set(_ptId2, _flatId2); // when provoking always set the cellId as an original non-provoking value
+      // will have been stored and we need to overwrite that
+
+      state.flatIdToCellId[_flatId2] = cellId;
+      state.ibo[state.iboId++] = _flatId2; // insert remaining ptIds (they do not need to provoke)
+
+      for (var _ptIdx2 = _ptIdx + 1; _ptIdx2 < _ptIdx + numPtIds; _ptIdx2++) {
+        _ptId2 = ptIds[_ptIdx2 % numPtIds];
+        _flatId2 = _getOrAddFlatId(state, _ptId2, cellId); // add to ibo
+
+        state.ibo[state.iboId++] = _flatId2;
+      } // all done now
+
+
+      return;
+    }
+  } // if we got here then none of the ptIds could be used to provoke
+  // so just duplicate the first one
+
+
+  var ptId = ptIds[0];
+  var flatId = state.flatId;
+  state.cellProvokedMap.set(ptId, flatId);
+  state.flatIdToPointId[state.flatId] = ptId;
+  state.flatIdToCellId[state.flatId] = cellId;
+  state.flatId++; // add to ibo
+
+  state.ibo[state.iboId++] = flatId; // insert remaining ptIds (they do not need to provoke)
+
+  for (var _ptIdx3 = 1; _ptIdx3 < numPtIds; _ptIdx3++) {
+    ptId = ptIds[_ptIdx3];
+    flatId = _getOrAddFlatId(state, ptId, cellId); // add to ibo
+
+    state.ibo[state.iboId++] = flatId;
+  }
+}
+
+function countCell(ptIds, cellId, state) {
+  var numPtIds = ptIds.length;
+  state.iboSize += numPtIds; // are any points already marked for this cell? If so use that as the provoking point
+
+  for (var ptIdx = 0; ptIdx < numPtIds; ptIdx++) {
+    var ptId = ptIds[ptIdx];
+
+    if (state.cellProvokedMap.has(ptId)) {
+      return;
+    }
+  } // else have any of the points not been used yet? (not in provokedPointIds)
+
+
+  for (var _ptIdx4 = 0; _ptIdx4 < numPtIds; _ptIdx4++) {
+    var _ptId3 = ptIds[_ptIdx4];
+
+    if (!state.provokedPointIds[_ptId3]) {
+      state.provokedPointIds[_ptId3] = 1;
+      state.cellProvokedMap.set(_ptId3, 1);
+      return;
+    }
+  } // if we got here then none of the ptIds could be used to provoke
+
+
+  state.cellProvokedMap.set(ptIds[0], 1);
+  state.extraPoints++;
+}
+
+var processCell;
+
+var _single = new Uint32Array(1);
+
+var _double = new Uint32Array(2);
+
+var _triple = new Uint32Array(3);
+
+var _indexCellBuilders = {
+  // easy, every input point becomes an output point
+  anythingToPoints: function anythingToPoints(numPoints, cellPts, offset, cellId, state) {
+    for (var i = 0; i < numPoints; ++i) {
+      _single[0] = cellPts[offset + i];
+      processCell(_single, cellId, state);
+    }
+  },
+  linesToWireframe: function linesToWireframe(numPoints, cellPts, offset, cellId, state) {
+    // for lines we add a bunch of segments
+    for (var i = 0; i < numPoints - 1; ++i) {
+      _double[0] = cellPts[offset + i];
+      _double[1] = cellPts[offset + i + 1];
+      processCell(_double, cellId, state);
+    }
+  },
+  polysToWireframe: function polysToWireframe(numPoints, cellPts, offset, cellId, state) {
+    // for polys we add a bunch of segments and close it
+    if (numPoints > 2) {
+      for (var i = 0; i < numPoints; ++i) {
+        _double[0] = cellPts[offset + i];
+        _double[1] = cellPts[offset + (i + 1) % numPoints];
+        processCell(_double, cellId, state);
+      }
+    }
+  },
+  stripsToWireframe: function stripsToWireframe(numPoints, cellPts, offset, cellId, state) {
+    if (numPoints > 2) {
+      // for strips we add a bunch of segments and close it
+      for (var i = 0; i < numPoints - 1; ++i) {
+        _double[0] = cellPts[offset + i];
+        _double[1] = cellPts[offset + i + 1];
+        processCell(_double, cellId, state);
+      }
+
+      for (var _i = 0; _i < numPoints - 2; _i++) {
+        _double[0] = cellPts[offset + _i];
+        _double[1] = cellPts[offset + _i + 2];
+        processCell(_double, cellId, state);
+      }
+    }
+  },
+  polysToSurface: function polysToSurface(npts, cellPts, offset, cellId, state) {
+    for (var i = 0; i < npts - 2; i++) {
+      _triple[0] = cellPts[offset];
+      _triple[1] = cellPts[offset + i + 1];
+      _triple[2] = cellPts[offset + i + 2];
+      processCell(_triple, cellId, state);
+    }
+  },
+  stripsToSurface: function stripsToSurface(npts, cellPts, offset, cellId, state) {
+    for (var i = 0; i < npts - 2; i++) {
+      _triple[0] = cellPts[offset + i];
+      _triple[1] = cellPts[offset + i + 1 + i % 2];
+      _triple[2] = cellPts[offset + i + 1 + (i + 1) % 2];
+      processCell(_triple, cellId, state);
+    }
+  }
+}; // ----------------------------------------------------------------------------
+// vtkWebGPUIndexBufferManager methods
+// ----------------------------------------------------------------------------
+
+function vtkWebGPUIndexBuffer(publicAPI, model) {
+  // Set our className
+  model.classHierarchy.push('vtkWebGPUIndexBuffer');
+
+  publicAPI.buildIndexBuffer = function (req) {
+    var cellArray = req.cells;
+    var primitiveType = req.primitiveType;
+    var representation = req.representation;
+    var cellOffset = req.cellOffset;
+    var array = cellArray.getData();
+    var cellArraySize = array.length;
+    var inRepName = getPrimitiveName(primitiveType);
+    var numPts = req.numberOfPoints;
+    var state = {
+      provokedPointIds: new Uint8Array(numPts),
+      // size is good
+      extraPoints: 0,
+      iboSize: 0,
+      flatId: 0,
+      iboId: 0,
+      cellProvokedMap: new _LimitedMap()
+    };
+    var func = null;
+
+    if (representation === Representation.POINTS || primitiveType === PrimitiveTypes.Points) {
+      func = _indexCellBuilders.anythingToPoints;
+    } else if (representation === Representation.WIREFRAME || primitiveType === PrimitiveTypes.Lines) {
+      func = _indexCellBuilders["".concat(inRepName, "ToWireframe")];
+    } else {
+      func = _indexCellBuilders["".concat(inRepName, "ToSurface")];
+    } // first we count how many extra provoking points we need
+
+
+    processCell = countCell;
+    var cellId = cellOffset || 0;
+
+    for (var cellArrayIndex = 0; cellArrayIndex < cellArraySize;) {
+      state.cellProvokedMap.clear();
+      func(array[cellArrayIndex], array, cellArrayIndex + 1, cellId, state);
+      cellArrayIndex += array[cellArrayIndex] + 1;
+      cellId++;
+    } // then we allocate the remaining structures
+    // (we pick the best size to save space and transfer costs)
+
+
+    if (numPts <= 0xffff) {
+      state.flatIdToPointId = new Uint16Array(numPts + state.extraPoints);
+    } else {
+      state.flatIdToPointId = new Uint32Array(numPts + state.extraPoints);
+    }
+
+    if (numPts + state.extraPoints < 0x8fff) {
+      state.pointIdToFlatId = new Int16Array(numPts);
+    } else {
+      state.pointIdToFlatId = new Int32Array(numPts);
+    }
+
+    if (numPts + state.extraPoints <= 0xffff) {
+      state.ibo = new Uint16Array(state.iboSize);
+      req.format = 'uint16';
+    } else {
+      state.ibo = new Uint32Array(state.iboSize);
+      req.format = 'uint32';
+    }
+
+    if (cellId <= 0xffff) {
+      state.flatIdToCellId = new Uint16Array(numPts + state.extraPoints);
+    } else {
+      state.flatIdToCellId = new Uint32Array(numPts + state.extraPoints);
+    }
+
+    state.pointIdToFlatId.fill(-1);
+    state.provokedPointIds.fill(0); // and fill them in
+
+    processCell = fillCell;
+    cellId = cellOffset || 0;
+
+    for (var _cellArrayIndex = 0; _cellArrayIndex < cellArraySize;) {
+      state.cellProvokedMap.clear();
+      func(array[_cellArrayIndex], array, _cellArrayIndex + 1, cellId, state);
+      _cellArrayIndex += array[_cellArrayIndex] + 1;
+      cellId++;
+    }
+
+    delete state.provokedPointIds;
+    delete state.pointIdToFlatId; // store the results we need
+
+    req.nativeArray = state.ibo;
+    model.flatIdToPointId = state.flatIdToPointId;
+    model.flatIdToCellId = state.flatIdToCellId;
+    model.flatSize = state.flatId;
+    model.indexCount = state.iboId;
+  };
+} // ----------------------------------------------------------------------------
+// Object factory
+// ----------------------------------------------------------------------------
+
+
+var DEFAULT_VALUES = {
+  flatIdToPointId: null,
+  flatIdToCellId: null,
+  flatSize: 0,
+  indexCount: 0
+}; // ----------------------------------------------------------------------------
+
+function extend(publicAPI, model) {
+  var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  Object.assign(model, DEFAULT_VALUES, initialValues); // Inheritance
+
+  vtkWebGPUBuffer.extend(publicAPI, model, initialValues);
+  macro.setGet(publicAPI, model, ['flatIdToPointId', 'flatIdToCellId', 'flatSize', 'indexCount']);
+  vtkWebGPUIndexBuffer(publicAPI, model);
+} // ----------------------------------------------------------------------------
+
+var newInstance = macro.newInstance(extend); // ----------------------------------------------------------------------------
+
+var vtkWebGPUIndexBuffer$1 = _objectSpread({
+  newInstance: newInstance,
+  extend: extend
+}, Constants);
+
+export { vtkWebGPUIndexBuffer$1 as default, extend, newInstance };

package/Rendering/WebGPU/RenderEncoder.js

@@ -1,7 +1,7 @@
 import { newInstance as newInstance$1, obj, get, setGet } from '../../macros.js';
 import vtkWebGPUShaderCache from './ShaderCache.js';
 
-var forwarded = ['setBindGroup', 'setVertexBuffer', 'draw']; // ----------------------------------------------------------------------------
+var forwarded = ['setBindGroup', 'setIndexBuffer', 'setVertexBuffer', 'draw', 'drawIndexed']; // ----------------------------------------------------------------------------
 // vtkWebGPURenderEncoder methods
 // ----------------------------------------------------------------------------
 

package/Rendering/WebGPU/SimpleMapper.js

@@ -179,7 +179,13 @@ function vtkWebGPUSimpleMapper(publicAPI, model) {
     renderEncoder.activateBindGroup(model.bindGroup); // bind the vertex input
 
     pipeline.bindVertexInput(renderEncoder, model.vertexInput);
-    renderEncoder.draw(model.numberOfVertices, model.numberOfInstances, 0, 0);
+    var indexBuffer = model.vertexInput.getIndexBuffer();
+
+    if (indexBuffer) {
+      renderEncoder.drawIndexed(indexBuffer.getIndexCount(), model.numberOfInstances, 0, 0, 0);
+    } else {
+      renderEncoder.draw(model.numberOfVertices, model.numberOfInstances, 0, 0);
+    }
   };
 
   publicAPI.getBindables = function () {

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
       };