@kitware/vtk.js 28.10.1 → 28.11.0

package/Rendering/WebGPU/RenderWindow.js

@@ -1,6 +1,4 @@
-import _asyncToGenerator from '@babel/runtime/helpers/asyncToGenerator';
-import _regeneratorRuntime from '@babel/runtime/regenerator';
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.js';
 import { registerViewConstructor } from '../Core/RenderWindow.js';
 import vtkForwardPass from './ForwardPass.js';
 import vtkWebGPUBuffer from './Buffer.js';
@@ -11,29 +9,29 @@ import vtkRenderPass from '../SceneGraph/RenderPass.js';
 import vtkRenderWindowViewNode from '../SceneGraph/RenderWindowViewNode.js';
 import HalfFloat from '../../Common/Core/HalfFloat.js';
 
-var vtkErrorMacro = macro.vtkErrorMacro; // const IS_CHROME = navigator.userAgent.indexOf('Chrome') !== -1;
-
-var SCREENSHOT_PLACEHOLDER = {
+const {
+  vtkErrorMacro
+} = macro;
+// const IS_CHROME = navigator.userAgent.indexOf('Chrome') !== -1;
+const SCREENSHOT_PLACEHOLDER = {
   position: 'absolute',
   top: 0,
   left: 0,
   width: '100%',
   height: '100%'
-}; // ----------------------------------------------------------------------------
+};
+
+// ----------------------------------------------------------------------------
 // vtkWebGPURenderWindow methods
 // ----------------------------------------------------------------------------
 
 function vtkWebGPURenderWindow(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkWebGPURenderWindow');
+  publicAPI.getViewNodeFactory = () => model.myFactory;
 
-  publicAPI.getViewNodeFactory = function () {
-    return model.myFactory;
-  }; // Auto update style
-
-
-  var previousSize = [0, 0];
-
+  // Auto update style
+  const previousSize = [0, 0];
   function updateWindow() {
     // Canvas size
     if (model.renderable) {
@@ -44,35 +42,33 @@ function vtkWebGPURenderWindow(publicAPI, model) {
         model.canvas.setAttribute('height', model.size[1]);
         publicAPI.recreateSwapChain();
       }
-    } // ImageStream size
-
+    }
 
+    // ImageStream size
     if (model.viewStream) {
       // If same size that's a NoOp
       model.viewStream.setSize(model.size[0], model.size[1]);
-    } // Offscreen ?
-
+    }
 
-    model.canvas.style.display = model.useOffScreen ? 'none' : 'block'; // Cursor type
+    // Offscreen ?
+    model.canvas.style.display = model.useOffScreen ? 'none' : 'block';
 
+    // Cursor type
     if (model.el) {
       model.el.style.cursor = model.cursorVisibility ? model.cursor : 'none';
-    } // Invalidate cached DOM container size
-
+    }
 
+    // Invalidate cached DOM container size
     model.containerSize = null;
   }
-
   publicAPI.onModified(updateWindow);
-
-  publicAPI.recreateSwapChain = function () {
+  publicAPI.recreateSwapChain = () => {
     if (model.context) {
       model.context.unconfigure();
       model.presentationFormat = navigator.gpu.getPreferredCanvasFormat(model.adapter);
-      /* eslint-disable no-undef */
 
+      /* eslint-disable no-undef */
       /* eslint-disable no-bitwise */
-
       model.context.configure({
         device: model.device.getHandle(),
         format: model.presentationFormat,
@@ -84,18 +80,14 @@ function vtkWebGPURenderWindow(publicAPI, model) {
       model._configured = true;
     }
   };
+  publicAPI.getCurrentTexture = () => model.context.getCurrentTexture();
 
-  publicAPI.getCurrentTexture = function () {
-    return model.context.getCurrentTexture();
-  }; // Builds myself.
-
-
-  publicAPI.buildPass = function (prepass) {
+  // Builds myself.
+  publicAPI.buildPass = prepass => {
     if (prepass) {
       if (!model.renderable) {
         return;
       }
-
       publicAPI.prepareNodes();
       publicAPI.addMissingNodes(model.renderable.getRenderersByReference());
       publicAPI.removeUnusedNodes();
@@ -104,10 +96,11 @@ function vtkWebGPURenderWindow(publicAPI, model) {
       if (!model._configured) {
         publicAPI.recreateSwapChain();
       }
-
       model.commandEncoder = model.device.createCommandEncoder();
     }
-  }; // publicAPI.traverseRenderers = (renPass) => {
+  };
+
+  // publicAPI.traverseRenderers = (renPass) => {
   //   // iterate over renderers
   //   const numlayers = publicAPI.getRenderable().getNumberOfLayers();
   //   const renderers = publicAPI.getChildren();
@@ -122,137 +115,88 @@ function vtkWebGPURenderWindow(publicAPI, model) {
   //   }
   // };
 
-
-  publicAPI.initialize = function () {
+  publicAPI.initialize = () => {
     if (!model.initializing) {
       model.initializing = true;
-
       if (!navigator.gpu) {
         vtkErrorMacro('WebGPU is not enabled.');
         return;
       }
-
-      publicAPI.create3DContextAsync().then(function () {
+      publicAPI.create3DContextAsync().then(() => {
         model.initialized = true;
-
         if (model.deleted) {
           return;
         }
-
         publicAPI.invokeInitialized();
       });
     }
   };
-
-  publicAPI.setContainer = function (el) {
+  publicAPI.setContainer = el => {
     if (model.el && model.el !== el) {
       if (model.canvas.parentNode !== model.el) {
         vtkErrorMacro('Error: canvas parent node does not match container');
-      } // Remove canvas from previous container
+      }
 
+      // Remove canvas from previous container
+      model.el.removeChild(model.canvas);
 
-      model.el.removeChild(model.canvas); // If the renderer has previously added
+      // If the renderer has previously added
       // a background image, remove it from the DOM.
-
       if (model.el.contains(model.bgImage)) {
         model.el.removeChild(model.bgImage);
       }
     }
-
     if (model.el !== el) {
       model.el = el;
-
       if (model.el) {
-        model.el.appendChild(model.canvas); // If the renderer is set to use a background
-        // image, attach it to the DOM.
+        model.el.appendChild(model.canvas);
 
+        // If the renderer is set to use a background
+        // image, attach it to the DOM.
         if (model.useBackgroundImage) {
           model.el.appendChild(model.bgImage);
         }
-      } // Trigger modified()
-
+      }
 
+      // Trigger modified()
       publicAPI.modified();
     }
   };
-
-  publicAPI.getContainer = function () {
-    return model.el;
-  };
-
-  publicAPI.getContainerSize = function () {
+  publicAPI.getContainer = () => model.el;
+  publicAPI.getContainerSize = () => {
     if (!model.containerSize && model.el) {
-      var _model$el$getBounding = model.el.getBoundingClientRect(),
-          width = _model$el$getBounding.width,
-          height = _model$el$getBounding.height;
-
+      const {
+        width,
+        height
+      } = model.el.getBoundingClientRect();
       model.containerSize = [width, height];
     }
-
     return model.containerSize || model.size;
   };
-
-  publicAPI.getFramebufferSize = function () {
-    return model.size;
+  publicAPI.getFramebufferSize = () => model.size;
+  publicAPI.create3DContextAsync = async () => {
+    // Get a GPU device to render with
+    model.adapter = await navigator.gpu.requestAdapter({
+      powerPreference: 'high-performance'
+    });
+    if (model.deleted) {
+      return;
+    }
+    // console.log([...model.adapter.features]);
+    model.device = vtkWebGPUDevice.newInstance();
+    model.device.initialize(await model.adapter.requestDevice());
+    if (model.deleted) {
+      model.device = null;
+      return;
+    }
+    // model.device.getHandle().lost.then((info) => {
+    //   console.log(`${info.message}`);
+    //   publicAPI.releaseGraphicsResources();
+    // });
+    model.context = model.canvas.getContext('webgpu');
   };
-
-  publicAPI.create3DContextAsync = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
-    return _regeneratorRuntime.wrap(function _callee$(_context) {
-      while (1) {
-        switch (_context.prev = _context.next) {
-          case 0:
-            _context.next = 2;
-            return navigator.gpu.requestAdapter({
-              powerPreference: 'high-performance'
-            });
-
-          case 2:
-            model.adapter = _context.sent;
-
-            if (!model.deleted) {
-              _context.next = 5;
-              break;
-            }
-
-            return _context.abrupt("return");
-
-          case 5:
-            // console.log([...model.adapter.features]);
-            model.device = vtkWebGPUDevice.newInstance();
-            _context.t0 = model.device;
-            _context.next = 9;
-            return model.adapter.requestDevice();
-
-          case 9:
-            _context.t1 = _context.sent;
-
-            _context.t0.initialize.call(_context.t0, _context.t1);
-
-            if (!model.deleted) {
-              _context.next = 14;
-              break;
-            }
-
-            model.device = null;
-            return _context.abrupt("return");
-
-          case 14:
-            // model.device.getHandle().lost.then((info) => {
-            //   console.log(`${info.message}`);
-            //   publicAPI.releaseGraphicsResources();
-            // });
-            model.context = model.canvas.getContext('webgpu');
-
-          case 15:
-          case "end":
-            return _context.stop();
-        }
-      }
-    }, _callee);
-  }));
-
-  publicAPI.releaseGraphicsResources = function () {
-    var rp = vtkRenderPass.newInstance();
+  publicAPI.releaseGraphicsResources = () => {
+    const rp = vtkRenderPass.newInstance();
     rp.setCurrentOperation('Release');
     rp.traverse(publicAPI, null);
     model.adapter = null;
@@ -261,367 +205,299 @@ function vtkWebGPURenderWindow(publicAPI, model) {
     model.initialized = false;
     model.initializing = false;
   };
-
-  publicAPI.setBackgroundImage = function (img) {
+  publicAPI.setBackgroundImage = img => {
     model.bgImage.src = img.src;
   };
+  publicAPI.setUseBackgroundImage = value => {
+    model.useBackgroundImage = value;
 
-  publicAPI.setUseBackgroundImage = function (value) {
-    model.useBackgroundImage = value; // Add or remove the background image from the
+    // Add or remove the background image from the
     // DOM as specified.
-
     if (model.useBackgroundImage && !model.el.contains(model.bgImage)) {
       model.el.appendChild(model.bgImage);
     } else if (!model.useBackgroundImage && model.el.contains(model.bgImage)) {
       model.el.removeChild(model.bgImage);
     }
   };
-
-  function getCanvasDataURL() {
-    return _getCanvasDataURL.apply(this, arguments);
-  }
-
-  function _getCanvasDataURL() {
-    _getCanvasDataURL = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee3() {
-      var format,
-          temporaryCanvas,
-          temporaryContext,
-          result,
-          imageData,
-          mainBoundingClientRect,
-          renderWindow,
-          renderers,
-          screenshot,
-          _args3 = arguments;
-      return _regeneratorRuntime.wrap(function _callee3$(_context3) {
-        while (1) {
-          switch (_context3.prev = _context3.next) {
-            case 0:
-              format = _args3.length > 0 && _args3[0] !== undefined ? _args3[0] : model.imageFormat;
-              // Copy current canvas to not modify the original
-              temporaryCanvas = document.createElement('canvas');
-              temporaryContext = temporaryCanvas.getContext('2d');
-              temporaryCanvas.width = model.canvas.width;
-              temporaryCanvas.height = model.canvas.height;
-              _context3.next = 7;
-              return publicAPI.getPixelsAsync();
-
-            case 7:
-              result = _context3.sent;
-              imageData = new ImageData(result.colorValues, result.width, result.height); // temporaryCanvas.putImageData(imageData, 0, 0);
-
-              temporaryContext.putImageData(imageData, 0, 0); // Get current client rect to place canvas
-
-              mainBoundingClientRect = model.canvas.getBoundingClientRect();
-              renderWindow = model.renderable;
-              renderers = renderWindow.getRenderers();
-              renderers.forEach(function (renderer) {
-                var viewProps = renderer.getViewProps();
-                viewProps.forEach(function (viewProp) {
-                  // Check if the prop has a container that should have canvas
-                  if (viewProp.getContainer) {
-                    var container = viewProp.getContainer();
-                    var canvasList = container.getElementsByTagName('canvas'); // Go throughout all canvas and copy it into temporary main canvas
-
-                    for (var i = 0; i < canvasList.length; i++) {
-                      var currentCanvas = canvasList[i];
-                      var boundingClientRect = currentCanvas.getBoundingClientRect();
-                      var newXPosition = boundingClientRect.x - mainBoundingClientRect.x;
-                      var newYPosition = boundingClientRect.y - mainBoundingClientRect.y;
-                      temporaryContext.drawImage(currentCanvas, newXPosition, newYPosition);
-                    }
-                  }
-                });
-              });
-              screenshot = temporaryCanvas.toDataURL(format);
-              temporaryCanvas.remove();
-              publicAPI.invokeImageReady(screenshot);
-
-            case 17:
-            case "end":
-              return _context3.stop();
+  async function getCanvasDataURL() {
+    let format = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : model.imageFormat;
+    // Copy current canvas to not modify the original
+    const temporaryCanvas = document.createElement('canvas');
+    const temporaryContext = temporaryCanvas.getContext('2d');
+    temporaryCanvas.width = model.canvas.width;
+    temporaryCanvas.height = model.canvas.height;
+    const result = await publicAPI.getPixelsAsync();
+    const imageData = new ImageData(result.colorValues, result.width, result.height);
+    // temporaryCanvas.putImageData(imageData, 0, 0);
+    temporaryContext.putImageData(imageData, 0, 0);
+
+    // Get current client rect to place canvas
+    const mainBoundingClientRect = model.canvas.getBoundingClientRect();
+    const renderWindow = model.renderable;
+    const renderers = renderWindow.getRenderers();
+    renderers.forEach(renderer => {
+      const viewProps = renderer.getViewProps();
+      viewProps.forEach(viewProp => {
+        // Check if the prop has a container that should have canvas
+        if (viewProp.getContainer) {
+          const container = viewProp.getContainer();
+          const canvasList = container.getElementsByTagName('canvas');
+          // Go throughout all canvas and copy it into temporary main canvas
+          for (let i = 0; i < canvasList.length; i++) {
+            const currentCanvas = canvasList[i];
+            const boundingClientRect = currentCanvas.getBoundingClientRect();
+            const newXPosition = boundingClientRect.x - mainBoundingClientRect.x;
+            const newYPosition = boundingClientRect.y - mainBoundingClientRect.y;
+            temporaryContext.drawImage(currentCanvas, newXPosition, newYPosition);
           }
         }
-      }, _callee3);
-    }));
-    return _getCanvasDataURL.apply(this, arguments);
+      });
+    });
+    const screenshot = temporaryCanvas.toDataURL(format);
+    temporaryCanvas.remove();
+    publicAPI.invokeImageReady(screenshot);
   }
-
   publicAPI.captureNextImage = function () {
-    var format = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'image/png';
-
-    var _ref2 = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
-        _ref2$resetCamera = _ref2.resetCamera,
-        resetCamera = _ref2$resetCamera === void 0 ? false : _ref2$resetCamera,
-        _ref2$size = _ref2.size,
-        size = _ref2$size === void 0 ? null : _ref2$size,
-        _ref2$scale = _ref2.scale,
-        scale = _ref2$scale === void 0 ? 1 : _ref2$scale;
-
+    let format = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'image/png';
+    let {
+      resetCamera = false,
+      size = null,
+      scale = 1
+    } = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
     if (model.deleted) {
       return null;
     }
-
     model.imageFormat = format;
-    var previous = model.notifyStartCaptureImage;
+    const previous = model.notifyStartCaptureImage;
     model.notifyStartCaptureImage = true;
     model._screenshot = {
-      size: !!size || scale !== 1 ? size || model.size.map(function (val) {
-        return val * scale;
-      }) : null
+      size: !!size || scale !== 1 ? size || model.size.map(val => val * scale) : null
     };
-    return new Promise(function (resolve, reject) {
-      var subscription = publicAPI.onImageReady(function (imageURL) {
+    return new Promise((resolve, reject) => {
+      const subscription = publicAPI.onImageReady(imageURL => {
         if (model._screenshot.size === null) {
           model.notifyStartCaptureImage = previous;
           subscription.unsubscribe();
-
           if (model._screenshot.placeHolder) {
             // resize the main canvas back to its original size and show it
-            model.size = model._screenshot.originalSize; // process the resize
+            model.size = model._screenshot.originalSize;
 
-            publicAPI.modified(); // restore the saved camera parameters, if applicable
+            // process the resize
+            publicAPI.modified();
 
+            // restore the saved camera parameters, if applicable
             if (model._screenshot.cameras) {
-              model._screenshot.cameras.forEach(function (_ref3) {
-                var restoreParamsFn = _ref3.restoreParamsFn,
-                    arg = _ref3.arg;
+              model._screenshot.cameras.forEach(_ref => {
+                let {
+                  restoreParamsFn,
+                  arg
+                } = _ref;
                 return restoreParamsFn(arg);
               });
-            } // Trigger a render at the original size
-
+            }
 
-            publicAPI.traverseAllPasses(); // Remove and clean up the placeholder, revealing the original
+            // Trigger a render at the original size
+            publicAPI.traverseAllPasses();
 
+            // Remove and clean up the placeholder, revealing the original
             model.el.removeChild(model._screenshot.placeHolder);
-
             model._screenshot.placeHolder.remove();
-
             model._screenshot = null;
           }
-
           resolve(imageURL);
         } else {
           // Create a placeholder image overlay while we resize and render
-          var tmpImg = document.createElement('img');
+          const tmpImg = document.createElement('img');
           tmpImg.style = SCREENSHOT_PLACEHOLDER;
           tmpImg.src = imageURL;
-          model._screenshot.placeHolder = model.el.appendChild(tmpImg); // hide the main canvas
+          model._screenshot.placeHolder = model.el.appendChild(tmpImg);
 
-          model.canvas.style.display = 'none'; // remember the main canvas original size, then resize it
+          // hide the main canvas
+          model.canvas.style.display = 'none';
 
+          // remember the main canvas original size, then resize it
           model._screenshot.originalSize = model.size;
           model.size = model._screenshot.size;
-          model._screenshot.size = null; // process the resize
+          model._screenshot.size = null;
 
+          // process the resize
           publicAPI.modified();
-
           if (resetCamera) {
-            var isUserResetCamera = resetCamera !== true; // If resetCamera was requested, we first save camera parameters
-            // from all the renderers, so we can restore them later
+            const isUserResetCamera = resetCamera !== true;
 
-            model._screenshot.cameras = model.renderable.getRenderers().map(function (renderer) {
-              var camera = renderer.getActiveCamera();
-              var params = camera.get('focalPoint', 'position', 'parallelScale');
+            // If resetCamera was requested, we first save camera parameters
+            // from all the renderers, so we can restore them later
+            model._screenshot.cameras = model.renderable.getRenderers().map(renderer => {
+              const camera = renderer.getActiveCamera();
+              const params = camera.get('focalPoint', 'position', 'parallelScale');
               return {
                 resetCameraArgs: isUserResetCamera ? {
-                  renderer: renderer
+                  renderer
                 } : undefined,
                 resetCameraFn: isUserResetCamera ? resetCamera : renderer.resetCamera,
                 restoreParamsFn: camera.set,
                 // "clone" the params so we don't keep refs to properties
                 arg: JSON.parse(JSON.stringify(params))
               };
-            }); // Perform the resetCamera() on each renderer only after capturing
+            });
+
+            // Perform the resetCamera() on each renderer only after capturing
             // the params from all active cameras, in case there happen to be
             // linked cameras among the renderers.
-
-            model._screenshot.cameras.forEach(function (_ref4) {
-              var resetCameraFn = _ref4.resetCameraFn,
-                  resetCameraArgs = _ref4.resetCameraArgs;
+            model._screenshot.cameras.forEach(_ref2 => {
+              let {
+                resetCameraFn,
+                resetCameraArgs
+              } = _ref2;
               return resetCameraFn(resetCameraArgs);
             });
-          } // Trigger a render at the custom size
-
+          }
 
+          // Trigger a render at the custom size
           publicAPI.traverseAllPasses();
         }
       });
     });
   };
-
-  publicAPI.traverseAllPasses = function () {
+  publicAPI.traverseAllPasses = () => {
     if (model.deleted) {
       return;
-    } // if we are not initialized then we call initialize
+    }
+    // if we are not initialized then we call initialize
     // which is async so we will not actually get a render
     // so we queue up another traverse for when we are initialized
-
-
     if (!model.initialized) {
       publicAPI.initialize();
-      var subscription = publicAPI.onInitialized(function () {
+      const subscription = publicAPI.onInitialized(() => {
         subscription.unsubscribe();
         publicAPI.traverseAllPasses();
       });
     } else {
       if (model.renderPasses) {
-        for (var index = 0; index < model.renderPasses.length; ++index) {
+        for (let index = 0; index < model.renderPasses.length; ++index) {
           model.renderPasses[index].traverse(publicAPI, null);
         }
       }
-
       if (model.commandEncoder) {
         model.device.submitCommandEncoder(model.commandEncoder);
         model.commandEncoder = null;
-
         if (model.notifyStartCaptureImage) {
-          model.device.onSubmittedWorkDone().then(function () {
+          model.device.onSubmittedWorkDone().then(() => {
             getCanvasDataURL();
           });
         }
       }
     }
   };
-
-  publicAPI.setViewStream = function (stream) {
+  publicAPI.setViewStream = stream => {
     if (model.viewStream === stream) {
       return false;
     }
-
     if (model.subscription) {
       model.subscription.unsubscribe();
       model.subscription = null;
     }
-
     model.viewStream = stream;
-
     if (model.viewStream) {
       // Force background to be transparent + render
-      var mainRenderer = model.renderable.getRenderers()[0];
-      mainRenderer.getBackgroundByReference()[3] = 0; // Enable display of the background image
+      const mainRenderer = model.renderable.getRenderers()[0];
+      mainRenderer.getBackgroundByReference()[3] = 0;
 
-      publicAPI.setUseBackgroundImage(true); // Bind to remote stream
+      // Enable display of the background image
+      publicAPI.setUseBackgroundImage(true);
 
-      model.subscription = model.viewStream.onImageReady(function (e) {
-        return publicAPI.setBackgroundImage(e.image);
-      });
+      // Bind to remote stream
+      model.subscription = model.viewStream.onImageReady(e => publicAPI.setBackgroundImage(e.image));
       model.viewStream.setSize(model.size[0], model.size[1]);
       model.viewStream.invalidateCache();
       model.viewStream.render();
       publicAPI.modified();
     }
-
     return true;
   };
-
-  publicAPI.getUniquePropID = function () {
-    return model.nextPropID++;
-  };
-
-  publicAPI.getPropFromID = function (id) {
-    for (var i = 0; i < model.children.length; i++) {
-      var res = model.children[i].getPropFromID(id);
-
+  publicAPI.getUniquePropID = () => model.nextPropID++;
+  publicAPI.getPropFromID = id => {
+    for (let i = 0; i < model.children.length; i++) {
+      const res = model.children[i].getPropFromID(id);
       if (res !== null) {
         return res;
       }
     }
-
     return null;
   };
+  publicAPI.getPixelsAsync = async () => {
+    const device = model.device;
+    const texture = model.renderPasses[0].getOpaquePass().getColorTexture();
+
+    // as this is async we really don't want to store things in
+    // the class as multiple calls may start before resolving
+    // so anything specific to this request gets put into the
+    // result object (by value in most cases)
+    const result = {
+      width: texture.getWidth(),
+      height: texture.getHeight()
+    };
 
-  publicAPI.getPixelsAsync = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2() {
-    var device, texture, result, colorBuffer, cmdEnc, cLoad, tmparray, y, x, doffset, soffset;
-    return _regeneratorRuntime.wrap(function _callee2$(_context2) {
-      while (1) {
-        switch (_context2.prev = _context2.next) {
-          case 0:
-            device = model.device;
-            texture = model.renderPasses[0].getOpaquePass().getColorTexture(); // as this is async we really don't want to store things in
-            // the class as multiple calls may start before resolving
-            // so anything specific to this request gets put into the
-            // result object (by value in most cases)
-
-            result = {
-              width: texture.getWidth(),
-              height: texture.getHeight()
-            }; // must be a multiple of 256 bytes, so 32 texels with rgba16
-
-            result.colorBufferWidth = 32 * Math.floor((result.width + 31) / 32);
-            result.colorBufferSizeInBytes = result.colorBufferWidth * result.height * 8;
-            colorBuffer = vtkWebGPUBuffer.newInstance();
-            colorBuffer.setDevice(device);
-            /* eslint-disable no-bitwise */
-
-            /* eslint-disable no-undef */
-
-            colorBuffer.create(result.colorBufferSizeInBytes, GPUBufferUsage.MAP_READ | GPUBufferUsage.COPY_DST);
-            /* eslint-enable no-bitwise */
-
-            /* eslint-enable no-undef */
-
-            cmdEnc = model.device.createCommandEncoder();
-            cmdEnc.copyTextureToBuffer({
-              texture: texture.getHandle()
-            }, {
-              buffer: colorBuffer.getHandle(),
-              bytesPerRow: 8 * result.colorBufferWidth,
-              rowsPerImage: result.height
-            }, {
-              width: result.width,
-              height: result.height,
-              depthOrArrayLayers: 1
-            });
-            device.submitCommandEncoder(cmdEnc);
-            /* eslint-disable no-undef */
-
-            cLoad = colorBuffer.mapAsync(GPUMapMode.READ);
-            _context2.next = 14;
-            return cLoad;
-
-          case 14:
-            /* eslint-enable no-undef */
-            result.colorValues = new Uint16Array(colorBuffer.getMappedRange().slice());
-            colorBuffer.unmap(); // repack the array
-
-            tmparray = new Uint8ClampedArray(result.height * result.width * 4);
-
-            for (y = 0; y < result.height; y++) {
-              for (x = 0; x < result.width; x++) {
-                doffset = (y * result.width + x) * 4;
-                soffset = (y * result.colorBufferWidth + x) * 4;
-                tmparray[doffset] = 255.0 * HalfFloat.fromHalf(result.colorValues[soffset]);
-                tmparray[doffset + 1] = 255.0 * HalfFloat.fromHalf(result.colorValues[soffset + 1]);
-                tmparray[doffset + 2] = 255.0 * HalfFloat.fromHalf(result.colorValues[soffset + 2]);
-                tmparray[doffset + 3] = 255.0 * HalfFloat.fromHalf(result.colorValues[soffset + 3]);
-              }
-            }
-
-            result.colorValues = tmparray;
-            return _context2.abrupt("return", result);
-
-          case 20:
-          case "end":
-            return _context2.stop();
-        }
+    // must be a multiple of 256 bytes, so 32 texels with rgba16
+    result.colorBufferWidth = 32 * Math.floor((result.width + 31) / 32);
+    result.colorBufferSizeInBytes = result.colorBufferWidth * result.height * 8;
+    const colorBuffer = vtkWebGPUBuffer.newInstance();
+    colorBuffer.setDevice(device);
+    /* eslint-disable no-bitwise */
+    /* eslint-disable no-undef */
+    colorBuffer.create(result.colorBufferSizeInBytes, GPUBufferUsage.MAP_READ | GPUBufferUsage.COPY_DST);
+    /* eslint-enable no-bitwise */
+    /* eslint-enable no-undef */
+
+    const cmdEnc = model.device.createCommandEncoder();
+    cmdEnc.copyTextureToBuffer({
+      texture: texture.getHandle()
+    }, {
+      buffer: colorBuffer.getHandle(),
+      bytesPerRow: 8 * result.colorBufferWidth,
+      rowsPerImage: result.height
+    }, {
+      width: result.width,
+      height: result.height,
+      depthOrArrayLayers: 1
+    });
+    device.submitCommandEncoder(cmdEnc);
+
+    /* eslint-disable no-undef */
+    const cLoad = colorBuffer.mapAsync(GPUMapMode.READ);
+    await cLoad;
+    /* eslint-enable no-undef */
+
+    result.colorValues = new Uint16Array(colorBuffer.getMappedRange().slice());
+    colorBuffer.unmap();
+    // repack the array
+    const tmparray = new Uint8ClampedArray(result.height * result.width * 4);
+    for (let y = 0; y < result.height; y++) {
+      for (let x = 0; x < result.width; x++) {
+        const doffset = (y * result.width + x) * 4;
+        const soffset = (y * result.colorBufferWidth + x) * 4;
+        tmparray[doffset] = 255.0 * HalfFloat.fromHalf(result.colorValues[soffset]);
+        tmparray[doffset + 1] = 255.0 * HalfFloat.fromHalf(result.colorValues[soffset + 1]);
+        tmparray[doffset + 2] = 255.0 * HalfFloat.fromHalf(result.colorValues[soffset + 2]);
+        tmparray[doffset + 3] = 255.0 * HalfFloat.fromHalf(result.colorValues[soffset + 3]);
       }
-    }, _callee2);
-  }));
-
-  publicAPI.createSelector = function () {
-    var ret = vtkWebGPUHardwareSelector.newInstance();
+    }
+    result.colorValues = tmparray;
+    return result;
+  };
+  publicAPI.createSelector = () => {
+    const ret = vtkWebGPUHardwareSelector.newInstance();
     ret.setWebGPURenderWindow(publicAPI);
     return ret;
   };
-
   publicAPI.delete = macro.chain(publicAPI.delete, publicAPI.setViewStream);
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
-
-var DEFAULT_VALUES = {
+const DEFAULT_VALUES = {
   initialized: false,
   context: null,
   adapter: null,
@@ -638,57 +514,67 @@ var DEFAULT_VALUES = {
   nextPropID: 1,
   xrSupported: false,
   presentationFormat: null
-}; // ----------------------------------------------------------------------------
+};
+
+// ----------------------------------------------------------------------------
 
 function extend(publicAPI, model) {
-  var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-  Object.assign(model, DEFAULT_VALUES, initialValues); // Create internal instances
+  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  Object.assign(model, DEFAULT_VALUES, initialValues);
 
+  // Create internal instances
   model.canvas = document.createElement('canvas');
-  model.canvas.style.width = '100%'; // Create internal bgImage
+  model.canvas.style.width = '100%';
 
+  // Create internal bgImage
   model.bgImage = new Image();
   model.bgImage.style.position = 'absolute';
   model.bgImage.style.left = '0';
   model.bgImage.style.top = '0';
   model.bgImage.style.width = '100%';
   model.bgImage.style.height = '100%';
-  model.bgImage.style.zIndex = '-1'; // Inheritance
+  model.bgImage.style.zIndex = '-1';
 
+  // Inheritance
   vtkRenderWindowViewNode.extend(publicAPI, model, initialValues);
   model.myFactory = vtkWebGPUViewNodeFactory.newInstance();
   /* eslint-disable no-use-before-define */
-
   model.myFactory.registerOverride('vtkRenderWindow', newInstance);
   /* eslint-enable no-use-before-define */
-  // setup default forward pass rendering
 
+  // setup default forward pass rendering
   model.renderPasses[0] = vtkForwardPass.newInstance();
-
   if (!model.selector) {
     model.selector = vtkWebGPUHardwareSelector.newInstance();
     model.selector.setWebGPURenderWindow(publicAPI);
   }
-
   macro.event(publicAPI, model, 'imageReady');
-  macro.event(publicAPI, model, 'initialized'); // Build VTK API
+  macro.event(publicAPI, model, 'initialized');
 
+  // Build VTK API
   macro.get(publicAPI, model, ['commandEncoder', 'device', 'presentationFormat', 'useBackgroundImage', 'xrSupported']);
   macro.setGet(publicAPI, model, ['initialized', 'context', 'canvas', 'device', 'renderPasses', 'notifyStartCaptureImage', 'cursor', 'useOffScreen']);
-  macro.setGetArray(publicAPI, model, ['size'], 2); // Object methods
+  macro.setGetArray(publicAPI, model, ['size'], 2);
 
+  // Object methods
   vtkWebGPURenderWindow(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 
-var newInstance = macro.newInstance(extend, 'vtkWebGPURenderWindow'); // ----------------------------------------------------------------------------
+const newInstance = macro.newInstance(extend, 'vtkWebGPURenderWindow');
+
+// ----------------------------------------------------------------------------
 // Register API specific RenderWindow implementation
 // ----------------------------------------------------------------------------
 
-registerViewConstructor('WebGPU', newInstance); // ----------------------------------------------------------------------------
+registerViewConstructor('WebGPU', newInstance);
+
+// ----------------------------------------------------------------------------
 
 var vtkRenderWindow = {
-  newInstance: newInstance,
-  extend: extend
+  newInstance,
+  extend
 };
 
 export { vtkRenderWindow as default, extend, newInstance };