@kitware/vtk.js 21.2.0 → 21.3.1

package/Rendering/Core/Property2D.js

@@ -1,11 +1,38 @@
 import macro from '../../macros.js';
+import Constants from './Property2D/Constants.js';
+import { Representation } from './Property/Constants.js';
 
+var DisplayLocation = Constants.DisplayLocation; // ----------------------------------------------------------------------------
 // vtkProperty2D methods
 // ----------------------------------------------------------------------------
 
 function vtkProperty2D(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkProperty2D');
+
+  publicAPI.setDisplayLocationToBackground = function () {
+    return publicAPI.setDisplayLocation(DisplayLocation.BACKGROUND);
+  };
+
+  publicAPI.setDisplayLocationToForeground = function () {
+    return publicAPI.setDisplayLocation(DisplayLocation.FOREGROUND);
+  };
+
+  publicAPI.setRepresentationToWireframe = function () {
+    return publicAPI.setRepresentation(Representation.WIREFRAME);
+  };
+
+  publicAPI.setRepresentationToSurface = function () {
+    return publicAPI.setRepresentation(Representation.SURFACE);
+  };
+
+  publicAPI.setRepresentationToPoints = function () {
+    return publicAPI.setRepresentation(Representation.POINTS);
+  };
+
+  publicAPI.getRepresentationAsString = function () {
+    return macro.enumToString(Representation, model.representation);
+  };
 } // ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
@@ -16,7 +43,8 @@ var DEFAULT_VALUES = {
   opacity: 1,
   pointSize: 1,
   lineWidth: 1,
-  displayLocation: 'Foreground'
+  representation: Representation.SURFACE,
+  displayLocation: DisplayLocation.FOREGROUND
 }; // ----------------------------------------------------------------------------
 
 function extend(publicAPI, model) {
@@ -24,7 +52,7 @@ function extend(publicAPI, model) {
   Object.assign(model, DEFAULT_VALUES, initialValues); // Build VTK API
 
   macro.obj(publicAPI, model);
-  macro.setGet(publicAPI, model, ['opacity', 'lineWidth', 'pointSize', 'displayLocation']);
+  macro.setGet(publicAPI, model, ['opacity', 'lineWidth', 'pointSize', 'displayLocation', 'representation']);
   macro.setGetArray(publicAPI, model, ['color'], 3); // Object methods
 
   vtkProperty2D(publicAPI, model);

package/Rendering/Core.js

@@ -22,6 +22,7 @@ import vtkInteractorObserver from './Core/InteractorObserver.js';
 import vtkInteractorStyle from './Core/InteractorStyle.js';
 import vtkLight from './Core/Light.js';
 import vtkMapper from './Core/Mapper.js';
+import vtkMapper2D from './Core/Mapper2D.js';
 import vtkPicker from './Core/Picker.js';
 import vtkPixelSpaceCallbackMapper from './Core/PixelSpaceCallbackMapper.js';
 import vtkPointPicker from './Core/PointPicker.js';
@@ -70,6 +71,7 @@ var Core = {
   vtkInteractorStyle: vtkInteractorStyle,
   vtkLight: vtkLight,
   vtkMapper: vtkMapper,
+  vtkMapper2D: vtkMapper2D,
   vtkPicker: vtkPicker,
   vtkPixelSpaceCallbackMapper: vtkPixelSpaceCallbackMapper,
   vtkPointPicker: vtkPointPicker,

package/Rendering/OpenGL/Actor2D.js

@@ -21,52 +21,85 @@ function vtkOpenGLActor2D(publicAPI, model) {
       publicAPI.prepareNodes();
       publicAPI.addMissingNodes(model.renderable.getTextures());
       publicAPI.addMissingNode(model.renderable.getMapper());
-      publicAPI.removeUnusedNodes();
+      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];
+
+        if (child.isA('vtkOpenGLTexture')) {
+          if (!model.ogltextures) {
+            model.ogltextures = [];
+          }
+
+          model.ogltextures.push(child);
+        } else {
+          model.oglmapper = child;
+        }
+      }
+    }
+  };
+
+  publicAPI.queryPass = function (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) {
-    if (!model.renderable || !model.renderable.getNestedVisibility() || !model.renderable.getIsOpaque() || model.openGLRenderer.getSelector() && !model.renderable.getNestedPickable()) {
+    if (!model.oglmapper || !model.renderable || !model.renderable.getNestedVisibility() || !model.renderable.getIsOpaque() || model.openGLRenderer.getSelector() && !model.renderable.getNestedPickable()) {
       return;
     }
 
     publicAPI.apply(renderPass, true);
-    model.children.forEach(function (child) {
-      if (!child.isA('vtkOpenGLTexture')) {
-        child.traverse(renderPass);
-      }
-    });
+    model.oglmapper.traverse(renderPass);
     publicAPI.apply(renderPass, false);
   }; // we draw textures, then mapper, then post pass textures
 
 
   publicAPI.traverseTranslucentPass = function (renderPass) {
-    if (!model.renderable || !model.renderable.getNestedVisibility() || model.renderable.getIsOpaque() || model.openGLRenderer.getSelector() && !model.renderable.getNestedPickable()) {
+    if (!model.oglmapper || !model.renderable || !model.renderable.getNestedVisibility() || model.renderable.getIsOpaque() || model.openGLRenderer.getSelector() && !model.renderable.getNestedPickable()) {
       return;
     }
 
     publicAPI.apply(renderPass, true);
-    model.children.forEach(function (child) {
-      if (!child.isA('vtkOpenGLTexture')) {
-        child.traverse(renderPass);
-      }
-    });
+    model.oglmapper.traverse(renderPass);
+    publicAPI.apply(renderPass, false);
+  };
+
+  publicAPI.traverseOverlayPass = function (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 () {
     // always traverse textures first, then mapper
+    if (!model.ogltextures) {
+      return;
+    }
+
     model.activeTextures = [];
-    model.children.forEach(function (child) {
-      if (child.isA('vtkOpenGLTexture')) {
-        child.render();
 
-        if (child.getHandle()) {
-          model.activeTextures.push(child);
-        }
+    for (var index = 0; index < model.ogltextures.length; index++) {
+      var child = model.ogltextures[index];
+      child.render();
+
+      if (child.getHandle()) {
+        model.activeTextures.push(child);
       }
-    });
+    }
   }; // Renders myself
 
 
@@ -74,11 +107,11 @@ function vtkOpenGLActor2D(publicAPI, model) {
     if (prepass) {
       model.context.depthMask(true);
       publicAPI.activateTextures();
-    } else {
+    } else if (model.activeTextures) {
       // deactivate textures
-      model.activeTextures.forEach(function (child) {
-        child.deactivate();
-      });
+      for (var index = 0; index < model.activeTextures.length; index++) {
+        model.activeTextures[index].deactivate();
+      }
     }
   }; // Renders myself
 
@@ -87,12 +120,23 @@ function vtkOpenGLActor2D(publicAPI, model) {
     if (prepass) {
       model.context.depthMask(false);
       publicAPI.activateTextures();
-    } else {
-      // deactivate textures
-      model.activeTextures.forEach(function (child) {
-        child.deactivate();
-      });
+    } else if (model.activeTextures) {
+      for (var index = 0; index < model.activeTextures.length; index++) {
+        model.activeTextures[index].deactivate();
+      }
+    }
+  }; // Renders myself
+
+
+  publicAPI.overlayPass = function (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++) {
+        model.activeTextures[index].deactivate();
+      }
     }
   };
 } // ----------------------------------------------------------------------------
@@ -102,7 +146,7 @@ function vtkOpenGLActor2D(publicAPI, model) {
 
 var DEFAULT_VALUES = {
   context: null,
-  activeTextures: []
+  activeTextures: null
 }; // ----------------------------------------------------------------------------
 
 function extend(publicAPI, model) {

package/Rendering/OpenGL/ForwardPass.js

@@ -35,6 +35,7 @@ function vtkForwardPass(publicAPI, model) {
           model.opaqueActorCount = 0;
           model.translucentActorCount = 0;
           model.volumeCount = 0;
+          model.overlayActorCount = 0;
           publicAPI.setCurrentOperation('queryPass');
           renNode.traverse(publicAPI); // do we need to capture a zbuffer?
 
@@ -79,6 +80,11 @@ function vtkForwardPass(publicAPI, model) {
             publicAPI.setCurrentOperation('volumePass');
             renNode.traverse(publicAPI);
           }
+
+          if (model.overlayActorCount > 0) {
+            publicAPI.setCurrentOperation('overlayPass');
+            renNode.traverse(publicAPI);
+          }
         }
       }
     }
@@ -107,6 +113,10 @@ function vtkForwardPass(publicAPI, model) {
   publicAPI.incrementVolumeCount = function () {
     return model.volumeCount++;
   };
+
+  publicAPI.incrementOverlayActorCount = function () {
+    return model.overlayActorCount++;
+  };
 } // ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
@@ -116,6 +126,7 @@ var DEFAULT_VALUES = {
   opaqueActorCount: 0,
   translucentActorCount: 0,
   volumeCount: 0,
+  overlayActorCount: 0,
   framebuffer: null,
   depthRequested: false
 }; // ----------------------------------------------------------------------------

package/Rendering/OpenGL/PolyDataMapper.js

@@ -1269,9 +1269,10 @@ var newInstance = newInstance$1(extend, 'vtkOpenGLPolyDataMapper'); // ---------
 
 var vtkOpenGLPolyDataMapper$1 = {
   newInstance: newInstance,
-  extend: extend
+  extend: extend,
+  primTypes: primTypes
 }; // Register ourself to OpenGL backend if imported
 
 registerOverride('vtkMapper', newInstance);
 
-export { vtkOpenGLPolyDataMapper$1 as default, extend, newInstance };
+export { vtkOpenGLPolyDataMapper$1 as default, extend, newInstance, primTypes };