@kitware/vtk.js 21.1.5 → 21.2.0

package/Rendering/OpenGL/RenderWindow.js

@@ -1,19 +1,20 @@
 import _slicedToArray from '@babel/runtime/helpers/slicedToArray';
 import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
+import _asyncToGenerator from '@babel/runtime/helpers/asyncToGenerator';
+import _regeneratorRuntime from '@babel/runtime/regenerator';
+import { VtkDataTypes } from '../../Common/Core/DataArray/Constants.js';
 import macro from '../../macros.js';
 import { registerViewConstructor } from '../Core/RenderWindow.js';
 import vtkForwardPass from './ForwardPass.js';
+import vtkHardwareSelector from './HardwareSelector.js';
+import vtkShaderCache from './ShaderCache.js';
+import vtkTextureUnitManager from './TextureUnitManager.js';
 import vtkViewNodeFactory from './ViewNodeFactory.js';
 import vtkRenderPass from '../SceneGraph/RenderPass.js';
-import vtkShaderCache from './ShaderCache.js';
 import vtkRenderWindowViewNode from '../SceneGraph/RenderWindowViewNode.js';
-import vtkTextureUnitManager from './TextureUnitManager.js';
-import vtkHardwareSelector from './HardwareSelector.js';
-import { VtkDataTypes } from '../../Common/Core/DataArray/Constants.js';
 
 var vtkDebugMacro = macro.vtkDebugMacro,
     vtkErrorMacro = macro.vtkErrorMacro;
-var IS_CHROME = navigator.userAgent.indexOf('Chrome') !== -1;
 var SCREENSHOT_PLACEHOLDER = {
   position: 'absolute',
   top: 0,
@@ -211,7 +212,12 @@ function vtkOpenGLRenderWindow(publicAPI, model) {
       depth: true,
       alpha: true
     };
-    var result = null;
+    var result = null; // Do we have webxr support
+
+    if (navigator.xr !== undefined && navigator.xr.isSessionSupported('immersive-vr')) {
+      publicAPI.invokeHaveVRDisplay();
+    }
+
     var webgl2Supported = typeof WebGL2RenderingContext !== 'undefined';
     model.webgl2 = false;
 
@@ -227,22 +233,6 @@ function vtkOpenGLRenderWindow(publicAPI, model) {
     if (!result) {
       vtkDebugMacro('using webgl1');
       result = model.canvas.getContext('webgl', options) || model.canvas.getContext('experimental-webgl', options);
-    } // Do we have webvr support
-
-
-    if (navigator.getVRDisplays) {
-      navigator.getVRDisplays().then(function (displays) {
-        if (displays.length > 0) {
-          // take the first display for now
-          model.vrDisplay = displays[0]; // set the clipping ranges
-
-          model.vrDisplay.depthNear = 0.01; // meters
-
-          model.vrDisplay.depthFar = 100.0; // meters
-
-          publicAPI.invokeHaveVRDisplay();
-        }
-      });
     } // prevent default context lost handler
 
 
@@ -251,84 +241,180 @@ function vtkOpenGLRenderWindow(publicAPI, model) {
     }, false);
     model.canvas.addEventListener('webglcontextrestored', publicAPI.restoreContext, false);
     return result;
-  };
-
-  publicAPI.startVR = function () {
-    model.oldCanvasSize = model.size.slice();
+  }; // Request an XR session on the user device with WebXR,
+  // typically in response to a user request such as a button press
 
-    if (model.vrDisplay.capabilities.canPresent) {
-      model.vrDisplay.requestPresent([{
-        source: model.canvas
-      }]).then(function () {
-        if (model.el && model.vrDisplay.capabilities.hasExternalDisplay && model.hideCanvasInVR) {
-          model.el.style.display = 'none';
-        }
 
-        if (model.queryVRSize) {
-          var leftEye = model.vrDisplay.getEyeParameters('left');
-          var rightEye = model.vrDisplay.getEyeParameters('right');
-          var width = Math.floor(leftEye.renderWidth + rightEye.renderWidth);
-          var height = Math.floor(Math.max(leftEye.renderHeight, rightEye.renderHeight));
-          publicAPI.setSize(width, height);
-        } else {
-          publicAPI.setSize(model.vrResolution);
-        }
+  publicAPI.startXR = function () {
+    if (navigator.xr === undefined) {
+      throw new Error('WebXR is not available');
+    }
 
-        var ren = model.renderable.getRenderers()[0];
-        ren.resetCamera();
-        model.vrFrameData = new VRFrameData();
-        model.renderable.getInteractor().switchToVRAnimation();
-        model.vrSceneFrame = model.vrDisplay.requestAnimationFrame(publicAPI.vrRender); // If Broswer is chrome we need to request animation again to canvas update
+    if (!navigator.xr.isSessionSupported('immersive-vr')) {
+      throw new Error('VR display is not available');
+    }
 
-        if (IS_CHROME) {
-          model.vrSceneFrame = model.vrDisplay.requestAnimationFrame(publicAPI.vrRender);
-        }
-      }).catch(function () {
-        console.error('failed to requestPresent');
+    if (model.xrSession === null) {
+      navigator.xr.requestSession('immersive-vr').then(publicAPI.enterXR, function () {
+        throw new Error('Failed to create VR session!');
       });
     } else {
-      vtkErrorMacro('vrDisplay is not connected');
+      throw new Error('VR Session already exists!');
     }
-  };
+  }; // When an XR session is available, set up the XRWebGLLayer
+  // and request the first animation frame for the device
+
+
+  publicAPI.enterXR = /*#__PURE__*/function () {
+    var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(xrSession) {
+      var gl, glLayer;
+      return _regeneratorRuntime.wrap(function _callee$(_context) {
+        while (1) {
+          switch (_context.prev = _context.next) {
+            case 0:
+              model.xrSession = xrSession;
+              model.oldCanvasSize = model.size.slice();
+
+              if (!(model.xrSession !== null)) {
+                _context.next = 14;
+                break;
+              }
+
+              gl = publicAPI.get3DContext();
+              _context.next = 6;
+              return gl.makeXRCompatible();
+
+            case 6:
+              glLayer = new global.XRWebGLLayer(model.xrSession, gl);
+              publicAPI.setSize(glLayer.framebufferWidth, glLayer.framebufferHeight);
+              model.xrSession.updateRenderState({
+                baseLayer: glLayer
+              });
+              model.xrSession.requestReferenceSpace('local').then(function (refSpace) {
+                model.xrReferenceSpace = refSpace;
+              });
+              model.renderable.getInteractor().switchToXRAnimation();
+              model.xrSceneFrame = model.xrSession.requestAnimationFrame(publicAPI.xrRender);
+              _context.next = 15;
+              break;
 
-  publicAPI.stopVR = function () {
-    model.renderable.getInteractor().returnFromVRAnimation();
-    model.vrDisplay.exitPresent();
-    model.vrDisplay.cancelAnimationFrame(model.vrSceneFrame);
-    publicAPI.setSize.apply(publicAPI, _toConsumableArray(model.oldCanvasSize));
+            case 14:
+              throw new Error('Failed to enter VR with a null xrSession.');
 
-    if (model.el && model.vrDisplay.capabilities.hasExternalDisplay) {
-      model.el.style.display = 'block';
-    }
+            case 15:
+            case "end":
+              return _context.stop();
+          }
+        }
+      }, _callee);
+    }));
 
-    var ren = model.renderable.getRenderers()[0];
-    ren.getActiveCamera().setProjectionMatrix(null);
-    ren.setViewport(0.0, 0, 1.0, 1.0);
-    publicAPI.traverseAllPasses();
-  };
+    return function (_x) {
+      return _ref.apply(this, arguments);
+    };
+  }();
+
+  publicAPI.stopXR = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2() {
+    var gl, ren;
+    return _regeneratorRuntime.wrap(function _callee2$(_context2) {
+      while (1) {
+        switch (_context2.prev = _context2.next) {
+          case 0:
+            if (!(navigator.xr === undefined)) {
+              _context2.next = 2;
+              break;
+            }
+
+            return _context2.abrupt("return");
+
+          case 2:
+            if (!(model.xrSession !== null)) {
+              _context2.next = 10;
+              break;
+            }
+
+            model.xrSession.cancelAnimationFrame(model.xrSceneFrame);
+            model.renderable.getInteractor().returnFromXRAnimation();
+            gl = publicAPI.get3DContext();
+            gl.bindFramebuffer(gl.FRAMEBUFFER, null);
+            _context2.next = 9;
+            return model.xrSession.end().catch(function (error) {
+              if (!(error instanceof DOMException)) {
+                throw error;
+              }
+            });
 
-  publicAPI.vrRender = function () {
-    // If not presenting for any reason, we do not submit frame
-    if (!model.vrDisplay.isPresenting) {
-      return;
-    }
+          case 9:
+            model.xrSession = null;
 
-    model.renderable.getInteractor().updateGamepads(model.vrDisplay.displayId);
-    model.vrSceneFrame = model.vrDisplay.requestAnimationFrame(publicAPI.vrRender);
-    model.vrDisplay.getFrameData(model.vrFrameData); // get the first renderer
-
-    var ren = model.renderable.getRenderers()[0]; // do the left eye
-
-    ren.setViewport(0, 0, 0.5, 1.0);
-    ren.getActiveCamera().computeViewParametersFromPhysicalMatrix(model.vrFrameData.leftViewMatrix);
-    ren.getActiveCamera().setProjectionMatrix(model.vrFrameData.leftProjectionMatrix);
-    publicAPI.traverseAllPasses();
-    ren.setViewport(0.5, 0, 1.0, 1.0);
-    ren.getActiveCamera().computeViewParametersFromPhysicalMatrix(model.vrFrameData.rightViewMatrix);
-    ren.getActiveCamera().setProjectionMatrix(model.vrFrameData.rightProjectionMatrix);
-    publicAPI.traverseAllPasses();
-    model.vrDisplay.submitFrame();
-  };
+          case 10:
+            publicAPI.setSize.apply(publicAPI, _toConsumableArray(model.oldCanvasSize)); // Reset to default canvas
+
+            ren = model.renderable.getRenderers()[0];
+            ren.getActiveCamera().setProjectionMatrix(null);
+            ren.resetCamera();
+            ren.setViewport(0.0, 0, 1.0, 1.0);
+            publicAPI.traverseAllPasses();
+
+          case 16:
+          case "end":
+            return _context2.stop();
+        }
+      }
+    }, _callee2);
+  }));
+
+  publicAPI.xrRender = /*#__PURE__*/function () {
+    var _ref3 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee3(t, frame) {
+      var xrSession, xrPose, gl, glLayer, ren;
+      return _regeneratorRuntime.wrap(function _callee3$(_context3) {
+        while (1) {
+          switch (_context3.prev = _context3.next) {
+            case 0:
+              xrSession = frame.session;
+              model.xrSceneFrame = model.xrSession.requestAnimationFrame(publicAPI.xrRender);
+              xrPose = frame.getViewerPose(model.xrReferenceSpace);
+
+              if (xrPose) {
+                gl = publicAPI.get3DContext();
+                glLayer = xrSession.renderState.baseLayer;
+                gl.bindFramebuffer(gl.FRAMEBUFFER, glLayer.framebuffer);
+                gl.clear(gl.COLOR_BUFFER_BIT);
+                gl.clear(gl.DEPTH_BUFFER_BIT); // get the first renderer
+
+                ren = model.renderable.getRenderers()[0]; // Do a render pass for each eye
+
+                xrPose.views.forEach(function (view) {
+                  var viewport = glLayer.getViewport(view);
+                  gl.viewport(viewport.x, viewport.y, viewport.width, viewport.height);
+
+                  if (view.eye === 'left') {
+                    ren.setViewport(0, 0, 0.5, 1.0);
+                  } else if (view.eye === 'right') {
+                    ren.setViewport(0.5, 0, 1.0, 1.0);
+                  } else {
+                    // No handling for non-eye viewport
+                    return;
+                  }
+
+                  ren.getActiveCamera().computeViewParametersFromPhysicalMatrix(view.transform.inverse.matrix);
+                  ren.getActiveCamera().setProjectionMatrix(view.projectionMatrix);
+                  publicAPI.traverseAllPasses();
+                });
+              }
+
+            case 4:
+            case "end":
+              return _context3.stop();
+          }
+        }
+      }, _callee3);
+    }));
+
+    return function (_x2, _x3) {
+      return _ref3.apply(this, arguments);
+    };
+  }();
 
   publicAPI.restoreContext = function () {
     var rp = vtkRenderPass.newInstance();
@@ -486,13 +572,13 @@ function vtkOpenGLRenderWindow(publicAPI, model) {
   publicAPI.captureNextImage = function () {
     var format = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'image/png';
 
-    var _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
-        _ref$resetCamera = _ref.resetCamera,
-        resetCamera = _ref$resetCamera === void 0 ? false : _ref$resetCamera,
-        _ref$size = _ref.size,
-        size = _ref$size === void 0 ? null : _ref$size,
-        _ref$scale = _ref.scale,
-        scale = _ref$scale === void 0 ? 1 : _ref$scale;
+    var _ref4 = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
+        _ref4$resetCamera = _ref4.resetCamera,
+        resetCamera = _ref4$resetCamera === void 0 ? false : _ref4$resetCamera,
+        _ref4$size = _ref4.size,
+        size = _ref4$size === void 0 ? null : _ref4$size,
+        _ref4$scale = _ref4.scale,
+        scale = _ref4$scale === void 0 ? 1 : _ref4$scale;
 
     if (model.deleted) {
       return null;
@@ -519,9 +605,9 @@ function vtkOpenGLRenderWindow(publicAPI, model) {
             publicAPI.modified(); // restore the saved camera parameters, if applicable
 
             if (model._screenshot.cameras) {
-              model._screenshot.cameras.forEach(function (_ref2) {
-                var restoreParamsFn = _ref2.restoreParamsFn,
-                    arg = _ref2.arg;
+              model._screenshot.cameras.forEach(function (_ref5) {
+                var restoreParamsFn = _ref5.restoreParamsFn,
+                    arg = _ref5.arg;
                 return restoreParamsFn(arg);
               });
             } // Trigger a render at the original size
@@ -568,8 +654,8 @@ function vtkOpenGLRenderWindow(publicAPI, model) {
             // the params from all active cameras, in case there happen to be
             // linked cameras among the renderers.
 
-            model._screenshot.cameras.forEach(function (_ref3) {
-              var resetCameraFn = _ref3.resetCameraFn;
+            model._screenshot.cameras.forEach(function (_ref6) {
+              var resetCameraFn = _ref6.resetCameraFn;
               return resetCameraFn();
             });
           } // Trigger a render at the custom size
@@ -688,11 +774,9 @@ var DEFAULT_VALUES = {
   webgl2: false,
   defaultToWebgl2: true,
   // attempt webgl2 on by default
-  vrResolution: [2160, 1200],
-  queryVRSize: false,
-  hideCanvasInVR: true,
   activeFramebuffer: null,
-  vrDisplay: null,
+  xrSession: null,
+  xrReferenceSpace: null,
   imageFormat: 'image/png',
   useOffScreen: false,
   useBackgroundImage: false
@@ -736,12 +820,12 @@ function extend(publicAPI, model) {
   macro.event(publicAPI, model, 'haveVRDisplay'); // Build VTK API
 
   macro.get(publicAPI, model, ['shaderCache', 'textureUnitManager', 'webgl2', 'vrDisplay', 'useBackgroundImage']);
-  macro.setGet(publicAPI, model, ['initialized', 'context', 'canvas', 'renderPasses', 'notifyStartCaptureImage', 'defaultToWebgl2', 'cursor', 'queryVRSize', 'hideCanvasInVR', 'useOffScreen', // might want to make this not call modified as
+  macro.setGet(publicAPI, model, ['initialized', 'context', 'canvas', 'renderPasses', 'notifyStartCaptureImage', 'defaultToWebgl2', 'cursor', 'useOffScreen', // might want to make this not call modified as
   // we change the active framebuffer a lot. Or maybe
   // only mark modified if the size or depth
   // of the buffer has changed
   'activeFramebuffer']);
-  macro.setGetArray(publicAPI, model, ['size', 'vrResolution'], 2); // Object methods
+  macro.setGetArray(publicAPI, model, ['size'], 2); // Object methods
 
   vtkOpenGLRenderWindow(publicAPI, model);
 } // ----------------------------------------------------------------------------

package/Rendering/OpenGL/ShaderProgram.js

@@ -421,18 +421,6 @@ function vtkShaderProgram(publicAPI, model) {
     return true;
   };
 
-  publicAPI.setUniform4fv = function (name, count, v) {
-    var location = publicAPI.findUniform(name);
-
-    if (location === -1) {
-      model.error = "Could not set uniform ".concat(name, " . No such uniform.");
-      return false;
-    }
-
-    model.context.uniform4fv(location, v);
-    return true;
-  };
-
   publicAPI.findUniform = function (name) {
     if (!name || !model.linked) {
       return -1;

package/interfaces.d.ts

@@ -1,4 +1,6 @@
 import vtkDataArray from '@kitware/vtk.js/Common/Core/DataArray';
+import vtkImageData from '@kitware/vtk.js/Common/DataModel/ImageData';
+import vtkPolyData from '@kitware/vtk.js/Common/DataModel/PolyData';
 import { vtkPipelineConnection } from '@kitware/vtk.js/types';
 
 /**
@@ -32,48 +34,88 @@ export interface vtkOutputPort {
  * vtkAlgorithm API
  */
 export interface vtkAlgorithm {
+
 	/**
-	 * @param dataset
-	 * @param port (default 0)
+	 * Assign a data object as input.
+	 * @param {vtkPolyData} dataset 
+	 * @param {Number} [port] The port number (default 0).
 	 */
-	setInputData(dataset: any, port?: number): void;
+	setInputData(dataset: vtkPolyData, port?: number): void;
+
 	/**
-	 * @param port (default 0)
+	 * @param {Number} [port] The port number (default 0).
 	 */
 	getInputData(port?: number): any;
+
 	/**
 	 * @param outputPort
-	 * @param port (default 0)
+	 * @param {Number} [port] The port number (default 0).
 	 */
 	setInputConnection(outputPort: vtkPipelineConnection, port?: number): void;
+
 	/**
-	 * @param port (default 0)
+	 * @param {Number} [port] The port number (default 0).
 	 */
 	getInputConnection(port?: number): vtkPipelineConnection;
+
+	/**
+	 * Add a connection to the given input port index.
+	 * @param {vtkPipelineConnection} outputPort 
+	 */
 	addInputConnection(outputPort: vtkPipelineConnection): void;
+
+	/**
+	 * 
+	 * @param dataset 
+	 */
 	addInputData(dataset: any): void;
+
 	/**
-	 * @param port (default 0)
+	 * Get the data object that will contain the algorithm output for the given
+	 * port.
+	 * @param {Number} [port] The port number (default 0).
+	 */
+	getOutputData(port?: number): vtkImageData | vtkPolyData;
+
+	/**
+	 * 
 	 */
-	getOutputData(port?: number): any;
 	shouldUpdate(): boolean;
+
 	/**
-	 * @param port (default 0)
+	 * Get a proxy object corresponding to the given output port of this
+	 * algorithm. 
+	 * @param {Number} [port] The port number (default 0).
 	 */
 	getOutputPort(port?: number): vtkPipelineConnection;
+
+	/**
+	 * Bring this algorithm's outputs up-to-date.
+	 */
 	update(): void;
+
+	/**
+	 * Get the number of input ports used by the algorithm.
+	 */
 	getNumberOfInputPorts(): number;
+
+	/**
+	 * Get the number of output ports provided by the algorithm.
+	 */
 	getNumberOfOutputPorts(): number;
+
 	/**
-	 * @param port (default 0)
+	 * Get the actual data array for the input array sepcified by idx.
+	 * @param {Number} port (default 0)
 	 */
 	getInputArrayToProcess(inputPort?: number): vtkDataArray;
+
 	/**
-	 *
-	 * @param inputPort
-	 * @param arrayName
-	 * @param fieldAssociation
-	 * @param attributeType (default 'Scalars')
+	 * Set the input data arrays that this algorithm will process. 
+	 * @param {Number} inputPort The port number.
+	 * @param {String} arrayName The name of the array.
+	 * @param {String} fieldAssociation The name of the association field.
+	 * @param {String} attributeType (default 'Scalars')
 	 */
 	setInputArrayToProcess(
 		inputPort: number,
@@ -87,9 +129,9 @@ export interface vtkAlgorithm {
 * Base vtkClass which provides MTime tracking and class infrastructure
 */
 export interface vtkObject {
+	
 	/**
 	 * Allow to check if that object was deleted (.delete() was called before).
-	 *
 	 * @returns true if delete() was previously called
 	 */
 	isDeleted(): boolean;
@@ -137,14 +179,14 @@ export interface vtkObject {
 	 * Generic method to set many fields at one.
 	 *
 	 * For example calling the following function
-	 * ```
+	 * ```js
 	 * changeDetected = sphereSourceInstance.set({
 	 *    phiResolution: 10,
 	 *    thetaResolution: 20,
 	 * });
 	 * ```
 	 * will be equivalent of calling
-	 * ```
+	 * ```js
 	 * changeDetected += sphereSourceInstance.setPhiResolution(10);
 	 * changeDetected += sphereSourceInstance.setThetaResolution(20);
 	 * changeDetected = !!changeDetected;
@@ -157,9 +199,9 @@ export interface vtkObject {
 	 * If `noFunction` is set to true, the field will be set directly on the model
 	 * without calling the `set${FieldName}()` method.
 	 *
-	 * @param map (default: {}) Object capturing the set of fieldNames and associated values to set.
-	 * @param noWarning (default: false) Boolean to disable any warning.
-	 * @param noFunctions (default: false) Boolean to skip any function execution and rely on only setting the fields on the model.
+	 * @param [map] (default: {}) Object capturing the set of fieldNames and associated values to set.
+	 * @param [noWarning] (default: false) Boolean to disable any warning.
+	 * @param [noFunctions] (default: false) Boolean to skip any function execution and rely on only setting the fields on the model.
 	 * @return true if a change was actually performed. False otherwise when the value provided were equal to the ones already set inside the instance.
 	 */
 	set(map?: object, noWarning?: boolean, noFunction?: boolean): boolean;
@@ -215,15 +257,15 @@ export interface vtkObject {
 	/**
 	 * Try to copy the state of the other to ourselves by just using references.
 	 *
-	 * @param other instance to copy the reference from
-	 * @param debug (default: false) if true feedback will be provided when mismatch happen
+	 * @param {vtkObject} other instance to copy the reference from
+	 * @param {Boolean} [debug] (default: false) if true feedback will be provided when mismatch happen
 	 */
 	shallowCopy(other: vtkObject, debug?: boolean): void;
 }
 
 export interface vtkProperty {
 	name: string;
-	children?: Array<vtkProperty>;
+	children?: vtkProperty[];
 }
 
 export interface vtkPropertyDomain {}

package/package.json

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

package/types.d.ts

@@ -17,9 +17,12 @@ declare type Extent = [number, number, number, number, number, number];
 declare type Placement = 'top' | 'left' | 'right' | 'bottom';
 declare type Size = [number, number];
 declare type Range = [number, number];
-declare type Point = [number, number, number];
 declare type Vector2 = [number, number];
 declare type Vector3 = [number, number, number];
+/**
+ * @deprecated The `Point` type is depracted, please use `Vector3` instead.
+ */
+declare type Point = Vector3;
 declare type HSLColor = [number, number, number];
 declare type HSVColor = [number, number, number];
 declare type RGBColor = [number, number, number];