@kitware/vtk.js 24.5.2 → 24.5.5

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/FullScreenQuad.js

@@ -1,6 +1,6 @@
 import macro from '../../macros.js';
 import vtkWebGPUShaderCache from './ShaderCache.js';
-import vtkWebGPUMapperHelper from './MapperHelper.js';
+import vtkWebGPUSimpleMapper from './SimpleMapper.js';
 
 // vtkWebGPUFullScreenQuad methods
 // ----------------------------------------------------------------------------
@@ -18,13 +18,11 @@ function vtkWebGPUFullScreenQuad(publicAPI, model) {
   };
 
   model.shaderReplacements.set('replaceShaderPosition', publicAPI.replaceShaderPosition);
-  var superclassBuild = publicAPI.build;
 
-  publicAPI.build = function (renderEncoder, device) {
-    var buff = device.getBufferManager().getFullScreenQuadBuffer();
+  publicAPI.updateBuffers = function () {
+    var buff = model.device.getBufferManager().getFullScreenQuadBuffer();
     model.vertexInput.addBuffer(buff, ['vertexBC']);
     model.numberOfVertices = 6;
-    superclassBuild(renderEncoder, device);
   };
 } // ----------------------------------------------------------------------------
 // Object factory
@@ -37,7 +35,7 @@ function extend(publicAPI, model) {
   var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
   Object.assign(model, DEFAULT_VALUES, initialValues); // Inheritance
 
-  vtkWebGPUMapperHelper.extend(publicAPI, model, initialValues); // Object methods
+  vtkWebGPUSimpleMapper.extend(publicAPI, model, initialValues); // Object methods
 
   vtkWebGPUFullScreenQuad(publicAPI, model);
 } // ----------------------------------------------------------------------------

package/Rendering/WebGPU/Glyph3DMapper.js

@@ -1,21 +1,18 @@
 import _defineProperty from '@babel/runtime/helpers/defineProperty';
 import { newInstance as newInstance$1, obj } from '../../macros.js';
+import vtkWebGPUCellArrayMapper from './CellArrayMapper.js';
 import vtkWebGPUPolyDataMapper from './PolyDataMapper.js';
 import vtkWebGPUStorageBuffer from './StorageBuffer.js';
 import vtkWebGPUShaderCache from './ShaderCache.js';
-import vtkWebGPUBufferManager from './BufferManager.js';
 import { registerOverride } from './ViewNodeFactory.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 PrimitiveTypes = vtkWebGPUBufferManager.PrimitiveTypes; // ----------------------------------------------------------------------------
-// vtkWebGPUSphereMapper methods
-// ----------------------------------------------------------------------------
 
-function vtkWebGPUGlyph3DMapper(publicAPI, model) {
+function vtkWebGPUGlyph3DCellArrayMapper(publicAPI, model) {
   // Set our className
-  model.classHierarchy.push('vtkWebGPUGlyph3DMapper'); // Capture 'parentClass' api for internal use
+  model.classHierarchy.push('vtkWebGPUGlyph3DCellArrayMapper');
 
   var superClass = _objectSpread({}, publicAPI);
 
@@ -28,6 +25,8 @@ function vtkWebGPUGlyph3DMapper(publicAPI, model) {
     vDesc.setCode(code);
   };
 
+  model.shaderReplacements.set('replaceShaderPosition', publicAPI.replaceShaderPosition);
+
   publicAPI.replaceShaderNormal = function (hash, pipeline, vertexInput) {
     if (vertexInput.hasAttribute('normalMC')) {
       var vDesc = pipeline.getShaderDescription('vertex');
@@ -39,8 +38,10 @@ function vtkWebGPUGlyph3DMapper(publicAPI, model) {
     superClass.replaceShaderNormal(hash, pipeline, vertexInput);
   };
 
+  model.shaderReplacements.set('replaceShaderNormal', publicAPI.replaceShaderNormal);
+
   publicAPI.replaceShaderColor = function (hash, pipeline, vertexInput) {
-    if (!model.carray) {
+    if (!model.renderable.getColorArray()) {
       superClass.replaceShaderColor(hash, pipeline, vertexInput);
       return;
     }
@@ -56,6 +57,8 @@ function vtkWebGPUGlyph3DMapper(publicAPI, model) {
     fDesc.setCode(code);
   };
 
+  model.shaderReplacements.set('replaceShaderColor', publicAPI.replaceShaderColor);
+
   publicAPI.replaceShaderSelect = function (hash, pipeline, vertexInput) {
     if (hash.includes('sel')) {
       var vDesc = pipeline.getShaderDescription('vertex');
@@ -70,21 +73,69 @@ function vtkWebGPUGlyph3DMapper(publicAPI, model) {
     }
   };
 
-  publicAPI.buildPrimitives = function () {
+  model.shaderReplacements.set('replaceShaderSelect', publicAPI.replaceShaderSelect);
+} // ----------------------------------------------------------------------------
+
+
+function caExtend(publicAPI, model) {
+  var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  Object.assign(model, {}, initialValues); // Inheritance
+
+  vtkWebGPUCellArrayMapper.extend(publicAPI, model, initialValues); // Object methods
+
+  vtkWebGPUGlyph3DCellArrayMapper(publicAPI, model);
+}
+var caNewInstance = newInstance$1(caExtend, 'vtkWebGPUGlyph3DCellArrayMapper'); // ----------------------------------------------------------------------------
+// vtkWebGPUSphereMapper methods
+// ----------------------------------------------------------------------------
+
+function vtkWebGPUGlyph3DMapper(publicAPI, model) {
+  // Set our className
+  model.classHierarchy.push('vtkWebGPUGlyph3DMapper');
+
+  publicAPI.createCellArrayMapper = function () {
+    var mpr = caNewInstance();
+    mpr.setSSBO(model.SSBO);
+    mpr.setRenderable(model.renderable);
+    return mpr;
+  };
+
+  publicAPI.buildPass = function (prepass) {
+    if (prepass) {
+      model.WebGPUActor = publicAPI.getFirstAncestorOfType('vtkWebGPUActor');
+
+      if (!model.renderable.getStatic()) {
+        model.renderable.update();
+      }
+
+      var gpoly = model.renderable.getInputData(1);
+      model.renderable.mapScalars(gpoly, 1.0);
+      publicAPI.updateSSBO();
+      publicAPI.updateCellArrayMappers(gpoly);
+
+      for (var i = 0; i < model.children.length; i++) {
+        var cellMapper = model.children[i];
+        cellMapper.setNumberOfInstances(model.numInstances);
+      }
+    }
+  };
+
+  publicAPI.updateSSBO = function () {
     model.currentInput = model.renderable.getInputData(1);
     model.renderable.buildArrays(); // update the buffer objects if needed
 
     var garray = model.renderable.getMatrixArray();
     var narray = model.renderable.getNormalArray();
     model.carray = model.renderable.getColorArray();
-    var numInstances = garray.length / 16;
+    model.numInstances = garray.length / 16;
 
     if (model.renderable.getBuildTime().getMTime() > model.glyphBOBuildTime.getMTime()) {
       // In Core class all arrays are rebuilt when this happens
       // but these arrays can be shared between all primType
+      model.WebGPURenderWindow = publicAPI.getFirstAncestorOfType('vtkWebGPURenderWindow');
       var device = model.WebGPURenderWindow.getDevice();
       model.SSBO.clearData();
-      model.SSBO.setNumberOfInstances(numInstances);
+      model.SSBO.setNumberOfInstances(model.numInstances);
       model.SSBO.addEntry('matrix', 'mat4x4<f32>');
       model.SSBO.addEntry('normal', 'mat4x4<f32>');
 
@@ -102,13 +153,6 @@ function vtkWebGPUGlyph3DMapper(publicAPI, model) {
       model.SSBO.send(device);
       model.glyphBOBuildTime.modified();
     }
-
-    superClass.buildPrimitives();
-
-    for (var i = 0; i < model.primitives.length; i++) {
-      var primHelper = model.primitives[i];
-      primHelper.setNumberOfInstances(numInstances);
-    }
   };
 } // ----------------------------------------------------------------------------
 // Object factory
@@ -131,15 +175,6 @@ function extend(publicAPI, model) {
   }); // Object methods
 
   vtkWebGPUGlyph3DMapper(publicAPI, model);
-
-  for (var i = PrimitiveTypes.Start; i < PrimitiveTypes.End; i++) {
-    model.primitives[i].setSSBO(model.SSBO);
-    var sr = model.primitives[i].getShaderReplacements();
-    sr.set('replaceShaderPosition', publicAPI.replaceShaderPosition);
-    sr.set('replaceShaderNormal', publicAPI.replaceShaderNormal);
-    sr.set('replaceShaderSelect', publicAPI.replaceShaderSelect);
-    sr.set('replaceShaderColor', publicAPI.replaceShaderColor);
-  }
 } // ----------------------------------------------------------------------------
 
 var newInstance = newInstance$1(extend, 'vtkWebGPUGlyph3DMapper'); // ----------------------------------------------------------------------------
@@ -151,4 +186,4 @@ var index = {
 
 registerOverride('vtkGlyph3DMapper', newInstance);
 
-export { index as default, extend, newInstance };
+export { caExtend, index as default, extend, newInstance };

package/Rendering/WebGPU/ImageMapper.js

@@ -2,11 +2,9 @@ import { mat4, vec4 } from 'gl-matrix';
 import Constants from '../Core/ImageMapper/Constants.js';
 import { newInstance as newInstance$1, obj } from '../../macros.js';
 import vtkWebGPUShaderCache from './ShaderCache.js';
-import vtkWebGPUStorageBuffer from './StorageBuffer.js';
 import vtkWebGPUFullScreenQuad from './FullScreenQuad.js';
 import vtkWebGPUUniformBuffer from './UniformBuffer.js';
 import vtkWebGPUSampler from './Sampler.js';
-import vtkViewNode from '../SceneGraph/ViewNode.js';
 import { InterpolationType } from '../Core/ImageProperty/Constants.js';
 import { registerOverride } from './ViewNodeFactory.js';
 
@@ -69,10 +67,8 @@ function vtkWebGPUImageMapper(publicAPI, model) {
   publicAPI.render = function () {
     model.renderable.update();
     model.currentInput = model.renderable.getInputData();
-    model.renderEncoder = model.WebGPURenderer.getRenderEncoder();
-    publicAPI.build(model.renderEncoder, model.device); // update descriptor sets
-
-    publicAPI.updateUBO(model.device);
+    publicAPI.prepareToDraw(model.WebGPURenderer.getRenderEncoder());
+    model.renderEncoder.registerDrawCallback(model.pipeline, publicAPI.draw);
   };
 
   publicAPI.computePipelineHash = function () {
@@ -87,7 +83,7 @@ function vtkWebGPUImageMapper(publicAPI, model) {
     }
   };
 
-  publicAPI.updateUBO = function (device) {
+  publicAPI.updateUBO = function () {
     var utime = model.UBO.getSendTime();
     var actor = model.WebGPUImageSlice.getRenderable();
     var volMapr = actor.getMapper();
@@ -172,7 +168,7 @@ function vtkWebGPUImageMapper(publicAPI, model) {
 
       var cScale = [1, 1, 1, 1];
       var cShift = [0, 0, 0, 0];
-      var tView = model.helper.getTextureViews()[0];
+      var tView = model.textureViews[0];
       var tScale = tView.getTexture().getScale();
       var numComp = tView.getTexture().getNumberOfComponents();
       var iComps = false; // todo handle independent?
@@ -195,13 +191,13 @@ function vtkWebGPUImageMapper(publicAPI, model) {
 
       model.UBO.setArray('cScale', cScale);
       model.UBO.setArray('cShift', cShift);
-      model.UBO.sendIfNeeded(device);
+      model.UBO.sendIfNeeded(model.device);
     }
   };
 
-  publicAPI.updateLUTImage = function (device) {
+  publicAPI.updateLUTImage = function () {
     var actorProperty = model.WebGPUImageSlice.getRenderable().getProperty();
-    var tView = model.helper.getTextureViews()[0];
+    var tView = publicAPI.getTextureViews()[0];
     tView.getTexture().getNumberOfComponents();
 
     var numIComps = 1;
@@ -257,35 +253,28 @@ function vtkWebGPUImageMapper(publicAPI, model) {
           depth: 1,
           format: 'rgba8unorm'
         };
-        var newTex = device.getTextureManager().getTexture(treq);
+        var newTex = model.device.getTextureManager().getTexture(treq);
         var tview = newTex.createView('tfunTexture');
-        var tViews = model.helper.getTextureViews();
-        tViews[1] = tview;
+        model.textureViews[1] = tview;
       }
       model.colorTextureString = cfunToString;
     }
   };
 
-  publicAPI.updateBuffers = function (device) {
-    var treq = {
-      imageData: model.currentInput,
-      owner: model.currentInput.getPointData().getScalars()
-    };
-    var newTex = device.getTextureManager().getTexture(treq);
-    var tViews = model.helper.getTextureViews();
+  var superClassUpdateBuffers = publicAPI.updateBuffers;
+
+  publicAPI.updateBuffers = function () {
+    superClassUpdateBuffers();
+    var newTex = model.device.getTextureManager().getTextureForImageData(model.currentInput);
+    var tViews = model.textureViews;
 
     if (!tViews[0] || tViews[0].getTexture() !== newTex) {
       var tview = newTex.createView('imgTexture');
       tViews[0] = tview;
     }
 
-    publicAPI.updateLUTImage(device);
-  };
-
-  publicAPI.build = function (renderEncoder, device) {
-    publicAPI.computePipelineHash();
-    model.helper.setPipelineHash(model.pipelineHash);
-    publicAPI.updateBuffers(device); // set interpolation on the texture based on property setting
+    publicAPI.updateLUTImage();
+    publicAPI.updateUBO(); // set interpolation on the texture based on property setting
 
     var actorProperty = model.WebGPUImageSlice.getRenderable().getProperty();
     var iType = actorProperty.getInterpolationType() === InterpolationType.NEAREST ? 'nearest' : 'linear';
@@ -294,26 +283,15 @@ function vtkWebGPUImageMapper(publicAPI, model) {
       model.clampSampler = vtkWebGPUSampler.newInstance({
         label: 'clampSampler'
       });
-      model.clampSampler.create(device, {
+      model.clampSampler.create(model.device, {
         minFilter: iType,
         magFilter: iType
       });
+      model.additionalBindables = [model.clampSampler];
     }
-
-    model.helper.setAdditionalBindables(publicAPI.getBindables());
-    model.helper.setWebGPURenderer(model.WebGPURenderer);
-    model.helper.build(renderEncoder, device);
-    model.helper.registerToDraw();
   };
 
-  publicAPI.getBindables = function () {
-    var bindables = []; // bindables.push(model.componentSSBO);
-
-    bindables.push(model.clampSampler);
-    return bindables;
-  };
-
-  var sr = model.helper.getShaderReplacements();
+  var sr = publicAPI.getShaderReplacements();
 
   publicAPI.replaceShaderPosition = function (hash, pipeline, vertexInput) {
     var vDesc = pipeline.getShaderDescription('vertex');
@@ -367,27 +345,15 @@ function vtkWebGPUImageMapper(publicAPI, model) {
 
 
 var DEFAULT_VALUES = {
-  rowLength: 1024 // VBOBuildTime: 0,
-  // VBOBuildString: null,
-  // webGPUTexture: null,
-  // tris: null,
-  // imagemat: null,
-  // imagematinv: null,
-  // colorTexture: null,
-  // pwfTexture: null,
-  // lastHaveSeenDepthRequest: false,
-  // haveSeenDepthRequest: false,
-  // lastTextureComponents: 0,
-
+  rowLength: 1024
 }; // ----------------------------------------------------------------------------
 
 function extend(publicAPI, model) {
   var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
   Object.assign(model, DEFAULT_VALUES, initialValues); // Inheritance
 
-  vtkViewNode.extend(publicAPI, model, initialValues);
-  model.helper = vtkWebGPUFullScreenQuad.newInstance();
-  model.helper.setFragmentShaderTemplate(imgFragTemplate);
+  vtkWebGPUFullScreenQuad.extend(publicAPI, model, initialValues);
+  publicAPI.setFragmentShaderTemplate(imgFragTemplate);
   model.UBO = vtkWebGPUUniformBuffer.newInstance({
     label: 'mapperUBO'
   });
@@ -397,13 +363,6 @@ function extend(publicAPI, model) {
   model.UBO.addEntry('Axis1', 'vec4<f32>');
   model.UBO.addEntry('cScale', 'vec4<f32>');
   model.UBO.addEntry('cShift', 'vec4<f32>');
-  model.helper.setUBO(model.UBO);
-  model.SSBO = vtkWebGPUStorageBuffer.newInstance({
-    label: 'volumeSSBO'
-  });
-  model.componentSSBO = vtkWebGPUStorageBuffer.newInstance({
-    label: 'componentSSBO'
-  });
   model.lutBuildTime = {};
   obj(model.lutBuildTime, {
     mtime: 0

package/Rendering/WebGPU/OrderIndependentTranslucentPass.js

@@ -77,11 +77,9 @@ function vtkWebGPUOrderIndependentTranslucentPass(publicAPI, model) {
   publicAPI.finalPass = function (viewNode, renNode) {
     model.translucentFinalEncoder.setColorTextureView(0, model.colorTextureView);
     model.translucentFinalEncoder.attachTextureViews();
-    renNode.setRenderEncoder(model.translucentFinalEncoder);
-    model.translucentFinalEncoder.begin(viewNode.getCommandEncoder()); // set viewport
-
+    model.translucentFinalEncoder.begin(viewNode.getCommandEncoder());
     renNode.scissorAndViewport(model.translucentFinalEncoder);
-    model.fullScreenQuad.render(model.translucentFinalEncoder, viewNode.getDevice());
+    model.fullScreenQuad.prepareAndDraw(model.translucentFinalEncoder);
     model.translucentFinalEncoder.end();
   };
 
@@ -116,8 +114,8 @@ function vtkWebGPUOrderIndependentTranslucentPass(publicAPI, model) {
       fDesc.addOutput('f32', 'outAccum');
       fDesc.addBuiltinInput('vec4<f32>', '@builtin(position) fragPos');
       var code = fDesc.getCode();
-      code = vtkWebGPUShaderCache.substitute(code, '//VTK::RenderEncoder::Impl', [// very simple depth weighting in w
-      'var w: f32 = 1.0 - input.fragPos.z * 0.9;', 'output.outColor = vec4<f32>(computedColor.rgb*computedColor.a, computedColor.a) * w;', 'output.outAccum = computedColor.a;']).result;
+      code = vtkWebGPUShaderCache.substitute(code, '//VTK::RenderEncoder::Impl', [// very simple depth weighting in w z ranges from 1.0 near to 0.0
+      'var w: f32 = computedColor.a * pow(0.1 + input.fragPos.z, 2.0);', 'output.outColor = vec4<f32>(computedColor.rgb*w, w);', 'output.outAccum = computedColor.a;']).result;
       fDesc.setCode(code);
     });
     model.translucentRenderEncoder.setPipelineHash('oitpr');

package/Rendering/WebGPU/Pipeline.js

@@ -83,6 +83,17 @@ function vtkWebGPUPipeline(publicAPI, model) {
   publicAPI.bindVertexInput = function (renderEncoder, vInput) {
     vInput.bindBuffers(renderEncoder);
   };
+
+  publicAPI.addDrawCallback = function (cb) {
+    model._drawCallbacks.push(cb);
+  }; // handle anything that needs to be done when drawing
+
+
+  publicAPI.draw = function (encoder) {
+    for (var cb = 0; cb < model._drawCallbacks.length; cb++) {
+      model._drawCallbacks[cb](encoder, publicAPI);
+    }
+  };
 } // ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
@@ -105,6 +116,7 @@ function extend(publicAPI, model) {
   obj(publicAPI, model);
   model.layouts = [];
   model.shaderDescriptions = [];
+  model._drawCallbacks = [];
   get(publicAPI, model, ['handle', 'pipelineDescription']);
   setGet(publicAPI, model, ['device', 'renderEncoder', 'topology', 'vertexState']); // For more macro methods, see "Sources/macros.js"
   // Object specific methods