@kitware/vtk.js 28.10.1 → 28.11.0

package/Rendering/OpenGL/RadialDistortionPass.js

@@ -1,4 +1,4 @@
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.js';
 import vtkDataArray from '../../Common/Core/DataArray.js';
 import vtkHelper from './Helper.js';
 import vtkOpenGLFramebuffer from './Framebuffer.js';
@@ -6,175 +6,164 @@ import vtkRenderPass from '../SceneGraph/RenderPass.js';
 import vtkVertexArrayObject from './VertexArrayObject.js';
 import { Representation } from '../Core/Property/Constants.js';
 
-var vtkErrorMacro = macro.vtkErrorMacro; // ----------------------------------------------------------------------------
+const {
+  vtkErrorMacro
+} = macro;
+
+// ----------------------------------------------------------------------------
 
 function vtkRadialDistortionPass(publicAPI, model) {
   // Set our className
-  model.classHierarchy.push('vtkRadialDistortionPass'); // handles radial distortion and calll delegate
+  model.classHierarchy.push('vtkRadialDistortionPass');
 
+  // handles radial distortion and calll delegate
   publicAPI.traverse = function (viewNode) {
-
     if (model.deleted) {
       return;
-    } // if values are zero then we are a no-op
-
+    }
 
+    // if values are zero then we are a no-op
     if (model.k1 === 0.0 && model.k2 === 0.0) {
-      model.delegates.forEach(function (val) {
+      model.delegates.forEach(val => {
         val.traverse(viewNode, publicAPI);
       });
       return;
-    } // allocate framebuffer if needed and bind it
-
+    }
 
+    // allocate framebuffer if needed and bind it
     if (model.framebuffer === null) {
       model.framebuffer = vtkOpenGLFramebuffer.newInstance();
-    } // rebuild vbo if needed
-
+    }
 
+    // rebuild vbo if needed
     if (model.VBOBuildTime.getMTime() < publicAPI.getMTime()) {
       model.tris.setOpenGLRenderWindow(viewNode);
       publicAPI.buildVBO();
     }
-
-    var size = viewNode.getSize();
+    const size = viewNode.getSize();
     model.framebuffer.setOpenGLRenderWindow(viewNode);
     model.framebuffer.saveCurrentBindingsAndBuffers();
-    var fbSize = model.framebuffer.getSize();
-    var targetSize = [model.renderRatio * size[0], model.renderRatio * size[1]];
-
+    const fbSize = model.framebuffer.getSize();
+    const targetSize = [model.renderRatio * size[0], model.renderRatio * size[1]];
     if (fbSize === null || fbSize[0] !== targetSize[0] || fbSize[1] !== targetSize[1]) {
       model.framebuffer.create(targetSize[0], targetSize[1]);
       model.framebuffer.populateFramebuffer();
     }
-
     model.framebuffer.bind();
-    model.delegates.forEach(function (val) {
+    model.delegates.forEach(val => {
       val.traverse(viewNode, publicAPI);
-    }); // now draw the distorted values
+    });
 
+    // now draw the distorted values
     model.framebuffer.restorePreviousBindingsAndBuffers();
-    var gl = viewNode.getContext();
-
+    const gl = viewNode.getContext();
     if (model.copyShader === null) {
       model.copyShader = viewNode.getShaderCache().readyShaderProgramArray(['//VTK::System::Dec', 'attribute vec4 vertexDC;', 'attribute vec2 tcoordTC;', 'varying vec2 tcoord;', 'void main() { tcoord = tcoordTC; gl_Position = vertexDC; }'].join('\n'), ['//VTK::System::Dec', '//VTK::Output::Dec', 'uniform sampler2D distTexture;', 'varying vec2 tcoord;', 'void main() { gl_FragData[0] = texture2D(distTexture,tcoord); }'].join('\n'), '');
-      var program = model.copyShader;
+      const program = model.copyShader;
       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.copyShader);
     }
-
     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.copyShader.setUniformi('distTexture', tex.getTextureUnit()); // render quad
+    model.copyShader.setUniformi('distTexture', tex.getTextureUnit());
 
+    // render quad
     gl.drawArrays(gl.TRIANGLES, 0, model.tris.getCABO().getElementCount());
     tex.deactivate();
   };
-
-  publicAPI.buildVBO = function () {
-    var xdim = 20;
-    var xtotal = xdim * 2;
-    var ydim = 20;
-    var ptsArray = new Float32Array(3 * xtotal * ydim);
-    var tcoordArray = new Float32Array(2 * xtotal * ydim);
-    var count = 0;
+  publicAPI.buildVBO = () => {
+    const xdim = 20;
+    const xtotal = xdim * 2;
+    const ydim = 20;
+    const ptsArray = new Float32Array(3 * xtotal * ydim);
+    const tcoordArray = new Float32Array(2 * xtotal * ydim);
+    let count = 0;
     model.renderRatio = 1.0 + model.k1 + model.k2;
-    var shrink = 1.0 / model.renderRatio;
-
-    for (var y = 0; y < ydim; ++y) {
-      var yo = 2.0 * (y / (ydim - 1.0)) - 1.0;
-      var ydo = yo - model.cameraCenterY;
-
-      for (var x = 0; x < xdim; ++x) {
+    const shrink = 1.0 / model.renderRatio;
+    for (let y = 0; y < ydim; ++y) {
+      const yo = 2.0 * (y / (ydim - 1.0)) - 1.0;
+      const ydo = yo - model.cameraCenterY;
+      for (let x = 0; x < xdim; ++x) {
         ptsArray[count * 3] = x / (xdim - 1.0) - 1.0;
         ptsArray[count * 3 + 1] = yo;
         ptsArray[count * 3 + 2] = -1.0;
-        var xo = 2.0 * (x / (xdim - 1.0)) - 1.0;
-        var xdo = xo - model.cameraCenterX1;
-        var ro = Math.sqrt(xdo * xdo + ydo * ydo);
-        var rf = shrink * (1 + ro * ro * (model.k1 + ro * ro * model.k2));
+        const xo = 2.0 * (x / (xdim - 1.0)) - 1.0;
+        const xdo = xo - model.cameraCenterX1;
+        const ro = Math.sqrt(xdo * xdo + ydo * ydo);
+        const rf = shrink * (1 + ro * ro * (model.k1 + ro * ro * model.k2));
         tcoordArray[count * 2] = 0.25 + 0.25 * (xdo * rf + model.cameraCenterX1);
         tcoordArray[count * 2 + 1] = 0.5 + 0.5 * (ydo * rf + model.cameraCenterY);
         count++;
       }
-
-      for (var _x = 0; _x < xdim; ++_x) {
-        ptsArray[count * 3] = _x / (xdim - 1.0);
+      for (let x = 0; x < xdim; ++x) {
+        ptsArray[count * 3] = x / (xdim - 1.0);
         ptsArray[count * 3 + 1] = yo;
         ptsArray[count * 3 + 2] = -1.0;
-
-        var _xo = 2.0 * (_x / (xdim - 1.0)) - 1.0;
-
-        var _xdo = _xo - model.cameraCenterX2;
-
-        var _ro = Math.sqrt(_xdo * _xdo + ydo * ydo);
-
-        var _rf = shrink * (1 + _ro * _ro * (model.k1 + _ro * _ro * model.k2));
-
-        tcoordArray[count * 2] = 0.75 + 0.25 * (_xdo * _rf + model.cameraCenterX2);
-        tcoordArray[count * 2 + 1] = 0.5 + 0.5 * (ydo * _rf + model.cameraCenterY);
+        const xo = 2.0 * (x / (xdim - 1.0)) - 1.0;
+        const xdo = xo - model.cameraCenterX2;
+        const ro = Math.sqrt(xdo * xdo + ydo * ydo);
+        const rf = shrink * (1 + ro * ro * (model.k1 + ro * ro * model.k2));
+        tcoordArray[count * 2] = 0.75 + 0.25 * (xdo * rf + model.cameraCenterX2);
+        tcoordArray[count * 2 + 1] = 0.5 + 0.5 * (ydo * rf + model.cameraCenterY);
         count++;
       }
     }
-
-    var cellArray = new Uint16Array((xtotal - 1) * (ydim - 1) * 2 * 4);
+    const cellArray = new Uint16Array((xtotal - 1) * (ydim - 1) * 2 * 4);
     count = 0;
-
-    for (var _y = 0; _y < ydim - 1; ++_y) {
-      for (var _x2 = 0; _x2 < xtotal - 1; ++_x2) {
+    for (let y = 0; y < ydim - 1; ++y) {
+      for (let x = 0; x < xtotal - 1; ++x) {
         cellArray[count] = 3;
-        cellArray[count + 1] = _x2 + _y * xtotal;
-        cellArray[count + 2] = _x2 + _y * xtotal + 1;
-        cellArray[count + 3] = _x2 + (_y + 1) * xtotal + 1;
+        cellArray[count + 1] = x + y * xtotal;
+        cellArray[count + 2] = x + y * xtotal + 1;
+        cellArray[count + 3] = x + (y + 1) * xtotal + 1;
         cellArray[count + 4] = 3;
-        cellArray[count + 5] = _x2 + _y * xtotal;
-        cellArray[count + 6] = _x2 + (_y + 1) * xtotal + 1;
-        cellArray[count + 7] = _x2 + (_y + 1) * xtotal;
+        cellArray[count + 5] = x + y * xtotal;
+        cellArray[count + 6] = x + (y + 1) * xtotal + 1;
+        cellArray[count + 7] = x + (y + 1) * xtotal;
         count += 8;
       }
     }
-
-    var points = vtkDataArray.newInstance({
+    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 = {
   copyShader: null,
   framebuffer: null,
   tris: null,
@@ -184,12 +173,15 @@ var DEFAULT_VALUES = {
   cameraCenterX2: 0.0,
   cameraCenterY: 0.0,
   renderRatio: 2.0
-}; // ----------------------------------------------------------------------------
+};
+
+// ----------------------------------------------------------------------------
 
 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, {
@@ -197,16 +189,21 @@ function extend(publicAPI, model) {
   });
   model.tris = vtkHelper.newInstance();
   macro.setGet(publicAPI, model, ['k1', 'k2', 'cameraCenterY', 'cameraCenterX1', 'cameraCenterX2']);
-  macro.get(publicAPI, model, ['framebuffer']); // Object methods
+  macro.get(publicAPI, model, ['framebuffer']);
 
+  // Object methods
   vtkRadialDistortionPass(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 
-var newInstance = macro.newInstance(extend, 'vtkRadialDistortionPass'); // ----------------------------------------------------------------------------
+const newInstance = macro.newInstance(extend, 'vtkRadialDistortionPass');
+
+// ----------------------------------------------------------------------------
 
 var index = {
-  newInstance: newInstance,
-  extend: extend
+  newInstance,
+  extend
 };
 
 export { index as default, extend, newInstance };

package/Rendering/OpenGL/RenderWindow/Constants.js

@@ -1,4 +1,4 @@
-var XrSessionTypes = {
+const XrSessionTypes = {
   HmdVR: 0,
   // Head-mounted display (HMD), two-camera virtual reality session
   MobileAR: 1,
@@ -8,7 +8,7 @@ var XrSessionTypes = {
   HmdAR: 3
 };
 var Constants = {
-  XrSessionTypes: XrSessionTypes
+  XrSessionTypes
 };
 
 export { XrSessionTypes, Constants as default };

package/Rendering/OpenGL/RenderWindow/ContextProxy.js

@@ -1,25 +1,27 @@
 // This is used to access the underlying 3D context
-var GET_UNDERLYING_CONTEXT = '__getUnderlyingContext';
+const GET_UNDERLYING_CONTEXT = '__getUnderlyingContext';
 function createContextProxyHandler() {
-  var cache = new Map();
-  var getParameterHandler = {
-    apply: function apply(target, gl, args) {
+  const cache = new Map();
+  const getParameterHandler = {
+    apply(target, gl, args) {
       if (cache.has(args[0])) {
         return cache.get(args[0]);
       }
-
       return target.apply(gl, args);
     }
-  }; // only supports single-value setters
+  };
 
+  // only supports single-value setters
   function cachedSetterHandler(key) {
     return {
-      apply: function apply(target, gl, args) {
+      apply(target, gl, args) {
         cache.set(key, args[0]);
         return target.apply(gl, args);
       }
     };
-  } // When a property is accessed on the webgl context proxy,
+  }
+
+  // When a property is accessed on the webgl context proxy,
   // it's accessed is intercepted. If the property name matches
   // any of the keys of `propHandlers`, then that handler is called
   // with the following arguments: (gl, prop, receiver, propValue)
@@ -28,43 +30,32 @@ function createContextProxyHandler() {
   // - receiver (Proxy): the webgl context proxy
   // - propValue (unknown): the value of `gl[propName]`
 
+  const propHandlers = Object.create(null);
 
-  var propHandlers = Object.create(null); // Sets getParameter(property) as a cached getter proxy.
+  // Sets getParameter(property) as a cached getter proxy.
   // propValue.bind(gl) is to avoid Illegal Invocation errors.
+  propHandlers.getParameter = (gl, prop, receiver, propValue) => new Proxy(propValue.bind(gl), getParameterHandler);
 
-  propHandlers.getParameter = function (gl, prop, receiver, propValue) {
-    return new Proxy(propValue.bind(gl), getParameterHandler);
-  }; // Sets depthMask(flag) as a cached setter proxy.
-
-
-  propHandlers.depthMask = function (gl, prop, receiver, propValue) {
-    return new Proxy(propValue.bind(gl), cachedSetterHandler(gl.DEPTH_WRITEMASK));
-  };
-
+  // Sets depthMask(flag) as a cached setter proxy.
+  propHandlers.depthMask = (gl, prop, receiver, propValue) => new Proxy(propValue.bind(gl), cachedSetterHandler(gl.DEPTH_WRITEMASK));
   return {
-    get: function get(gl, prop, receiver) {
-      if (prop === GET_UNDERLYING_CONTEXT) return function () {
-        return gl;
-      };
-      var value = Reflect.get(gl, prop, gl);
-
+    get(gl, prop, receiver) {
+      if (prop === GET_UNDERLYING_CONTEXT) return () => gl;
+      let value = Reflect.get(gl, prop, gl);
       if (value instanceof Function) {
         // prevents Illegal Invocation errors
         value = value.bind(gl);
       }
-
-      var propHandler = propHandlers[prop];
-
+      const propHandler = propHandlers[prop];
       if (propHandler) {
         return propHandler(gl, prop, receiver, value);
       }
-
       return value;
     }
   };
 }
 var ContextProxy = {
-  createContextProxyHandler: createContextProxyHandler
+  createContextProxyHandler
 };
 
 export { GET_UNDERLYING_CONTEXT, createContextProxyHandler, ContextProxy as default };