@kitware/vtk.js 25.1.1 → 25.2.0

package/Rendering/WebGPU/Renderer.js

@@ -1,18 +1,41 @@
 import { mat4, vec3 } from 'gl-matrix';
 import { newInstance as newInstance$1, obj, get, getArray, setGet, vtkDebugMacro as vtkDebugMacro$1 } from '../../macros.js';
+import { r as radiansFromDegrees } from '../../Common/Core/Math/index.js';
 import vtkViewNode from '../SceneGraph/ViewNode.js';
 import vtkWebGPUBindGroup from './BindGroup.js';
 import vtkWebGPUFullScreenQuad from './FullScreenQuad.js';
+import vtkWebGPUStorageBuffer from './StorageBuffer.js';
 import vtkWebGPUUniformBuffer from './UniformBuffer.js';
 import { registerOverride } from './ViewNodeFactory.js';
 
 var vtkDebugMacro = vtkDebugMacro$1;
-var clearFragTemplate = "\n//VTK::Renderer::Dec\n\n//VTK::Mapper::Dec\n\n//VTK::TCoord::Dec\n\n//VTK::RenderEncoder::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 computedColor: vec4<f32> = mapperUBO.BackgroundColor;\n\n  //VTK::RenderEncoder::Impl\n  return output;\n}\n"; // ----------------------------------------------------------------------------
+var clearFragTemplate = "\n//VTK::Renderer::Dec\n\n//VTK::Mapper::Dec\n\n//VTK::TCoord::Dec\n\n//VTK::RenderEncoder::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 computedColor: vec4<f32> = mapperUBO.BackgroundColor;\n\n  //VTK::RenderEncoder::Impl\n  return output;\n}\n"; // Light type index gives either 0, 1, or 2 which indicates what type of light there is.
+// While technically, there are only spot and directional lights, within the CellArrayMapper
+// there is a third, positional light. It is technically just a variant of a spot light with
+// a cone angle of 90 or above, however certain calculations can be skipped if it is treated
+// separately.
+// The mappings are shown below:
+// 0 -> positional light
+// 1 -> directional light
+// 2 -> spot light
+
+function getLightTypeIndex(light) {
+  if (light.getPositional()) {
+    if (light.getConeAngle() >= 90) {
+      return 0;
+    }
+
+    return 2;
+  }
+
+  return 1;
+} // ----------------------------------------------------------------------------
 // vtkWebGPURenderer methods
 // ----------------------------------------------------------------------------
 
 /* eslint-disable no-bitwise */
 
+
 function vtkWebGPURenderer(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkWebGPURenderer'); // Builds myself.
@@ -108,6 +131,7 @@ function vtkWebGPURenderer(publicAPI, model) {
       model.UBO.setArray('SCVCMatrix', keyMats.scvc);
       model.UBO.setArray('VCPCMatrix', keyMats.vcpc);
       model.UBO.setArray('WCVCNormals', keyMats.normalMatrix);
+      model.UBO.setValue('LightCount', model.renderable.getLights().length);
       var tsize = publicAPI.getYInvertedTiledSizeAndOrigin();
       model.UBO.setArray('viewportSize', [tsize.usize, tsize.vsize]);
       model.UBO.setValue('cameraParallel', model.camera.getParallelProjection());
@@ -118,6 +142,79 @@ function vtkWebGPURenderer(publicAPI, model) {
     }
   };
 
+  publicAPI.updateSSBO = function () {
+    var lights = model.renderable.getLights();
+    var keyMats = model.webgpuCamera.getKeyMatrices(publicAPI);
+    var lightTimeString = "".concat(model.renderable.getMTime());
+
+    for (var i = 0; i < lights.length; i++) {
+      lightTimeString += lights[i].getMTime();
+    }
+
+    if (lightTimeString !== model.lightTimeString) {
+      var lightPosArray = new Float32Array(lights.length * 4);
+      var lightDirArray = new Float32Array(lights.length * 4);
+      var lightColorArray = new Float32Array(lights.length * 4);
+      var lightTypeArray = new Float32Array(lights.length * 4);
+
+      for (var _i = 0; _i < lights.length; _i++) {
+        var offset = _i * 4; // Position
+
+        var viewCoordinatePosition = lights[_i].getPosition();
+
+        vec3.transformMat4(viewCoordinatePosition, viewCoordinatePosition, keyMats.wcvc); // console.log(viewCoordinatePosition);
+        // viewCoordinatePosition
+
+        lightPosArray[offset] = viewCoordinatePosition[0];
+        lightPosArray[offset + 1] = viewCoordinatePosition[1];
+        lightPosArray[offset + 2] = viewCoordinatePosition[2];
+        lightPosArray[offset + 3] = 0; // Rotation (All are negative to correct for -Z being forward)
+
+        lightDirArray[offset] = -lights[_i].getDirection()[0];
+        lightDirArray[offset + 1] = -lights[_i].getDirection()[1];
+        lightDirArray[offset + 2] = -lights[_i].getDirection()[2];
+        lightDirArray[offset + 3] = 0; // Color
+
+        lightColorArray[offset] = lights[_i].getColor()[0];
+        lightColorArray[offset + 1] = lights[_i].getColor()[1];
+        lightColorArray[offset + 2] = lights[_i].getColor()[2];
+        lightColorArray[offset + 3] = lights[_i].getIntensity() * 5; // arbitrary multiplication to fix the dullness of low value PBR lights
+        // Type
+
+        lightTypeArray[offset] = getLightTypeIndex(lights[_i]); // Type
+
+        lightTypeArray[offset + 1] = Math.cos(radiansFromDegrees(lights[_i].getConeAngle())); // Inner Phi, should probably do some check on these to make sure they dont excede limits
+
+        lightTypeArray[offset + 2] = Math.cos(radiansFromDegrees(lights[_i].getConeAngle() + lights[_i].getConeFalloff())); // Outer Phi
+
+        lightTypeArray[offset + 3] = 0;
+      } // Im not sure how correct this is, but this is what the example does
+      // https://kitware.github.io/vtk-js/api/Rendering_WebGPU_VolumePassFSQ.html
+
+
+      model.SSBO.clearData();
+      model.SSBO.setNumberOfInstances(lights.length);
+      model.SSBO.addEntry('LightPos', 'vec4<f32>'); // Position
+
+      model.SSBO.addEntry('LightDir', 'vec4<f32>'); // Direction
+
+      model.SSBO.addEntry('LightColor', 'vec4<f32>'); // Color (r, g, b, intensity)
+
+      model.SSBO.addEntry('LightData', 'vec4<f32>'); // Other data (type, etc, etc, etc)
+
+      model.SSBO.setAllInstancesFromArray('LightPos', lightPosArray);
+      model.SSBO.setAllInstancesFromArray('LightDir', lightDirArray);
+      model.SSBO.setAllInstancesFromArray('LightColor', lightColorArray);
+      model.SSBO.setAllInstancesFromArray('LightData', lightTypeArray);
+
+      var device = model._parent.getDevice();
+
+      model.SSBO.send(device);
+    }
+
+    model.lightTimeString = lightTimeString;
+  };
+
   publicAPI.scissorAndViewport = function (encoder) {
     var tsize = publicAPI.getYInvertedTiledSizeAndOrigin();
     encoder.getHandle().setViewport(tsize.lowerLeftU, tsize.lowerLeftV, tsize.usize, tsize.vsize, 0.0, 1.0); // set scissor
@@ -134,6 +231,7 @@ function vtkWebGPURenderer(publicAPI, model) {
     if (prepass) {
       model.renderEncoder.begin(model._parent.getCommandEncoder());
       publicAPI.updateUBO();
+      publicAPI.updateSSBO();
     } else {
       publicAPI.scissorAndViewport(model.renderEncoder);
       publicAPI.clear();
@@ -284,7 +382,8 @@ 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);
+  vtkViewNode.extend(publicAPI, model, initialValues); // UBO
+
   model.UBO = vtkWebGPUUniformBuffer.newInstance({
     label: 'rendererUBO'
   });
@@ -295,11 +394,17 @@ function extend(publicAPI, model) {
   model.UBO.addEntry('VCPCMatrix', 'mat4x4<f32>');
   model.UBO.addEntry('WCVCNormals', 'mat4x4<f32>');
   model.UBO.addEntry('viewportSize', 'vec2<f32>');
-  model.UBO.addEntry('cameraParallel', 'u32');
+  model.UBO.addEntry('LightCount', 'i32');
+  model.UBO.addEntry('cameraParallel', 'u32'); // SSBO (Light data)
+
+  model.SSBO = vtkWebGPUStorageBuffer.newInstance({
+    label: 'rendererLightSSBO'
+  });
+  model.lightTimeString = '';
   model.bindGroup = vtkWebGPUBindGroup.newInstance({
     label: 'rendererBG'
   });
-  model.bindGroup.setBindables([model.UBO]);
+  model.bindGroup.setBindables([model.UBO, model.SSBO]);
   model.tmpMat4 = mat4.identity(new Float64Array(16));
   model.stabilizedTime = {};
   obj(model.stabilizedTime, {

package/Rendering/WebGPU/SphereMapper.js

@@ -7,7 +7,7 @@ import { registerOverride } from './ViewNodeFactory.js';
 
 var BufferUsage = vtkWebGPUBufferManager.BufferUsage;
 var vtkErrorMacro = vtkErrorMacro$1;
-var vtkWebGPUSphereMapperVS = "\n//VTK::Renderer::Dec\n\n//VTK::Mapper::Dec\n\n//VTK::Color::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 vertexVC: vec4<f32> = rendererUBO.SCVCMatrix * mapperUBO.BCSCMatrix * vec4<f32>(vertexBC.x, vertexBC.y, vertexBC.z, 1.0);\n\n  //VTK::Color::Impl\n\n  // compute the projected vertex position\n  output.centerVC = vertexVC.xyz;\n  output.radiusVC = length(offsetMC)*0.5;\n\n  // make the triangle face the camera\n  if (rendererUBO.cameraParallel == 0u)\n    {\n    var dir: vec3<f32> = normalize(-vertexVC.xyz);\n    var base2: vec3<f32> = normalize(cross(dir,vec3<f32>(1.0,0.0,0.0)));\n    var base1: vec3<f32> = cross(base2,dir);\n    dir = vertexVC.xyz + offsetMC.x*base1 + offsetMC.y*base2;\n    vertexVC = vec4<f32>(dir, 1.0);\n    }\n  else\n    {\n    // add in the offset\n    var tmp2: vec2<f32> = vertexVC.xy + offsetMC;\n    vertexVC = vec4<f32>(tmp2, vertexVC.zw);\n    }\n\n  output.vertexVC = vertexVC.xyz;\n\n  //VTK::Position::Impl\n\n  return output;\n}\n"; // ----------------------------------------------------------------------------
+var vtkWebGPUSphereMapperVS = "\n//VTK::Renderer::Dec\n\n//VTK::Mapper::Dec\n\n//VTK::Color::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 vertexVC: vec4<f32> = rendererUBO.SCVCMatrix * mapperUBO.BCSCMatrix * vec4<f32>(vertexBC.xyz, 1.0);\n\n  //VTK::Color::Impl\n\n  // compute the projected vertex position\n  output.centerVC = vertexVC.xyz;\n  output.radiusVC = length(offsetMC)*0.5;\n\n  // make the triangle face the camera\n  if (rendererUBO.cameraParallel == 0u)\n    {\n    var dir: vec3<f32> = normalize(-vertexVC.xyz);\n    var base2: vec3<f32> = normalize(cross(dir,vec3<f32>(1.0,0.0,0.0)));\n    var base1: vec3<f32> = cross(base2,dir);\n    dir = vertexVC.xyz + offsetMC.x*base1 + offsetMC.y*base2;\n    vertexVC = vec4<f32>(dir, 1.0);\n    }\n  else\n    {\n    // add in the offset\n    var tmp2: vec2<f32> = vertexVC.xy + offsetMC;\n    vertexVC = vec4<f32>(tmp2, vertexVC.zw);\n    }\n\n  output.vertexVC = vec4<f32>(vertexVC.xyz, 0.0);\n\n  //VTK::Position::Impl\n\n  return output;\n}\n"; // ----------------------------------------------------------------------------
 // vtkWebGPUSphereMapper methods
 // ----------------------------------------------------------------------------
 
@@ -32,7 +32,7 @@ function vtkWebGPUSphereMapper(publicAPI, model) {
 
   publicAPI.replaceShaderNormal = function (hash, pipeline, vertexInput) {
     var vDesc = pipeline.getShaderDescription('vertex');
-    vDesc.addOutput('vec3<f32>', 'vertexVC');
+    if (!vDesc.hasOutput('vertexVC')) vDesc.addOutput('vec4<f32>', 'vertexVC');
     vDesc.addOutput('vec3<f32>', 'centerVC');
     vDesc.addOutput('f32', 'radiusVC');
     var fDesc = pipeline.getShaderDescription('fragment');

package/Rendering/WebGPU/StickMapper.js

@@ -26,7 +26,7 @@ var vtkErrorMacro = vtkErrorMacro$1; // Vertices
 // 4: 011
 // 5: 111
 
-var vtkWebGPUStickMapperVS = "\n//VTK::Renderer::Dec\n\n//VTK::Mapper::Dec\n\n//VTK::Color::Dec\n\n//VTK::IOStructs::Dec\n\n@vertex\nfn main(\n//VTK::IOStructs::Input\n)\n//VTK::IOStructs::Output\n{\n  var offsetsArray: array<vec3<f32>, 12> = array<vec3<f32>, 12>(\n    vec3<f32>(-1.0, -1.0, -1.0),\n    vec3<f32>(1.0, -1.0, -1.0),\n    vec3<f32>(1.0, -1.0, 1.0),\n\n    vec3<f32>(-1.0, -1.0, -1.0),\n    vec3<f32>(1.0, -1.0, 1.0),\n    vec3<f32>(-1.0, -1.0, 1.0),\n\n    vec3<f32>(-1.0, -1.0, 1.0),\n    vec3<f32>(1.0, -1.0, 1.0),\n    vec3<f32>(1.0, 1.0, 1.0),\n\n    vec3<f32>(-1.0, -1.0, 1.0),\n    vec3<f32>(1.0, 1.0, 1.0),\n    vec3<f32>(-1.0, 1.0, 1.0)\n  );\n\n  var output : vertexOutput;\n\n  var vertexVC: vec4<f32> = rendererUBO.SCVCMatrix * mapperUBO.BCSCMatrix * vec4<f32>(vertexBC.x, vertexBC.y, vertexBC.z, 1.0);\n\n  //VTK::Color::Impl\n\n  // compute the projected vertex position\n  output.centerVC = vertexVC.xyz;\n  output.radiusVC = radiusMC;\n  output.lengthVC = length(orientMC);\n  output.orientVC = (rendererUBO.WCVCNormals * vec4<f32>(normalize(orientMC), 0.0)).xyz;\n\n  // make sure it is pointing out of the screen\n  if (output.orientVC.z < 0.0)\n    {\n    output.orientVC = -output.orientVC;\n    }\n\n  // make the basis\n  var xbase: vec3<f32>;\n  var ybase: vec3<f32>;\n  var dir: vec3<f32> = vec3<f32>(0.0,0.0,1.0);\n  if (rendererUBO.cameraParallel == 0u)\n    {\n    dir = normalize(-vertexVC.xyz);\n    }\n  if (abs(dot(dir,output.orientVC)) == 1.0)\n    {\n    xbase = normalize(cross(vec3<f32>(0.0,1.0,0.0),output.orientVC));\n    ybase = cross(xbase,output.orientVC);\n    }\n  else\n    {\n    xbase = normalize(cross(output.orientVC,dir));\n    ybase = cross(output.orientVC,xbase);\n    }\n\n\n  var vertIdx: u32 = input.vertexIndex % 12u;\n  var offsets: vec3<f32> = offsetsArray[vertIdx];\n\n  vertexVC = vec4<f32>(vertexVC.xyz +\n    output.radiusVC * offsets.x * xbase +\n    output.radiusVC * offsets.y * ybase +\n    0.5 * output.lengthVC * offsets.z * output.orientVC, 1.0);\n\n  output.vertexVC = vertexVC;\n\n  //VTK::Position::Impl\n\n  return output;\n}\n"; // ----------------------------------------------------------------------------
+var vtkWebGPUStickMapperVS = "\n//VTK::Renderer::Dec\n\n//VTK::Mapper::Dec\n\n//VTK::Color::Dec\n\n//VTK::IOStructs::Dec\n\n@vertex\nfn main(\n//VTK::IOStructs::Input\n)\n//VTK::IOStructs::Output\n{\n  var offsetsArray: array<vec3<f32>, 12> = array<vec3<f32>, 12>(\n    vec3<f32>(-1.0, -1.0, -1.0),\n    vec3<f32>(1.0, -1.0, -1.0),\n    vec3<f32>(1.0, -1.0, 1.0),\n\n    vec3<f32>(-1.0, -1.0, -1.0),\n    vec3<f32>(1.0, -1.0, 1.0),\n    vec3<f32>(-1.0, -1.0, 1.0),\n\n    vec3<f32>(-1.0, -1.0, 1.0),\n    vec3<f32>(1.0, -1.0, 1.0),\n    vec3<f32>(1.0, 1.0, 1.0),\n\n    vec3<f32>(-1.0, -1.0, 1.0),\n    vec3<f32>(1.0, 1.0, 1.0),\n    vec3<f32>(-1.0, 1.0, 1.0)\n  );\n\n  var output : vertexOutput;\n\n  var vertexVC: vec4<f32> = rendererUBO.SCVCMatrix * mapperUBO.BCSCMatrix * vec4<f32>(vertexBC.xyz, 1.0);\n\n  //VTK::Color::Impl\n\n  // compute the projected vertex position\n  output.centerVC = vertexVC.xyz;\n  output.radiusVC = radiusMC;\n  output.lengthVC = length(orientMC);\n  output.orientVC = (rendererUBO.WCVCNormals * vec4<f32>(normalize(orientMC), 0.0)).xyz;\n\n  // make sure it is pointing out of the screen\n  if (output.orientVC.z < 0.0)\n    {\n    output.orientVC = -output.orientVC;\n    }\n\n  // make the basis\n  var xbase: vec3<f32>;\n  var ybase: vec3<f32>;\n  var dir: vec3<f32> = vec3<f32>(0.0,0.0,1.0);\n  if (rendererUBO.cameraParallel == 0u)\n    {\n    dir = normalize(-vertexVC.xyz);\n    }\n  if (abs(dot(dir,output.orientVC)) == 1.0)\n    {\n    xbase = normalize(cross(vec3<f32>(0.0,1.0,0.0),output.orientVC));\n    ybase = cross(xbase,output.orientVC);\n    }\n  else\n    {\n    xbase = normalize(cross(output.orientVC,dir));\n    ybase = cross(output.orientVC,xbase);\n    }\n\n\n  var vertIdx: u32 = input.vertexIndex % 12u;\n  var offsets: vec3<f32> = offsetsArray[vertIdx];\n\n  vertexVC = vec4<f32>(vertexVC.xyz +\n    output.radiusVC * offsets.x * xbase +\n    output.radiusVC * offsets.y * ybase +\n    0.5 * output.lengthVC * offsets.z * output.orientVC, 1.0);\n\n  output.vertexVC = vertexVC;\n\n  //VTK::Position::Impl\n\n  return output;\n}\n"; // ----------------------------------------------------------------------------
 // vtkWebGPUStickMapper methods
 // ----------------------------------------------------------------------------
 
@@ -51,7 +51,7 @@ function vtkWebGPUStickMapper(publicAPI, model) {
 
   publicAPI.replaceShaderNormal = function (hash, pipeline, vertexInput) {
     var vDesc = pipeline.getShaderDescription('vertex');
-    vDesc.addOutput('vec4<f32>', 'vertexVC');
+    if (!vDesc.hasOutput('vertexVC')) vDesc.addOutput('vec4<f32>', 'vertexVC');
     vDesc.addOutput('vec3<f32>', 'centerVC');
     vDesc.addOutput('vec3<f32>', 'orientVC');
     vDesc.addOutput('f32', 'radiusVC');

package/Rendering/WebGPU/Texture.js

@@ -184,6 +184,14 @@ function vtkWebGPUTexture(publicAPI, model) {
     return tDetails.numComponents;
   };
 
+  publicAPI.getDimensionality = function () {
+    var dims = 0;
+    if (model.width > 1) dims++;
+    if (model.height > 1) dims++;
+    if (model.depth > 1) dims++;
+    return dims;
+  };
+
   publicAPI.resizeToMatch = function (tex) {
     if (tex.getWidth() !== model.width || tex.getHeight() !== model.height || tex.getDepth() !== model.depth) {
       model.width = tex.getWidth();

package/Rendering/WebGPU/Types.js

@@ -325,7 +325,7 @@ function getByteStrideFromBufferFormat(format) {
   var numComp = 1;
 
   if (format[format.length - 2] === 'x') {
-    numComp = format[format.length - 1];
+    numComp = Number(format[format.length - 1]);
   }
 
   var sizeStart = numComp === 1 ? format.length - 1 : format.length - 3; // options are 8, 16, 32 resulting in 8, 6, 2 as the last char
@@ -350,7 +350,7 @@ function getNumberOfComponentsFromBufferFormat(format) {
   var numComp = 1;
 
   if (format[format.length - 2] === 'x') {
-    numComp = format[format.length - 1];
+    numComp = Number(format[format.length - 1]);
   }
 
   return numComp;
@@ -421,7 +421,7 @@ function getByteStrideFromShaderFormat(format) {
   var numComp = 1;
 
   if (format.substring(0, 3) === 'vec') {
-    numComp = format[3];
+    numComp = Number(format[3]);
   } else if (format.substring(0, 3) === 'mat') {
     numComp = format[3] * format[5];
   }

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),

package/Widgets/Widgets3D/ImageCroppingWidget.js

@@ -100,8 +100,6 @@ function vtkImageCroppingWidget(publicAPI, model) {
     }
   }); // --- Widget Requirement ---------------------------------------------------
 
-  model.behavior = widgetBehavior;
-  model.widgetState = build();
   model.methodsToLink = ['scaleInPixels']; // Given a view type (geometry, slice, volume), return a description
   // of what representations to create and what widget state to pass
   // to the respective representations.
@@ -162,14 +160,20 @@ function vtkImageCroppingWidget(publicAPI, model) {
 } // ----------------------------------------------------------------------------
 
 
-var DEFAULT_VALUES = {// cornerManipulator: null,
-  // edgeManipulator: null,
-  // faceManipulator: null
+var defaultValues = function defaultValues(initialValues) {
+  return _objectSpread({
+    // cornerManipulator: null,
+    // edgeManipulator: null,
+    // faceManipulator: null,
+    behavior: widgetBehavior,
+    widgetState: build()
+  }, 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, ['cornerManipulator', 'edgeManipulator', 'faceManipulator']);
   vtkImageCroppingWidget(publicAPI, model);

package/Widgets/Widgets3D/ImplicitPlaneWidget.js

@@ -1,3 +1,4 @@
+import _defineProperty from '@babel/runtime/helpers/defineProperty';
 import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
 import macro from '../../macros.js';
 import vtkAbstractWidgetFactory from '../Core/AbstractWidgetFactory.js';
@@ -7,6 +8,9 @@ import vtkTrackballManipulator from '../Manipulators/TrackballManipulator.js';
 import vtkPlanePointManipulator from '../Manipulators/PlaneManipulator.js';
 import { ViewTypes } from '../Core/WidgetManager/Constants.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; }
 // Widget linked to a view
 // ----------------------------------------------------------------------------
 
@@ -143,8 +147,6 @@ function widgetBehavior(publicAPI, model) {
 function vtkImplicitPlaneWidget(publicAPI, model) {
   model.classHierarchy.push('vtkPlaneWidget'); // --- Widget Requirement ---------------------------------------------------
 
-  model.widgetState = vtkImplicitPlaneRepresentation.generateState();
-  model.behavior = widgetBehavior;
   model.methodsToLink = ['representationStyle', 'sphereResolution', 'handleSizeRatio', 'axisScale', 'normalVisible', 'originVisible', 'planeVisible', 'outlineVisible'];
 
   publicAPI.getRepresentationsForViewType = function (viewType) {
@@ -162,11 +164,17 @@ function vtkImplicitPlaneWidget(publicAPI, model) {
 } // ----------------------------------------------------------------------------
 
 
-var DEFAULT_VALUES = {}; // ----------------------------------------------------------------------------
+var defaultValues = function defaultValues(initialValues) {
+  return _objectSpread({
+    behavior: widgetBehavior,
+    widgetState: vtkImplicitPlaneRepresentation.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);
   vtkImplicitPlaneWidget(publicAPI, model);
 } // ----------------------------------------------------------------------------

package/Widgets/Widgets3D/InteractiveOrientationWidget.js

@@ -1,3 +1,4 @@
+import _defineProperty from '@babel/runtime/helpers/defineProperty';
 import macro from '../../macros.js';
 import vtkAbstractWidgetFactory from '../Core/AbstractWidgetFactory.js';
 import vtkConvexFaceContextRepresentation from '../Representations/ConvexFaceContextRepresentation.js';
@@ -6,6 +7,9 @@ import { generateState, INITIAL_POINTS } from './InteractiveOrientationWidget/st
 import { Behavior } from '../Representations/WidgetRepresentation/Constants.js';
 import { ViewTypes } from '../Core/WidgetManager/Constants.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; }
 // Factory
 // ----------------------------------------------------------------------------
 
@@ -13,8 +17,6 @@ function vtkInteractiveOrientationWidget(publicAPI, model) {
   model.classHierarchy.push('vtkInteractiveOrientationWidget'); // --- Widget Requirement ---------------------------------------------------
 
   model.methodsToLink = ['closePolyLine', 'activeScaleFactor', 'activeColor', 'useActiveColor', 'glyphResolution', 'defaultScale'];
-  model.behavior = widgetBehavior;
-  model.widgetState = generateState();
 
   publicAPI.setBounds = function (bounds) {
     var handles = model.widgetState.getStatesWithLabel('handles');
@@ -107,11 +109,17 @@ function vtkInteractiveOrientationWidget(publicAPI, model) {
 } // ----------------------------------------------------------------------------
 
 
-var DEFAULT_VALUES = {}; // ----------------------------------------------------------------------------
+var defaultValues = function defaultValues(initialValues) {
+  return _objectSpread({
+    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);
   vtkInteractiveOrientationWidget(publicAPI, model);
 } // ----------------------------------------------------------------------------

package/Widgets/Widgets3D/LabelWidget.js

@@ -22,8 +22,6 @@ function vtkLabelWidget(publicAPI, model) {
 
 
   model.methodsToLink = ['textProps', 'fontProperties', 'strokeFontProperties', 'scaleInPixels'];
-  model.behavior = widgetBehavior;
-  model.widgetState = generateState();
 
   publicAPI.getRepresentationsForViewType = function (viewType) {
     switch (viewType) {
@@ -72,7 +70,10 @@ function vtkLabelWidget(publicAPI, model) {
 
 
 function defaultValues(initialValues) {
-  return _objectSpread({}, initialValues);
+  return _objectSpread({
+    behavior: widgetBehavior,
+    widgetState: generateState()
+  }, initialValues);
 } // ----------------------------------------------------------------------------
 
 

package/Widgets/Widgets3D/LineWidget.js

@@ -21,10 +21,8 @@ function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { va
 function vtkLineWidget(publicAPI, model) {
   model.classHierarchy.push('vtkLineWidget');
 
-  var superClass = _objectSpread({}, publicAPI);
+  var superClass = _objectSpread({}, publicAPI); // --- Widget Requirement ---------------------------------------------------
 
-  model.widgetState = generateState();
-  model.behavior = widgetBehavior; // --- Widget Requirement ---------------------------------------------------
 
   model.methodsToLink = ['activeScaleFactor', 'activeColor', 'useActiveColor', 'glyphResolution', 'defaultScale', 'scaleInPixels'];
 
@@ -165,12 +163,18 @@ function vtkLineWidget(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']);
   vtkLineWidget(publicAPI, model);

package/Widgets/Widgets3D/PaintWidget.js

@@ -20,9 +20,6 @@ function vtkPaintWidget(publicAPI, model) {
   var superClass = _objectSpread({}, publicAPI); // --- Widget Requirement ---------------------------------------------------
 
 
-  model.behavior = widgetBehavior;
-  model.widgetState = generateState(model.radius);
-
   publicAPI.getRepresentationsForViewType = function (viewType) {
     switch (viewType) {
       case ViewTypes.DEFAULT:
@@ -67,16 +64,23 @@ function vtkPaintWidget(publicAPI, model) {
 } // ----------------------------------------------------------------------------
 
 
-var DEFAULT_VALUES = {
-  // manipulator: null,
-  radius: 1,
-  painting: false,
-  color: [1]
+var defaultValues = function defaultValues(initialValues) {
+  var _initialValues$radius;
+
+  return _objectSpread({
+    // manipulator: null,
+    radius: 1,
+    painting: false,
+    color: [1],
+    behavior: widgetBehavior,
+    widgetState: generateState((_initialValues$radius = initialValues === null || initialValues === void 0 ? void 0 : initialValues.radius) !== null && _initialValues$radius !== void 0 ? _initialValues$radius : 1)
+  }, 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.get(publicAPI, model, ['painting']);
   macro.setGet(publicAPI, model, ['manipulator', 'radius', 'color']);

package/Widgets/Widgets3D/PolyLineWidget.js

@@ -22,8 +22,6 @@ function vtkPolyLineWidget(publicAPI, model) {
 
 
   model.methodsToLink = ['activeColor', 'activeScaleFactor', 'closePolyLine', 'defaultScale', 'glyphResolution', 'lineThickness', 'useActiveColor', 'scaleInPixels'];
-  model.behavior = widgetBehavior;
-  model.widgetState = generateState();
 
   publicAPI.getRepresentationsForViewType = function (viewType) {
     switch (viewType) {
@@ -78,12 +76,18 @@ function vtkPolyLineWidget(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']);
   vtkPolyLineWidget(publicAPI, model);