@kitware/vtk.js 29.11.2 → 30.1.0

package/Rendering/Core/Picker.js

@@ -1,8 +1,8 @@
 import { m as macro } from '../../macros2.js';
 import vtkAbstractPicker from './AbstractPicker.js';
 import vtkBoundingBox from '../../Common/DataModel/BoundingBox.js';
-import { d as dot, l as normalize, n as norm, e as distance2BetweenPoints } from '../../Common/Core/Math/index.js';
-import { mat4, vec4 } from 'gl-matrix';
+import { d as dot, l as normalize, s as subtract, e as distance2BetweenPoints } from '../../Common/Core/Math/index.js';
+import { vec3, mat4, vec4 } from 'gl-matrix';
 
 const {
   vtkErrorMacro
@@ -62,17 +62,114 @@ function vtkPicker(publicAPI, model) {
     return Math.sqrt(tolerance);
   }
 
+  /**
+   * Perform picking on the given renderer, given a ray defined in world coordinates.
+   * @param {*} renderer
+   * @param {*} tolerance
+   * @param {*} p1World
+   * @param {*} p2World
+   * @returns true if we picked something else false
+   */
+  function pick3DInternal(renderer, tolerance, p1World, p2World) {
+    const p1Mapper = new Float64Array(4);
+    const p2Mapper = new Float64Array(4);
+    const ray = [];
+    const hitPosition = [];
+    const props = model.pickFromList ? model.pickList : renderer.getActors();
+
+    // pre-allocate some arrays.
+    const transformScale = new Float64Array(3);
+    const pickedPosition = new Float64Array(3);
+
+    // Loop over props.
+    // Transform ray (defined from position of camera to selection point) into coordinates of mapper (not
+    // transformed to actors coordinates!  Reduces overall computation!!!).
+    // Note that only vtkProp3D's can be picked by vtkPicker.
+    props.forEach(prop => {
+      const mapper = prop.getMapper();
+      const propIsNotFullyTranslucent = prop.getProperty?.()?.getOpacity() > 0.0;
+      const pickable = prop.getNestedPickable() && prop.getNestedVisibility() && propIsNotFullyTranslucent;
+      if (!pickable) {
+        // prop cannot be picked
+        return;
+      }
+
+      // The prop is candidate for picking:
+      // - get its composite matrix and invert it
+      // - use the inverted matrix to transform the ray points into mapper coordinates
+      model.transformMatrix = prop.getMatrix().slice(0);
+      mat4.transpose(model.transformMatrix, model.transformMatrix);
+      mat4.invert(model.transformMatrix, model.transformMatrix);
+      vec4.transformMat4(p1Mapper, p1World, model.transformMatrix);
+      vec4.transformMat4(p2Mapper, p2World, model.transformMatrix);
+      vec3.scale(p1Mapper, p1Mapper, 1 / p1Mapper[3]);
+      vec3.scale(p2Mapper, p2Mapper, 1 / p2Mapper[3]);
+      subtract(p2Mapper, p1Mapper, ray);
+
+      // We now have the ray endpoints in mapper coordinates.
+      // Compare it with the mapper bounds to check if intersection is possible.
+
+      // Get the bounding box of the mapper.
+      // Note that the tolerance is added to the bounding box to make sure things on the edge of the
+      // bounding box are picked correctly.
+      const bounds = mapper ? vtkBoundingBox.inflate(mapper.getBounds(), tolerance) : [...vtkBoundingBox.INIT_BOUNDS];
+      if (vtkBoundingBox.intersectBox(bounds, p1Mapper, ray, hitPosition, [])) {
+        mat4.getScaling(transformScale, model.transformMatrix);
+        const t = model.intersectWithLine(p1Mapper, p2Mapper, tolerance * 0.333 * (transformScale[0] + transformScale[1] + transformScale[2]), prop, mapper);
+        if (t < Number.MAX_VALUE) {
+          pickedPosition[0] = (1.0 - t) * p1World[0] + t * p2World[0];
+          pickedPosition[1] = (1.0 - t) * p1World[1] + t * p2World[1];
+          pickedPosition[2] = (1.0 - t) * p1World[2] + t * p2World[2];
+          const actorIndex = model.actors.indexOf(prop);
+          if (actorIndex !== -1) {
+            // If already in list, compare the previous picked position with the new one.
+            // Store the new one if it is closer from the ray endpoint.
+            const previousPickedPosition = model.pickedPositions[actorIndex];
+            if (distance2BetweenPoints(p1World, pickedPosition) < distance2BetweenPoints(p1World, previousPickedPosition)) {
+              model.pickedPositions[actorIndex] = pickedPosition.slice(0);
+            }
+          } else {
+            model.actors.push(prop);
+            model.pickedPositions.push(pickedPosition.slice(0));
+          }
+        }
+      }
+    });
+
+    // sort array by distance
+    const tempArray = [];
+    for (let i = 0; i < model.pickedPositions.length; i++) {
+      tempArray.push({
+        actor: model.actors[i],
+        pickedPosition: model.pickedPositions[i],
+        distance2: distance2BetweenPoints(p1World, model.pickedPositions[i])
+      });
+    }
+    tempArray.sort((a, b) => {
+      const keyA = a.distance2;
+      const keyB = b.distance2;
+      // order the actors based on the distance2 attribute, so the near actors comes
+      // first in the list
+      if (keyA < keyB) return -1;
+      if (keyA > keyB) return 1;
+      return 0;
+    });
+    model.pickedPositions = [];
+    model.actors = [];
+    tempArray.forEach(obj => {
+      model.pickedPositions.push(obj.pickedPosition);
+      model.actors.push(obj.actor);
+    });
+  }
+
   // Intersect data with specified ray.
   // Project the center point of the mapper onto the ray and determine its parametric value
-  publicAPI.intersectWithLine = (p1, p2, tol, mapper) => {
+  model.intersectWithLine = (p1, p2, tolerance, prop, mapper) => {
     if (!mapper) {
       return Number.MAX_VALUE;
     }
     const center = mapper.getCenter();
-    const ray = [];
-    for (let i = 0; i < 3; i++) {
-      ray[i] = p2[i] - p1[i];
-    }
+    const ray = vec3.subtract(new Float64Array(3), p2, p1);
     const rayFactor = dot(ray, ray);
     if (rayFactor === 0.0) {
       return 2.0;
@@ -86,55 +183,43 @@ function vtkPicker(publicAPI, model) {
   // To be overridden in subclasses
   publicAPI.pick = (selection, renderer) => {
     if (selection.length !== 3) {
-      vtkWarningMacro('vtkPicker::pick: selectionPt needs three components');
+      vtkWarningMacro('vtkPicker.pick - selection needs three components');
     }
+    if (!renderer) {
+      vtkErrorMacro('vtkPicker.pick - renderer cannot be null');
+      throw new Error('renderer cannot be null');
+    }
+    initialize();
     const selectionX = selection[0];
     const selectionY = selection[1];
     let selectionZ = selection[2];
-    let cameraPos = [];
-    let cameraFP = [];
-    let displayCoords = [];
-    let worldCoords = [];
-    const ray = [];
-    const cameraDOP = [];
-    let clipRange = [];
-    let tF;
-    let tB;
-    const p1World = [];
-    const p2World = [];
-    let props = [];
-    let pickable = false;
-    const p1Mapper = new Float64Array(4);
-    const p2Mapper = new Float64Array(4);
-    const bbox = vtkBoundingBox.newInstance();
-    const t = [];
-    const hitPosition = [];
-    const view = renderer.getRenderWindow().getViews()[0];
-    initialize();
     model.renderer = renderer;
     model.selectionPoint[0] = selectionX;
     model.selectionPoint[1] = selectionY;
     model.selectionPoint[2] = selectionZ;
-    if (!renderer) {
-      vtkErrorMacro('Picker::Pick Must specify renderer');
-      return;
-    }
+    const p1World = new Float64Array(4);
+    const p2World = new Float64Array(4);
 
     // Get camera focal point and position. Convert to display (screen)
     // coordinates. We need a depth value for z-buffer.
     const camera = renderer.getActiveCamera();
-    cameraPos = camera.getPosition();
-    cameraFP = camera.getFocalPoint();
+    const cameraPos = camera.getPosition();
+    const cameraFP = camera.getFocalPoint();
+    const view = renderer.getRenderWindow().getViews()[0];
     const dims = view.getViewportSize(renderer);
+    if (dims[1] === 0) {
+      vtkWarningMacro('vtkPicker.pick - viewport area is 0');
+      return;
+    }
     const aspect = dims[0] / dims[1];
+    let displayCoords = [];
     displayCoords = renderer.worldToNormalizedDisplay(cameraFP[0], cameraFP[1], cameraFP[2], aspect);
     displayCoords = view.normalizedDisplayToDisplay(displayCoords[0], displayCoords[1], displayCoords[2]);
     selectionZ = displayCoords[2];
-    const tolerance = computeTolerance(selectionZ, aspect, renderer) * model.tolerance;
 
     // Convert the selection point into world coordinates.
     const normalizedDisplay = view.displayToNormalizedDisplay(selectionX, selectionY, selectionZ);
-    worldCoords = renderer.normalizedDisplayToWorld(normalizedDisplay[0], normalizedDisplay[1], normalizedDisplay[2], aspect);
+    const worldCoords = renderer.normalizedDisplayToWorld(normalizedDisplay[0], normalizedDisplay[1], normalizedDisplay[2], aspect);
     for (let i = 0; i < 3; i++) {
       model.pickPosition[i] = worldCoords[i];
     }
@@ -143,9 +228,11 @@ function vtkPicker(publicAPI, model) {
     //  the camera position to the selection point, starting where this line
     //  intersects the front clipping plane, and terminating where this
     //  line intersects the back clipping plane.
+    const ray = [];
     for (let i = 0; i < 3; i++) {
       ray[i] = model.pickPosition[i] - cameraPos[i];
     }
+    const cameraDOP = [];
     for (let i = 0; i < 3; i++) {
       cameraDOP[i] = cameraFP[i] - cameraPos[i];
     }
@@ -155,7 +242,9 @@ function vtkPicker(publicAPI, model) {
       vtkWarningMacro('Picker::Pick Cannot process points');
       return;
     }
-    clipRange = camera.getClippingRange();
+    const clipRange = camera.getClippingRange();
+    let tF;
+    let tB;
     if (camera.getParallelProjection()) {
       tF = clipRange[0] - rayLength;
       tB = clipRange[1] - rayLength;
@@ -173,105 +262,25 @@ function vtkPicker(publicAPI, model) {
     }
     p1World[3] = 1.0;
     p2World[3] = 1.0;
-    if (model.pickFromList) {
-      props = model.pickList;
-    } else {
-      props = renderer.getActors();
+    const tolerance = computeTolerance(selectionZ, aspect, renderer) * model.tolerance;
+    pick3DInternal(model.renderer, tolerance, p1World, p2World);
+  };
+  publicAPI.pick3DPoint = (selectionPoint, focalPoint, renderer) => {
+    if (!renderer) {
+      throw new Error('renderer cannot be null');
     }
-    const scale = [];
-    props.forEach(prop => {
-      const mapper = prop.getMapper();
-      pickable = prop.getNestedPickable() && prop.getNestedVisibility();
-      if (prop.getProperty().getOpacity?.() <= 0.0) {
-        pickable = false;
-      }
-      if (pickable) {
-        model.transformMatrix = prop.getMatrix().slice(0);
-        // Webgl need a transpose matrix but we need the untransposed one to project world points
-        // into the right referential
-        mat4.transpose(model.transformMatrix, model.transformMatrix);
-        mat4.invert(model.transformMatrix, model.transformMatrix);
-        // Extract scale
-        const col1 = [model.transformMatrix[0], model.transformMatrix[1], model.transformMatrix[2]];
-        const col2 = [model.transformMatrix[4], model.transformMatrix[5], model.transformMatrix[6]];
-        const col3 = [model.transformMatrix[8], model.transformMatrix[9], model.transformMatrix[10]];
-        scale[0] = norm(col1);
-        scale[1] = norm(col2);
-        scale[2] = norm(col3);
-        vec4.transformMat4(p1Mapper, p1World, model.transformMatrix);
-        vec4.transformMat4(p2Mapper, p2World, model.transformMatrix);
-        p1Mapper[0] /= p1Mapper[3];
-        p1Mapper[1] /= p1Mapper[3];
-        p1Mapper[2] /= p1Mapper[3];
-        p2Mapper[0] /= p2Mapper[3];
-        p2Mapper[1] /= p2Mapper[3];
-        p2Mapper[2] /= p2Mapper[3];
-        for (let i = 0; i < 3; i++) {
-          ray[i] = p2Mapper[i] - p1Mapper[i];
-        }
-        if (mapper) {
-          bbox.setBounds(mapper.getBounds());
-          bbox.inflate(tolerance);
-        } else {
-          bbox.reset();
-        }
-        if (bbox.intersectBox(p1Mapper, ray, hitPosition, t)) {
-          t[0] = publicAPI.intersectWithLine(p1Mapper, p2Mapper, tolerance * 0.333 * (scale[0] + scale[1] + scale[2]), prop, mapper);
-          if (t[0] < Number.MAX_VALUE) {
-            const p = [];
-            p[0] = (1.0 - t[0]) * p1World[0] + t[0] * p2World[0];
-            p[1] = (1.0 - t[0]) * p1World[1] + t[0] * p2World[1];
-            p[2] = (1.0 - t[0]) * p1World[2] + t[0] * p2World[2];
-
-            // Check if the current actor is already in the list
-            let actorID = -1;
-            for (let i = 0; i < model.actors.length; i++) {
-              if (model.actors[i] === prop) {
-                actorID = i;
-                break;
-              }
-            }
-            if (actorID === -1) {
-              model.actors.push(prop);
-              model.pickedPositions.push(p);
-            } else {
-              const oldPoint = model.pickedPositions[actorID];
-              const distOld = distance2BetweenPoints(p1World, oldPoint);
-              const distCurrent = distance2BetweenPoints(p1World, p);
-              if (distCurrent < distOld) {
-                model.pickedPositions[actorID] = p;
-              }
-            }
-          }
-        }
-      }
-      publicAPI.invokePickChange(model.pickedPositions);
-      return 1;
-    });
-    // sort array by distance
-    const tempArray = [];
-    for (let i = 0; i < model.pickedPositions.length; i++) {
-      tempArray.push({
-        actor: model.actors[i],
-        pickedPosition: model.pickedPositions[i],
-        distance2: distance2BetweenPoints(p1World, model.pickedPositions[i])
-      });
+    initialize();
+    model.renderer = renderer;
+    vec3.copy(model.selectionPoint, selectionPoint);
+    const view = renderer.getRenderWindow().getViews()[0];
+    const dims = view.getViewportSize(renderer);
+    if (dims[1] === 0) {
+      vtkWarningMacro('vtkPicker.pick3DPoint - viewport area is 0');
+      return;
     }
-    tempArray.sort((a, b) => {
-      const keyA = a.distance2;
-      const keyB = b.distance2;
-      // order the actors based on the distance2 attribute, so the near actors comes
-      // first in the list
-      if (keyA < keyB) return -1;
-      if (keyA > keyB) return 1;
-      return 0;
-    });
-    model.pickedPositions = [];
-    model.actors = [];
-    tempArray.forEach(obj => {
-      model.pickedPositions.push(obj.pickedPosition);
-      model.actors.push(obj.actor);
-    });
+    const aspect = dims[0] / dims[1];
+    const tolerance = computeTolerance(model.selectionPoint[2], aspect, renderer) * model.tolerance;
+    pick3DInternal(renderer, tolerance, selectionPoint, focalPoint);
   };
 }
 

package/Rendering/Core/PointPicker.d.ts

@@ -1,6 +1,8 @@
 import vtkPicker, { IPickerInitialValues } from './Picker';
 import vtkMapper from './Mapper';
 import { Vector3 } from './../../types';
+import vtkProp3D from './Prop3D';
+import { Nullable } from './../../types';
 
 interface IPointPickerInitialValues extends IPickerInitialValues {
 	pointId?: number;
@@ -31,24 +33,6 @@ export interface vtkPointPicker extends vtkPicker {
 	 */
 	getUseCells(): boolean;
 
-	/**
-	 * 
-	 * @param {Vector3} p1 
-	 * @param {Vector3} p2 
-	 * @param {Number} tol 
-	 * @param {vtkMapper} mapper 
-	 */
-	intersectWithLine(p1: Vector3, p2: Vector3, tol: number, mapper: vtkMapper): number;
-
-	/**
-	 * 
-	 * @param {Vector3} p1 
-	 * @param {Vector3} p2 
-	 * @param {Number} tol 
-	 * @param {vtkMapper} mapper 
-	 */
-	intersectActorWithLine(p1: Vector3, p2: Vector3, tol: number, mapper: vtkMapper): number;
-
 	/**
 	 * Specify whether the point search should be based on cell points or directly on the point list.
 	 * @param useCells 

package/Rendering/Core/PointPicker.js

@@ -13,7 +13,7 @@ const {
 function vtkPointPicker(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkPointPicker');
-  publicAPI.intersectWithLine = (p1, p2, tol, actor, mapper) => {
+  model.intersectWithLine = (p1, p2, tolerance, prop, mapper) => {
     let tMin = Number.MAX_VALUE;
     if (mapper.isA('vtkImageMapper') || mapper.isA('vtkImageArrayMapper')) {
       const pickData = mapper.intersectWithLineForPointPicking(p1, p2);
@@ -22,11 +22,11 @@ function vtkPointPicker(publicAPI, model) {
         model.pointIJK = pickData.ijk;
       }
     } else if (mapper.isA('vtkMapper')) {
-      tMin = publicAPI.intersectActorWithLine(p1, p2, tol, mapper);
+      tMin = model.intersectActorWithLine(p1, p2, tolerance, mapper);
     }
     return tMin;
   };
-  publicAPI.intersectActorWithLine = (p1, p2, tol, mapper) => {
+  model.intersectActorWithLine = (p1, p2, tolerance, mapper) => {
     // Get dataset
     const input = mapper.getInputData();
 
@@ -77,7 +77,7 @@ function vtkPointPicker(publicAPI, model) {
                 maxDist = dist;
               }
             } // end for i
-            if (maxDist <= tol && maxDist < minPtDist) {
+            if (maxDist <= tolerance && maxDist < minPtDist) {
               // within tolerance
               minPtId = ptId;
               minPtDist = maxDist;
@@ -105,7 +105,7 @@ function vtkPointPicker(publicAPI, model) {
               maxDist = dist;
             }
           } // end for i
-          if (maxDist <= tol && maxDist < minPtDist) {
+          if (maxDist <= tolerance && maxDist < minPtDist) {
             // within tolerance
             minPtId = ptId;
             minPtDist = maxDist;

package/Rendering/Core/Prop3D.d.ts

@@ -1,4 +1,4 @@
-import { mat4 } from "gl-matrix";
+import { mat4, quat } from "gl-matrix";
 import { Bounds, Vector3, Range } from './../../types';
 import vtkProp, { IPropInitialValues } from './Prop';
 
@@ -88,6 +88,13 @@ export interface vtkProp3D extends vtkProp {
 	 */
 	getOrientationWXYZ(): number[];
 
+	/**
+	 * Get the orientation quaternion of the Prop3D.
+	 * out is optional and will be created if not supplied.
+	 * @param {quat | undefined} out
+	 */
+	getOrientationQuaternion(out?: quat): quat;
+
 	/**
 	 * Get a reference to the Prop3D’s 4x4 composite matrix.
 	 * Get the matrix from the position, origin, scale and orientation This
@@ -167,6 +174,14 @@ export interface vtkProp3D extends vtkProp {
 	 */
 	rotateWXYZ(degrees: number, x: number, y: number, z: number): void;
 
+	/**
+	 * Rotate the Prop3D by the provided orientation quaternion.
+	 * If the provided quaternion is identity (~epsilon), this function does nothing.
+	 * The quaternion should follow the gl-matrix convention: [x,y,z,w]
+	 * @param {quat} orientationQuaternion The quaternion to rotate the prop by.
+	 */
+	rotateQuaternion(orientationQuaternion: quat): void;
+
 	/**
 	 * Orientation is specified as X, Y and Z rotations in that order,
 	 * but they are performed as RotateZ, RotateX, and finally RotateY.

package/Rendering/Core/Prop3D.js

@@ -4,6 +4,8 @@ import vtkBoundingBox from '../../Common/DataModel/BoundingBox.js';
 import { A as degreesFromRadians, r as radiansFromDegrees, a as areMatricesEqual } from '../../Common/Core/Math/index.js';
 import vtkProp from './Prop.js';
 
+const VTK_EPSILON = 1e-6;
+
 // ----------------------------------------------------------------------------
 // vtkProp3D methods
 // ----------------------------------------------------------------------------
@@ -22,6 +24,10 @@ function vtkProp3D(publicAPI, model) {
     const w = quat.getAxisAngle(oaxis, q);
     return [degreesFromRadians(w), oaxis[0], oaxis[1], oaxis[2]];
   };
+  publicAPI.getOrientationQuaternion = function () {
+    let out = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+    return mat4.getRotation(out, model.rotation);
+  };
   publicAPI.rotateX = val => {
     if (val === 0.0) {
       return;
@@ -57,6 +63,14 @@ function vtkProp3D(publicAPI, model) {
     mat4.multiply(model.rotation, model.rotation, quatMat);
     publicAPI.modified();
   };
+  publicAPI.rotateQuaternion = orientationQuaternion => {
+    if (Math.abs(orientationQuaternion[3]) >= 1 - VTK_EPSILON) {
+      return;
+    }
+    const oriQuatMat = mat4.fromQuat(new Float64Array(16), orientationQuaternion);
+    mat4.multiply(model.rotation, model.rotation, oriQuatMat);
+    publicAPI.modified();
+  };
   publicAPI.setOrientation = (x, y, z) => {
     if (x === model.orientation[0] && y === model.orientation[1] && z === model.orientation[2]) {
       return false;

package/Rendering/Core/RenderWindowInteractor.d.ts

@@ -81,6 +81,20 @@ export interface IRenderWindowInteractorEvent {
 	type: InteractorEventType;
 }
 
+export interface I3DEvent {
+	gamepad: Gamepad;
+	position: DOMPointReadOnly;
+	orientation: DOMPointReadOnly;
+	targetPosition: DOMPointReadOnly;
+	targetOrientation: DOMPointReadOnly;
+	device: Device;
+}
+
+export interface IButton3DEvent extends I3DEvent {
+	pressed: boolean;
+	input: Input;
+}
+
 export interface vtkRenderWindowInteractor extends vtkObject {
 
 	/**
@@ -678,10 +692,11 @@ export interface vtkRenderWindowInteractor extends vtkObject {
 	animationEvent(args: any): any;
 
 	/**
-	 *
+	 * Triggers the 'Button3D' event.
+	 * 
 	 * @param args
 	 */
-	button3DEvent(args: any): any;
+	button3DEvent(eventPayload: IButton3DEvent): void;
 
 	/**
 	 *
@@ -804,10 +819,11 @@ export interface vtkRenderWindowInteractor extends vtkObject {
 	mouseWheelEvent(args: any): any;
 
 	/**
-	 *
-	 * @param args
+	 * Triggers the 'Move3D' event.
+	 * 
+	 * @param eventPayload
 	 */
-	move3DEvent(args: any): any;
+	move3DEvent(eventPayload: I3DEvent): void;
 
 	/**
 	 *

package/Rendering/Core/RenderWindowInteractor.js

@@ -481,45 +481,51 @@ function vtkRenderWindowInteractor(publicAPI, model) {
     // watch for when buttons change state and fire events
     xrSession.inputSources.forEach(inputSource => {
       const gripPose = inputSource.gripSpace == null ? null : xrFrame.getPose(inputSource.gripSpace, xrRefSpace);
-      const gp = inputSource.gamepad;
+      const targetRayPose = inputSource.gripSpace == null ? null : xrFrame.getPose(inputSource.targetRaySpace, xrRefSpace);
+      const gamepad = inputSource.gamepad;
       const hand = inputSource.handedness;
-      if (gp) {
-        if (!(gp.index in model.lastGamepadValues)) {
-          model.lastGamepadValues[gp.index] = {
-            left: {
-              buttons: {}
-            },
-            right: {
-              buttons: {}
-            },
-            none: {
-              buttons: {}
-            }
-          };
-        }
-        for (let b = 0; b < gp.buttons.length; ++b) {
-          if (!(b in model.lastGamepadValues[gp.index][hand].buttons)) {
-            model.lastGamepadValues[gp.index][hand].buttons[b] = false;
-          }
-          if (model.lastGamepadValues[gp.index][hand].buttons[b] !== gp.buttons[b].pressed && gripPose != null) {
-            publicAPI.button3DEvent({
-              gamepad: gp,
-              position: gripPose.transform.position,
-              orientation: gripPose.transform.orientation,
-              pressed: gp.buttons[b].pressed,
-              device: inputSource.handedness === 'left' ? Device.LeftController : Device.RightController,
-              input: deviceInputMap[gp.mapping] && deviceInputMap[gp.mapping][b] ? deviceInputMap[gp.mapping][b] : Input.Trigger
-            });
-            model.lastGamepadValues[gp.index][hand].buttons[b] = gp.buttons[b].pressed;
-          }
-          if (model.lastGamepadValues[gp.index][hand].buttons[b] && gripPose != null) {
-            publicAPI.move3DEvent({
-              gamepad: gp,
-              position: gripPose.transform.position,
-              orientation: gripPose.transform.orientation,
-              device: inputSource.handedness === 'left' ? Device.LeftController : Device.RightController
-            });
+      if (!gamepad) {
+        return;
+      }
+      if (!(gamepad.index in model.lastGamepadValues)) {
+        model.lastGamepadValues[gamepad.index] = {
+          left: {
+            buttons: {}
+          },
+          right: {
+            buttons: {}
+          },
+          none: {
+            buttons: {}
           }
+        };
+      }
+      for (let buttonIdx = 0; buttonIdx < gamepad.buttons.length; ++buttonIdx) {
+        if (!(buttonIdx in model.lastGamepadValues[gamepad.index][hand].buttons)) {
+          model.lastGamepadValues[gamepad.index][hand].buttons[buttonIdx] = false;
+        }
+        if (model.lastGamepadValues[gamepad.index][hand].buttons[buttonIdx] !== gamepad.buttons[buttonIdx].pressed && gripPose != null) {
+          publicAPI.button3DEvent({
+            gamepad,
+            position: gripPose.transform.position,
+            orientation: gripPose.transform.orientation,
+            targetPosition: targetRayPose.transform.position,
+            targetOrientation: targetRayPose.transform.orientation,
+            pressed: gamepad.buttons[buttonIdx].pressed,
+            device: inputSource.handedness === 'left' ? Device.LeftController : Device.RightController,
+            input: deviceInputMap[gamepad.mapping] && deviceInputMap[gamepad.mapping][buttonIdx] ? deviceInputMap[gamepad.mapping][buttonIdx] : Input.Trigger
+          });
+          model.lastGamepadValues[gamepad.index][hand].buttons[buttonIdx] = gamepad.buttons[buttonIdx].pressed;
+        }
+        if (model.lastGamepadValues[gamepad.index][hand].buttons[buttonIdx] && gripPose != null) {
+          publicAPI.move3DEvent({
+            gamepad,
+            position: gripPose.transform.position,
+            orientation: gripPose.transform.orientation,
+            targetPosition: targetRayPose.transform.position,
+            targetOrientation: targetRayPose.transform.orientation,
+            device: inputSource.handedness === 'left' ? Device.LeftController : Device.RightController
+          });
         }
       }
     });

package/Rendering/Core/VolumeMapper.d.ts

@@ -1,12 +1,12 @@
 import vtkPiecewiseFunction from './../../Common/DataModel/PiecewiseFunction';
 import { Bounds, Range } from './../../types';
-import vtkAbstractMapper, { IAbstractMapperInitialValues } from './AbstractMapper';
+import vtkAbstractMapper3D, { IAbstractMapper3DInitialValues } from './AbstractMapper3D';
 import { BlendMode, FilterMode } from './VolumeMapper/Constants';
 
 /**
  *
  */
-export interface IVolumeMapperInitialValues extends IAbstractMapperInitialValues {
+export interface IVolumeMapperInitialValues extends IAbstractMapper3DInitialValues {
 	anisotropy?: number;
 	autoAdjustSampleDistances?: boolean;
 	averageIPScalarRange?: Range;
@@ -23,7 +23,7 @@ export interface IVolumeMapperInitialValues extends IAbstractMapperInitialValues
 	LAOKernelSize?: number;
 }
 
-export interface vtkVolumeMapper extends vtkAbstractMapper {
+export interface vtkVolumeMapper extends vtkAbstractMapper3D {
 
 	/**
      * Get the bounds for this mapper as [xmin, xmax, ymin, ymax,zmin, zmax].