@kitware/vtk.js 21.1.4 → 21.2.2

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/_virtual/rollup-plugin-web-worker-loader__helper__browser__createInlineWorkerFactory.js

@@ -0,0 +1,17 @@
+import { f as funcToSource } from './rollup-plugin-web-worker-loader__helper__funcToSource.js';
+
+function createURL(fn, sourcemapArg) {
+    var lines = funcToSource(fn, sourcemapArg);
+    var blob = new Blob(lines, { type: 'application/javascript' });
+    return URL.createObjectURL(blob);
+}
+
+function createInlineWorkerFactory(fn, sourcemapArg) {
+    var url;
+    return function WorkerFactory(options) {
+        url = url || createURL(fn, sourcemapArg);
+        return new Worker(url, options);
+    };
+}
+
+export { createInlineWorkerFactory as c };

package/_virtual/rollup-plugin-web-worker-loader__helper__funcToSource.js

@@ -0,0 +1,18 @@
+function funcToSource(fn, sourcemapArg) {
+    var sourcemap = sourcemapArg === undefined ? null : sourcemapArg;
+    var source = fn.toString();
+    var lines = source.split('\n');
+    lines.pop();
+    lines.shift();
+    var blankPrefixLength = lines[0].search(/\S/);
+    var regex = /(['"])__worker_loader_strict__(['"])/g;
+    for (var i = 0, n = lines.length; i < n; ++i) {
+        lines[i] = lines[i].substring(blankPrefixLength).replace(regex, '$1use strict$2') + '\n';
+    }
+    if (sourcemap) {
+        lines.push('\/\/# sourceMappingURL=' + sourcemap + '\n');
+    }
+    return lines;
+}
+
+export { funcToSource as f };