@kitware/vtk.js 23.4.2 → 23.4.4

package/Rendering/WebGPU/SimpleMapper.js

@@ -0,0 +1,290 @@
+import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
+import macro from '../../macros.js';
+import vtkViewNode from '../SceneGraph/ViewNode.js';
+import vtkWebGPUBindGroup from './BindGroup.js';
+import vtkWebGPUPipeline from './Pipeline.js';
+import vtkWebGPUShaderCache from './ShaderCache.js';
+import vtkWebGPUShaderDescription from './ShaderDescription.js';
+import vtkWebGPUVertexInput from './VertexInput.js';
+
+var vtkWebGPUSimpleMapperVS = "\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 vtkWebGPUSimpleMapperFS = "\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::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  //VTK::Color::Impl\n\n  //VTK::Normal::Impl\n\n  //VTK::Light::Impl\n\n  //VTK::TCoord::Impl\n\n  //VTK::Select::Impl\n\n  // var computedColor:vec4<f32> = vec4<f32>(1.0,0.5,0.5,1.0);\n\n  //VTK::RenderEncoder::Impl\n  return output;\n}\n"; // ----------------------------------------------------------------------------
+// vtkWebGPUSimpleMapper methods
+// ----------------------------------------------------------------------------
+
+function vtkWebGPUSimpleMapper(publicAPI, model) {
+  // Set our className
+  model.classHierarchy.push('vtkWebGPUSimpleMapper');
+
+  publicAPI.generateShaderDescriptions = function (hash, pipeline, vertexInput) {
+    // create the shader descriptions
+    var vDesc = vtkWebGPUShaderDescription.newInstance({
+      type: 'vertex',
+      hash: hash,
+      code: model.vertexShaderTemplate
+    });
+    var fDesc = vtkWebGPUShaderDescription.newInstance({
+      type: 'fragment',
+      hash: hash,
+      code: model.fragmentShaderTemplate
+    }); // add them to the pipeline
+
+    var sdrs = pipeline.getShaderDescriptions();
+    sdrs.push(vDesc);
+    sdrs.push(fDesc); // look for replacements to invoke
+
+    var scode = model.vertexShaderTemplate + model.fragmentShaderTemplate; // eslint-disable-next-line prefer-regex-literals
+
+    var re = new RegExp('//VTK::[^:]*::', 'g');
+    var unique = scode.match(re).filter(function (v, i, a) {
+      return a.indexOf(v) === i;
+    });
+    var fnames = unique.map(function (v) {
+      return "replaceShader".concat(v.substring(7, v.length - 2));
+    }); // now invoke shader replacement functions
+
+    for (var i = 0; i < fnames.length; i++) {
+      var fname = fnames[i];
+
+      if (fname !== 'replaceShaderIOStructs' && model.shaderReplacements.has(fname)) {
+        model.shaderReplacements.get(fname)(hash, pipeline, vertexInput);
+      }
+    } // always replace the IOStructs last as other replacement funcs may
+    // add inputs or outputs
+
+
+    publicAPI.replaceShaderIOStructs(hash, pipeline, vertexInput); // console.log(vDesc.getCode());
+    // console.log(fDesc.getCode());
+  };
+
+  publicAPI.replaceShaderIOStructs = function (hash, pipeline, vertexInput) {
+    var vDesc = pipeline.getShaderDescription('vertex');
+    vDesc.replaceShaderCode(null, vertexInput);
+    var fDesc = pipeline.getShaderDescription('fragment');
+    fDesc.replaceShaderCode(vDesc);
+  };
+
+  publicAPI.replaceShaderRenderEncoder = function (hash, pipeline, vertexInput) {
+    model.renderEncoder.replaceShaderCode(pipeline);
+  };
+
+  model.shaderReplacements.set('replaceShaderRenderEncoder', publicAPI.replaceShaderRenderEncoder);
+
+  publicAPI.replaceShaderRenderer = function (hash, pipeline, vertexInput) {
+    if (!model.WebGPURenderer) {
+      return;
+    }
+
+    var ubocode = model.WebGPURenderer.getBindGroup().getShaderCode(pipeline);
+    var vDesc = pipeline.getShaderDescription('vertex');
+    var code = vDesc.getCode();
+    code = vtkWebGPUShaderCache.substitute(code, '//VTK::Renderer::Dec', [ubocode]).result;
+    vDesc.setCode(code);
+    var fDesc = pipeline.getShaderDescription('fragment');
+    code = fDesc.getCode();
+    code = vtkWebGPUShaderCache.substitute(code, '//VTK::Renderer::Dec', [ubocode]).result;
+    fDesc.setCode(code);
+  };
+
+  model.shaderReplacements.set('replaceShaderRenderer', publicAPI.replaceShaderRenderer);
+
+  publicAPI.replaceShaderMapper = function (hash, pipeline, vertexInput) {
+    var ubocode = model.bindGroup.getShaderCode(pipeline);
+    var vDesc = pipeline.getShaderDescription('vertex');
+    var code = vDesc.getCode();
+    code = vtkWebGPUShaderCache.substitute(code, '//VTK::Mapper::Dec', [ubocode]).result;
+    vDesc.setCode(code);
+    var fDesc = pipeline.getShaderDescription('fragment');
+    fDesc.addBuiltinInput('bool', '@builtin(front_facing) frontFacing');
+    code = fDesc.getCode();
+    code = vtkWebGPUShaderCache.substitute(code, '//VTK::Mapper::Dec', [ubocode]).result;
+    fDesc.setCode(code);
+  };
+
+  model.shaderReplacements.set('replaceShaderMapper', publicAPI.replaceShaderMapper);
+
+  publicAPI.replaceShaderPosition = function (hash, pipeline, vertexInput) {
+    var vDesc = pipeline.getShaderDescription('vertex');
+    vDesc.addBuiltinOutput('vec4<f32>', '@builtin(position) Position');
+    var code = vDesc.getCode();
+    code = vtkWebGPUShaderCache.substitute(code, '//VTK::Position::Impl', ['    output.Position = rendererUBO.SCPCMatrix*vertexBC;']).result;
+    vDesc.setCode(code);
+  };
+
+  model.shaderReplacements.set('replaceShaderPosition', publicAPI.replaceShaderPosition);
+
+  publicAPI.replaceShaderTCoord = function (hash, pipeline, vertexInput) {
+    var vDesc = pipeline.getShaderDescription('vertex');
+    vDesc.addOutput('vec2<f32>', 'tcoordVS');
+  };
+
+  model.shaderReplacements.set('replaceShaderTCoord', publicAPI.replaceShaderTCoord);
+
+  publicAPI.addTextureView = function (view) {
+    // is it already there?
+    if (model.textureViews.includes(view)) {
+      return;
+    }
+
+    model.textureViews.push(view);
+  }; // do everything required for this mapper to be rerady to draw
+  // but do not bind or do the actual draw commands as the pipeline
+  // is not neccessarily bound yet
+
+
+  publicAPI.prepareToDraw = function (renderEncoder) {
+    model.renderEncoder = renderEncoder; // do anything needed to get our input data up to date
+
+    publicAPI.updateInput(); // make sure buffers are created and up to date
+
+    publicAPI.updateBuffers(); // update bindings and bind groups/layouts
+    // does not acutally bind them, that is done in draw(...)
+
+    publicAPI.updateBindings(); // update the pipeline, includes computing the hash, and if needed
+    // creating the pipeline, shader code etc
+
+    publicAPI.updatePipeline();
+  };
+
+  publicAPI.updateInput = function () {};
+
+  publicAPI.updateBuffers = function () {};
+
+  publicAPI.updateBindings = function () {
+    // bindings can change without a pipeline change
+    // as long as their layout remains the same.
+    // That is why this is done even when the pipeline
+    // hash doesn't change.
+    model.bindGroup.setBindables(publicAPI.getBindables());
+  };
+
+  publicAPI.computePipelineHash = function () {};
+
+  publicAPI.registerDrawCallback = function (encoder) {
+    encoder.registerDrawCallback(model.pipeline, publicAPI.draw);
+  };
+
+  publicAPI.prepareAndDraw = function (encoder) {
+    publicAPI.prepareToDraw(encoder);
+    encoder.setPipeline(model.pipeline);
+    publicAPI.draw(encoder);
+  }; // do the rest of the calls required to draw this mapper
+  // at this point the command encouder and pipeline are
+  // created and bound
+
+
+  publicAPI.draw = function (renderEncoder) {
+    var pipeline = renderEncoder.getBoundPipeline(); // bind the mapper bind group
+
+    renderEncoder.activateBindGroup(model.bindGroup);
+
+    if (model.WebGPURenderer) {
+      model.WebGPURenderer.bindUBO(renderEncoder);
+    } // bind the vertex input
+
+
+    pipeline.bindVertexInput(renderEncoder, model.vertexInput);
+    var indexBuffer = model.vertexInput.getIndexBuffer();
+
+    if (indexBuffer) {
+      renderEncoder.drawIndexed(indexBuffer.getIndexCount(), model.numberOfInstances, 0, 0, 0);
+    } else {
+      renderEncoder.draw(model.numberOfVertices, model.numberOfInstances, 0, 0);
+    }
+  };
+
+  publicAPI.getBindables = function () {
+    var bindables = _toConsumableArray(model.additionalBindables);
+
+    if (model.UBO) {
+      bindables.push(model.UBO);
+    }
+
+    if (model.SSBO) {
+      bindables.push(model.SSBO);
+    } // add texture BindGroupLayouts
+
+
+    for (var t = 0; t < model.textureViews.length; t++) {
+      bindables.push(model.textureViews[t]);
+      var samp = model.textureViews[t].getSampler();
+
+      if (samp) {
+        bindables.push(samp);
+      }
+    }
+
+    return bindables;
+  };
+
+  publicAPI.updatePipeline = function () {
+    publicAPI.computePipelineHash();
+    model.pipeline = model.device.getPipeline(model.pipelineHash); // build the pipeline if needed
+
+    if (!model.pipeline) {
+      model.pipeline = vtkWebGPUPipeline.newInstance();
+      model.pipeline.setDevice(model.device);
+
+      if (model.WebGPURenderer) {
+        model.pipeline.addBindGroupLayout(model.WebGPURenderer.getBindGroup());
+      }
+
+      model.pipeline.addBindGroupLayout(model.bindGroup);
+      publicAPI.generateShaderDescriptions(model.pipelineHash, model.pipeline, model.vertexInput);
+      model.pipeline.setTopology(model.topology);
+      model.pipeline.setRenderEncoder(model.renderEncoder);
+      model.pipeline.setVertexState(model.vertexInput.getVertexInputInformation());
+      model.device.createPipeline(model.pipelineHash, model.pipeline);
+    }
+  };
+} // ----------------------------------------------------------------------------
+// Object factory
+// ----------------------------------------------------------------------------
+
+
+var DEFAULT_VALUES = {
+  additionalBindables: undefined,
+  bindGroup: null,
+  device: null,
+  fragmentShaderTemplate: null,
+  numberOfInstances: 1,
+  numberOfVertices: 0,
+  pipelineHash: null,
+  shaderReplacements: null,
+  SSBO: null,
+  textureViews: null,
+  topology: 'triangle-list',
+  UBO: null,
+  vertexShaderTemplate: null,
+  WebGPURenderer: null
+}; // ----------------------------------------------------------------------------
+
+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.textureViews = [];
+  model.vertexInput = vtkWebGPUVertexInput.newInstance();
+  model.bindGroup = vtkWebGPUBindGroup.newInstance({
+    label: 'mapperBG'
+  });
+  model.additionalBindables = [];
+  model.fragmentShaderTemplate = model.fragmentShaderTemplate || vtkWebGPUSimpleMapperFS;
+  model.vertexShaderTemplate = model.vertexShaderTemplate || vtkWebGPUSimpleMapperVS;
+  model.shaderReplacements = new Map(); // Build VTK API
+
+  macro.get(publicAPI, model, ['pipeline', 'vertexInput']);
+  macro.setGet(publicAPI, model, ['additionalBindables', 'device', 'fragmentShaderTemplate', 'interpolate', 'numberOfInstances', 'numberOfVertices', 'pipelineHash', 'shaderReplacements', 'SSBO', 'textureViews', 'topology', 'UBO', 'vertexShaderTemplate', 'WebGPURenderer']); // Object methods
+
+  vtkWebGPUSimpleMapper(publicAPI, model);
+} // ----------------------------------------------------------------------------
+
+var newInstance = macro.newInstance(extend, 'vtkWebGPUSimpleMapper'); // ----------------------------------------------------------------------------
+
+var vtkWebGPUSimpleMapper$1 = {
+  newInstance: newInstance,
+  extend: extend
+};
+
+export { vtkWebGPUSimpleMapper$1 as default, extend, newInstance };

package/Widgets/Core/AbstractWidget.d.ts

@@ -0,0 +1,187 @@
+import vtkInteractorObserver from './../../Rendering/Core/InteractorObserver';
+import vtkProp from './../../Rendering/Core/Prop';
+import vtkRenderer from './../../Rendering/Core/Renderer';
+import vtkWidgetManager from './WidgetManager';
+import vtkWidgetRepresentation from './../Representations/WidgetRepresentation';
+import vtkWidgetState from './WidgetState';
+import { Bounds } from './../../types';
+import { RenderingTypes } from './WidgetManager/Constants';
+import { EventHandler, vtkSubscription } from './../../interfaces';
+
+export interface vtkAbstractWidget extends vtkProp, vtkInteractorObserver {
+  /**
+   * Get the bounds of the widget
+   */
+  getBounds(): Bounds;
+
+  /**
+   * Get all representations of the widget.
+   */
+  getNestedProps(): vtkWidgetRepresentation[];
+
+  /**
+   * Activate a handle, identified by both a state and a representation.
+   * Will also invoke appropriate events.
+   * 
+   * @param locator An object describing the handle to activate.
+   */
+  activateHandle(locator: { 
+    selectedState: vtkWidgetState; 
+    representation: vtkWidgetRepresentation; 
+  }): void;
+
+  /**
+   * Deactivate all the handles on the widget instance.
+   */
+  deactivateAllHandles(): void;
+
+  /**
+   * Returns true if the widget instance holds the given actor, false otherwise.
+   * 
+   * @param {vtkProp} actor
+   */
+  hasActor(actor: vtkProp): boolean;
+
+  /**
+   * Make the widget instance grab the focus.
+   * Should not be called directly or this will lead to unexpected behavior.
+   * To grab the focus on a widget, one should call `vtkWidgetManager.grabFocus(widgetInstanceToGiveFocusTo)`
+   */
+  grabFocus(): void;
+
+  /**
+   * Make the widget instance release the focus.
+   */
+  loseFocus(): void;
+
+  /**
+   * Returns true if the widget instance holds the focus, false otherwise.
+   */
+  hasFocus(): boolean;
+
+  /**
+   * Place a widget at the given bounds.
+   * 
+   * @param {Bounds} bounds
+   */
+  placeWidget(bounds: Bounds): void;
+
+  /**
+   * Get the place factor.
+   */
+  getPlaceFactor(): number;
+
+  /**
+   * Set the place factor.
+   * 
+   * @param {Number} factor The place factor.
+   */
+  setPlaceFactor(factor: number): void;
+
+  /**
+   * Get the `vtkWidgetRepresentation` instance associated with the given `vtkActor` instance.
+   * 
+   * @param {vtkProp} actor 
+   */
+  getRepresentationFromActor(actor: vtkProp): vtkWidgetRepresentation;
+
+  /**
+   * Update all the widget representations for render.
+   * 
+   * @param {RenderingTypes} renderingType Default value if `RenderingTypes.FRONT_BUFFER` 
+   */
+  updateRepresentationForRender(renderingType: RenderingTypes): void;
+
+  /**
+   * Get all the underlyings view widgets.
+   */
+  getViewWidgets(): vtkAbstractWidget[];
+
+
+  /**
+   * Set the context visibility.
+   * 
+   * @param {Boolean} visible 
+   */
+  setContextVisibility(visible: boolean): void;
+
+  /**
+   * Get the context visibility.
+   */
+  getContextVisibility(): boolean;
+
+  /**
+   * Defines if the handles should be visible or not.
+   * 
+   * @param {Boolean} visible 
+   */
+  setHandleVisibility(visible: boolean): void;
+
+  /**
+   * Returns true if the handles are visible, false otherwise.
+   */
+  getHandleVisibility(): boolean;
+
+  /**
+   * Set the widget manager associated with the widget instance.
+   * 
+   * @param {vtkWidgetManager} wm The widget manager instance
+   */
+  setWidgetManager(wm: vtkWidgetManager): void;
+
+  /**
+   * Get the widget manager associated with the widget instance.
+   */
+  getWidgetManager(): vtkWidgetManager;
+
+  /**
+   * Get all the representations of the widget instance.
+   */
+  getRepresentations(): vtkWidgetRepresentation[];
+
+  /**
+   * Get the the state of the widget instance.
+   */
+  getWidgetState(): vtkWidgetState;
+
+  /**
+   * Register a callback to be invoked when the `ActivateHandle` event occurs.
+   * 
+   * @param {EventHandler} cb The callback to register
+   * @param {Number} [priority] Priority of this subscription
+   */
+  onActivateHandle(cb: EventHandler, priority?: number): Readonly<vtkSubscription>;
+
+  /**
+   * Invoke the `ActivateHandle` event with the given payload.
+   * 
+   * @param args The event payload
+   */
+  invokeActivateHandle(...args: unknown[]): void;
+}
+
+/**
+ * Method used to decorate a given object (publicAPI+model) with vtkAbstractWidget characteristics.
+ *
+ * @param publicAPI object on which methods will be bounds (public)
+ * @param model object on which data structure will be bounds (protected)
+ * @param initialValues (default: {})
+ */
+export function extend(publicAPI: object, model: object, initialValues? : object): void;
+
+/**
+ * Method used to create a new instance of vtkAbstractWidget
+ * 
+ * @param initialValues For pre-setting some of its content
+ */
+export function newInstance(initialValues?: object): vtkAbstractWidget;
+
+/**
+ * vtkAbstractWidget is an abstract class to construct a widget.
+ */
+export declare const vtkAbstractWidget: {
+	newInstance: typeof newInstance,
+	extend: typeof extend,
+};
+
+export default vtkAbstractWidget;

package/Widgets/Core/AbstractWidgetFactory.d.ts

@@ -0,0 +1,131 @@
+import vtkAbstractWidget from './AbstractWidget';
+import vtkRenderer from './../../Rendering/Core/Renderer';
+import vtkWidgetState from './WidgetState';
+import { ViewTypes } from './WidgetManager/Constants';
+import { Bounds, Nullable } from './../../types';
+import { EventHandler, vtkSubscription, vtkObject } from './../../interfaces';
+
+export interface IGetWidgetForViewParams {
+  viewId: number;
+  renderer?: vtkRenderer;
+  viewType?: ViewTypes;
+  initialValues?: object;
+}
+
+export interface vtkAbstractWidgetFactory extends vtkObject {
+  /**
+   * Will return the widget associated with the view with Id id `locator.viewId`. 
+   * If there is no widget associated with the view, a new widget will be constructed, provided
+   * that the renderer, viewType, and optionally initialValues are also provided.
+   * 
+   * @param {IGetWidgetForViewParams} locator
+   */
+  getWidgetForView(locator: IGetWidgetForViewParams): Nullable<vtkAbstractWidget>;
+
+  /**
+   * Get a list of all the view ids.
+   */
+  getViewIds(): string[];
+
+  /**
+   * Get a list of all the instances of the widget.
+   */
+  getViewWidgets(): vtkAbstractWidget[];
+
+  /**
+   * Set the visiblity on each underlying view widget.
+   * 
+   * @param {Boolean} visible
+   */
+  setVisibility(visible: boolean): void 
+
+  /**
+   * Set the pickable flag for each underlying view widget.
+   * 
+   * @param {Boolean} pickable 
+   */
+  setPickable(pickable: boolean): void
+
+  /**
+   * Set the dragable flag for each underlying view widget.
+   * 
+   * @param {Boolean} dragable 
+   */
+  setDragable(dragable: boolean): void
+
+  /**
+   * Set the context visibility for each associated view widget.
+   * 
+   * @param {Boolean} visible 
+   */
+  setContextVisibility(visible: boolean): void
+
+  /**
+   * Set the handles visibility for each underlying view widget.
+   * 
+   * @param {Boolean} visible 
+   */
+  setHandleVisiblity(visible: boolean): void
+
+  /**
+   * Place a new widget at the given bounds.
+   * 
+   * @param {Bounds} bounds 
+   */
+  placeWidget(bounds: Bounds);
+
+  /**
+   * Get the place factor.
+   */
+  getPlaceFactor(): number;
+
+  /**
+   * Set the place factor.
+   * 
+   * @param {Number} factor 
+   */
+  setPlaceFactor(factor: number): void;
+
+  /**
+   * Get the `vtkWidgetState` instance
+   */
+  getWidgetState(): vtkWidgetState;
+
+  /**
+   * Register a callback to be called when the WidgetChange event arise.
+   * 
+   * @param {EventHandler} cb The callback to be invoked.
+   * @param {Number} [priority] The priority of this subscription
+   */
+  onWidgetChangeEvent(cb: EventHandler, priority?: number): Readonly<vtkSubscription>;
+
+  /**
+   * Invoke the WidgetChange event
+   * 
+   * @param args The event payload
+   */
+  invokeWidgetChangeEvent(...args: unknown[]): void;
+}
+
+/**
+ * Method used to decorate a given object (publicAPI+model) with vtkAbstractWidgetFactory characteristics.
+ *
+ * @param publicAPI object on which methods will be bounds (public)
+ * @param model object on which data structure will be bounds (protected)
+ * @param initialValues (default: {})
+ */
+export function extend(publicAPI: object, model: object, initialValues? : object): void;
+
+/**
+ * Method used to create a new instance of vtkAbstractWidgetFactory
+ * 
+ * @param initialValues for pre-setting some of its content
+ */
+export function newInstance(initialValues?: object): vtkAbstractWidgetFactory;
+
+export declare const vtkAbstractWidgetFactory: {
+	newInstance: typeof newInstance,
+	extend: typeof extend,
+};
+
+export default vtkAbstractWidgetFactory;

package/Widgets/Core/StateBuilder/color3Mixin.js

@@ -0,0 +1,24 @@
+import macro from '../../../macros.js';
+
+/**
+ * RGB Uint8 color mixin. Not to be used in conjunction with `color` mixin.
+ * @see color
+ */
+
+var DEFAULT_VALUES = {
+  color3: [255, 255, 255],
+  opacity: 255
+}; // ----------------------------------------------------------------------------
+
+function extend(publicAPI, model) {
+  var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  Object.assign(model, DEFAULT_VALUES, initialValues);
+  macro.setGetArray(publicAPI, model, ['color3'], 3, 255);
+  macro.setGet(publicAPI, model, ['opacity']);
+} // ----------------------------------------------------------------------------
+
+var color3 = {
+  extend: extend
+};
+
+export { color3 as default, extend };

package/Widgets/Core/StateBuilder/orientationMixin.js

@@ -1,5 +1,5 @@
 import macro from '../../../macros.js';
-import { l as normalize, j as cross } from '../../../Common/Core/Math/index.js';
+import { g as normalize, k as cross } from '../../../Common/Core/Math/index.js';
 
 function eq(v1, v2) {
   return v1.length === 3 && v2.length === 3 && v1[0] === v2[0] && v1[1] === v2[1] && v1[2] === v2[2];

package/Widgets/Core/StateBuilder.d.ts

@@ -0,0 +1,29 @@
+import vtkWidgetState from './WidgetState';
+
+export interface StateBuilder {
+  addDynamicMixinState(buildInfo: {
+    labels: string[];
+    mixins: string[];
+    name: string;
+    initialValues?: object;
+  }): StateBuilder;
+  addStateFromMixin(buildInfo: {
+    labels: string[];
+    mixins: string[];
+    name: string;
+    initialValues?: object;
+  }): StateBuilder;
+  addStateFromInstance(stateInfo: {
+    labels: string[];
+    name: string;
+    instance: vtkWidgetState;
+  });
+  addField(field: { name: string; initialValue: any });
+  build(...mixins: string[]): vtkWidgetState;
+}
+
+export function createBuilder(): StateBuilder;
+
+export declare const vtkStateBuilder: {
+  createBuilder: typeof createBuilder;
+};

package/Widgets/Core/WidgetManager/Constants.d.ts

@@ -0,0 +1,27 @@
+export declare enum ViewTypes {
+  DEFAULT = 0,
+  GEOMETRY = 1,
+  SLICE = 2,
+  VOLUME = 3,
+  YZ_PLANE = 4,
+  XZ_PLANE = 5,
+  XY_PLANE = 6
+}
+
+export declare enum RenderingTypes {
+  PICKING_BUFFER = 0,
+  FRONT_BUFFER = 1
+}
+
+export declare enum CaptureOn {
+  MOUSE_MOVE = 0,
+  MOUSE_RELEASE = 1
+}
+
+declare const _default: {
+  ViewTypes: typeof ViewTypes;
+  RenderingTypes: typeof RenderingTypes;
+  CaptureOn: typeof CaptureOn;
+}
+
+export default _default;