@kitware/vtk.js 26.8.1 → 26.9.0

package/BREAKING_CHANGES.md

@@ -3,7 +3,12 @@
 - **ResliceCursorWidget**: vtkResliceCursorContextRepresentation is deprecated and removed.
 Instead, a `vtkSphereHandleRepresentation` is used for `rotation` and `center` handles,
 and a `vtkLineHandleRepresenttion` is used for the axes. `rotateLineInView()` now
-takes an axis name (string, e.g. 'XinY') instead of a substate.
+takes an axis name (string, e.g. 'XinY') instead of a substate. `enableRotation`, `enableTranslation` and `keepOrthogonality` in widgetState are replaced by widget behavior accessors (e.g. `widgetInView.setEnableRotation(false)`). See RCW example.
+  - `widgetState.setShowCenter()` is replaced by `widgetState.getCenterHandle.setVisible()`
+  - `widgetState.setSphereRadius()` is replaced by `widgetState.getCenterHandle().setScale1()` and `widgetState.getStatesWithLabel('rotation').forEach((handle) => handle.setScale1())`
+  - `widgetState.setLineThickness(t)` is replaced by `widgetState.getStatesWithLabel('line').forEach((handle) => handle.setScale3(t,t,t))`
+  - `setScaleInPixels()` should now be set on the widget instead of the `widgetInView`.
+  - `widgetState.setOpacity()` is replaced by `widgetState.getStatesWithLabel('handles').forEach((handle) => handle.setOpacity())`
 - SVGRepresentation and SVG widget support has been fully removed.
 
 ## From 24.x to 25

package/Common/Core/DataArray.js

@@ -161,18 +161,12 @@ var STATIC = {
 function vtkDataArray(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkDataArray');
-
-  function dataChange() {
-    model.ranges = null;
-    publicAPI.modified();
-  }
   /**
    * Resize model.values and copy the old values to the new array.
    * @param {Number} requestedNumTuples Final expected number of tuples; must be >= 0
    * @returns {Boolean} True if a resize occured, false otherwise
    */
 
-
   function resize(requestedNumTuples) {
     if (requestedNumTuples < 0) {
       return false;
@@ -198,19 +192,24 @@ function vtkDataArray(publicAPI, model) {
 
     if (model.size > requestedNumTuples * numComps) {
       model.size = requestedNumTuples * numComps;
-      dataChange();
+      publicAPI.dataChange();
     }
 
     return true;
   }
 
+  publicAPI.dataChange = function () {
+    model.ranges = null;
+    publicAPI.modified();
+  };
+
   publicAPI.resize = function (requestedNumTuples) {
     resize(requestedNumTuples);
     var newSize = requestedNumTuples * publicAPI.getNumberOfComponents();
 
     if (model.size !== newSize) {
       model.size = newSize;
-      dataChange();
+      publicAPI.dataChange();
       return true;
     }
 
@@ -243,7 +242,7 @@ function vtkDataArray(publicAPI, model) {
   publicAPI.setComponent = function (tupleIdx, compIdx, value) {
     if (value !== model.values[tupleIdx * model.numberOfComponents + compIdx]) {
       model.values[tupleIdx * model.numberOfComponents + compIdx] = value;
-      dataChange();
+      publicAPI.dataChange();
     }
   };
 
@@ -448,7 +447,7 @@ function vtkDataArray(publicAPI, model) {
       model.numberOfComponents = 1;
     }
 
-    dataChange();
+    publicAPI.dataChange();
   }; // Override serialization support
 
 

package/Common/Core/ScalarsToColors.d.ts

@@ -124,10 +124,18 @@ export interface vtkScalarsToColors extends vtkObject {
 	getVectorSize(): number;
 
 	/**
-	 * 
+	 * @see areScalarsOpaque
 	 */
 	isOpaque(): boolean;
 
+	/**
+	 * Returns false if scalars are Uint8 LA or RGBA with A < 255,
+	 * otherwise rely on getAlpha() in case of direct mapping,
+	 * otherwise return isOpaque()
+	 * @see isOpaque, getAlpha
+	 */
+	areScalarsOpaque(scalars, colorMode, componentIn): boolean;
+
 	/**
 	 * 
 	 * @param newColors 

package/Common/Core/ScalarsToColors.js

@@ -504,6 +504,28 @@ function vtkScalarsToColors(publicAPI, model) {
   publicAPI.getRange = function () {
     return publicAPI.getMappingRange();
   };
+
+  publicAPI.areScalarsOpaque = function (scalars, colorMode, componentIn) {
+    if (!scalars) {
+      return publicAPI.isOpaque();
+    }
+
+    var numberOfComponents = scalars.getNumberOfComponents(); // map scalars through lookup table only if needed
+
+    if (colorMode === ColorMode.DEFAULT && scalars.getDataType() === VtkDataTypes.UNSIGNED_CHAR || colorMode === ColorMode.DIRECT_SCALARS) {
+      // we will be using the scalars directly, so look at the number of
+      // components and the range
+      if (numberOfComponents === 3 || numberOfComponents === 1) {
+        return model.alpha >= 1.0;
+      } // otherwise look at the range of the alpha channel
+
+
+      var range = scalars.getRange(numberOfComponents - 1);
+      return range[0] === 255;
+    }
+
+    return true;
+  };
 } // ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------

package/Rendering/Core/AxesActor.js

@@ -19,6 +19,16 @@ function centerDataSet(ds) {
   var center = [-(bounds[0] + bounds[1]) * 0.5, -(bounds[2] + bounds[3]) * 0.5, -(bounds[4] + bounds[5]) * 0.5];
 
   (_vtkMatrixBuilder$bui = vtkMatrixBuilder.buildFromDegree()).translate.apply(_vtkMatrixBuilder$bui, center).apply(ds.getPoints().getData());
+}
+
+function shiftDataset(ds, axis) {
+  var _vtkMatrixBuilder$bui2;
+
+  var bounds = ds.getPoints().getBounds();
+  var center = [0, 0, 0];
+  center[axis] = -bounds[axis * 2];
+
+  (_vtkMatrixBuilder$bui2 = vtkMatrixBuilder.buildFromDegree()).translate.apply(_vtkMatrixBuilder$bui2, center).apply(ds.getPoints().getData());
 } // ----------------------------------------------------------------------------
 
 
@@ -47,33 +57,100 @@ function vtkAxesActor(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkAxesActor');
 
+  var _mapper = vtkMapper.newInstance();
+
+  publicAPI.setMapper(_mapper);
+
   publicAPI.update = function () {
     var xAxis = vtkArrowSource.newInstance(_objectSpread({
       direction: [1, 0, 0]
     }, model.config)).getOutputData();
-    centerDataSet(xAxis);
+
+    if (model.config.recenter) {
+      centerDataSet(xAxis);
+    } else {
+      shiftDataset(xAxis, 0);
+    }
+
     addColor.apply(void 0, [xAxis].concat(_toConsumableArray(model.xAxisColor)));
     var yAxis = vtkArrowSource.newInstance(_objectSpread({
       direction: [0, 1, 0]
     }, model.config)).getOutputData();
-    centerDataSet(yAxis);
+
+    if (model.config.recenter) {
+      centerDataSet(yAxis);
+    } else {
+      shiftDataset(yAxis, 1);
+    }
+
     addColor.apply(void 0, [yAxis].concat(_toConsumableArray(model.yAxisColor)));
     var zAxis = vtkArrowSource.newInstance(_objectSpread({
       direction: [0, 0, 1]
     }, model.config)).getOutputData();
-    centerDataSet(zAxis);
+
+    if (model.config.recenter) {
+      centerDataSet(zAxis);
+    } else {
+      shiftDataset(zAxis, 2);
+    }
+
     addColor.apply(void 0, [zAxis].concat(_toConsumableArray(model.zAxisColor)));
     var source = vtkAppendPolyData.newInstance();
     source.setInputData(xAxis);
     source.addInputData(yAxis);
-    source.addInputData(zAxis); // set mapper
+    source.addInputData(zAxis);
 
-    var mapper = vtkMapper.newInstance();
-    mapper.setInputConnection(source.getOutputPort());
-    publicAPI.setMapper(mapper);
+    _mapper.setInputConnection(source.getOutputPort());
   };
 
   publicAPI.update();
+
+  var _debouncedUpdate = macro.debounce(publicAPI.update, 0);
+
+  var setConfig = publicAPI.setConfig,
+      setXAxisColor = publicAPI.setXAxisColor,
+      setYAxisColor = publicAPI.setYAxisColor,
+      setZAxisColor = publicAPI.setZAxisColor;
+
+  publicAPI.setConfig = function (c) {
+    if (setConfig(c)) {
+      _debouncedUpdate();
+
+      return true;
+    }
+
+    return false;
+  };
+
+  publicAPI.setXAxisColor = function (c) {
+    if (setXAxisColor(c)) {
+      _debouncedUpdate();
+
+      return true;
+    }
+
+    return false;
+  };
+
+  publicAPI.setYAxisColor = function (c) {
+    if (setYAxisColor(c)) {
+      _debouncedUpdate();
+
+      return true;
+    }
+
+    return false;
+  };
+
+  publicAPI.setZAxisColor = function (c) {
+    if (setZAxisColor(c)) {
+      _debouncedUpdate();
+
+      return true;
+    }
+
+    return false;
+  };
 } // ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
@@ -81,6 +158,7 @@ function vtkAxesActor(publicAPI, model) {
 
 var DEFAULT_VALUES = {
   config: {
+    recenter: true,
     tipResolution: 60,
     tipRadius: 0.1,
     tipLength: 0.2,

package/Rendering/Core/Mapper.js

@@ -375,12 +375,21 @@ function vtkMapper(publicAPI, model) {
   };
 
   publicAPI.getIsOpaque = function () {
+    var input = publicAPI.getInputData();
+    var gasResult = publicAPI.getAbstractScalars(input, model.scalarMode, model.arrayAccessMode, model.arrayId, model.colorByArrayName);
+    var scalars = gasResult.scalars;
+
+    if (!model.scalarVisibility || scalars == null) {
+      // No scalar colors.
+      return true;
+    }
+
     var lut = publicAPI.getLookupTable();
 
     if (lut) {
       // Ensure that the lookup table is built
       lut.build();
-      return lut.isOpaque();
+      return lut.areScalarsOpaque(scalars, model.colorMode, -1);
     }
 
     return true;

package/Rendering/Misc/SynchronizableRenderWindow/ObjectManager.js

@@ -27,6 +27,7 @@ import vtkImageProperty from '../../Core/ImageProperty.js';
 import vtkPiecewiseFunction from '../../../Common/DataModel/PiecewiseFunction.js';
 import vtkCubeAxesActor from '../../Core/CubeAxesActor.js';
 import vtkScalarBarActor from '../../Core/ScalarBarActor.js';
+import vtkAxesActor from '../../Core/AxesActor.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; }
 
@@ -583,6 +584,10 @@ var DEFAULT_ALIASES = {
 }; // ----------------------------------------------------------------------------
 
 var DEFAULT_MAPPING = {
+  vtkAxesActor: {
+    build: vtkAxesActor.newInstance,
+    update: genericUpdater
+  },
   vtkRenderWindow: {
     build: vtkRenderWindow.newInstance,
     update: vtkRenderWindowUpdater

package/Rendering/Misc/SynchronizableRenderWindow.d.ts

@@ -54,42 +54,42 @@ export interface IViewState {
 export interface vtkSynchronizableRenderWindow extends vtkRenderWindow {
 
   /**
-   * 
+   *
    */
   getSynchronizerContext(): ISynchronizerContext;
 
   // methods added by createSyncFunction
 
   /**
-   * 
-   * @param {IViewState} state 
+   *
+   * @param {IViewState} state
    */
   synchronize(state: IViewState): Promise<boolean>;
 
   /**
-   * 
-   * @param {String} viewId 
+   *
+   * @param {String} viewId
    */
   setSynchronizedViewId(viewId: string): void;
 
   /**
-   * 
+   *
    */
   getSynchronizedViewId(): string;
 
   /**
-   * 
-   * @param {Number} v 
+   *
+   * @param {Number} v
    */
   updateGarbageCollectorThreshold(v: number): void;
 
   /**
-   * 
+   *
    */
   getManagedInstanceIds(): string[];
 
   /**
-   * 
+   *
    */
   clearOneTimeUpdaters(): void;
 }
@@ -110,52 +110,60 @@ export function extend(publicAPI: object, model: object, initialValues?: ISynchr
 export function newInstance(initialValues?: ISynchronizableRenderWindowInitialValues): vtkSynchronizableRenderWindow;
 
 /**
- * 
- * @param {String} [name] 
+ *
+ * @param {String} [name]
  */
 export function getSynchronizerContext(name?: string): ISynchronizerContext;
 
 /**
- * 
- * @param {String} name 
- * @param {ISynchronizerContext} ctx 
+ *
+ * @param {String} name
+ * @param {Nullable<ISynchronizerContext>} ctx
  */
-export function setSynchronizerContext(name: string, ctx: ISynchronizerContext): ISynchronizerContext;
+export function setSynchronizerContext(name: string, ctx: Nullable<ISynchronizerContext>);
+
 
 /**
- * 
- * @param {vtkRenderWindow} renderWindow 
- * @param {String} [name] 
+ *
+ * @param name of the context to remove and if nothing provided clear them all.
+ */
+export function clearSynchronizerContext(name: Nullable<string>);
+
+/**
+ *
+ * @param {vtkRenderWindow} renderWindow
+ * @param {String} [name]
  */
 export function decorate(renderWindow: vtkRenderWindow, name?: string): object;
 
 /**
- * 
+ *
  */
 export function createInstanceMap(): object;
 
 /**
- * 
+ *
  */
 export function createArrayHandler(): object;
 
 /**
- * 
+ *
  */
 export function createProgressHandler(): object;
 
 /**
- * 
+ *
  */
 export function createSceneMtimeHandler(): object;
 
 /**
- * 
+ *
  */
 export declare const vtkSynchronizableRenderWindow: {
   newInstance: typeof newInstance;
   getSynchronizerContext: typeof getSynchronizerContext;
   setSynchronizerContext: typeof setSynchronizerContext;
+  clearSynchronizerContext: typeof clearSynchronizerContext;
   decorate: typeof decorate,
   createInstanceMap: typeof createInstanceMap,
   createArrayHandler: typeof createArrayHandler,

package/Rendering/Misc/SynchronizableRenderWindow.js

@@ -220,6 +220,20 @@ function getSynchronizerContext() {
 
 function setSynchronizerContext(name, ctx) {
   SYNCHRONIZER_CONTEXTS[name] = ctx;
+}
+
+function clearSynchronizerContext(name) {
+  if (name && SYNCHRONIZER_CONTEXTS[name]) {
+    delete SYNCHRONIZER_CONTEXTS[name];
+  }
+
+  if (!name) {
+    var keys = Object.keys(SYNCHRONIZER_CONTEXTS);
+
+    for (var i = 0; i < keys.length; i++) {
+      delete SYNCHRONIZER_CONTEXTS[keys[i]];
+    }
+  }
 } // ----------------------------------------------------------------------------
 
 
@@ -346,6 +360,7 @@ var vtkSynchronizableRenderWindow$1 = {
   extend: extend,
   getSynchronizerContext: getSynchronizerContext,
   setSynchronizerContext: setSynchronizerContext,
+  clearSynchronizerContext: clearSynchronizerContext,
   decorate: decorate,
   createInstanceMap: createInstanceMap,
   createArrayHandler: createArrayHandler,

package/Rendering/OpenGL/Actor.js

@@ -37,9 +37,10 @@ function vtkOpenGLActor(publicAPI, model) {
         }
       }
     }
-  };
+  }; // render both opaque and translucent actors
 
-  publicAPI.traverseOpaqueZBufferPass = function (renderPass) {
+
+  publicAPI.traverseZBufferPass = function (renderPass) {
     if (!model.renderable || !model.renderable.getNestedVisibility() || model._openGLRenderer.getSelector() && !model.renderable.getNestedPickable()) {
       return;
     }
@@ -47,6 +48,11 @@ function vtkOpenGLActor(publicAPI, model) {
     publicAPI.apply(renderPass, true);
     model.oglmapper.traverse(renderPass);
     publicAPI.apply(renderPass, false);
+  }; // only render opaque actors
+
+
+  publicAPI.traverseOpaqueZBufferPass = function (renderPass) {
+    return publicAPI.traverseOpaquePass(renderPass);
   }; // we draw textures, then mapper, then post pass textures
 
 
@@ -103,6 +109,10 @@ function vtkOpenGLActor(publicAPI, model) {
     }
   };
 
+  publicAPI.zBufferPass = function (prepass, renderPass) {
+    return publicAPI.opaquePass(prepass, renderPass);
+  };
+
   publicAPI.opaqueZBufferPass = function (prepass, renderPass) {
     return publicAPI.opaquePass(prepass, renderPass);
   };

package/Rendering/OpenGL/Camera.js

@@ -29,6 +29,7 @@ function vtkOpenGLCamera(publicAPI, model) {
   };
 
   publicAPI.translucentPass = publicAPI.opaquePass;
+  publicAPI.zBufferPass = publicAPI.opaquePass;
   publicAPI.opaqueZBufferPass = publicAPI.opaquePass;
   publicAPI.volumePass = publicAPI.opaquePass;
 

package/Rendering/OpenGL/ForwardPass.js

@@ -40,7 +40,7 @@ function vtkForwardPass(publicAPI, model) {
           publicAPI.setCurrentOperation('queryPass');
           renNode.traverse(publicAPI); // do we need to capture a zbuffer?
 
-          if (model.opaqueActorCount > 0 && model.volumeCount > 0 || model.depthRequested) {
+          if ((model.opaqueActorCount > 0 || model.translucentActorCount > 0) && model.volumeCount > 0 || model.depthRequested) {
             var size = viewNode.getFramebufferSize(); // make sure the framebuffer is setup
 
             if (model.framebuffer === null) {
@@ -56,8 +56,11 @@ function vtkForwardPass(publicAPI, model) {
               model.framebuffer.populateFramebuffer();
             }
 
-            model.framebuffer.bind();
-            publicAPI.setCurrentOperation('opaqueZBufferPass');
+            model.framebuffer.bind(); // opaqueZBufferPass only renders opaque actors
+            // zBufferPass renders both translucent and opaque actors
+            // we want to be able to pick translucent actors
+
+            publicAPI.setCurrentOperation('zBufferPass');
             renNode.traverse(publicAPI);
             model.framebuffer.restorePreviousBindingsAndBuffers(); // reset now that we have done it
 

package/Rendering/OpenGL/ImageMapper.js

@@ -68,7 +68,7 @@ function vtkOpenGLImageMapper(publicAPI, model) {
     }
   };
 
-  publicAPI.opaqueZBufferPass = function (prepass) {
+  publicAPI.zBufferPass = function (prepass) {
     if (prepass) {
       model.haveSeenDepthRequest = true;
       model.renderDepth = true;
@@ -77,6 +77,10 @@ function vtkOpenGLImageMapper(publicAPI, model) {
     }
   };
 
+  publicAPI.opaqueZBufferPass = function (prepass) {
+    return publicAPI.zBufferPass(prepass);
+  };
+
   publicAPI.opaquePass = function (prepass) {
     if (prepass) {
       publicAPI.render();

package/Rendering/OpenGL/ImageSlice.js

@@ -29,8 +29,20 @@ function vtkOpenGLImageSlice(publicAPI, model) {
     }
   };
 
+  publicAPI.traverseZBufferPass = function (renderPass) {
+    if (!model.renderable || !model.renderable.getNestedVisibility() || model._openGLRenderer.getSelector() && !model.renderable.getNestedPickable()) {
+      return;
+    }
+
+    publicAPI.apply(renderPass, true);
+    model.children.forEach(function (child) {
+      child.traverse(renderPass);
+    });
+    publicAPI.apply(renderPass, false);
+  };
+
   publicAPI.traverseOpaqueZBufferPass = function (renderPass) {
-    publicAPI.traverseOpaquePass(renderPass);
+    return publicAPI.traverseOpaquePass(renderPass);
   }; // we draw textures, then mapper, then post pass textures
 
 
@@ -73,6 +85,10 @@ function vtkOpenGLImageSlice(publicAPI, model) {
     }
   };
 
+  publicAPI.zBufferPass = function (prepass, renderPass) {
+    return publicAPI.opaquePass(prepass, renderPass);
+  };
+
   publicAPI.opaqueZBufferPass = function (prepass, renderPass) {
     return publicAPI.opaquePass(prepass, renderPass);
   }; // Renders myself

package/Rendering/OpenGL/OrderIndependentTranslucentPass.js

@@ -151,6 +151,7 @@ function vtkOpenGLOrderIndependentTranslucentPass(publicAPI, model) {
     // have the forward pass use a texture backed zbuffer
 
     if (forwardPass.getOpaqueActorCount() > 0) {
+      // Don't use zBufferPass as it will also render the depth of translucent actors
       forwardPass.setCurrentOperation('opaqueZBufferPass');
       renNode.traverse(forwardPass);
     }

package/Rendering/OpenGL/PolyDataMapper.js

@@ -72,7 +72,7 @@ function vtkOpenGLPolyDataMapper(publicAPI, model) {
     }
   };
 
-  publicAPI.opaqueZBufferPass = function (prepass) {
+  publicAPI.zBufferPass = function (prepass) {
     if (prepass) {
       model.haveSeenDepthRequest = true;
       model.renderDepth = true;
@@ -81,6 +81,10 @@ function vtkOpenGLPolyDataMapper(publicAPI, model) {
     }
   };
 
+  publicAPI.opaqueZBufferPass = function (prepass) {
+    return publicAPI.zBufferPass(prepass);
+  };
+
   publicAPI.opaquePass = function (prepass) {
     if (prepass) {
       publicAPI.render();

package/Rendering/OpenGL/RenderWindow.js

@@ -911,7 +911,26 @@ function vtkOpenGLRenderWindow(publicAPI, model) {
     model.canvas.removeEventListener('webglcontextrestored', publicAPI.restoreContext);
   }
 
-  publicAPI.delete = macro.chain(clearEvents, publicAPI.delete, publicAPI.setViewStream, deleteGLContext);
+  publicAPI.delete = macro.chain(clearEvents, publicAPI.delete, publicAPI.setViewStream, deleteGLContext); // Do not trigger modified for performance reasons
+
+  publicAPI.setActiveFramebuffer = function (newActiveFramebuffer) {
+    model.activeFramebuffer = newActiveFramebuffer;
+  };
+
+  var superSetSize = publicAPI.setSize;
+
+  publicAPI.setSize = function (width, height) {
+    var modified = superSetSize(width, height);
+
+    if (modified) {
+      publicAPI.invokeWindowResizeEvent({
+        width: width,
+        height: height
+      });
+    }
+
+    return modified;
+  };
 } // ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
@@ -979,13 +998,10 @@ function extend(publicAPI, model) {
   macro.event(publicAPI, model, 'imageReady');
   macro.event(publicAPI, model, 'haveVRDisplay'); // Build VTK API
 
-  macro.get(publicAPI, model, ['shaderCache', 'textureUnitManager', 'webgl2', 'vrDisplay', 'useBackgroundImage', 'xrSupported']);
-  macro.setGet(publicAPI, model, ['initialized', 'context', 'canvas', 'renderPasses', 'notifyStartCaptureImage', 'defaultToWebgl2', 'cursor', 'useOffScreen', // might want to make this not call modified as
-  // we change the active framebuffer a lot. Or maybe
-  // only mark modified if the size or depth
-  // of the buffer has changed
-  'activeFramebuffer']);
-  macro.setGetArray(publicAPI, model, ['size'], 2); // Object methods
+  macro.get(publicAPI, model, ['shaderCache', 'textureUnitManager', 'webgl2', 'vrDisplay', 'useBackgroundImage', 'xrSupported', 'activeFramebuffer']);
+  macro.setGet(publicAPI, model, ['initialized', 'context', 'canvas', 'renderPasses', 'notifyStartCaptureImage', 'defaultToWebgl2', 'cursor', 'useOffScreen']);
+  macro.setGetArray(publicAPI, model, ['size'], 2);
+  macro.event(publicAPI, model, 'windowResizeEvent'); // Object methods
 
   vtkOpenGLRenderWindow(publicAPI, model);
 } // ----------------------------------------------------------------------------

package/Rendering/OpenGL/Renderer.js

@@ -44,7 +44,7 @@ function vtkOpenGLRenderer(publicAPI, model) {
     return count;
   };
 
-  publicAPI.opaqueZBufferPass = function (prepass) {
+  publicAPI.zBufferPass = function (prepass) {
     if (prepass) {
       var clearMask = 0;
       var gl = model.context;
@@ -72,6 +72,10 @@ function vtkOpenGLRenderer(publicAPI, model) {
 
       gl.enable(gl.DEPTH_TEST);
     }
+  };
+
+  publicAPI.opaqueZBufferPass = function (prepass) {
+    return publicAPI.zBufferPass(prepass);
   }; // Renders myself