@kitware/vtk.js 29.11.2 → 30.1.0

package/Rendering/WebXR/RenderWindowHelper.js

@@ -1,6 +1,10 @@
 import { m as macro } from '../../macros2.js';
 import Constants from './RenderWindowHelper/Constants.js';
+import vtkActor from '@kitware/vtk.js/Rendering/Core/Actor';
+import vtkLineSource from '@kitware/vtk.js/Filters/Sources/LineSource';
+import vtkMapper from '@kitware/vtk.js/Rendering/Core/Mapper';
 import { GET_UNDERLYING_CONTEXT } from '../OpenGL/RenderWindow/ContextProxy.js';
+import { vec3 } from 'gl-matrix';
 
 const {
   XrSessionTypes
@@ -11,6 +15,23 @@ const DEFAULT_RESET_FACTORS = {
   translateZ: -1.5 // default translation initializes object in front of camera
 };
 
+function createRay() {
+  const targetRayLineSource = vtkLineSource.newInstance();
+  const targetRayMapper = vtkMapper.newInstance();
+  targetRayMapper.setInputConnection(targetRayLineSource.getOutputPort());
+  const targetRayActor = vtkActor.newInstance();
+  targetRayActor.getProperty().setColor(1, 0, 0);
+  targetRayActor.getProperty().setLineWidth(5);
+  targetRayActor.setMapper(targetRayMapper);
+  targetRayActor.setPickable(false);
+  return {
+    lineSource: targetRayLineSource,
+    mapper: targetRayMapper,
+    actor: targetRayActor,
+    visible: false
+  };
+}
+
 // ----------------------------------------------------------------------------
 // vtkWebXRRenderWindowHelper methods
 // ----------------------------------------------------------------------------
@@ -145,6 +166,36 @@ function vtkWebXRRenderWindowHelper(publicAPI, model) {
   model.xrRender = async (t, frame) => {
     const xrSession = frame.session;
     const isXrSessionHMD = [XrSessionTypes.HmdVR, XrSessionTypes.HmdAR].includes(model.xrSessionType);
+    if (isXrSessionHMD && model.drawControllersRay && model.xrReferenceSpace) {
+      const renderer = model.renderWindow.getRenderable().getRenderers()[0];
+      const camera = renderer.getActiveCamera();
+      const physicalToWorldMatrix = [];
+      camera.getPhysicalToWorldMatrix(physicalToWorldMatrix);
+      xrSession.inputSources.forEach(inputSource => {
+        if (inputSource.targetRaySpace == null || inputSource.gripSpace == null || inputSource.targetRayMode !== 'tracked-pointer') {
+          return;
+        }
+        if (model.inputSourceToRay[inputSource.handedness] == null) {
+          model.inputSourceToRay[inputSource.handedness] = createRay();
+        }
+        const ray = model.inputSourceToRay[inputSource.handedness];
+        const targetRayPose = frame.getPose(inputSource.targetRaySpace, model.xrReferenceSpace);
+        if (targetRayPose == null) {
+          return;
+        }
+        const targetRayPosition = vec3.fromValues(targetRayPose.transform.position.x, targetRayPose.transform.position.y, targetRayPose.transform.position.z);
+        const dir = camera.physicalOrientationToWorldDirection([targetRayPose.transform.orientation.x, targetRayPose.transform.orientation.y, targetRayPose.transform.orientation.z, targetRayPose.transform.orientation.w]);
+        const targetRayWorldPosition = vec3.transformMat4([], targetRayPosition, physicalToWorldMatrix);
+        const dist = renderer.getActiveCamera().getClippingRange()[1];
+        if (!ray.visible) {
+          renderer.addActor(ray.actor);
+          ray.visible = true;
+        }
+        ray.lineSource.setPoint1(targetRayWorldPosition[0] - dir[0] * dist, targetRayWorldPosition[1] - dir[1] * dist, targetRayWorldPosition[2] - dir[2] * dist);
+        ray.lineSource.setPoint2(...targetRayWorldPosition);
+      });
+      model.renderWindow.render();
+    }
     model.renderWindow.getRenderable().getInteractor().updateXRGamepads(xrSession, frame, model.xrReferenceSpace);
     model.xrSceneFrame = model.xrSession.requestAnimationFrame(model.xrRender);
     const xrPose = frame.getViewerPose(model.xrReferenceSpace);
@@ -202,27 +253,31 @@ function vtkWebXRRenderWindowHelper(publicAPI, model) {
 // Object factory
 // ----------------------------------------------------------------------------
 
-const DEFAULT_VALUES = {
-  initialized: false,
-  initCanvasSize: null,
-  initBackground: null,
-  renderWindow: null,
-  xrSession: null,
-  xrSessionType: 0,
-  xrReferenceSpace: null
-};
+function defaultValues() {
+  return {
+    initialized: false,
+    drawControllersRay: false,
+    inputSourceToRay: {},
+    initCanvasSize: null,
+    initBackground: null,
+    renderWindow: null,
+    xrSession: null,
+    xrSessionType: 0,
+    xrReferenceSpace: null
+  };
+}
 
 // ----------------------------------------------------------------------------
 
 function extend(publicAPI, model) {
   let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-  Object.assign(model, DEFAULT_VALUES, initialValues);
+  Object.assign(model, defaultValues(), initialValues);
 
   // Build VTK API
   macro.obj(publicAPI, model);
   macro.event(publicAPI, model, 'event');
   macro.get(publicAPI, model, ['xrSession']);
-  macro.setGet(publicAPI, model, ['renderWindow']);
+  macro.setGet(publicAPI, model, ['renderWindow', 'drawControllersRay']);
 
   // Object methods
   vtkWebXRRenderWindowHelper(publicAPI, model);

package/Widgets/Widgets3D/ResliceCursorWidget/behavior.d.ts

@@ -1,5 +1,4 @@
 import vtkAbstractWidget from '../../Core/AbstractWidget';
 
 export default interface vtkResliceCursorWidgetDefaultInstance extends vtkAbstractWidget {
-    invokeInternalInteractionEvent: () => void;
 }

package/Widgets/Widgets3D/ResliceCursorWidget/behavior.js

@@ -135,7 +135,7 @@ function widgetBehavior(publicAPI, model) {
         const step = previousPosition.y - callData.position.y;
         publicAPI.translateCenterOnPlaneDirection(step);
         previousPosition = callData.position;
-        publicAPI.invokeInternalInteractionEvent();
+        publicAPI.invokeInteractionEvent(publicAPI.getActiveInteraction());
       }
     }
     return macro.VOID;
@@ -164,7 +164,7 @@ function widgetBehavior(publicAPI, model) {
     const step = calldata.spinY;
     isScrolling = true;
     publicAPI.translateCenterOnPlaneDirection(step);
-    publicAPI.invokeInternalInteractionEvent(
+    publicAPI.invokeInteractionEvent(
     // Force interaction mode because mouse cursor could be above rotation handle
     InteractionMethodsName.TranslateCenter);
     isScrolling = false;
@@ -187,20 +187,11 @@ function widgetBehavior(publicAPI, model) {
     if (model.activeState.getActive()) {
       const methodName = publicAPI.getActiveInteraction();
       publicAPI[methodName](callData);
-      publicAPI.invokeInternalInteractionEvent(methodName);
+      publicAPI.invokeInteractionEvent(methodName);
       return macro.EVENT_ABORT;
     }
     return macro.VOID;
   };
-  publicAPI.invokeInternalInteractionEvent = function () {
-    let methodName = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : publicAPI.getActiveInteraction();
-    const computeFocalPointOffset = methodName !== InteractionMethodsName.RotateLine;
-    const canUpdateFocalPoint = methodName === InteractionMethodsName.RotateLine;
-    publicAPI.invokeInteractionEvent({
-      computeFocalPointOffset,
-      canUpdateFocalPoint
-    });
-  };
   publicAPI.startInteraction = () => {
     publicAPI.invokeStartInteractionEvent();
     // When interacting, plane actor and lines must be re-rendered on other views

package/Widgets/Widgets3D/ResliceCursorWidget.d.ts

@@ -33,7 +33,6 @@ export interface vtkResliceCursorWidget<WidgetInstance extends vtkAbstractWidget
     renderer: vtkRenderer,
     viewType: ViewTypes,
     resetFocalPoint: boolean,
-    keepCenterFocalDistance: boolean,
     computeFocalPointOffset: boolean
   ): void;
 

package/Widgets/Widgets3D/ResliceCursorWidget.js

@@ -215,8 +215,8 @@ function vtkResliceCursorWidget(publicAPI, model) {
   // Methods
   // --------------------------------------------------------------------------
 
-  publicAPI.updateCameraPoints = (renderer, viewType, resetFocalPoint, keepCenterFocalDistance, computeFocalPointOffset) => {
-    publicAPI.resetCamera(renderer, viewType, resetFocalPoint, keepCenterFocalDistance);
+  publicAPI.updateCameraPoints = (renderer, viewType, resetFocalPoint, computeFocalPointOffset) => {
+    publicAPI.resetCamera(renderer, viewType, resetFocalPoint, !computeFocalPointOffset);
     if (computeFocalPointOffset) {
       computeFocalPointOffsetFromResliceCursorCenter(viewType, renderer);
     }

package/index.d.ts

@@ -123,6 +123,7 @@
 /// <reference path="./Interaction/Manipulators/MouseCameraTrackballZoomManipulator.d.ts" />
 /// <reference path="./Interaction/Manipulators/MouseCameraTrackballZoomToMouseManipulator.d.ts" />
 /// <reference path="./Interaction/Manipulators/MouseRangeManipulator.d.ts" />
+/// <reference path="./Interaction/Style/InteractorStyleHMDXR.d.ts" />
 /// <reference path="./Interaction/Style/InteractorStyleImage.d.ts" />
 /// <reference path="./Interaction/Style/InteractorStyleManipulator.d.ts" />
 /// <reference path="./Interaction/Style/InteractorStyleTrackballCamera.d.ts" />

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kitware/vtk.js",
-  "version": "29.11.2",
+  "version": "30.1.0",
   "description": "Visualization Toolkit for the Web",
   "keywords": [
     "3d",