@kitware/vtk.js 24.5.0 → 24.5.3

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,67 @@ 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) {
+      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 +151,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 +173,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 +184,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,32 @@ 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 superClassUpdateBuffers = publicAPI.updateBuffers;
+
+  publicAPI.updateBuffers = function () {
+    superClassUpdateBuffers();
     var treq = {
       imageData: model.currentInput,
       owner: model.currentInput.getPointData().getScalars()
     };
-    var newTex = device.getTextureManager().getTexture(treq);
-    var tViews = model.helper.getTextureViews();
+    var newTex = model.device.getTextureManager().getTexture(treq);
+    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 +287,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 +349,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 +367,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