@kitware/vtk.js 28.10.2 → 28.11.1

package/Rendering/OpenGL/Skybox.js

@@ -1,5 +1,5 @@
 import { mat3, mat4 } from 'gl-matrix';
-import { newInstance as newInstance$1, obj, setGet, get, vtkErrorMacro as vtkErrorMacro$1 } from '../../macros.js';
+import { n as newInstance$1, o as obj, e as setGet, g as get, c as macro } from '../../macros2.js';
 import vtkDataArray from '../../Common/Core/DataArray.js';
 import vtkHelper from './Helper.js';
 import vtkViewNode from '../SceneGraph/ViewNode.js';
@@ -7,86 +7,78 @@ import vtkOpenGLTexture from './Texture.js';
 import { Representation } from '../Core/Property/Constants.js';
 import { registerOverride } from './ViewNodeFactory.js';
 
-var vtkErrorMacro = vtkErrorMacro$1; // ----------------------------------------------------------------------------
+const {
+  vtkErrorMacro
+} = macro;
+
+// ----------------------------------------------------------------------------
 // vtkOpenGLSkybox methods
 // ----------------------------------------------------------------------------
 
 function vtkOpenGLSkybox(publicAPI, model) {
   // Set our className
-  model.classHierarchy.push('vtkOpenGLSkybox'); // Builds myself.
+  model.classHierarchy.push('vtkOpenGLSkybox');
 
-  publicAPI.buildPass = function (prepass) {
+  // Builds myself.
+  publicAPI.buildPass = prepass => {
     if (prepass) {
       model._openGLRenderer = publicAPI.getFirstAncestorOfType('vtkOpenGLRenderer');
       model._openGLRenderWindow = model._openGLRenderer.getParent();
       model.context = model._openGLRenderWindow.getContext();
       model.tris.setOpenGLRenderWindow(model._openGLRenderWindow);
       model.openGLTexture.setOpenGLRenderWindow(model._openGLRenderWindow);
-
-      var ren = model._openGLRenderer.getRenderable();
-
+      const ren = model._openGLRenderer.getRenderable();
       model.openGLCamera = model._openGLRenderer.getViewNodeFor(ren.getActiveCamera());
     }
   };
-
-  publicAPI.queryPass = function (prepass, renderPass) {
+  publicAPI.queryPass = (prepass, renderPass) => {
     if (prepass) {
       if (!model.renderable || !model.renderable.getVisibility()) {
         return;
       }
-
       renderPass.incrementOpaqueActorCount();
     }
   };
-
-  publicAPI.opaquePass = function (prepass, renderPass) {
+  publicAPI.opaquePass = (prepass, renderPass) => {
     if (prepass && !model._openGLRenderer.getSelector()) {
       publicAPI.updateBufferObjects();
       model.context.depthMask(true);
-
       model._openGLRenderWindow.getShaderCache().readyShaderProgram(model.tris.getProgram());
-
       model.openGLTexture.render(model._openGLRenderWindow);
-      var texUnit = model.openGLTexture.getTextureUnit();
+      const texUnit = model.openGLTexture.getTextureUnit();
       model.tris.getProgram().setUniformi('sbtexture', texUnit);
-
-      var ren = model._openGLRenderer.getRenderable();
-
-      var keyMats = model.openGLCamera.getKeyMatrices(ren);
-      var imat = new Float64Array(16);
+      const ren = model._openGLRenderer.getRenderable();
+      const keyMats = model.openGLCamera.getKeyMatrices(ren);
+      const imat = new Float64Array(16);
       mat4.invert(imat, keyMats.wcpc);
       model.tris.getProgram().setUniformMatrix('IMCPCMatrix', imat);
-
       if (model.lastFormat === 'box') {
-        var camPos = ren.getActiveCamera().getPosition();
+        const camPos = ren.getActiveCamera().getPosition();
         model.tris.getProgram().setUniform3f('camPos', camPos[0], camPos[1], camPos[2]);
       }
+      model.tris.getVAO().bind();
 
-      model.tris.getVAO().bind(); // draw polygons
-
+      // draw polygons
       model.context.drawArrays(model.context.TRIANGLES, 0, model.tris.getCABO().getElementCount());
       model.tris.getVAO().release();
       model.openGLTexture.deactivate();
     }
   };
-
-  publicAPI.updateBufferObjects = function () {
+  publicAPI.updateBufferObjects = () => {
     // build the VBO if needed, only happens once
     if (!model.tris.getCABO().getElementCount()) {
-      var ptsArray = new Float32Array(12);
-
-      for (var i = 0; i < 4; i++) {
+      const ptsArray = new Float32Array(12);
+      for (let i = 0; i < 4; i++) {
         ptsArray[i * 3] = i % 2 * 2 - 1.0;
         ptsArray[i * 3 + 1] = i > 1 ? 1.0 : -1.0;
         ptsArray[i * 3 + 2] = 1.0;
       }
-
-      var points = vtkDataArray.newInstance({
+      const points = vtkDataArray.newInstance({
         numberOfComponents: 3,
         values: ptsArray
       });
       points.setName('points');
-      var cellArray = new Uint16Array(8);
+      const cellArray = new Uint16Array(8);
       cellArray[0] = 3;
       cellArray[1] = 0;
       cellArray[2] = 1;
@@ -95,20 +87,19 @@ function vtkOpenGLSkybox(publicAPI, model) {
       cellArray[5] = 0;
       cellArray[6] = 3;
       cellArray[7] = 2;
-      var cells = vtkDataArray.newInstance({
+      const cells = vtkDataArray.newInstance({
         numberOfComponents: 1,
         values: cellArray
       });
       model.tris.getCABO().createVBO(cells, 'polys', Representation.SURFACE, {
-        points: points,
+        points,
         cellOffset: 0
       });
-    } // update the program?
-
+    }
 
+    // update the program?
     if (model.renderable.getFormat() !== model.lastFormat) {
       model.lastFormat = model.renderable.getFormat();
-
       if (model.lastFormat === 'box') {
         // we invert Y below because opengl is messed up!
         // Cube Maps have been specified to follow the RenderMan
@@ -121,47 +112,88 @@ function vtkOpenGLSkybox(publicAPI, model) {
         // But now we're stuck with it.  From
         // https://stackoverflow.com/questions/11685608/convention-of-faces-in-opengl-cubemapping
         //
-        model.tris.setProgram(model._openGLRenderWindow.getShaderCache().readyShaderProgramArray("//VTK::System::Dec\n             attribute vec3 vertexMC;\n             uniform mat4 IMCPCMatrix;\n             varying vec3 TexCoords;\n             void main () {\n              gl_Position = vec4(vertexMC.xyz, 1.0);\n              vec4 wpos = IMCPCMatrix * gl_Position;\n              TexCoords = wpos.xyz/wpos.w;\n             }", "//VTK::System::Dec\n             //VTK::Output::Dec\n             varying vec3 TexCoords;\n             uniform samplerCube sbtexture;\n             uniform vec3 camPos;\n             void main () {\n               // skybox looks from inside out\n               // which means we have to adjust\n               // our tcoords. Otherwise text would\n               // be flipped\n               vec3 tc = normalize(TexCoords - camPos);\n               if (abs(tc.z) < max(abs(tc.x),abs(tc.y)))\n               {\n                 tc = vec3(1.0, 1.0, -1.0) * tc;\n               }\n               else\n               {\n                 tc = vec3(-1.0, 1.0, 1.0) * tc;\n               }\n               gl_FragData[0] = textureCube(sbtexture, tc);\n             }", ''));
+        model.tris.setProgram(model._openGLRenderWindow.getShaderCache().readyShaderProgramArray(`//VTK::System::Dec
+             attribute vec3 vertexMC;
+             uniform mat4 IMCPCMatrix;
+             varying vec3 TexCoords;
+             void main () {
+              gl_Position = vec4(vertexMC.xyz, 1.0);
+              vec4 wpos = IMCPCMatrix * gl_Position;
+              TexCoords = wpos.xyz/wpos.w;
+             }`, `//VTK::System::Dec
+             //VTK::Output::Dec
+             varying vec3 TexCoords;
+             uniform samplerCube sbtexture;
+             uniform vec3 camPos;
+             void main () {
+               // skybox looks from inside out
+               // which means we have to adjust
+               // our tcoords. Otherwise text would
+               // be flipped
+               vec3 tc = normalize(TexCoords - camPos);
+               if (abs(tc.z) < max(abs(tc.x),abs(tc.y)))
+               {
+                 tc = vec3(1.0, 1.0, -1.0) * tc;
+               }
+               else
+               {
+                 tc = vec3(-1.0, 1.0, 1.0) * tc;
+               }
+               gl_FragData[0] = textureCube(sbtexture, tc);
+             }`, ''));
       }
-
       if (model.lastFormat === 'background') {
         // maps the texture to the window
-        model.tris.setProgram(model._openGLRenderWindow.getShaderCache().readyShaderProgramArray("//VTK::System::Dec\n             attribute vec3 vertexMC;\n             uniform mat4 IMCPCMatrix;\n             varying vec2 TexCoords;\n             void main () {\n              gl_Position = vec4(vertexMC.xyz, 1.0);\n              vec4 wpos = IMCPCMatrix * gl_Position;\n              TexCoords = vec2(vertexMC.x, vertexMC.y)*0.5 + 0.5;\n             }", "//VTK::System::Dec\n             //VTK::Output::Dec\n             varying vec2 TexCoords;\n             uniform sampler2D sbtexture;\n             void main () {\n               gl_FragData[0] = texture2D(sbtexture, TexCoords);\n             }", ''));
+        model.tris.setProgram(model._openGLRenderWindow.getShaderCache().readyShaderProgramArray(`//VTK::System::Dec
+             attribute vec3 vertexMC;
+             uniform mat4 IMCPCMatrix;
+             varying vec2 TexCoords;
+             void main () {
+              gl_Position = vec4(vertexMC.xyz, 1.0);
+              vec4 wpos = IMCPCMatrix * gl_Position;
+              TexCoords = vec2(vertexMC.x, vertexMC.y)*0.5 + 0.5;
+             }`, `//VTK::System::Dec
+             //VTK::Output::Dec
+             varying vec2 TexCoords;
+             uniform sampler2D sbtexture;
+             void main () {
+               gl_FragData[0] = texture2D(sbtexture, TexCoords);
+             }`, ''));
       }
-
       model.tris.getShaderSourceTime().modified();
       model.tris.getVAO().bind();
-
       if (!model.tris.getVAO().addAttributeArray(model.tris.getProgram(), model.tris.getCABO(), 'vertexMC', model.tris.getCABO().getVertexOffset(), model.tris.getCABO().getStride(), model.context.FLOAT, 3, model.context.FALSE)) {
         vtkErrorMacro('Error setting vertexMC in shader VAO.');
       }
-    } // set/update the texture map if needed
-
-
-    var tmaps = model.renderable.getTextures();
+    }
 
+    // set/update the texture map if needed
+    const tmaps = model.renderable.getTextures();
     if (!tmaps.length) {
       vtkErrorMacro('vtkSkybox requires a texture map');
     }
-
     if (model.openGLTexture.getRenderable() !== tmaps[0]) {
       model.openGLTexture.releaseGraphicsResources(model._openGLRenderWindow);
       model.openGLTexture.setRenderable(tmaps[0]);
     }
   };
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
-
-var DEFAULT_VALUES = {
+const DEFAULT_VALUES = {
   context: null
-}; // ----------------------------------------------------------------------------
+};
+
+// ----------------------------------------------------------------------------
 
 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.openGLTexture = vtkOpenGLTexture.newInstance();
   model.tris = vtkHelper.newInstance();
@@ -172,21 +204,28 @@ function extend(publicAPI, model) {
   model.keyMatrices = {
     normalMatrix: mat3.identity(new Float64Array(9)),
     mcwc: mat4.identity(new Float64Array(16))
-  }; // Build VTK API
+  };
 
+  // Build VTK API
   setGet(publicAPI, model, ['context']);
-  get(publicAPI, model, ['activeTextures']); // Object methods
+  get(publicAPI, model, ['activeTextures']);
 
+  // Object methods
   vtkOpenGLSkybox(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
 
-var newInstance = newInstance$1(extend); // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+
+const newInstance = newInstance$1(extend);
+
+// ----------------------------------------------------------------------------
 
 var vtkSkybox = {
-  newInstance: newInstance,
-  extend: extend
-}; // Register ourself to OpenGL backend if imported
+  newInstance,
+  extend
+};
 
+// Register ourself to OpenGL backend if imported
 registerOverride('vtkSkybox', newInstance);
 
 export { vtkSkybox as default, extend, newInstance };

package/Rendering/OpenGL/SphereMapper.js

@@ -1,7 +1,6 @@
-import _defineProperty from '@babel/runtime/helpers/defineProperty';
 import { mat4 } from 'gl-matrix';
 import { ObjectType } from './BufferObject/Constants.js';
-import { newInstance as newInstance$1, vtkErrorMacro as vtkErrorMacro$1 } from '../../macros.js';
+import { n as newInstance$1, c as macro } from '../../macros2.js';
 import vtkBufferObject from './BufferObject.js';
 import { r as radiansFromDegrees } from '../../Common/Core/Math/index.js';
 import vtkShaderProgram from './ShaderProgram.js';
@@ -10,196 +9,180 @@ import { v as vtkSphereMapperVS } from './glsl/vtkSphereMapperVS.glsl.js';
 import { v as vtkPolyDataFS } from './glsl/vtkPolyDataFS.glsl.js';
 import { registerOverride } from './ViewNodeFactory.js';
 
-function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+const {
+  vtkErrorMacro
+} = macro;
 
-function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
-var vtkErrorMacro = vtkErrorMacro$1; // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
 // vtkOpenGLSphereMapper methods
 // ----------------------------------------------------------------------------
 
 function vtkOpenGLSphereMapper(publicAPI, model) {
   // Set our className
-  model.classHierarchy.push('vtkOpenGLSphereMapper'); // Capture 'parentClass' api for internal use
-
-  var superClass = _objectSpread({}, publicAPI);
+  model.classHierarchy.push('vtkOpenGLSphereMapper');
 
-  publicAPI.getShaderTemplate = function (shaders, ren, actor) {
+  // Capture 'parentClass' api for internal use
+  const superClass = {
+    ...publicAPI
+  };
+  publicAPI.getShaderTemplate = (shaders, ren, actor) => {
     shaders.Vertex = vtkSphereMapperVS;
     shaders.Fragment = vtkPolyDataFS;
     shaders.Geometry = '';
   };
-
-  publicAPI.replaceShaderValues = function (shaders, ren, actor) {
-    var VSSource = shaders.Vertex;
-    var FSSource = shaders.Fragment;
+  publicAPI.replaceShaderValues = (shaders, ren, actor) => {
+    let VSSource = shaders.Vertex;
+    let FSSource = shaders.Fragment;
     VSSource = vtkShaderProgram.substitute(VSSource, '//VTK::Camera::Dec', ['uniform mat4 VCPCMatrix;\n', 'uniform mat4 MCVCMatrix;']).result;
-    FSSource = vtkShaderProgram.substitute(FSSource, '//VTK::PositionVC::Dec', ['varying vec4 vertexVCVSOutput;']).result; // we create vertexVC below, so turn off the default
+    FSSource = vtkShaderProgram.substitute(FSSource, '//VTK::PositionVC::Dec', ['varying vec4 vertexVCVSOutput;']).result;
+
+    // we create vertexVC below, so turn off the default
     // implementation
+    FSSource = vtkShaderProgram.substitute(FSSource, '//VTK::PositionVC::Impl', ['vec4 vertexVC = vertexVCVSOutput;\n']).result;
 
-    FSSource = vtkShaderProgram.substitute(FSSource, '//VTK::PositionVC::Impl', ['vec4 vertexVC = vertexVCVSOutput;\n']).result; // for lights kit and positional the VCPC matrix is already defined
+    // for lights kit and positional the VCPC matrix is already defined
     // so don't redefine it
-
-    var replacement = ['uniform float invertedDepth;\n', 'uniform int cameraParallel;\n', 'varying float radiusVCVSOutput;\n', 'varying vec3 centerVCVSOutput;\n', 'uniform mat4 VCPCMatrix;\n'];
+    const replacement = ['uniform float invertedDepth;\n', 'uniform int cameraParallel;\n', 'varying float radiusVCVSOutput;\n', 'varying vec3 centerVCVSOutput;\n', 'uniform mat4 VCPCMatrix;\n'];
     FSSource = vtkShaderProgram.substitute(FSSource, '//VTK::Normal::Dec', replacement).result;
-    var fragString = '';
-
+    let fragString = '';
     if (model.context.getExtension('EXT_frag_depth')) {
       fragString = 'gl_FragDepthEXT = (pos.z / pos.w + 1.0) / 2.0;\n';
     }
-
     if (model._openGLRenderWindow.getWebgl2()) {
       fragString = 'gl_FragDepth = (pos.z / pos.w + 1.0) / 2.0;\n';
     }
-
-    FSSource = vtkShaderProgram.substitute(FSSource, '//VTK::Depth::Impl', [// compute the eye position and unit direction
-    '  vec3 EyePos;\n', '  vec3 EyeDir;\n', '  if (cameraParallel != 0) {\n', '    EyePos = vec3(vertexVC.x, vertexVC.y, vertexVC.z + 3.0*radiusVCVSOutput);\n', '    EyeDir = vec3(0.0,0.0,-1.0); }\n', '  else {\n', '    EyeDir = vertexVC.xyz;\n', '    EyePos = vec3(0.0,0.0,0.0);\n', '    float lengthED = length(EyeDir);\n', '    EyeDir = normalize(EyeDir);\n', // we adjust the EyePos to be closer if it is too far away
+    FSSource = vtkShaderProgram.substitute(FSSource, '//VTK::Depth::Impl', [
+    // compute the eye position and unit direction
+    '  vec3 EyePos;\n', '  vec3 EyeDir;\n', '  if (cameraParallel != 0) {\n', '    EyePos = vec3(vertexVC.x, vertexVC.y, vertexVC.z + 3.0*radiusVCVSOutput);\n', '    EyeDir = vec3(0.0,0.0,-1.0); }\n', '  else {\n', '    EyeDir = vertexVC.xyz;\n', '    EyePos = vec3(0.0,0.0,0.0);\n', '    float lengthED = length(EyeDir);\n', '    EyeDir = normalize(EyeDir);\n',
+    // we adjust the EyePos to be closer if it is too far away
     // to prevent floating point precision noise
-    '    if (lengthED > radiusVCVSOutput*3.0) {\n', '      EyePos = vertexVC.xyz - EyeDir*3.0*radiusVCVSOutput; }\n', '    }\n', // translate to Sphere center
-    '  EyePos = EyePos - centerVCVSOutput;\n', // scale to radius 1.0
-    '  EyePos = EyePos/radiusVCVSOutput;\n', // find the intersection
-    '  float b = 2.0*dot(EyePos,EyeDir);\n', '  float c = dot(EyePos,EyePos) - 1.0;\n', '  float d = b*b - 4.0*c;\n', '  vec3 normalVCVSOutput = vec3(0.0,0.0,1.0);\n', '  if (d < 0.0) { discard; }\n', '  else {\n', '    float t = (-b - invertedDepth*sqrt(d))*0.5;\n', // compute the normal, for unit sphere this is just
+    '    if (lengthED > radiusVCVSOutput*3.0) {\n', '      EyePos = vertexVC.xyz - EyeDir*3.0*radiusVCVSOutput; }\n', '    }\n',
+    // translate to Sphere center
+    '  EyePos = EyePos - centerVCVSOutput;\n',
+    // scale to radius 1.0
+    '  EyePos = EyePos/radiusVCVSOutput;\n',
+    // find the intersection
+    '  float b = 2.0*dot(EyePos,EyeDir);\n', '  float c = dot(EyePos,EyePos) - 1.0;\n', '  float d = b*b - 4.0*c;\n', '  vec3 normalVCVSOutput = vec3(0.0,0.0,1.0);\n', '  if (d < 0.0) { discard; }\n', '  else {\n', '    float t = (-b - invertedDepth*sqrt(d))*0.5;\n',
+    // compute the normal, for unit sphere this is just
     // the intersection point
-    '    normalVCVSOutput = invertedDepth*normalize(EyePos + t*EyeDir);\n', // compute the intersection point in VC
-    '    vertexVC.xyz = normalVCVSOutput*radiusVCVSOutput + centerVCVSOutput;\n', '    }\n', // compute the pixel's depth
+    '    normalVCVSOutput = invertedDepth*normalize(EyePos + t*EyeDir);\n',
+    // compute the intersection point in VC
+    '    vertexVC.xyz = normalVCVSOutput*radiusVCVSOutput + centerVCVSOutput;\n', '    }\n',
+    // compute the pixel's depth
     // ' normalVCVSOutput = vec3(0,0,1);\n'
-    '  vec4 pos = VCPCMatrix * vertexVC;\n', fragString]).result; // Strip out the normal line -- the normal is computed as part of the depth
+    '  vec4 pos = VCPCMatrix * vertexVC;\n', fragString]).result;
 
+    // Strip out the normal line -- the normal is computed as part of the depth
     FSSource = vtkShaderProgram.substitute(FSSource, '//VTK::Normal::Impl', '').result;
-
     if (model.haveSeenDepthRequest) {
       // special depth impl
       FSSource = vtkShaderProgram.substitute(FSSource, '//VTK::ZBuffer::Impl', ['if (depthRequest == 1) {', 'float computedZ = (pos.z / pos.w + 1.0) / 2.0;', 'float iz = floor(computedZ * 65535.0 + 0.1);', 'float rf = floor(iz/256.0)/255.0;', 'float gf = mod(iz,256.0)/255.0;', 'gl_FragData[0] = vec4(rf, gf, 0.0, 1.0); }']).result;
     }
-
     shaders.Vertex = VSSource;
     shaders.Fragment = FSSource;
     superClass.replaceShaderValues(shaders, ren, actor);
   };
-
-  publicAPI.setMapperShaderParameters = function (cellBO, ren, actor) {
+  publicAPI.setMapperShaderParameters = (cellBO, ren, actor) => {
     if (cellBO.getCABO().getElementCount() && (model.VBOBuildTime > cellBO.getAttributeUpdateTime().getMTime() || cellBO.getShaderSourceTime().getMTime() > cellBO.getAttributeUpdateTime().getMTime()) && cellBO.getProgram().isAttributeUsed('offsetMC')) {
-      if (!cellBO.getVAO().addAttributeArray(cellBO.getProgram(), cellBO.getCABO(), 'offsetMC', 12, // 12:this->VBO->ColorOffset+sizeof(float)
+      if (!cellBO.getVAO().addAttributeArray(cellBO.getProgram(), cellBO.getCABO(), 'offsetMC', 12,
+      // 12:this->VBO->ColorOffset+sizeof(float)
       cellBO.getCABO().getStride(), model.context.FLOAT, 2, false)) {
         vtkErrorMacro("Error setting 'offsetMC' in shader VAO.");
       }
     }
-
     if (cellBO.getProgram().isUniformUsed('invertedDepth')) {
       cellBO.getProgram().setUniformf('invertedDepth', model.invert ? -1.0 : 1.0);
     }
-
     if (cellBO.getProgram().isUniformUsed('scaleFactor')) {
       // apply scaling factor only if a scale array has been provided.
-      var poly = model.currentInput;
-      var pointData = poly.getPointData();
-
+      const poly = model.currentInput;
+      const pointData = poly.getPointData();
       if (model.renderable.getScaleArray() != null && pointData.hasArray(model.renderable.getScaleArray())) {
         cellBO.getProgram().setUniformf('scaleFactor', model.renderable.getScaleFactor());
       } else {
         cellBO.getProgram().setUniformf('scaleFactor', 1.0);
       }
     }
-
     superClass.setMapperShaderParameters(cellBO, ren, actor);
   };
-
-  publicAPI.setCameraShaderParameters = function (cellBO, ren, actor) {
-    var program = cellBO.getProgram();
-    var cam = ren.getActiveCamera();
-    var keyMats = model.openGLCamera.getKeyMatrices(ren);
-
+  publicAPI.setCameraShaderParameters = (cellBO, ren, actor) => {
+    const program = cellBO.getProgram();
+    const cam = ren.getActiveCamera();
+    const keyMats = model.openGLCamera.getKeyMatrices(ren);
     if (program.isUniformUsed('VCPCMatrix')) {
       program.setUniformMatrix('VCPCMatrix', keyMats.vcpc);
     }
-
     if (program.isUniformUsed('MCVCMatrix')) {
       if (!actor.getIsIdentity()) {
-        var actMats = model.openGLActor.getKeyMatrices();
-        var tmp4 = new Float64Array(16);
+        const actMats = model.openGLActor.getKeyMatrices();
+        const tmp4 = new Float64Array(16);
         mat4.multiply(tmp4, keyMats.wcvc, actMats.mcwc);
         program.setUniformMatrix('MCVCMatrix', tmp4);
       } else {
         program.setUniformMatrix('MCVCMatrix', keyMats.wcvc);
       }
     }
-
     if (program.isUniformUsed('cameraParallel')) {
       cellBO.getProgram().setUniformi('cameraParallel', cam.getParallelProjection());
     }
   };
-
-  publicAPI.getOpenGLMode = function (rep, type) {
-    return model.context.TRIANGLES;
-  };
-
-  publicAPI.buildBufferObjects = function (ren, actor) {
-    var poly = model.currentInput;
-
+  publicAPI.getOpenGLMode = (rep, type) => model.context.TRIANGLES;
+  publicAPI.buildBufferObjects = (ren, actor) => {
+    const poly = model.currentInput;
     if (poly === null) {
       return;
     }
-
     model.renderable.mapScalars(poly, 1.0);
-    var c = model.renderable.getColorMapColors();
-    var vbo = model.primitives[model.primTypes.Tris].getCABO();
-    var pointData = poly.getPointData();
-    var points = poly.getPoints();
-    var numPoints = points.getNumberOfPoints();
-    var pointArray = points.getData();
-    var pointSize = 5; // x,y,z,orientation1,orientation2
-
-    var scales = null;
-
+    const c = model.renderable.getColorMapColors();
+    const vbo = model.primitives[model.primTypes.Tris].getCABO();
+    const pointData = poly.getPointData();
+    const points = poly.getPoints();
+    const numPoints = points.getNumberOfPoints();
+    const pointArray = points.getData();
+    const pointSize = 5; // x,y,z,orientation1,orientation2
+    let scales = null;
     if (model.renderable.getScaleArray() != null && pointData.hasArray(model.renderable.getScaleArray())) {
       scales = pointData.getArray(model.renderable.getScaleArray()).getData();
     }
-
-    var colorData = null;
-    var colorComponents = 0;
-    var packedUCVBO = null;
-
+    let colorData = null;
+    let colorComponents = 0;
+    let packedUCVBO = null;
     if (c) {
       colorComponents = c.getNumberOfComponents();
       vbo.setColorOffset(0);
       vbo.setColorBOStride(4);
       colorData = c.getData();
       packedUCVBO = new Uint8Array(3 * numPoints * 4);
-
       if (!vbo.getColorBO()) {
         vbo.setColorBO(vtkBufferObject.newInstance());
       }
-
       vbo.getColorBO().setOpenGLRenderWindow(model._openGLRenderWindow);
     } else if (vbo.getColorBO()) {
       vbo.setColorBO(null);
     }
-
     vbo.setColorComponents(colorComponents);
-    var packedVBO = new Float32Array(pointSize * numPoints * 3);
+    const packedVBO = new Float32Array(pointSize * numPoints * 3);
     vbo.setStride(pointSize * 4);
-    var cos30 = Math.cos(radiansFromDegrees(30.0));
-    var pointIdx = 0;
-    var colorIdx = 0; //
+    const cos30 = Math.cos(radiansFromDegrees(30.0));
+    let pointIdx = 0;
+    let colorIdx = 0;
+
+    //
     // Generate points and point data for sides
     //
-
-    var vboIdx = 0;
-    var ucIdx = 0;
-
-    for (var i = 0; i < numPoints; ++i) {
-      var radius = model.renderable.getRadius();
-
+    let vboIdx = 0;
+    let ucIdx = 0;
+    for (let i = 0; i < numPoints; ++i) {
+      let radius = model.renderable.getRadius();
       if (scales) {
         radius = scales[i];
       }
-
       pointIdx = i * 3;
       packedVBO[vboIdx++] = pointArray[pointIdx++];
       packedVBO[vboIdx++] = pointArray[pointIdx++];
       packedVBO[vboIdx++] = pointArray[pointIdx++];
       packedVBO[vboIdx++] = -2.0 * radius * cos30;
       packedVBO[vboIdx++] = -radius;
-
       if (colorData) {
         colorIdx = i * colorComponents;
         packedUCVBO[ucIdx++] = colorData[colorIdx];
@@ -207,28 +190,24 @@ function vtkOpenGLSphereMapper(publicAPI, model) {
         packedUCVBO[ucIdx++] = colorData[colorIdx + 2];
         packedUCVBO[ucIdx++] = colorData[colorIdx + 3];
       }
-
       pointIdx = i * 3;
       packedVBO[vboIdx++] = pointArray[pointIdx++];
       packedVBO[vboIdx++] = pointArray[pointIdx++];
       packedVBO[vboIdx++] = pointArray[pointIdx++];
       packedVBO[vboIdx++] = 2.0 * radius * cos30;
       packedVBO[vboIdx++] = -radius;
-
       if (colorData) {
         packedUCVBO[ucIdx++] = colorData[colorIdx];
         packedUCVBO[ucIdx++] = colorData[colorIdx + 1];
         packedUCVBO[ucIdx++] = colorData[colorIdx + 2];
         packedUCVBO[ucIdx++] = colorData[colorIdx + 3];
       }
-
       pointIdx = i * 3;
       packedVBO[vboIdx++] = pointArray[pointIdx++];
       packedVBO[vboIdx++] = pointArray[pointIdx++];
       packedVBO[vboIdx++] = pointArray[pointIdx++];
       packedVBO[vboIdx++] = 0.0;
       packedVBO[vboIdx++] = 2.0 * radius;
-
       if (colorData) {
         packedUCVBO[ucIdx++] = colorData[colorIdx];
         packedUCVBO[ucIdx++] = colorData[colorIdx + 1];
@@ -236,39 +215,46 @@ function vtkOpenGLSphereMapper(publicAPI, model) {
         packedUCVBO[ucIdx++] = colorData[colorIdx + 3];
       }
     }
-
     vbo.setElementCount(vboIdx / pointSize);
     vbo.upload(packedVBO, ObjectType.ARRAY_BUFFER);
-
     if (c) {
       vbo.getColorBO().upload(packedUCVBO, ObjectType.ARRAY_BUFFER);
     }
-
     model.VBOBuildTime.modified();
   };
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // 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);
 
-  vtkOpenGLPolyDataMapper.extend(publicAPI, model, initialValues); // Object methods
+  // Inheritance
+  vtkOpenGLPolyDataMapper.extend(publicAPI, model, initialValues);
 
+  // Object methods
   vtkOpenGLSphereMapper(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
+
+const newInstance = newInstance$1(extend, 'vtkOpenGLSphereMapper');
 
-var newInstance = newInstance$1(extend, 'vtkOpenGLSphereMapper'); // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
 
 var vtkSphereMapper = {
-  newInstance: newInstance,
-  extend: extend
-}; // Register ourself to OpenGL backend if imported
+  newInstance,
+  extend
+};
 
+// Register ourself to OpenGL backend if imported
 registerOverride('vtkSphereMapper', newInstance);
 
 export { vtkSphereMapper as default, extend, newInstance };