@kitware/vtk.js 28.10.2 → 28.11.0

package/Rendering/OpenGL/Actor2D.js

@@ -1,39 +1,38 @@
-import { newInstance as newInstance$1, setGet, get } from '../../macros.js';
+import { n as newInstance$1, e as setGet, g as get } from '../../macros2.js';
 import vtkViewNode from '../SceneGraph/ViewNode.js';
 import { registerOverride } from './ViewNodeFactory.js';
 
+// ----------------------------------------------------------------------------
 // vtkOpenGLActor methods
 // ----------------------------------------------------------------------------
 
 function vtkOpenGLActor2D(publicAPI, model) {
   // Set our className
-  model.classHierarchy.push('vtkOpenGLActor2D'); // Builds myself.
+  model.classHierarchy.push('vtkOpenGLActor2D');
 
-  publicAPI.buildPass = function (prepass) {
+  // Builds myself.
+  publicAPI.buildPass = prepass => {
     if (prepass) {
       if (!model.renderable) {
         return;
       }
-
       model._openGLRenderWindow = publicAPI.getFirstAncestorOfType('vtkOpenGLRenderWindow');
       model._openGLRenderer = publicAPI.getFirstAncestorOfType('vtkOpenGLRenderer');
       model.context = model._openGLRenderWindow.getContext();
       publicAPI.prepareNodes();
       publicAPI.addMissingNodes(model.renderable.getTextures());
       publicAPI.addMissingNode(model.renderable.getMapper());
-      publicAPI.removeUnusedNodes(); // we store textures and mapper
+      publicAPI.removeUnusedNodes();
 
+      // we store textures and mapper
       model.ogltextures = null;
       model.activeTextures = null;
-
-      for (var index = 0; index < model.children.length; index++) {
-        var child = model.children[index];
-
+      for (let index = 0; index < model.children.length; index++) {
+        const child = model.children[index];
         if (child.isA('vtkOpenGLTexture')) {
           if (!model.ogltextures) {
             model.ogltextures = [];
           }
-
           model.ogltextures.push(child);
         } else {
           model.oglmapper = child;
@@ -41,133 +40,134 @@ function vtkOpenGLActor2D(publicAPI, model) {
       }
     }
   };
-
-  publicAPI.queryPass = function (prepass, renderPass) {
+  publicAPI.queryPass = (prepass, renderPass) => {
     if (prepass) {
       if (!model.renderable || !model.renderable.getVisibility()) {
         return;
       }
-
       renderPass.incrementOverlayActorCount();
     }
-  }; // we draw textures, then mapper, then post pass textures
-
+  };
 
-  publicAPI.traverseOpaquePass = function (renderPass) {
+  // we draw textures, then mapper, then post pass textures
+  publicAPI.traverseOpaquePass = renderPass => {
     if (!model.oglmapper || !model.renderable || !model.renderable.getNestedVisibility() || !model.renderable.getIsOpaque() || model._openGLRenderer.getSelector() && !model.renderable.getNestedPickable()) {
       return;
     }
-
     publicAPI.apply(renderPass, true);
     model.oglmapper.traverse(renderPass);
     publicAPI.apply(renderPass, false);
-  }; // we draw textures, then mapper, then post pass textures
-
+  };
 
-  publicAPI.traverseTranslucentPass = function (renderPass) {
+  // we draw textures, then mapper, then post pass textures
+  publicAPI.traverseTranslucentPass = renderPass => {
     if (!model.oglmapper || !model.renderable || !model.renderable.getNestedVisibility() || model.renderable.getIsOpaque() || model._openGLRenderer.getSelector() && !model.renderable.getNestedPickable()) {
       return;
     }
-
     publicAPI.apply(renderPass, true);
     model.oglmapper.traverse(renderPass);
     publicAPI.apply(renderPass, false);
   };
-
-  publicAPI.traverseOverlayPass = function (renderPass) {
+  publicAPI.traverseOverlayPass = renderPass => {
     if (!model.oglmapper || !model.renderable || !model.renderable.getNestedVisibility() || model._openGLRenderer.getSelector() && !model.renderable.getNestedPickable) {
       return;
     }
-
     publicAPI.apply(renderPass, true);
     model.oglmapper.traverse(renderPass);
     publicAPI.apply(renderPass, false);
   };
-
-  publicAPI.activateTextures = function () {
+  publicAPI.activateTextures = () => {
     // always traverse textures first, then mapper
     if (!model.ogltextures) {
       return;
     }
-
     model.activeTextures = [];
-
-    for (var index = 0; index < model.ogltextures.length; index++) {
-      var child = model.ogltextures[index];
+    for (let index = 0; index < model.ogltextures.length; index++) {
+      const child = model.ogltextures[index];
       child.render();
-
       if (child.getHandle()) {
         model.activeTextures.push(child);
       }
     }
-  }; // Renders myself
-
+  };
 
-  publicAPI.opaquePass = function (prepass, renderPass) {
+  // Renders myself
+  publicAPI.opaquePass = (prepass, renderPass) => {
     if (prepass) {
       model.context.depthMask(true);
       publicAPI.activateTextures();
     } else if (model.activeTextures) {
       // deactivate textures
-      for (var index = 0; index < model.activeTextures.length; index++) {
+      for (let index = 0; index < model.activeTextures.length; index++) {
         model.activeTextures[index].deactivate();
       }
     }
-  }; // Renders myself
-
+  };
 
-  publicAPI.translucentPass = function (prepass, renderPass) {
+  // Renders myself
+  publicAPI.translucentPass = (prepass, renderPass) => {
     if (prepass) {
       model.context.depthMask(false);
       publicAPI.activateTextures();
     } else if (model.activeTextures) {
-      for (var index = 0; index < model.activeTextures.length; index++) {
+      for (let index = 0; index < model.activeTextures.length; index++) {
         model.activeTextures[index].deactivate();
       }
     }
-  }; // Renders myself
-
+  };
 
-  publicAPI.overlayPass = function (prepass, renderPass) {
+  // Renders myself
+  publicAPI.overlayPass = (prepass, renderPass) => {
     if (prepass) {
       model.context.depthMask(true);
       publicAPI.activateTextures();
     } else if (model.activeTextures) {
       // deactivate textures
-      for (var index = 0; index < model.activeTextures.length; index++) {
+      for (let index = 0; index < model.activeTextures.length; index++) {
         model.activeTextures[index].deactivate();
       }
     }
   };
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
-
-var DEFAULT_VALUES = {
+const DEFAULT_VALUES = {
   context: null,
   activeTextures: 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);
 
-  vtkViewNode.extend(publicAPI, model, initialValues); // Build VTK API
+  // Inheritance
+  vtkViewNode.extend(publicAPI, model, initialValues);
 
+  // Build VTK API
   setGet(publicAPI, model, ['context']);
-  get(publicAPI, model, ['activeTextures']); // Object methods
+  get(publicAPI, model, ['activeTextures']);
 
+  // Object methods
   vtkOpenGLActor2D(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
 
-var newInstance = newInstance$1(extend); // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+
+const newInstance = newInstance$1(extend);
+
+// ----------------------------------------------------------------------------
 
 var vtkActor2D = {
-  newInstance: newInstance,
-  extend: extend
-}; // Register ourself to OpenGL backend if imported
+  newInstance,
+  extend
+};
 
+// Register ourself to OpenGL backend if imported
 registerOverride('vtkActor2D', newInstance);
 
 export { vtkActor2D as default, extend, newInstance };

package/Rendering/OpenGL/BufferObject/Constants.js

@@ -1,10 +1,10 @@
-var ObjectType = {
+const ObjectType = {
   ARRAY_BUFFER: 0,
   ELEMENT_ARRAY_BUFFER: 1,
   TEXTURE_BUFFER: 2
 };
 var Constants = {
-  ObjectType: ObjectType
+  ObjectType
 };
 
 export { ObjectType, Constants as default };

package/Rendering/OpenGL/BufferObject.js

@@ -1,162 +1,147 @@
-import _defineProperty from '@babel/runtime/helpers/defineProperty';
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.js';
 import Constants from './BufferObject/Constants.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 {
+  ObjectType
+} = Constants;
 
-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 ObjectType = Constants.ObjectType; // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
 // Global methods
 // ----------------------------------------------------------------------------
+
 // ----------------------------------------------------------------------------
 // Static API
 // ----------------------------------------------------------------------------
 
-var STATIC = {}; // ----------------------------------------------------------------------------
+const STATIC = {};
+
+// ----------------------------------------------------------------------------
 // vtkOpenGLBufferObject methods
 // ----------------------------------------------------------------------------
 
 function vtkOpenGLBufferObject(publicAPI, model) {
   // Set our className
-  model.classHierarchy.push('vtkOpenGLBufferObject'); // Class-specific private functions
+  model.classHierarchy.push('vtkOpenGLBufferObject');
 
+  // Class-specific private functions
   function convertType(type) {
     switch (type) {
       case ObjectType.ELEMENT_ARRAY_BUFFER:
         return model.context.ELEMENT_ARRAY_BUFFER;
-
       case ObjectType.TEXTURE_BUFFER:
         if ('TEXTURE_BUFFER' in model.context) {
           return model.context.TEXTURE_BUFFER;
         }
-
       /* eslint-disable no-fallthrough */
       // Intentional fallthrough in case there is no TEXTURE_BUFFER in WebGL
-
       case ObjectType.ARRAY_BUFFER:
       default:
         return model.context.ARRAY_BUFFER;
-
       /* eslint-enable no-fallthrough */
     }
   }
 
-  var internalType = null;
-  var internalHandle = null;
-  var dirty = true;
-  var error = ''; // Public API methods
-
-  publicAPI.getType = function () {
-    return internalType;
-  };
+  let internalType = null;
+  let internalHandle = null;
+  let dirty = true;
+  let error = '';
 
-  publicAPI.setType = function (value) {
+  // Public API methods
+  publicAPI.getType = () => internalType;
+  publicAPI.setType = value => {
     internalType = value;
   };
-
-  publicAPI.getHandle = function () {
-    return internalHandle;
-  };
-
-  publicAPI.isReady = function () {
-    return dirty === false;
-  };
-
-  publicAPI.generateBuffer = function (type) {
-    var objectTypeGL = convertType(type);
-
+  publicAPI.getHandle = () => internalHandle;
+  publicAPI.isReady = () => dirty === false;
+  publicAPI.generateBuffer = type => {
+    const objectTypeGL = convertType(type);
     if (internalHandle === null) {
       internalHandle = model.context.createBuffer();
       internalType = type;
     }
-
     return convertType(internalType) === objectTypeGL;
   };
-
-  publicAPI.upload = function (data, type) {
+  publicAPI.upload = (data, type) => {
     // buffer, size, type
-    var alreadyGenerated = publicAPI.generateBuffer(type);
-
+    const alreadyGenerated = publicAPI.generateBuffer(type);
     if (!alreadyGenerated) {
       error = 'Trying to upload array buffer to incompatible buffer.';
       return false;
     }
-
     model.context.bindBuffer(convertType(internalType), internalHandle);
     model.context.bufferData(convertType(internalType), data, model.context.STATIC_DRAW);
     dirty = false;
     return true;
   };
-
-  publicAPI.bind = function () {
+  publicAPI.bind = () => {
     if (!internalHandle) {
       return false;
     }
-
     model.context.bindBuffer(convertType(internalType), internalHandle);
     return true;
   };
-
-  publicAPI.release = function () {
+  publicAPI.release = () => {
     if (!internalHandle) {
       return false;
     }
-
     model.context.bindBuffer(convertType(internalType), null);
     return true;
   };
-
-  publicAPI.releaseGraphicsResources = function () {
+  publicAPI.releaseGraphicsResources = () => {
     if (internalHandle !== null) {
       model.context.bindBuffer(convertType(internalType), null);
       model.context.deleteBuffer(internalHandle);
       internalHandle = null;
     }
   };
-
-  publicAPI.setOpenGLRenderWindow = function (rw) {
+  publicAPI.setOpenGLRenderWindow = rw => {
     if (model._openGLRenderWindow === rw) {
       return;
     }
-
     publicAPI.releaseGraphicsResources();
     model._openGLRenderWindow = rw;
     model.context = null;
-
     if (rw) {
       model.context = model._openGLRenderWindow.getContext();
     }
   };
+  publicAPI.getError = () => error;
+}
 
-  publicAPI.getError = function () {
-    return error;
-  };
-} // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
-
-var DEFAULT_VALUES = {
+const DEFAULT_VALUES = {
   objectType: ObjectType.ARRAY_BUFFER,
   // _openGLRenderWindow: null,
   context: null
-}; // ----------------------------------------------------------------------------
+};
+
+// ----------------------------------------------------------------------------
 
 function extend(publicAPI, model) {
-  var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-  Object.assign(model, DEFAULT_VALUES, initialValues); // Object methods
+  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  Object.assign(model, DEFAULT_VALUES, initialValues);
 
+  // Object methods
   macro.obj(publicAPI, model);
   macro.get(publicAPI, model, ['_openGLRenderWindow']);
   macro.moveToProtected(publicAPI, model, ['openGLRenderWindow']);
   vtkOpenGLBufferObject(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
 
-var newInstance = macro.newInstance(extend); // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+
+const newInstance = macro.newInstance(extend);
+
+// ----------------------------------------------------------------------------
 
-var vtkBufferObject = _objectSpread(_objectSpread({
-  newInstance: newInstance,
-  extend: extend
-}, STATIC), Constants);
+var vtkBufferObject = {
+  newInstance,
+  extend,
+  ...STATIC,
+  ...Constants
+};
 
 export { STATIC, vtkBufferObject as default, extend, newInstance };

package/Rendering/OpenGL/Camera.js

@@ -1,96 +1,102 @@
 import { mat4, mat3 } from 'gl-matrix';
-import { newInstance as newInstance$1, obj, setGet } from '../../macros.js';
+import { n as newInstance$1, o as obj, e as setGet } from '../../macros2.js';
 import vtkViewNode from '../SceneGraph/ViewNode.js';
 import { registerOverride } from './ViewNodeFactory.js';
 
+// ----------------------------------------------------------------------------
 // vtkOpenGLCamera methods
 // ----------------------------------------------------------------------------
 
 function vtkOpenGLCamera(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkOpenGLCamera');
-
-  publicAPI.buildPass = function (prepass) {
+  publicAPI.buildPass = prepass => {
     if (prepass) {
       model._openGLRenderer = publicAPI.getFirstAncestorOfType('vtkOpenGLRenderer');
       model._openGLRenderWindow = model._openGLRenderer.getParent();
       model.context = model._openGLRenderWindow.getContext();
     }
-  }; // Renders myself
-
+  };
 
-  publicAPI.opaquePass = function (prepass) {
+  // Renders myself
+  publicAPI.opaquePass = prepass => {
     if (prepass) {
-      var tsize = model._openGLRenderer.getTiledSizeAndOrigin();
-
+      const tsize = model._openGLRenderer.getTiledSizeAndOrigin();
       model.context.viewport(tsize.lowerLeftU, tsize.lowerLeftV, tsize.usize, tsize.vsize);
       model.context.scissor(tsize.lowerLeftU, tsize.lowerLeftV, tsize.usize, tsize.vsize);
     }
   };
-
   publicAPI.translucentPass = publicAPI.opaquePass;
   publicAPI.zBufferPass = publicAPI.opaquePass;
   publicAPI.opaqueZBufferPass = publicAPI.opaquePass;
   publicAPI.volumePass = publicAPI.opaquePass;
-
-  publicAPI.getKeyMatrices = function (ren) {
+  publicAPI.getKeyMatrices = ren => {
     // has the camera changed?
     if (ren !== model.lastRenderer || model._openGLRenderWindow.getMTime() > model.keyMatrixTime.getMTime() || publicAPI.getMTime() > model.keyMatrixTime.getMTime() || ren.getMTime() > model.keyMatrixTime.getMTime() || model.renderable.getMTime() > model.keyMatrixTime.getMTime()) {
       mat4.copy(model.keyMatrices.wcvc, model.renderable.getViewMatrix());
       mat3.fromMat4(model.keyMatrices.normalMatrix, model.keyMatrices.wcvc);
       mat3.invert(model.keyMatrices.normalMatrix, model.keyMatrices.normalMatrix);
       mat4.transpose(model.keyMatrices.wcvc, model.keyMatrices.wcvc);
-
-      var aspectRatio = model._openGLRenderer.getAspectRatio();
-
+      const aspectRatio = model._openGLRenderer.getAspectRatio();
       mat4.copy(model.keyMatrices.vcpc, model.renderable.getProjectionMatrix(aspectRatio, -1, 1));
       mat4.transpose(model.keyMatrices.vcpc, model.keyMatrices.vcpc);
       mat4.multiply(model.keyMatrices.wcpc, model.keyMatrices.vcpc, model.keyMatrices.wcvc);
       model.keyMatrixTime.modified();
       model.lastRenderer = ren;
     }
-
     return model.keyMatrices;
   };
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
-
-var DEFAULT_VALUES = {
+const DEFAULT_VALUES = {
   context: null,
   lastRenderer: null,
   keyMatrixTime: null,
   keyMatrices: 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.keyMatrixTime = {};
-  obj(model.keyMatrixTime); // values always get set by the get method
+  obj(model.keyMatrixTime);
 
+  // values always get set by the get method
   model.keyMatrices = {
     normalMatrix: new Float64Array(9),
     vcpc: new Float64Array(16),
     wcvc: new Float64Array(16),
     wcpc: new Float64Array(16)
-  }; // Build VTK API
+  };
 
-  setGet(publicAPI, model, ['context', 'keyMatrixTime']); // Object methods
+  // Build VTK API
+  setGet(publicAPI, model, ['context', 'keyMatrixTime']);
 
+  // Object methods
   vtkOpenGLCamera(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 
-var newInstance = newInstance$1(extend); // ----------------------------------------------------------------------------
+const newInstance = newInstance$1(extend);
+
+// ----------------------------------------------------------------------------
 
 var vtkCamera = {
-  newInstance: newInstance,
-  extend: extend
-}; // Register ourself to OpenGL backend if imported
+  newInstance,
+  extend
+};
 
+// Register ourself to OpenGL backend if imported
 registerOverride('vtkCamera', newInstance);
 
 export { vtkCamera as default, extend, newInstance };