@kitware/vtk.js 28.10.2 → 28.11.0

package/Rendering/OpenGL/Convolution2DPass.js

@@ -1,4 +1,4 @@
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.js';
 import vtkOpenGLFramebuffer from './Framebuffer.js';
 import vtkRenderPass from '../SceneGraph/RenderPass.js';
 import vtkDataArray from '../../Common/Core/DataArray.js';
@@ -6,199 +6,200 @@ import vtkHelper from './Helper.js';
 import vtkVertexArrayObject from './VertexArrayObject.js';
 import { Representation } from '../Core/Property/Constants.js';
 
-var vtkErrorMacro = macro.vtkErrorMacro; // ----------------------------------------------------------------------------
+const {
+  vtkErrorMacro
+} = macro;
+// ----------------------------------------------------------------------------
 
 function vtkConvolution2DPass(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkConvolution2DPass');
-
   publicAPI.computeKernelWeight = function computeKernelWeight(kernel) {
-    var weight = kernel.reduce(function (prev, curr) {
-      return prev + curr;
-    });
+    const weight = kernel.reduce((prev, curr) => prev + curr);
     return weight <= 0 ? 1 : weight;
-  }; // handles post-processing via convolution kernel and call delegate
-
+  };
 
+  // handles post-processing via convolution kernel and call delegate
   publicAPI.traverse = function (viewNode) {
-
     if (model.deleted) {
       return;
-    } // check if kernel dimension is valid
-
+    }
 
+    // check if kernel dimension is valid
     if (model.kernelDimension % 2 !== 1) {
       vtkErrorMacro('Invalid kernel dimension! Kernel dimension must be odd (e.g. 3, 5, 7, ...).');
       return;
-    } // if no kernel is set, use the default kernel (no post-processing)
-
+    }
 
+    // if no kernel is set, use the default kernel (no post-processing)
     if (model.kernel === null) {
       model.kernel = new Float32Array(model.kernelDimension);
       model.kernel[Math.floor(model.kernelDimension / 2)] = 1;
     }
-
-    var kernelLength = model.kernelDimension * model.kernelDimension;
-
+    const kernelLength = model.kernelDimension * model.kernelDimension;
     if (model.kernel.length !== kernelLength) {
-      vtkErrorMacro("The given kernel is invalid. 2D convolution kernels have to be 1D arrays with ".concat(kernelLength, " components representing the ").concat(model.kernelDimension, "x").concat(model.kernelDimension, " kernel in row-major form."));
+      vtkErrorMacro(`The given kernel is invalid. 2D convolution kernels have to be 1D arrays with ${kernelLength} components representing the ${model.kernelDimension}x${model.kernelDimension} kernel in row-major form.`);
       return;
-    } // prepare framebuffer // allocate framebuffer if needed and bind it
-
+    }
 
+    // prepare framebuffer // allocate framebuffer if needed and bind it
     if (model.framebuffer === null) {
       model.framebuffer = vtkOpenGLFramebuffer.newInstance();
     }
-
-    var size = viewNode.getSize();
-    var gl = viewNode.getContext();
-
+    const size = viewNode.getSize();
+    const gl = viewNode.getContext();
     if (gl === null) {
       // nothing to do -> no render context
       // traverse delegate passes -> has to be done in order for the vtk render-pipeline to work correctly
-      model.delegates.forEach(function (val) {
+      model.delegates.forEach(val => {
         val.traverse(viewNode, publicAPI);
       });
       return;
-    } // prepare rendering
-
+    }
 
+    // prepare rendering
     if (model.VBOBuildTime.getMTime() < publicAPI.getMTime()) {
       model.tris.setOpenGLRenderWindow(viewNode);
       publicAPI.buildVertexBuffer();
-    } // store framebuffer bindings to restore them later
-
+    }
 
+    // store framebuffer bindings to restore them later
     model.framebuffer.setOpenGLRenderWindow(viewNode);
     model.framebuffer.saveCurrentBindingsAndBuffers();
-    var fbSize = model.framebuffer.getSize();
-
+    const fbSize = model.framebuffer.getSize();
     if (fbSize === null || fbSize[0] !== size[0] || fbSize[1] !== size[1]) {
       // create post-processing framebuffer if not already existing
       model.framebuffer.create(size[0], size[1]);
       model.framebuffer.populateFramebuffer();
-    } // bind framebuffer to re-direct the render-output of the delegate passes to the buffer
-
+    }
 
-    model.framebuffer.bind(); // do the delegate rendering
+    // bind framebuffer to re-direct the render-output of the delegate passes to the buffer
+    model.framebuffer.bind();
 
-    model.delegates.forEach(function (val) {
+    // do the delegate rendering
+    model.delegates.forEach(val => {
       val.traverse(viewNode, publicAPI);
-    }); // now draw the convolved values
+    });
 
-    model.framebuffer.restorePreviousBindingsAndBuffers(); // check if kernel dimension has changed and convolution shader needs to be re-compiled
+    // now draw the convolved values
+    model.framebuffer.restorePreviousBindingsAndBuffers();
 
+    // check if kernel dimension has changed and convolution shader needs to be re-compiled
     if (model.convolutionShader !== null && model.oldKernelDimension !== model.kernelDimension) {
       model.convolutionShader = null;
       model.oldKernelDimension = model.kernelDimension;
-    } // make sure the convolution shader is ready
-
+    }
 
+    // make sure the convolution shader is ready
     if (model.convolutionShader === null) {
       model.convolutionShader = viewNode.getShaderCache().readyShaderProgramArray(['//VTK::System::Dec', 'attribute vec4 vertexDC;', 'attribute vec2 tcoordTC;', 'varying vec2 tcoord;', 'void main() { tcoord = tcoordTC; gl_Position = vertexDC; }'].join('\n'), publicAPI.getFragmentShaderCode(model.kernelDimension), '');
-      var program = model.convolutionShader; // prepare the vertex and triangle data for the image plane to render to
+      const program = model.convolutionShader;
 
+      // prepare the vertex and triangle data for the image plane to render to
       model.copyVAO = vtkVertexArrayObject.newInstance();
       model.copyVAO.setOpenGLRenderWindow(viewNode);
       model.tris.getCABO().bind();
-
       if (!model.copyVAO.addAttributeArray(program, model.tris.getCABO(), 'vertexDC', model.tris.getCABO().getVertexOffset(), model.tris.getCABO().getStride(), gl.FLOAT, 3, gl.FALSE)) {
         vtkErrorMacro('Error setting vertexDC in copy shader VAO.');
       }
-
       if (!model.copyVAO.addAttributeArray(program, model.tris.getCABO(), 'tcoordTC', model.tris.getCABO().getTCoordOffset(), model.tris.getCABO().getStride(), gl.FLOAT, 2, gl.FALSE)) {
         vtkErrorMacro('Error setting vertexDC in copy shader VAO.');
       }
     } else {
       viewNode.getShaderCache().readyShaderProgram(model.convolutionShader);
     }
-
     gl.viewport(0, 0, size[0], size[1]);
-    gl.scissor(0, 0, size[0], size[1]); // activate texture
+    gl.scissor(0, 0, size[0], size[1]);
 
-    var tex = model.framebuffer.getColorTexture();
+    // activate texture
+    const tex = model.framebuffer.getColorTexture();
     tex.activate();
     model.convolutionShader.setUniformi('u_image', tex.getTextureUnit());
     model.convolutionShader.setUniform2f('u_textureSize', tex.getWidth(), tex.getHeight());
     model.convolutionShader.setUniformfv('u_kernel', model.kernel);
-    model.convolutionShader.setUniformf('u_kernelWeight', publicAPI.computeKernelWeight(model.kernel)); // render quad
+    model.convolutionShader.setUniformf('u_kernelWeight', publicAPI.computeKernelWeight(model.kernel));
 
+    // render quad
     gl.drawArrays(gl.TRIANGLES, 0, model.tris.getCABO().getElementCount());
     tex.deactivate();
   };
-
-  publicAPI.getFragmentShaderCode = function (kernelDimension) {
+  publicAPI.getFragmentShaderCode = kernelDimension => {
     // generate new shader code
-    var kernelLength = kernelDimension * kernelDimension;
-    var shaderCode = ['//VTK::System::Dec', '//VTK::Output::Dec', 'uniform sampler2D u_image;', 'uniform vec2 u_textureSize;', "uniform float u_kernel[".concat(kernelLength, "];"), 'uniform float u_kernelWeight;', 'varying vec2 tcoord;', 'void main(){', '    vec2 onePixel = vec2(1.0, 1.0) / u_textureSize;', '    vec4 colorSum =\n'].join('\n');
-    var halfDim = Math.floor(kernelDimension / 2); // generate sum per pixel
-
-    var i = 0;
-
-    for (var y = -halfDim; y <= halfDim; ++y) {
-      for (var x = -halfDim; x <= halfDim; ++x) {
-        shaderCode += "        texture2D(u_image, tcoord + onePixel * vec2(".concat(x, ", ").concat(y, ")) * u_kernel[").concat(i, "]");
+    const kernelLength = kernelDimension * kernelDimension;
+    let shaderCode = ['//VTK::System::Dec', '//VTK::Output::Dec', 'uniform sampler2D u_image;', 'uniform vec2 u_textureSize;', `uniform float u_kernel[${kernelLength}];`, 'uniform float u_kernelWeight;', 'varying vec2 tcoord;', 'void main(){', '    vec2 onePixel = vec2(1.0, 1.0) / u_textureSize;', '    vec4 colorSum =\n'].join('\n');
+    const halfDim = Math.floor(kernelDimension / 2);
+
+    // generate sum per pixel
+    let i = 0;
+    for (let y = -halfDim; y <= halfDim; ++y) {
+      for (let x = -halfDim; x <= halfDim; ++x) {
+        shaderCode += `        texture2D(u_image, tcoord + onePixel * vec2(${x}, ${y})) * u_kernel[${i}]`;
         ++i;
-
         if (i !== kernelLength) {
           shaderCode += ' +\n';
         }
       }
-    } // finish code
-
+    }
 
+    // finish code
     shaderCode += [';', '    gl_FragData[0] = vec4((colorSum / u_kernelWeight).rgb, texture2D(u_image, tcoord).a);', '}'].join('\n');
     return shaderCode;
-  }; // build vertices etc
-
+  };
 
-  publicAPI.buildVertexBuffer = function () {
+  // build vertices etc
+  publicAPI.buildVertexBuffer = () => {
     // 4 corner points in clipping space in order (x, y, z) where z is always set to -1
     // prettier-ignore
-    var ptsArray = new Float32Array([-1, -1, -1, 1, -1, -1, -1, 1, -1, 1, 1, -1]); // 4 corresponding corner points in texture space in order (x, y)
+    const ptsArray = new Float32Array([-1, -1, -1, 1, -1, -1, -1, 1, -1, 1, 1, -1]);
 
-    var tcoordArray = new Float32Array([0, 0, 1, 0, 0, 1, 1, 1]); // a square defined as cell relation ship in order (cell_size, v1, v2, v3, v4)
+    // 4 corresponding corner points in texture space in order (x, y)
+    const tcoordArray = new Float32Array([0, 0, 1, 0, 0, 1, 1, 1]);
 
-    var cellArray = new Uint16Array([4, 0, 1, 3, 2]);
-    var points = vtkDataArray.newInstance({
+    // a square defined as cell relation ship in order (cell_size, v1, v2, v3, v4)
+    const cellArray = new Uint16Array([4, 0, 1, 3, 2]);
+    const points = vtkDataArray.newInstance({
       numberOfComponents: 3,
       values: ptsArray
     });
     points.setName('points');
-    var tcoords = vtkDataArray.newInstance({
+    const tcoords = vtkDataArray.newInstance({
       numberOfComponents: 2,
       values: tcoordArray
     });
     tcoords.setName('tcoords');
-    var cells = vtkDataArray.newInstance({
+    const cells = vtkDataArray.newInstance({
       numberOfComponents: 1,
       values: cellArray
     });
     model.tris.getCABO().createVBO(cells, 'polys', Representation.SURFACE, {
-      points: points,
-      tcoords: tcoords,
+      points,
+      tcoords,
       cellOffset: 0
     });
     model.VBOBuildTime.modified();
   };
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
-
-var DEFAULT_VALUES = {
+const DEFAULT_VALUES = {
   framebuffer: null,
   convolutionShader: null,
   tris: null,
   kernel: [0, 0, 0, 0, 1, 0, 0, 0, 0],
   oldKernelDimension: 3,
   kernelDimension: 3
-}; // ----------------------------------------------------------------------------
+};
+
+// ----------------------------------------------------------------------------
 
 function extend(publicAPI, model) {
-  var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-  Object.assign(model, DEFAULT_VALUES, initialValues); // Build VTK API
+  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  Object.assign(model, DEFAULT_VALUES, initialValues);
 
+  // Build VTK API
   vtkRenderPass.extend(publicAPI, model, initialValues);
   model.VBOBuildTime = {};
   macro.obj(model.VBOBuildTime, {
@@ -206,16 +207,21 @@ function extend(publicAPI, model) {
   });
   model.tris = vtkHelper.newInstance();
   macro.setGet(publicAPI, model, ['kernel', 'kernelDimension']);
-  macro.get(publicAPI, model, ['framebuffer']); // Object methods
+  macro.get(publicAPI, model, ['framebuffer']);
 
+  // Object methods
   vtkConvolution2DPass(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 
-var newInstance = macro.newInstance(extend, 'vtkConvolution2DPass'); // ----------------------------------------------------------------------------
+const newInstance = macro.newInstance(extend, 'vtkConvolution2DPass');
+
+// ----------------------------------------------------------------------------
 
 var vtkConvolution2DPass$1 = {
-  newInstance: newInstance,
-  extend: extend
+  newInstance,
+  extend
 };
 
 export { vtkConvolution2DPass$1 as default, extend, newInstance };

package/Rendering/OpenGL/CubeAxesActor.js

@@ -1,63 +1,70 @@
-import { newInstance as newInstance$1 } from '../../macros.js';
+import { n as newInstance$1 } from '../../macros2.js';
 import vtkCubeAxesActor from '../Core/CubeAxesActor.js';
 import vtkViewNode from '../SceneGraph/ViewNode.js';
 import { registerOverride } from './ViewNodeFactory.js';
 
+// ----------------------------------------------------------------------------
 // vtkOpenGLCubeAxesActor methods
 // ----------------------------------------------------------------------------
 
 function vtkOpenGLCubeAxesActor(publicAPI, model) {
-  model.classHierarchy.push('vtkOpenGLCubeAxesActor'); // Builds myself.
+  model.classHierarchy.push('vtkOpenGLCubeAxesActor');
 
-  publicAPI.buildPass = function (prepass) {
+  // Builds myself.
+  publicAPI.buildPass = prepass => {
     if (prepass) {
       model._openGLRenderer = publicAPI.getFirstAncestorOfType('vtkOpenGLRenderer');
       model._openGLRenderWindow = model._openGLRenderer.getParent();
-
       if (!model.CubeAxesActorHelper.getRenderable()) {
         model.CubeAxesActorHelper.setRenderable(model.renderable);
       }
-
       publicAPI.prepareNodes();
       publicAPI.addMissingNode(model.CubeAxesActorHelper.getTmActor());
       publicAPI.addMissingNode(model.renderable.getGridActor());
       publicAPI.removeUnusedNodes();
     }
   };
-
-  publicAPI.opaquePass = function (prepass, renderPass) {
+  publicAPI.opaquePass = (prepass, renderPass) => {
     if (prepass) {
-      var camera = model._openGLRenderer ? model._openGLRenderer.getRenderable().getActiveCamera() : null;
-
-      var tsize = model._openGLRenderer.getTiledSizeAndOrigin();
-
+      const camera = model._openGLRenderer ? model._openGLRenderer.getRenderable().getActiveCamera() : null;
+      const tsize = model._openGLRenderer.getTiledSizeAndOrigin();
       model.CubeAxesActorHelper.updateAPISpecificData([tsize.usize, tsize.vsize], camera, model._openGLRenderWindow.getRenderable());
     }
   };
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
+const DEFAULT_VALUES = {};
 
-var DEFAULT_VALUES = {}; // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
 
 function extend(publicAPI, model) {
-  var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-  Object.assign(model, DEFAULT_VALUES, initialValues); // Inheritance
+  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  Object.assign(model, DEFAULT_VALUES, initialValues);
 
+  // Inheritance
   vtkViewNode.extend(publicAPI, model, initialValues);
-  model.CubeAxesActorHelper = vtkCubeAxesActor.newCubeAxesActorHelper(); // Object methods
+  model.CubeAxesActorHelper = vtkCubeAxesActor.newCubeAxesActorHelper();
 
+  // Object methods
   vtkOpenGLCubeAxesActor(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
+
+const newInstance = newInstance$1(extend, 'vtkOpenGLCubeAxesActor');
 
-var newInstance = newInstance$1(extend, 'vtkOpenGLCubeAxesActor'); // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
 
 var index = {
-  newInstance: newInstance,
-  extend: extend
-}; // Register ourself to OpenGL backend if imported
+  newInstance,
+  extend
+};
 
+// Register ourself to OpenGL backend if imported
 registerOverride('vtkCubeAxesActor', newInstance);
 
 export { index as default, extend, newInstance };

package/Rendering/OpenGL/ForwardPass.js

@@ -1,36 +1,38 @@
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.js';
 import vtkOpenGLFramebuffer from './Framebuffer.js';
 import vtkRenderPass from '../SceneGraph/RenderPass.js';
 import vtkOpenGLOrderIndependentTranslucentPass from './OrderIndependentTranslucentPass.js';
 
+// ----------------------------------------------------------------------------
+
 function vtkForwardPass(publicAPI, model) {
   // Set our className
-  model.classHierarchy.push('vtkForwardPass'); // this pass implements a forward rendering pipeline
+  model.classHierarchy.push('vtkForwardPass');
+
+  // this pass implements a forward rendering pipeline
   // if both volumes and opaque geometry are present
   // it will mix the two together by capturing a zbuffer
   // first
-
   publicAPI.traverse = function (viewNode) {
-    var parent = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
-
+    let parent = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
     if (model.deleted) {
       return;
-    } // we just render our delegates in order
-
+    }
 
-    model._currentParent = parent; // build
+    // we just render our delegates in order
+    model._currentParent = parent;
 
+    // build
     publicAPI.setCurrentOperation('buildPass');
     viewNode.traverse(publicAPI);
-    var numlayers = viewNode.getRenderable().getNumberOfLayers(); // iterate over renderers
-
-    var renderers = viewNode.getChildren();
-
-    for (var i = 0; i < numlayers; i++) {
-      for (var index = 0; index < renderers.length; index++) {
-        var renNode = renderers[index];
-        var ren = viewNode.getRenderable().getRenderers()[index];
-
+    const numlayers = viewNode.getRenderable().getNumberOfLayers();
+
+    // iterate over renderers
+    const renderers = viewNode.getChildren();
+    for (let i = 0; i < numlayers; i++) {
+      for (let index = 0; index < renderers.length; index++) {
+        const renNode = renderers[index];
+        const ren = viewNode.getRenderable().getRenderers()[index];
         if (ren.getDraw() && ren.getLayer() === i) {
           // check for both opaque and volume actors
           model.opaqueActorCount = 0;
@@ -38,56 +40,49 @@ function vtkForwardPass(publicAPI, model) {
           model.volumeCount = 0;
           model.overlayActorCount = 0;
           publicAPI.setCurrentOperation('queryPass');
-          renNode.traverse(publicAPI); // do we need to capture a zbuffer?
+          renNode.traverse(publicAPI);
 
+          // do we need to capture a zbuffer?
           if ((model.opaqueActorCount > 0 || model.translucentActorCount > 0) && model.volumeCount > 0 || model.depthRequested) {
-            var size = viewNode.getFramebufferSize(); // make sure the framebuffer is setup
-
+            const size = viewNode.getFramebufferSize();
+            // make sure the framebuffer is setup
             if (model.framebuffer === null) {
               model.framebuffer = vtkOpenGLFramebuffer.newInstance();
             }
-
             model.framebuffer.setOpenGLRenderWindow(viewNode);
             model.framebuffer.saveCurrentBindingsAndBuffers();
-            var fbSize = model.framebuffer.getSize();
-
+            const fbSize = model.framebuffer.getSize();
             if (fbSize === null || fbSize[0] !== size[0] || fbSize[1] !== size[1]) {
               model.framebuffer.create(size[0], size[1]);
               model.framebuffer.populateFramebuffer();
             }
-
-            model.framebuffer.bind(); // opaqueZBufferPass only renders opaque actors
+            model.framebuffer.bind();
+            // opaqueZBufferPass only renders opaque actors
             // zBufferPass renders both translucent and opaque actors
             // we want to be able to pick translucent actors
-
             publicAPI.setCurrentOperation('zBufferPass');
             renNode.traverse(publicAPI);
-            model.framebuffer.restorePreviousBindingsAndBuffers(); // reset now that we have done it
+            model.framebuffer.restorePreviousBindingsAndBuffers();
 
+            // reset now that we have done it
             model.depthRequested = false;
           }
-
           publicAPI.setCurrentOperation('cameraPass');
           renNode.traverse(publicAPI);
-
           if (model.opaqueActorCount > 0) {
             publicAPI.setCurrentOperation('opaquePass');
             renNode.traverse(publicAPI);
           }
-
           if (model.translucentActorCount > 0) {
             if (!model.translucentPass) {
               model.translucentPass = vtkOpenGLOrderIndependentTranslucentPass.newInstance();
             }
-
             model.translucentPass.traverse(viewNode, renNode, publicAPI);
           }
-
           if (model.volumeCount > 0) {
             publicAPI.setCurrentOperation('volumePass');
             renNode.traverse(publicAPI);
           }
-
           if (model.overlayActorCount > 0) {
             publicAPI.setCurrentOperation('overlayPass');
             renNode.traverse(publicAPI);
@@ -96,63 +91,57 @@ function vtkForwardPass(publicAPI, model) {
       }
     }
   };
-
-  publicAPI.getZBufferTexture = function () {
+  publicAPI.getZBufferTexture = () => {
     if (model.framebuffer) {
       return model.framebuffer.getColorTexture();
     }
-
     return null;
   };
-
-  publicAPI.requestDepth = function () {
+  publicAPI.requestDepth = () => {
     model.depthRequested = true;
   };
+  publicAPI.incrementOpaqueActorCount = () => model.opaqueActorCount++;
+  publicAPI.incrementTranslucentActorCount = () => model.translucentActorCount++;
+  publicAPI.incrementVolumeCount = () => model.volumeCount++;
+  publicAPI.incrementOverlayActorCount = () => model.overlayActorCount++;
+}
 
-  publicAPI.incrementOpaqueActorCount = function () {
-    return model.opaqueActorCount++;
-  };
-
-  publicAPI.incrementTranslucentActorCount = function () {
-    return model.translucentActorCount++;
-  };
-
-  publicAPI.incrementVolumeCount = function () {
-    return model.volumeCount++;
-  };
-
-  publicAPI.incrementOverlayActorCount = function () {
-    return model.overlayActorCount++;
-  };
-} // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
-
-var DEFAULT_VALUES = {
+const DEFAULT_VALUES = {
   opaqueActorCount: 0,
   translucentActorCount: 0,
   volumeCount: 0,
   overlayActorCount: 0,
   framebuffer: null,
   depthRequested: false
-}; // ----------------------------------------------------------------------------
+};
+
+// ----------------------------------------------------------------------------
 
 function extend(publicAPI, model) {
-  var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-  Object.assign(model, DEFAULT_VALUES, initialValues); // Build VTK API
+  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  Object.assign(model, DEFAULT_VALUES, initialValues);
 
+  // Build VTK API
   vtkRenderPass.extend(publicAPI, model, initialValues);
-  macro.get(publicAPI, model, ['framebuffer', 'opaqueActorCount', 'translucentActorCount', 'volumeCount']); // Object methods
+  macro.get(publicAPI, model, ['framebuffer', 'opaqueActorCount', 'translucentActorCount', 'volumeCount']);
 
+  // Object methods
   vtkForwardPass(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 
-var newInstance = macro.newInstance(extend, 'vtkForwardPass'); // ----------------------------------------------------------------------------
+const newInstance = macro.newInstance(extend, 'vtkForwardPass');
+
+// ----------------------------------------------------------------------------
 
 var vtkForwardPass$1 = {
-  newInstance: newInstance,
-  extend: extend
+  newInstance,
+  extend
 };
 
 export { vtkForwardPass$1 as default, extend, newInstance };