@kitware/vtk.js 28.10.2 → 28.11.0

package/Rendering/OpenGL/Glyph3DMapper.js

@@ -1,6 +1,5 @@
-import _defineProperty from '@babel/runtime/helpers/defineProperty';
 import { mat3, mat4 } from 'gl-matrix';
-import { newInstance as newInstance$1, obj, vtkErrorMacro as vtkErrorMacro$1 } from '../../macros.js';
+import { n as newInstance$1, o as obj, c as macro } from '../../macros2.js';
 import vtkBufferObject from './BufferObject.js';
 import vtkHardwareSelector from './HardwareSelector.js';
 import vtkProperty from '../Core/Property.js';
@@ -8,104 +7,105 @@ import vtkOpenGLPolyDataMapper from './PolyDataMapper.js';
 import vtkShaderProgram from './ShaderProgram.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; }
-
-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;
-var Representation = vtkProperty.Representation;
-var ObjectType = vtkBufferObject.ObjectType;
-var PassTypes = vtkHardwareSelector.PassTypes;
-var StartEvent = {
+const {
+  vtkErrorMacro
+} = macro;
+const {
+  Representation
+} = vtkProperty;
+const {
+  ObjectType
+} = vtkBufferObject;
+const {
+  PassTypes
+} = vtkHardwareSelector;
+const StartEvent = {
   type: 'StartEvent'
 };
-var EndEvent = {
+const EndEvent = {
   type: 'EndEvent'
-}; // ----------------------------------------------------------------------------
+};
+
+// ----------------------------------------------------------------------------
 // vtkOpenGLSphereMapper methods
 // ----------------------------------------------------------------------------
 
 function vtkOpenGLGlyph3DMapper(publicAPI, model) {
   // Set our className
-  model.classHierarchy.push('vtkOpenGLGlyph3DMapper'); // Capture 'parentClass' api for internal use
-
-  var superClass = _objectSpread({}, publicAPI);
+  model.classHierarchy.push('vtkOpenGLGlyph3DMapper');
 
-  publicAPI.renderPiece = function (ren, actor) {
+  // Capture 'parentClass' api for internal use
+  const superClass = {
+    ...publicAPI
+  };
+  publicAPI.renderPiece = (ren, actor) => {
     publicAPI.invokeEvent(StartEvent);
-
     if (!model.renderable.getStatic()) {
       model.renderable.update();
     }
-
     model.currentInput = model.renderable.getInputData(1);
     publicAPI.invokeEvent(EndEvent);
-
     if (!model.currentInput) {
       vtkErrorMacro('No input!');
       return;
-    } // if there are no points then we are done
-
+    }
 
+    // if there are no points then we are done
     if (!model.currentInput.getPoints || !model.currentInput.getPoints().getNumberOfValues()) {
       return;
-    } // apply faceCulling
-
-
-    var gl = model.context;
+    }
 
+    // apply faceCulling
+    const gl = model.context;
     if (model._openGLRenderWindow.getWebgl2()) {
       model.hardwareSupport = true;
       model.extension = null;
     } else if (!model.extension) {
       model.extension = model.context.getExtension('ANGLE_instanced_arrays');
       model.hardwareSupport = !!model.extension;
-    } // to test without extension support uncomment the next two lines
+    }
+    // to test without extension support uncomment the next two lines
     // model.extension = null;
     // model.hardwareSupport = !!model.extension;
 
-
-    var backfaceCulling = actor.getProperty().getBackfaceCulling();
-    var frontfaceCulling = actor.getProperty().getFrontfaceCulling();
-
+    const backfaceCulling = actor.getProperty().getBackfaceCulling();
+    const frontfaceCulling = actor.getProperty().getFrontfaceCulling();
     if (!backfaceCulling && !frontfaceCulling) {
       model._openGLRenderWindow.disableCullFace();
     } else if (frontfaceCulling) {
       model._openGLRenderWindow.enableCullFace();
-
       gl.cullFace(gl.FRONT);
     } else {
       model._openGLRenderWindow.enableCullFace();
-
       gl.cullFace(gl.BACK);
     }
-
     publicAPI.renderPieceStart(ren, actor);
     publicAPI.renderPieceDraw(ren, actor);
     publicAPI.renderPieceFinish(ren, actor);
   };
-
-  publicAPI.multiply4x4WithOffset = function (out, a, b, off) {
-    var a00 = a[0];
-    var a01 = a[1];
-    var a02 = a[2];
-    var a03 = a[3];
-    var a10 = a[4];
-    var a11 = a[5];
-    var a12 = a[6];
-    var a13 = a[7];
-    var a20 = a[8];
-    var a21 = a[9];
-    var a22 = a[10];
-    var a23 = a[11];
-    var a30 = a[12];
-    var a31 = a[13];
-    var a32 = a[14];
-    var a33 = a[15]; // Cache only the current line of the second matrix
-
-    var b0 = b[off];
-    var b1 = b[off + 1];
-    var b2 = b[off + 2];
-    var b3 = b[off + 3];
+  publicAPI.multiply4x4WithOffset = (out, a, b, off) => {
+    const a00 = a[0];
+    const a01 = a[1];
+    const a02 = a[2];
+    const a03 = a[3];
+    const a10 = a[4];
+    const a11 = a[5];
+    const a12 = a[6];
+    const a13 = a[7];
+    const a20 = a[8];
+    const a21 = a[9];
+    const a22 = a[10];
+    const a23 = a[11];
+    const a30 = a[12];
+    const a31 = a[13];
+    const a32 = a[14];
+    const a33 = a[15];
+
+    // Cache only the current line of the second matrix
+    let b0 = b[off];
+    let b1 = b[off + 1];
+    let b2 = b[off + 2];
+    let b3 = b[off + 3];
     out[0] = b0 * a00 + b1 * a10 + b2 * a20 + b3 * a30;
     out[1] = b0 * a01 + b1 * a11 + b2 * a21 + b3 * a31;
     out[2] = b0 * a02 + b1 * a12 + b2 * a22 + b3 * a32;
@@ -135,55 +135,46 @@ function vtkOpenGLGlyph3DMapper(publicAPI, model) {
     out[14] = b0 * a02 + b1 * a12 + b2 * a22 + b3 * a32;
     out[15] = b0 * a03 + b1 * a13 + b2 * a23 + b3 * a33;
   };
-
-  publicAPI.replaceShaderNormal = function (shaders, ren, actor) {
+  publicAPI.replaceShaderNormal = (shaders, ren, actor) => {
     if (model.hardwareSupport) {
-      var lastLightComplexity = model.lastBoundBO.getReferenceByName('lastLightComplexity');
-
+      const lastLightComplexity = model.lastBoundBO.getReferenceByName('lastLightComplexity');
       if (lastLightComplexity > 0) {
-        var VSSource = shaders.Vertex;
-
+        let VSSource = shaders.Vertex;
         if (model.lastBoundBO.getCABO().getNormalOffset()) {
           VSSource = vtkShaderProgram.substitute(VSSource, '//VTK::Normal::Dec', ['attribute vec3 normalMC;', 'attribute mat3 gNormal;', 'uniform mat3 normalMatrix;', 'varying vec3 normalVCVSOutput;']).result;
           VSSource = vtkShaderProgram.substitute(VSSource, '//VTK::Normal::Impl', ['normalVCVSOutput = normalMatrix * gNormal * normalMC;']).result;
         }
-
         shaders.Vertex = VSSource;
       }
     }
-
     superClass.replaceShaderNormal(shaders, ren, actor);
   };
-
-  publicAPI.replaceShaderColor = function (shaders, ren, actor) {
+  publicAPI.replaceShaderColor = (shaders, ren, actor) => {
     if (model.hardwareSupport && model.renderable.getColorArray()) {
-      var VSSource = shaders.Vertex;
-      var GSSource = shaders.Geometry;
-      var FSSource = shaders.Fragment;
-      var lastLightComplexity = model.lastBoundBO.getReferenceByName('lastLightComplexity'); // create the material/color property declarations, and VS implementation
-      // these are always defined
-
-      var colorDec = ['uniform float ambient;', 'uniform float diffuse;', 'uniform float specular;', 'uniform float opacityUniform; // the fragment opacity']; // add more for specular
+      let VSSource = shaders.Vertex;
+      let GSSource = shaders.Geometry;
+      let FSSource = shaders.Fragment;
+      const lastLightComplexity = model.lastBoundBO.getReferenceByName('lastLightComplexity');
 
+      // create the material/color property declarations, and VS implementation
+      // these are always defined
+      let colorDec = ['uniform float ambient;', 'uniform float diffuse;', 'uniform float specular;', 'uniform float opacityUniform; // the fragment opacity'];
+      // add more for specular
       if (lastLightComplexity) {
         colorDec = colorDec.concat(['uniform vec3 specularColorUniform;', 'uniform float specularPowerUniform;']);
-      } // now handle the more complex fragment shader implementation
+      }
+
+      // now handle the more complex fragment shader implementation
       // the following are always defined variables.  We start
       // by assigning a default value from the uniform
-
-
-      var colorImpl = ['vec3 ambientColor;', '  vec3 diffuseColor;', '  float opacity;'];
-
+      let colorImpl = ['vec3 ambientColor;', '  vec3 diffuseColor;', '  float opacity;'];
       if (lastLightComplexity) {
         colorImpl = colorImpl.concat(['  vec3 specularColor;', '  float specularPower;']);
       }
-
       colorImpl = colorImpl.concat(['  opacity = opacityUniform;']);
-
       if (lastLightComplexity) {
         colorImpl = colorImpl.concat(['  specularColor = specularColorUniform;', '  specularPower = specularPowerUniform;']);
       }
-
       if (!model.drawingEdges) {
         colorDec = colorDec.concat(['varying vec4 vertexColorVSOutput;']);
         VSSource = vtkShaderProgram.substitute(VSSource, '//VTK::Color::Dec', ['attribute vec4 gColor;', 'varying vec4 vertexColorVSOutput;']).result;
@@ -192,23 +183,20 @@ function vtkOpenGLGlyph3DMapper(publicAPI, model) {
         GSSource = vtkShaderProgram.substitute(GSSource, '//VTK::Color::Impl', ['vertexColorGSOutput = vertexColorVSOutput[i];']).result;
         colorImpl = colorImpl.concat(['  diffuseColor = vertexColorVSOutput.rgb;', '  ambientColor = vertexColorVSOutput.rgb;', '  opacity = opacity*vertexColorVSOutput.a;']);
       }
-
       FSSource = vtkShaderProgram.substitute(FSSource, '//VTK::Color::Impl', colorImpl).result;
       FSSource = vtkShaderProgram.substitute(FSSource, '//VTK::Color::Dec', colorDec).result;
       shaders.Vertex = VSSource;
       shaders.Geometry = GSSource;
       shaders.Fragment = FSSource;
     }
-
     superClass.replaceShaderColor(shaders, ren, actor);
   };
-
-  publicAPI.replaceShaderPositionVC = function (shaders, ren, actor) {
+  publicAPI.replaceShaderPositionVC = (shaders, ren, actor) => {
     if (model.hardwareSupport) {
-      var VSSource = shaders.Vertex; // do we need the vertex in the shader in View Coordinates
-
-      var lastLightComplexity = model.lastBoundBO.getReferenceByName('lastLightComplexity');
+      let VSSource = shaders.Vertex;
 
+      // do we need the vertex in the shader in View Coordinates
+      const lastLightComplexity = model.lastBoundBO.getReferenceByName('lastLightComplexity');
       if (lastLightComplexity > 0) {
         VSSource = vtkShaderProgram.substitute(VSSource, '//VTK::PositionVC::Impl', ['vec4 gVertexMC = gMatrix * vertexMC;', 'vertexVCVSOutput = MCVCMatrix * gVertexMC;', '  gl_Position = MCPCMatrix * gVertexMC;']).result;
         VSSource = vtkShaderProgram.substitute(VSSource, '//VTK::Camera::Dec', ['attribute mat4 gMatrix;', 'uniform mat4 MCPCMatrix;', 'uniform mat4 MCVCMatrix;']).result;
@@ -216,17 +204,14 @@ function vtkOpenGLGlyph3DMapper(publicAPI, model) {
         VSSource = vtkShaderProgram.substitute(VSSource, '//VTK::Camera::Dec', ['attribute mat4 gMatrix;', 'uniform mat4 MCPCMatrix;']).result;
         VSSource = vtkShaderProgram.substitute(VSSource, '//VTK::PositionVC::Impl', ['vec4 gVertexMC = gMatrix * vertexMC;', '  gl_Position = MCPCMatrix * gVertexMC;']).result;
       }
-
       shaders.Vertex = VSSource;
     }
-
     superClass.replaceShaderPositionVC(shaders, ren, actor);
   };
-
-  publicAPI.replaceShaderPicking = function (shaders, ren, actor) {
+  publicAPI.replaceShaderPicking = (shaders, ren, actor) => {
     if (model.hardwareSupport) {
-      var FSSource = shaders.Fragment;
-      var VSSource = shaders.Vertex;
+      let FSSource = shaders.Fragment;
+      let VSSource = shaders.Vertex;
       VSSource = vtkShaderProgram.substitute(VSSource, '//VTK::Picking::Dec', ['attribute vec3 mapperIndexVS;', 'varying vec3 mapperIndexVSOutput;']).result;
       VSSource = vtkShaderProgram.substitute(VSSource, '//VTK::Picking::Impl', '  mapperIndexVSOutput = mapperIndexVS;').result;
       shaders.Vertex = VSSource;
@@ -237,33 +222,31 @@ function vtkOpenGLGlyph3DMapper(publicAPI, model) {
       superClass.replaceShaderPicking(shaders, ren, actor);
     }
   };
-
-  publicAPI.updateGlyphShaderParameters = function (normalMatrixUsed, mcvcMatrixUsed, cellBO, carray, garray, narray, p, selector) {
-    var program = cellBO.getProgram();
-
+  publicAPI.updateGlyphShaderParameters = (normalMatrixUsed, mcvcMatrixUsed, cellBO, carray, garray, narray, p, selector) => {
+    const program = cellBO.getProgram();
     if (normalMatrixUsed) {
-      var a = model.normalMatrix;
-      var b = narray;
-      var ofs = p * 9;
-      var out = model.tmpMat3;
-      var a00 = a[0];
-      var a01 = a[1];
-      var a02 = a[2];
-      var a10 = a[3];
-      var a11 = a[4];
-      var a12 = a[5];
-      var a20 = a[6];
-      var a21 = a[7];
-      var a22 = a[8];
-      var b00 = b[ofs];
-      var b01 = b[ofs + 1];
-      var b02 = b[ofs + 2];
-      var b10 = b[ofs + 3];
-      var b11 = b[ofs + 4];
-      var b12 = b[ofs + 5];
-      var b20 = b[ofs + 6];
-      var b21 = b[ofs + 7];
-      var b22 = b[ofs + 8];
+      const a = model.normalMatrix;
+      const b = narray;
+      const ofs = p * 9;
+      const out = model.tmpMat3;
+      const a00 = a[0];
+      const a01 = a[1];
+      const a02 = a[2];
+      const a10 = a[3];
+      const a11 = a[4];
+      const a12 = a[5];
+      const a20 = a[6];
+      const a21 = a[7];
+      const a22 = a[8];
+      const b00 = b[ofs];
+      const b01 = b[ofs + 1];
+      const b02 = b[ofs + 2];
+      const b10 = b[ofs + 3];
+      const b11 = b[ofs + 4];
+      const b12 = b[ofs + 5];
+      const b20 = b[ofs + 6];
+      const b21 = b[ofs + 7];
+      const b22 = b[ofs + 8];
       out[0] = b00 * a00 + b01 * a10 + b02 * a20;
       out[1] = b00 * a01 + b01 * a11 + b02 * a21;
       out[2] = b00 * a02 + b01 * a12 + b02 * a22;
@@ -275,69 +258,64 @@ function vtkOpenGLGlyph3DMapper(publicAPI, model) {
       out[8] = b20 * a02 + b21 * a12 + b22 * a22;
       program.setUniformMatrix3x3('normalMatrix', model.tmpMat3);
     }
-
     publicAPI.multiply4x4WithOffset(model.tmpMat4, model.mcpcMatrix, garray, p * 16);
     program.setUniformMatrix('MCPCMatrix', model.tmpMat4);
-
     if (mcvcMatrixUsed) {
       publicAPI.multiply4x4WithOffset(model.tmpMat4, model.mcvcMatrix, garray, p * 16);
       program.setUniformMatrix('MCVCMatrix', model.tmpMat4);
-    } // set color
-
+    }
 
+    // set color
     if (carray) {
-      var cdata = carray.getData();
+      const cdata = carray.getData();
       model.tmpColor[0] = cdata[p * 4] / 255.0;
       model.tmpColor[1] = cdata[p * 4 + 1] / 255.0;
       model.tmpColor[2] = cdata[p * 4 + 2] / 255.0;
       program.setUniform3fArray('ambientColorUniform', model.tmpColor);
       program.setUniform3fArray('diffuseColorUniform', model.tmpColor);
     }
-
     if (selector) {
       program.setUniform3fArray('mapperIndex', selector.getPropColorValue());
     }
   };
+  publicAPI.renderPieceDraw = (ren, actor) => {
+    const representation = actor.getProperty().getRepresentation();
+    const gl = model.context;
+    const drawSurfaceWithEdges = actor.getProperty().getEdgeVisibility() && representation === Representation.SURFACE;
 
-  publicAPI.renderPieceDraw = function (ren, actor) {
-    var representation = actor.getProperty().getRepresentation();
-    var gl = model.context;
-    var drawSurfaceWithEdges = actor.getProperty().getEdgeVisibility() && representation === Representation.SURFACE; // [WMVP]C == {world, model, view, projection} coordinates
+    // [WMVP]C == {world, model, view, projection} coordinates
     // E.g., WCPC == world to projection coordinate transformation
+    const keyMats = model.openGLCamera.getKeyMatrices(ren);
+    const actMats = model.openGLActor.getKeyMatrices();
 
-    var keyMats = model.openGLCamera.getKeyMatrices(ren);
-    var actMats = model.openGLActor.getKeyMatrices(); // precompute the actor+camera mats once
-
+    // precompute the actor+camera mats once
     mat3.multiply(model.normalMatrix, keyMats.normalMatrix, actMats.normalMatrix);
     mat4.multiply(model.mcpcMatrix, keyMats.wcpc, actMats.mcwc);
     mat4.multiply(model.mcvcMatrix, keyMats.wcvc, actMats.mcwc);
-    var garray = model.renderable.getMatrixArray();
-    var narray = model.renderable.getNormalArray();
-    var carray = model.renderable.getColorArray();
-    var numPts = garray.length / 16;
-    var compositePass = false;
-
+    const garray = model.renderable.getMatrixArray();
+    const narray = model.renderable.getNormalArray();
+    const carray = model.renderable.getColorArray();
+    const numPts = garray.length / 16;
+    let compositePass = false;
     if (model._openGLRenderer.getSelector()) {
       if (model._openGLRenderer.getSelector().getCurrentPass() === PassTypes.COMPOSITE_INDEX_PASS) {
         compositePass = true;
       }
-    } // for every primitive type
-
+    }
 
-    for (var i = model.primTypes.Start; i < model.primTypes.End; i++) {
+    // for every primitive type
+    for (let i = model.primTypes.Start; i < model.primTypes.End; i++) {
       // if there are entries
-      var cabo = model.primitives[i].getCABO();
-
+      const cabo = model.primitives[i].getCABO();
       if (cabo.getElementCount()) {
         // are we drawing edges
         model.drawingEdges = drawSurfaceWithEdges && (i === model.primTypes.TrisEdges || i === model.primTypes.TriStripsEdges);
         model.lastBoundBO = model.primitives[i];
         model.primitives[i].updateShaders(ren, actor, publicAPI);
-        var program = model.primitives[i].getProgram();
-        var mode = model.primitives[i].getOpenGLMode(representation);
-        var normalMatrixUsed = program.isUniformUsed('normalMatrix');
-        var mcvcMatrixUsed = program.isUniformUsed('MCVCMatrix');
-
+        const program = model.primitives[i].getProgram();
+        const mode = model.primitives[i].getOpenGLMode(representation);
+        const normalMatrixUsed = program.isUniformUsed('normalMatrix');
+        const mcvcMatrixUsed = program.isUniformUsed('MCVCMatrix');
         if (model.hardwareSupport) {
           if (model.extension) {
             model.extension.drawArraysInstancedANGLE(mode, 0, cabo.getElementCount(), numPts);
@@ -346,11 +324,10 @@ function vtkOpenGLGlyph3DMapper(publicAPI, model) {
           }
         } else {
           // draw the array multiple times with different cam matrix
-          for (var p = 0; p < numPts; ++p) {
+          for (let p = 0; p < numPts; ++p) {
             if (compositePass) {
               model._openGLRenderer.getSelector().renderCompositeIndex(p);
             }
-
             publicAPI.updateGlyphShaderParameters(normalMatrixUsed, mcvcMatrixUsed, model.primitives[i], carray, garray, narray, p, compositePass ? model._openGLRenderer.getSelector() : null);
             gl.drawArrays(mode, 0, cabo.getElementCount());
           }
@@ -358,8 +335,7 @@ function vtkOpenGLGlyph3DMapper(publicAPI, model) {
       }
     }
   };
-
-  publicAPI.setMapperShaderParameters = function (cellBO, ren, actor) {
+  publicAPI.setMapperShaderParameters = (cellBO, ren, actor) => {
     if (cellBO.getCABO().getElementCount() && (model.glyphBOBuildTime.getMTime() > cellBO.getAttributeUpdateTime().getMTime() || cellBO.getShaderSourceTime().getMTime() > cellBO.getAttributeUpdateTime().getMTime())) {
       if (cellBO.getProgram().isAttributeUsed('gMatrix')) {
         if (!cellBO.getVAO().addAttributeMatrixWithDivisor(cellBO.getProgram(), model.matrixBuffer, 'gMatrix', 0, 64, model.context.FLOAT, 4, false, 1)) {
@@ -368,7 +344,6 @@ function vtkOpenGLGlyph3DMapper(publicAPI, model) {
       } else {
         cellBO.getVAO().removeAttributeArray('gMatrix');
       }
-
       if (cellBO.getProgram().isAttributeUsed('gNormal')) {
         if (!cellBO.getVAO().addAttributeMatrixWithDivisor(cellBO.getProgram(), model.normalBuffer, 'gNormal', 0, 36, model.context.FLOAT, 3, false, 1)) {
           vtkErrorMacro('Error setting gNormal in shader VAO.');
@@ -376,7 +351,6 @@ function vtkOpenGLGlyph3DMapper(publicAPI, model) {
       } else {
         cellBO.getVAO().removeAttributeArray('gNormal');
       }
-
       if (cellBO.getProgram().isAttributeUsed('gColor')) {
         if (!cellBO.getVAO().addAttributeArrayWithDivisor(cellBO.getProgram(), model.colorBuffer, 'gColor', 0, 4, model.context.UNSIGNED_BYTE, 4, true, 1, false)) {
           vtkErrorMacro('Error setting gColor in shader VAO.');
@@ -384,7 +358,6 @@ function vtkOpenGLGlyph3DMapper(publicAPI, model) {
       } else {
         cellBO.getVAO().removeAttributeArray('gColor');
       }
-
       if (cellBO.getProgram().isAttributeUsed('mapperIndexVS')) {
         if (!cellBO.getVAO().addAttributeArrayWithDivisor(cellBO.getProgram(), model.pickBuffer, 'mapperIndexVS', 0, 4, model.context.UNSIGNED_BYTE, 4, true, 1, false)) {
           vtkErrorMacro('Error setting mapperIndexVS in shader VAO.');
@@ -392,43 +365,35 @@ function vtkOpenGLGlyph3DMapper(publicAPI, model) {
       } else {
         cellBO.getVAO().removeAttributeArray('mapperIndexVS');
       }
-
       superClass.setMapperShaderParameters(cellBO, ren, actor);
       cellBO.getAttributeUpdateTime().modified();
       return;
     }
-
     superClass.setMapperShaderParameters(cellBO, ren, actor);
   };
+  publicAPI.getNeedToRebuildBufferObjects = (ren, actor) => {
+    model.renderable.buildArrays();
 
-  publicAPI.getNeedToRebuildBufferObjects = function (ren, actor) {
-    model.renderable.buildArrays(); // first do a coarse check
+    // first do a coarse check
     // Note that the actor's mtime includes it's properties mtime
-
-    var vmtime = model.VBOBuildTime.getMTime();
-
+    const vmtime = model.VBOBuildTime.getMTime();
     if (vmtime < model.renderable.getBuildTime().getMTime()) {
       return true;
     }
-
     return superClass.getNeedToRebuildBufferObjects(ren, actor);
   };
-
-  publicAPI.getNeedToRebuildShaders = function (cellBO, ren, actor) {
+  publicAPI.getNeedToRebuildShaders = (cellBO, ren, actor) => {
     if (superClass.getNeedToRebuildShaders(cellBO, ren, actor) || cellBO.getShaderSourceTime().getMTime() < model.renderable.getMTime() || cellBO.getShaderSourceTime().getMTime() < model.currentInput.getMTime()) {
       return true;
     }
-
     return false;
   };
-
-  publicAPI.buildBufferObjects = function (ren, actor) {
+  publicAPI.buildBufferObjects = (ren, actor) => {
     if (model.hardwareSupport) {
       // update the buffer objects if needed
-      var garray = model.renderable.getMatrixArray();
-      var narray = model.renderable.getNormalArray();
-      var carray = model.renderable.getColorArray();
-
+      const garray = model.renderable.getMatrixArray();
+      const narray = model.renderable.getNormalArray();
+      const carray = model.renderable.getColorArray();
       if (!model.matrixBuffer) {
         model.matrixBuffer = vtkBufferObject.newInstance();
         model.matrixBuffer.setOpenGLRenderWindow(model._openGLRenderWindow);
@@ -439,23 +404,19 @@ function vtkOpenGLGlyph3DMapper(publicAPI, model) {
         model.pickBuffer = vtkBufferObject.newInstance();
         model.pickBuffer.setOpenGLRenderWindow(model._openGLRenderWindow);
       }
-
       if (model.renderable.getBuildTime().getMTime() > model.glyphBOBuildTime.getMTime()) {
         model.matrixBuffer.upload(garray, ObjectType.ARRAY_BUFFER);
         model.normalBuffer.upload(narray, ObjectType.ARRAY_BUFFER);
-
         if (carray) {
           model.colorBuffer.upload(carray.getData(), ObjectType.ARRAY_BUFFER);
         } else {
           model.colorBuffer.releaseGraphicsResources();
         }
-
-        var numPts = garray.length / 16;
-        var parray = new Uint8Array(4 * numPts);
-
-        for (var i = 0; i < numPts; ++i) {
-          var value = i + 1;
-          var offset = i * 4;
+        const numPts = garray.length / 16;
+        const parray = new Uint8Array(4 * numPts);
+        for (let i = 0; i < numPts; ++i) {
+          let value = i + 1;
+          const offset = i * 4;
           parray[offset] = value % 256;
           value -= parray[offset];
           value /= 256;
@@ -465,29 +426,31 @@ function vtkOpenGLGlyph3DMapper(publicAPI, model) {
           parray[offset + 2] = value % 256;
           parray[offset + 3] = 255;
         }
-
         model.pickBuffer.upload(parray, ObjectType.ARRAY_BUFFER);
         model.glyphBOBuildTime.modified();
       }
     }
-
     return superClass.buildBufferObjects(ren, actor);
   };
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
-
-var DEFAULT_VALUES = {
+const DEFAULT_VALUES = {
   normalMatrix: null,
   mcpcMatrix: null,
   mcwcMatrix: 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
   vtkOpenGLPolyDataMapper.extend(publicAPI, model, initialValues);
   model.tmpMat3 = mat3.identity(new Float64Array(9));
   model.normalMatrix = mat3.identity(new Float64Array(9));
@@ -497,18 +460,24 @@ function extend(publicAPI, model) {
   model.glyphBOBuildTime = {};
   obj(model.glyphBOBuildTime, {
     mtime: 0
-  }); // Object methods
+  });
 
+  // Object methods
   vtkOpenGLGlyph3DMapper(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
 
-var newInstance = newInstance$1(extend, 'vtkOpenGLGlyph3DMapper'); // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+
+const newInstance = newInstance$1(extend, 'vtkOpenGLGlyph3DMapper');
+
+// ----------------------------------------------------------------------------
 
 var vtkGlyph3DMapper = {
-  newInstance: newInstance,
-  extend: extend
-}; // Register ourself to OpenGL backend if imported
+  newInstance,
+  extend
+};
 
+// Register ourself to OpenGL backend if imported
 registerOverride('vtkGlyph3DMapper', newInstance);
 
 export { vtkGlyph3DMapper as default, extend, newInstance };

package/Rendering/OpenGL/HardwareSelector/Constants.js

@@ -1,4 +1,4 @@
-var PassTypes = {
+const PassTypes = {
   MIN_KNOWN_PASS: 0,
   ACTOR_PASS: 0,
   COMPOSITE_INDEX_PASS: 1,
@@ -7,7 +7,7 @@ var PassTypes = {
   MAX_KNOWN_PASS: 3
 };
 var Constants = {
-  PassTypes: PassTypes
+  PassTypes
 };
 
 export { PassTypes, Constants as default };