@kitware/vtk.js 25.0.2 → 25.1.2

package/Rendering/WebGPU/Actor2D.js

@@ -0,0 +1,149 @@
+import { mat4 } from 'gl-matrix';
+import macro from '../../macros.js';
+import vtkProp from '../Core/Prop.js';
+import vtkViewNode from '../SceneGraph/ViewNode.js';
+import { registerOverride } from './ViewNodeFactory.js';
+
+var CoordinateSystem = vtkProp.CoordinateSystem; // ----------------------------------------------------------------------------
+// vtkWebGPUActor methods
+// ----------------------------------------------------------------------------
+
+function vtkWebGPUActor2D(publicAPI, model) {
+  // Set our className
+  model.classHierarchy.push('vtkWebGPUActor2D'); // Builds myself.
+
+  publicAPI.buildPass = function (prepass) {
+    if (prepass) {
+      model.WebGPURenderer = publicAPI.getFirstAncestorOfType('vtkWebGPURenderer');
+      model.WebGPURenderWindow = model.WebGPURenderer.getFirstAncestorOfType('vtkWebGPURenderWindow');
+
+      if (model.propID === undefined) {
+        model.propID = model.WebGPURenderWindow.getUniquePropID();
+      }
+
+      publicAPI.prepareNodes();
+      publicAPI.addMissingNode(model.renderable.getMapper());
+      publicAPI.removeUnusedNodes();
+    }
+  }; // we draw textures, then mapper, then post pass textures
+
+
+  publicAPI.traverseOpaquePass = function (renderPass) {
+    if (!model.renderable || !model.renderable.getNestedVisibility() || !model.renderable.getIsOpaque() || model.WebGPURenderer.getSelector() && !model.renderable.getNestedPickable()) {
+      return;
+    }
+
+    publicAPI.apply(renderPass, true);
+
+    if (model.children[0]) {
+      model.children[0].traverse(renderPass);
+    }
+
+    publicAPI.apply(renderPass, false);
+  }; // we draw textures, then mapper, then post pass textures
+
+
+  publicAPI.traverseTranslucentPass = function (renderPass) {
+    if (!model.renderable || !model.renderable.getNestedVisibility() || model.renderable.getIsOpaque() || model.WebGPURenderer.getSelector() && !model.renderable.getNestedPickable()) {
+      return;
+    }
+
+    publicAPI.apply(renderPass, true);
+
+    if (model.children[0]) {
+      model.children[0].traverse(renderPass);
+    }
+
+    publicAPI.apply(renderPass, false);
+  };
+
+  publicAPI.queryPass = function (prepass, renderPass) {
+    if (prepass) {
+      if (!model.renderable || !model.renderable.getVisibility()) {
+        return;
+      }
+
+      if (model.renderable.getIsOpaque()) {
+        renderPass.incrementOpaqueActorCount();
+      } else {
+        renderPass.incrementTranslucentActorCount();
+      }
+    }
+  };
+
+  publicAPI.getBufferShift = function (wgpuRen) {
+    publicAPI.getKeyMatrices(wgpuRen);
+    return model.bufferShift;
+  };
+
+  publicAPI.getKeyMatrices = function (wgpuRen) {
+    // has the actor or stabilization center changed?
+    if (Math.max(model.renderable.getMTime(), wgpuRen.getStabilizedTime()) > model.keyMatricesTime.getMTime()) {
+      // compute the net shift, only apply stabilized coords with world coordinates
+      model.bufferShift[0] = 0.0;
+      model.bufferShift[1] = 0.0;
+      model.bufferShift[2] = 0.0;
+      var center = wgpuRen.getStabilizedCenterByReference();
+
+      if (model.renderable.getCoordinateSystem() === CoordinateSystem.WORLD) {
+        model.bufferShift[0] -= center[0];
+        model.bufferShift[1] -= center[1];
+        model.bufferShift[2] -= center[2];
+      }
+
+      mat4.identity(model.keyMatrices.bcwc);
+      mat4.identity(model.keyMatrices.normalMatrix); // only meed the buffer shift to get to world
+
+      mat4.translate(model.keyMatrices.bcwc, model.keyMatrices.bcwc, [-model.bufferShift[0], -model.bufferShift[1], -model.bufferShift[2]]); // to get to stabilized we also need the center
+
+      if (model.renderable.getCoordinateSystem() === CoordinateSystem.WORLD) {
+        mat4.translate(model.keyMatrices.bcsc, model.keyMatrices.bcwc, [-center[0], -center[1], -center[2]]);
+      }
+
+      model.keyMatricesTime.modified();
+    }
+
+    return model.keyMatrices;
+  };
+} // ----------------------------------------------------------------------------
+// Object factory
+// ----------------------------------------------------------------------------
+
+
+var DEFAULT_VALUES = {
+  keyMatricesTime: null,
+  keyMatrices: null,
+  propID: undefined,
+  bufferShift: undefined
+}; // ----------------------------------------------------------------------------
+
+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.keyMatricesTime = {};
+  macro.obj(model.keyMatricesTime, {
+    mtime: 0
+  });
+  model.keyMatrices = {
+    normalMatrix: new Float64Array(16),
+    bcwc: new Float64Array(16),
+    bcsc: new Float64Array(16)
+  };
+  macro.get(publicAPI, model, ['propID', 'keyMatricesTime']);
+  model.bufferShift = [0, 0, 0, 0]; // Object methods
+
+  vtkWebGPUActor2D(publicAPI, model);
+} // ----------------------------------------------------------------------------
+
+var newInstance = macro.newInstance(extend); // ----------------------------------------------------------------------------
+
+var index = {
+  newInstance: newInstance,
+  extend: extend
+}; // Register ourself to WebGPU backend if imported
+
+registerOverride('vtkActor2D', newInstance);
+
+export { index as default, extend, newInstance };

package/Rendering/WebGPU/CellArrayMapper.js

@@ -1,7 +1,9 @@
 import { mat3, mat4 } from 'gl-matrix';
 import { newInstance as newInstance$1, setGet } from '../../macros.js';
 import vtkMapper from '../Core/Mapper.js';
+import vtkProp from '../Core/Prop.js';
 import vtkProperty from '../Core/Property.js';
+import vtkProperty2D from '../Core/Property2D.js';
 import vtkTexture from '../Core/Texture.js';
 import vtkWebGPUBufferManager from './BufferManager.js';
 import vtkWebGPUShaderCache from './ShaderCache.js';
@@ -12,6 +14,8 @@ var BufferUsage = vtkWebGPUBufferManager.BufferUsage,
     PrimitiveTypes = vtkWebGPUBufferManager.PrimitiveTypes;
 var Representation = vtkProperty.Representation;
 var ScalarMode = vtkMapper.ScalarMode;
+var CoordinateSystem = vtkProp.CoordinateSystem;
+var DisplayLocation = vtkProperty2D.DisplayLocation;
 var vtkWebGPUPolyDataVS = "\n//VTK::Renderer::Dec\n\n//VTK::Color::Dec\n\n//VTK::Normal::Dec\n\n//VTK::TCoord::Dec\n\n//VTK::Select::Dec\n\n//VTK::Mapper::Dec\n\n//VTK::IOStructs::Dec\n\n@vertex\nfn main(\n//VTK::IOStructs::Input\n)\n//VTK::IOStructs::Output\n{\n  var output : vertexOutput;\n\n  var vertex: vec4<f32> = vertexBC;\n\n  //VTK::Color::Impl\n\n  //VTK::Normal::Impl\n\n  //VTK::TCoord::Impl\n\n  //VTK::Select::Impl\n\n  //VTK::Position::Impl\n\n  return output;\n}\n";
 var vtkWebGPUPolyDataFS = "\n//VTK::Renderer::Dec\n\n//VTK::Color::Dec\n\n// optional surface normal declaration\n//VTK::Normal::Dec\n\n//VTK::TCoord::Dec\n\n//VTK::Select::Dec\n\n//VTK::RenderEncoder::Dec\n\n//VTK::Mapper::Dec\n\n//VTK::IOStructs::Dec\n\n@fragment\nfn main(\n//VTK::IOStructs::Input\n)\n//VTK::IOStructs::Output\n{\n  var output : fragmentOutput;\n\n  var ambientColor: vec4<f32> = mapperUBO.AmbientColor;\n  var diffuseColor: vec4<f32> = mapperUBO.DiffuseColor;\n  var opacity: f32 = mapperUBO.Opacity;\n\n  //VTK::Color::Impl\n\n  //VTK::Normal::Impl\n\n  //VTK::Light::Impl\n\n  var computedColor: vec4<f32> = vec4<f32>(ambientColor.rgb * mapperUBO.AmbientIntensity\n     + diffuse * mapperUBO.DiffuseIntensity\n     + specular * mapperUBO.SpecularIntensity,\n     opacity);\n\n  //VTK::TCoord::Impl\n\n  //VTK::Select::Impl\n\n  if (computedColor.a == 0.0) { discard; };\n\n  //VTK::Position::Impl\n\n  //VTK::RenderEncoder::Impl\n  return output;\n}\n";
 
@@ -29,7 +33,16 @@ function vtkWebGPUCellArrayMapper(publicAPI, model) {
 
   publicAPI.buildPass = function (prepass) {
     if (prepass) {
-      model.WebGPUActor = publicAPI.getFirstAncestorOfType('vtkWebGPUActor');
+      if (model.is2D) {
+        model.WebGPUActor = publicAPI.getFirstAncestorOfType('vtkWebGPUActor2D');
+        model.forceZValue = true;
+      } else {
+        model.WebGPUActor = publicAPI.getFirstAncestorOfType('vtkWebGPUActor');
+        model.forceZValue = false;
+      }
+
+      model.coordinateSystem = model.WebGPUActor.getRenderable().getCoordinateSystem();
+      model.useRendererMatrix = model.coordinateSystem !== CoordinateSystem.DISPLAY;
       model.WebGPURenderer = model.WebGPUActor.getFirstAncestorOfType('vtkWebGPURenderer');
       model.WebGPURenderWindow = model.WebGPURenderer.getParent();
       model.device = model.WebGPURenderWindow.getDevice();
@@ -62,19 +75,31 @@ function vtkWebGPUCellArrayMapper(publicAPI, model) {
       model.UBO.setArray('BCWCMatrix', keyMats.bcwc);
       model.UBO.setArray('BCSCMatrix', keyMats.bcsc);
       model.UBO.setArray('MCWCNormals', keyMats.normalMatrix);
-      var aColor = ppty.getAmbientColorByReference();
-      model.UBO.setValue('AmbientIntensity', ppty.getAmbient());
-      model.UBO.setArray('AmbientColor', [aColor[0], aColor[1], aColor[2], 1.0]);
-      model.UBO.setValue('DiffuseIntensity', ppty.getDiffuse());
-      aColor = ppty.getDiffuseColorByReference();
-      model.UBO.setArray('DiffuseColor', [aColor[0], aColor[1], aColor[2], 1.0]);
-      model.UBO.setValue('SpecularIntensity', ppty.getSpecular());
-      model.UBO.setValue('SpecularPower', ppty.getSpecularPower());
-      aColor = ppty.getSpecularColorByReference();
-      model.UBO.setArray('SpecularColor', [aColor[0], aColor[1], aColor[2], 1.0]);
+
+      if (model.is2D) {
+        model.UBO.setValue('ZValue', model.WebGPUActor.getRenderable().getProperty().getDisplayLocation() === DisplayLocation.FOREGROUND ? 1.0 : 0.0);
+        var aColor = ppty.getColorByReference();
+        model.UBO.setValue('AmbientIntensity', 1.0);
+        model.UBO.setArray('AmbientColor', [aColor[0], aColor[1], aColor[2], 1.0]);
+        model.UBO.setValue('DiffuseIntensity', 0.0);
+        model.UBO.setValue('SpecularIntensity', 0.0);
+      } else {
+        var _aColor = ppty.getAmbientColorByReference();
+
+        model.UBO.setValue('AmbientIntensity', ppty.getAmbient());
+        model.UBO.setArray('AmbientColor', [_aColor[0], _aColor[1], _aColor[2], 1.0]);
+        model.UBO.setValue('DiffuseIntensity', ppty.getDiffuse());
+        _aColor = ppty.getDiffuseColorByReference();
+        model.UBO.setArray('DiffuseColor', [_aColor[0], _aColor[1], _aColor[2], 1.0]);
+        model.UBO.setValue('SpecularIntensity', ppty.getSpecular());
+        model.UBO.setValue('SpecularPower', ppty.getSpecularPower());
+        _aColor = ppty.getSpecularColorByReference();
+        model.UBO.setArray('SpecularColor', [_aColor[0], _aColor[1], _aColor[2], 1.0]);
+        _aColor = ppty.getEdgeColorByReference();
+        model.UBO.setArray('EdgeColor', [_aColor[0], _aColor[1], _aColor[2], 1.0]);
+      }
+
       model.UBO.setValue('LineWidth', ppty.getLineWidth());
-      aColor = ppty.getEdgeColorByReference();
-      model.UBO.setArray('EdgeColor', [aColor[0], aColor[1], aColor[2], 1.0]);
       model.UBO.setValue('Opacity', ppty.getOpacity());
       model.UBO.setValue('PropID', model.WebGPUActor.getPropID());
       var device = model.WebGPURenderWindow.getDevice();
@@ -106,15 +131,28 @@ function vtkWebGPUCellArrayMapper(publicAPI, model) {
     vDesc.addBuiltinOutput('vec4<f32>', '@builtin(position) Position');
     var code = vDesc.getCode();
 
+    if (model.useRendererMatrix) {
+      code = vtkWebGPUShaderCache.substitute(code, '//VTK::Position::Impl', ['    var pCoord: vec4<f32> = rendererUBO.SCPCMatrix*mapperUBO.BCSCMatrix*vertexBC;', '//VTK::Position::Impl']).result;
+
+      if (model.forceZValue) {
+        code = vtkWebGPUShaderCache.substitute(code, '//VTK::Position::Impl', ['pCoord = vec4<f32>(pCoord.xyz/pCoord.w, 1.0);', 'pCoord.z = mapperUBO.ZValue;', '//VTK::Position::Impl']).result;
+      }
+    } else {
+      code = vtkWebGPUShaderCache.substitute(code, '//VTK::Position::Impl', ['    var pCoord: vec4<f32> = mapperUBO.BCSCMatrix*vertexBC;', '    pCoord.x = 2.0* pCoord.x / rendererUBO.viewportSize.x - 1.0;', '    pCoord.y = 2.0* pCoord.y / rendererUBO.viewportSize.y - 1.0;', '    pCoord.z = 0.5 - 0.5 * pCoord.z;', '//VTK::Position::Impl']).result;
+
+      if (model.forceZValue) {
+        code = vtkWebGPUShaderCache.substitute(code, '//VTK::Position::Impl', ['    pCoord.z = mapperUBO.ZValue;', '//VTK::Position::Impl']).result;
+      }
+    }
+
     if (publicAPI.haveWideLines()) {
       vDesc.addBuiltinInput('u32', '@builtin(instance_index) instanceIndex'); // widen the edge
 
-      code = vtkWebGPUShaderCache.substitute(code, '//VTK::Position::Impl', ['    var tmpPos: vec4<f32> = rendererUBO.SCPCMatrix*mapperUBO.BCSCMatrix*vertexBC;', '    var numSteps: f32 = ceil(mapperUBO.LineWidth - 1.0);', '    var offset: f32 = (mapperUBO.LineWidth - 1.0) * (f32(input.instanceIndex / 2u) - numSteps/2.0) / numSteps;', '    var tmpPos2: vec3<f32> = tmpPos.xyz / tmpPos.w;', '    tmpPos2.x = tmpPos2.x + 2.0 * (f32(input.instanceIndex) % 2.0) * offset / rendererUBO.viewportSize.x;', '    tmpPos2.y = tmpPos2.y + 2.0 * (f32(input.instanceIndex + 1u) % 2.0) * offset / rendererUBO.viewportSize.y;', '    tmpPos2.z = tmpPos2.z + 0.00001;', // could become a setting
-      '    output.Position = vec4<f32>(tmpPos2.xyz * tmpPos.w, tmpPos.w);']).result;
-    } else {
-      code = vtkWebGPUShaderCache.substitute(code, '//VTK::Position::Impl', ['    output.Position = rendererUBO.SCPCMatrix*mapperUBO.BCSCMatrix*vertexBC;']).result;
+      code = vtkWebGPUShaderCache.substitute(code, '//VTK::Position::Impl', ['    var tmpPos: vec4<f32> = pCoord;', '    var numSteps: f32 = ceil(mapperUBO.LineWidth - 1.0);', '    var offset: f32 = (mapperUBO.LineWidth - 1.0) * (f32(input.instanceIndex / 2u) - numSteps/2.0) / numSteps;', '    var tmpPos2: vec3<f32> = tmpPos.xyz / tmpPos.w;', '    tmpPos2.x = tmpPos2.x + 2.0 * (f32(input.instanceIndex) % 2.0) * offset / rendererUBO.viewportSize.x;', '    tmpPos2.y = tmpPos2.y + 2.0 * (f32(input.instanceIndex + 1u) % 2.0) * offset / rendererUBO.viewportSize.y;', '    tmpPos2.z = min(1.0, tmpPos2.z + 0.00001);', // could become a setting
+      '    pCoord = vec4<f32>(tmpPos2.xyz * tmpPos.w, tmpPos.w);', '//VTK::Position::Impl']).result;
     }
 
+    code = vtkWebGPUShaderCache.substitute(code, '//VTK::Position::Impl', ['    output.Position = pCoord;']).result;
     vDesc.setCode(code);
   };
 
@@ -265,6 +303,8 @@ function vtkWebGPUCellArrayMapper(publicAPI, model) {
   };
 
   publicAPI.buildVertexInput = function () {
+    var _model$renderable$get, _model$renderable;
+
     var pd = model.currentInput;
     var cells = model.cellArray;
     var primType = model.primitiveType;
@@ -327,7 +367,8 @@ function vtkWebGPUCellArrayMapper(publicAPI, model) {
 
     var usage = publicAPI.getUsage(representation, primType);
 
-    if (usage === BufferUsage.Triangles || usage === BufferUsage.Strips) {
+    if (!model.is2D && ( // no lighting on Property2D
+    usage === BufferUsage.Triangles || usage === BufferUsage.Strips)) {
       var normals = pd.getPointData().getNormals();
       var _buffRequest2 = {
         format: 'snorm8x4',
@@ -398,7 +439,7 @@ function vtkWebGPUCellArrayMapper(publicAPI, model) {
 
     var tcoords = null;
 
-    if (model.renderable.getInterpolateScalarsBeforeMapping() && model.renderable.getColorCoordinates()) {
+    if ((_model$renderable$get = (_model$renderable = model.renderable).getInterpolateScalarsBeforeMapping) !== null && _model$renderable$get !== void 0 && _model$renderable$get.call(_model$renderable) && model.renderable.getColorCoordinates()) {
       tcoords = model.renderable.getColorCoordinates();
     } else {
       tcoords = pd.getPointData().getTCoords();
@@ -414,12 +455,14 @@ function vtkWebGPUCellArrayMapper(publicAPI, model) {
   };
 
   publicAPI.updateTextures = function () {
+    var _model$renderable$get2, _model$renderable2;
+
     // we keep track of new and used textures so
     // that we can clean up any unused textures so we don't hold onto them
     var usedTextures = [];
     var newTextures = []; // do we have a scalar color texture
 
-    var idata = model.renderable.getColorTextureMap(); // returns an imagedata
+    var idata = (_model$renderable$get2 = (_model$renderable2 = model.renderable).getColorTextureMap) === null || _model$renderable$get2 === void 0 ? void 0 : _model$renderable$get2.call(_model$renderable2);
 
     if (idata) {
       if (!model.colorTexture) {
@@ -491,7 +534,7 @@ function vtkWebGPUCellArrayMapper(publicAPI, model) {
 
 
   publicAPI.computePipelineHash = function () {
-    var pipelineHash = 'pd';
+    var pipelineHash = "pd".concat(model.useRendererMatrix ? 'r' : '').concat(model.forceZValue ? 'z' : '');
 
     if (model.primitiveType === PrimitiveTypes.TriangleEdges || model.primitiveType === PrimitiveTypes.TriangleStripEdges) {
       pipelineHash += 'edge';
@@ -542,6 +585,8 @@ function vtkWebGPUCellArrayMapper(publicAPI, model) {
     if (publicAPI.haveWideLines()) {
       var ppty = actor.getProperty();
       publicAPI.setNumberOfInstances(Math.ceil(ppty.getLineWidth() * 2.0));
+    } else {
+      publicAPI.setNumberOfInstances(1);
     }
   };
 } // ----------------------------------------------------------------------------
@@ -550,6 +595,7 @@ function vtkWebGPUCellArrayMapper(publicAPI, model) {
 
 
 var DEFAULT_VALUES = {
+  is2D: false,
   cellArray: null,
   currentInput: null,
   cellOffset: 0,
@@ -584,9 +630,10 @@ function extend(publicAPI, model) {
   model.UBO.addEntry('LineWidth', 'f32');
   model.UBO.addEntry('Opacity', 'f32');
   model.UBO.addEntry('SpecularPower', 'f32');
+  model.UBO.addEntry('ZValue', 'f32');
   model.UBO.addEntry('PropID', 'u32'); // Build VTK API
 
-  setGet(publicAPI, model, ['cellArray', 'currentInput', 'cellOffset', 'primitiveType', 'renderEncoder']);
+  setGet(publicAPI, model, ['cellArray', 'currentInput', 'cellOffset', 'is2D', 'primitiveType', 'renderEncoder']);
   model.textures = []; // Object methods
 
   vtkWebGPUCellArrayMapper(publicAPI, model);

package/Rendering/WebGPU/Glyph3DMapper.js

@@ -16,6 +16,15 @@ function vtkWebGPUGlyph3DCellArrayMapper(publicAPI, model) {
 
   var superClass = _objectSpread({}, publicAPI);
 
+  publicAPI.setGlyphInstances = function (val) {
+    model.glyphInstances = val;
+  };
+
+  publicAPI.updateBuffers = function () {
+    superClass.updateBuffers();
+    publicAPI.setNumberOfInstances(model.glyphInstances);
+  };
+
   publicAPI.replaceShaderPosition = function (hash, pipeline, vertexInput) {
     var vDesc = pipeline.getShaderDescription('vertex');
     vDesc.addBuiltinInput('u32', '@builtin(instance_index) instanceIndex');
@@ -115,7 +124,7 @@ function vtkWebGPUGlyph3DMapper(publicAPI, model) {
 
       for (var i = 0; i < model.children.length; i++) {
         var cellMapper = model.children[i];
-        cellMapper.setNumberOfInstances(model.numInstances);
+        cellMapper.setGlyphInstances(model.numInstances);
       }
     }
   };

package/Rendering/WebGPU/OrderIndependentTranslucentPass.js

@@ -174,7 +174,7 @@ function vtkWebGPUOrderIndependentTranslucentPass(publicAPI, model) {
       fDesc.addOutput('vec4<f32>', 'outColor');
       fDesc.addBuiltinInput('vec4<f32>', '@builtin(position) fragPos');
       var code = fDesc.getCode();
-      code = vtkWebGPUShaderCache.substitute(code, '//VTK::RenderEncoder::Impl', ['output.outColor = vec4<f32>(computedColor.rgb*computedColor.a, computedColor.a);']).result;
+      code = vtkWebGPUShaderCache.substitute(code, '//VTK::RenderEncoder::Impl', ['output.outColor = vec4<f32>(computedColor.rgb, computedColor.a);']).result;
       fDesc.setCode(code);
     });
     model.translucentFinalEncoder.setPipelineHash('oitpf');

package/Rendering/WebGPU/PolyDataMapper2D.js

@@ -0,0 +1,99 @@
+import _defineProperty from '@babel/runtime/helpers/defineProperty';
+import { newInstance as newInstance$1 } from '../../macros.js';
+import vtkWebGPUBufferManager from './BufferManager.js';
+import vtkWebGPUCellArrayMapper from './CellArrayMapper.js';
+import vtkViewNode from '../SceneGraph/ViewNode.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; // ----------------------------------------------------------------------------
+// vtkWebGPUPolyDataMapper methods
+// ----------------------------------------------------------------------------
+
+function vtkWebGPUPolyDataMapper2D(publicAPI, model) {
+  // Set our className
+  model.classHierarchy.push('vtkWebGPUPolyDataMapper2D');
+
+  publicAPI.createCellArrayMapper = function () {
+    return vtkWebGPUCellArrayMapper.newInstance();
+  };
+
+  publicAPI.buildPass = function (prepass) {
+    if (prepass) {
+      model.WebGPUActor = publicAPI.getFirstAncestorOfType('vtkWebGPUActor2D');
+
+      if (!model.renderable.getStatic()) {
+        model.renderable.update();
+      }
+
+      var poly = model.renderable.getInputData();
+      model.renderable.mapScalars(poly, 1.0);
+      publicAPI.updateCellArrayMappers(poly);
+    }
+  };
+
+  publicAPI.updateCellArrayMappers = function (poly) {
+    var prims = [poly.getVerts(), poly.getLines(), poly.getPolys(), poly.getStrips()]; // we instantiate a cell array mapper for each cellArray that has cells
+    // and they handle the rendering of that cell array
+
+    var cellMappers = [];
+    var cellOffset = 0;
+
+    for (var i = PrimitiveTypes.Points; i <= PrimitiveTypes.Triangles; i++) {
+      if (prims[i].getNumberOfValues() > 0) {
+        if (!model.primitives[i]) {
+          model.primitives[i] = publicAPI.createCellArrayMapper();
+        }
+
+        var cellMapper = model.primitives[i];
+        cellMapper.setCellArray(prims[i]);
+        cellMapper.setCurrentInput(poly);
+        cellMapper.setCellOffset(cellOffset);
+        cellMapper.setPrimitiveType(i);
+        cellMapper.setRenderable(model.renderable);
+        cellMapper.setIs2D(true);
+        cellOffset += prims[i].getNumberOfCells();
+        cellMappers.push(cellMapper);
+      } else {
+        model.primitives[i] = null;
+      }
+    }
+
+    publicAPI.prepareNodes();
+    publicAPI.addMissingChildren(cellMappers);
+    publicAPI.removeUnusedNodes();
+  };
+} // ----------------------------------------------------------------------------
+// Object factory
+// ----------------------------------------------------------------------------
+
+
+function defaultValues(initialValues) {
+  return _objectSpread({
+    primitives: []
+  }, initialValues);
+} // ----------------------------------------------------------------------------
+
+
+function extend(publicAPI, model) {
+  var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  Object.assign(model, defaultValues(initialValues)); // Inheritance
+
+  vtkViewNode.extend(publicAPI, model, initialValues);
+  model.primitives = []; // Object methods
+
+  vtkWebGPUPolyDataMapper2D(publicAPI, model);
+} // ----------------------------------------------------------------------------
+
+var newInstance = newInstance$1(extend, 'vtkWebGPUPolyDataMapper2D'); // ----------------------------------------------------------------------------
+
+var index = {
+  newInstance: newInstance,
+  extend: extend
+}; // Register ourself to WebGPU backend if imported
+
+registerOverride('vtkMapper2D', newInstance);
+
+export { index as default, extend, newInstance };

package/Rendering/WebGPU/Profiles/All.js

@@ -1,8 +1,10 @@
 import '../Camera.js';
 import '../Renderer.js';
 import '../Actor.js';
+import '../Actor2D.js';
 import '../CubeAxesActor.js';
 import '../PolyDataMapper.js';
+import '../PolyDataMapper2D.js';
 import '../ScalarBarActor.js';
 import '../Texture.js';
 import '../Glyph3DMapper.js';

package/Rendering/WebGPU/Profiles/Geometry.js

@@ -1,8 +1,10 @@
 import '../Camera.js';
 import '../Renderer.js';
 import '../Actor.js';
+import '../Actor2D.js';
 import '../CubeAxesActor.js';
 import '../PolyDataMapper.js';
+import '../PolyDataMapper2D.js';
 import '../ScalarBarActor.js';
 import '../Texture.js';
 import '../PixelSpaceCallbackMapper.js';

package/Rendering/WebGPU.js

@@ -1,5 +1,6 @@
 import vtkRenderWindow from './WebGPU/RenderWindow.js';
 import './WebGPU/Actor.js';
+import './WebGPU/Actor2D.js';
 import './WebGPU/Camera.js';
 import './WebGPU/CubeAxesActor.js';
 import './WebGPU/ForwardPass.js';
@@ -9,6 +10,7 @@ import './WebGPU/ImageMapper.js';
 import './WebGPU/ImageSlice.js';
 import './WebGPU/PixelSpaceCallbackMapper.js';
 import './WebGPU/PolyDataMapper.js';
+import './WebGPU/PolyDataMapper2D.js';
 import './WebGPU/Renderer.js';
 import './WebGPU/ScalarBarActor.js';
 import './WebGPU/SphereMapper.js';

package/Widgets/Core/AbstractWidgetFactory.js

@@ -187,19 +187,19 @@ function vtkAbstractWidgetFactory(publicAPI, model) {
   var unsubscribe = NoOp;
   publicAPI.delete = macro.chain(publicAPI.delete, function () {
     return unsubscribe();
-  }); // Defer after object instantiation so model.widgetState actually exist
+  });
 
-  setTimeout(function () {
-    if (model.widgetState) {
-      unsubscribe = model.widgetState.onModified(function () {
-        return publicAPI.invokeWidgetChange(model.widgetState);
-      }).unsubscribe;
-    }
-  }, 0);
+  if (model.widgetState) {
+    unsubscribe = model.widgetState.onModified(function () {
+      return publicAPI.invokeWidgetChange(model.widgetState);
+    }).unsubscribe;
+  }
 } // ----------------------------------------------------------------------------
 
 
 function extend(publicAPI, model) {
+  var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  Object.assign(model, initialValues);
   macro.obj(publicAPI, model);
   macro.get(publicAPI, model, ['widgetState']);
   macro.event(publicAPI, model, 'WidgetChange');

package/Widgets/Widgets3D/AngleWidget.js

@@ -22,8 +22,6 @@ function vtkAngleWidget(publicAPI, model) {
 
 
   model.methodsToLink = ['activeScaleFactor', 'activeColor', 'useActiveColor', 'glyphResolution', 'defaultScale', 'scaleInPixels'];
-  model.behavior = widgetBehavior;
-  model.widgetState = generateState();
 
   publicAPI.getRepresentationsForViewType = function (viewType) {
     switch (viewType) {
@@ -87,12 +85,18 @@ function vtkAngleWidget(publicAPI, model) {
 } // ----------------------------------------------------------------------------
 
 
-var DEFAULT_VALUES = {// manipulator: null,
+var defaultValues = function defaultValues(initialValues) {
+  return _objectSpread({
+    // manipulator: null,
+    behavior: widgetBehavior,
+    widgetState: generateState()
+  }, initialValues);
 }; // ----------------------------------------------------------------------------
 
+
 function extend(publicAPI, model) {
   var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-  Object.assign(model, DEFAULT_VALUES, initialValues);
+  Object.assign(model, defaultValues(initialValues));
   vtkAbstractWidgetFactory.extend(publicAPI, model, initialValues);
   macro.setGet(publicAPI, model, ['manipulator']);
   vtkAngleWidget(publicAPI, model);

package/Widgets/Widgets3D/DistanceWidget.js

@@ -22,8 +22,6 @@ function vtkDistanceWidget(publicAPI, model) {
 
 
   model.methodsToLink = ['activeScaleFactor', 'activeColor', 'useActiveColor', 'glyphResolution', 'defaultScale', 'scaleInPixels'];
-  model.behavior = widgetBehavior;
-  model.widgetState = generateState();
 
   publicAPI.getRepresentationsForViewType = function (viewType) {
     switch (viewType) {
@@ -82,12 +80,18 @@ function vtkDistanceWidget(publicAPI, model) {
 } // ----------------------------------------------------------------------------
 
 
-var DEFAULT_VALUES = {// manipulator: null,
+var defaultValues = function defaultValues(initialValues) {
+  return _objectSpread({
+    // manipulator: null,
+    behavior: widgetBehavior,
+    widgetState: generateState()
+  }, initialValues);
 }; // ----------------------------------------------------------------------------
 
+
 function extend(publicAPI, model) {
   var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-  Object.assign(model, DEFAULT_VALUES, initialValues);
+  Object.assign(model, defaultValues(initialValues));
   vtkAbstractWidgetFactory.extend(publicAPI, model, initialValues);
   macro.setGet(publicAPI, model, ['manipulator']);
   vtkDistanceWidget(publicAPI, model);

package/Widgets/Widgets3D/EllipseWidget.js

@@ -21,7 +21,6 @@ function vtkEllipseWidget(publicAPI, model) {
   model.classHierarchy.push('vtkEllipseWidget'); // --- Widget Requirement ---------------------------------------------------
 
   model.methodsToLink = [].concat(_toConsumableArray(model.methodsToLink), ['activeScaleFactor', 'activeColor', 'useActiveColor', 'glyphResolution', 'defaultScale', 'drawBorder', 'drawFace', 'opacity']);
-  model.behavior = widgetBehavior;
 
   publicAPI.getRepresentationsForViewType = function (viewType) {
     switch (viewType) {
@@ -49,7 +48,6 @@ function vtkEllipseWidget(publicAPI, model) {
   // --------------------------------------------------------------------------
 
 
-  model.widgetState = generateState();
   publicAPI.setManipulator(model.manipulator || vtkPlanePointManipulator.newInstance({
     useCameraNormal: true
   }));
@@ -60,6 +58,8 @@ function defaultValues(initialValues) {
   var _None;
 
   return _objectSpread({
+    behavior: widgetBehavior,
+    widgetState: generateState(),
     modifierBehavior: {
       None: (_None = {}, _defineProperty(_None, BehaviorCategory.PLACEMENT, ShapeBehavior[BehaviorCategory.PLACEMENT].CLICK_AND_DRAG), _defineProperty(_None, BehaviorCategory.POINTS, ShapeBehavior[BehaviorCategory.POINTS].CENTER_TO_CORNER), _defineProperty(_None, BehaviorCategory.RATIO, ShapeBehavior[BehaviorCategory.RATIO].FREE), _None),
       Shift: _defineProperty({}, BehaviorCategory.RATIO, ShapeBehavior[BehaviorCategory.RATIO].FIXED),