@kitware/vtk.js 30.9.3 → 31.0.0

package/Rendering/Misc/FullScreenRenderWindow.js

@@ -104,17 +104,18 @@ function vtkFullScreenRenderWindow(publicAPI, model) {
   publicAPI.toggleControllerVisibility = () => {
     publicAPI.setControllerVisibility(!model.controllerVisibility);
   };
+  function handleKeypress(e) {
+    if (String.fromCharCode(e.charCode) === 'c') {
+      publicAPI.toggleControllerVisibility();
+    }
+  }
   publicAPI.addController = html => {
     model.controlContainer = document.createElement('div');
     applyStyle(model.controlContainer, model.controlPanelStyle || STYLE_CONTROL_PANEL);
     model.rootContainer.appendChild(model.controlContainer);
     model.controlContainer.innerHTML = html;
     publicAPI.setControllerVisibility(model.controllerVisibility);
-    model.rootContainer.addEventListener('keypress', e => {
-      if (String.fromCharCode(e.charCode) === 'c') {
-        publicAPI.toggleControllerVisibility();
-      }
-    });
+    model.rootContainer.addEventListener('keypress', handleKeypress);
   };
 
   // Update BG color
@@ -131,7 +132,10 @@ function vtkFullScreenRenderWindow(publicAPI, model) {
   };
 
   // Properly release GL context
-  publicAPI.delete = macro.chain(publicAPI.setContainer, model.apiSpecificRenderWindow.delete, publicAPI.delete);
+  publicAPI.delete = macro.chain(publicAPI.setContainer, model.apiSpecificRenderWindow.delete, () => {
+    model.rootContainer?.removeEventListener('keypress', handleKeypress);
+    window.removeEventListener('resize', publicAPI.resize);
+  }, publicAPI.delete);
 
   // Handle window resize
   publicAPI.resize = () => {

package/Rendering/Misc/GenericRenderWindow.js

@@ -68,7 +68,9 @@ function vtkGenericRenderWindow(publicAPI, model) {
   };
 
   // Properly release GL context
-  publicAPI.delete = macro.chain(publicAPI.setContainer, model._apiSpecificRenderWindow.delete, publicAPI.delete);
+  publicAPI.delete = macro.chain(publicAPI.setContainer, model._apiSpecificRenderWindow.delete, () => {
+    window.removeEventListener('resize', publicAPI.resize);
+  }, publicAPI.delete);
 
   // Handle size
   if (model.listenWindowResize) {

package/Rendering/OpenGL/Actor.js

@@ -113,7 +113,7 @@ function vtkOpenGLActor(publicAPI, model) {
   // Renders myself
   publicAPI.translucentPass = (prepass, renderPass) => {
     if (prepass) {
-      model.context.depthMask(false);
+      model.context.depthMask(model._openGLRenderer.getSelector() && model.renderable.getNestedPickable());
       publicAPI.activateTextures();
     } else if (model.activeTextures) {
       for (let index = 0; index < model.activeTextures.length; index++) {

package/Rendering/OpenGL/ImageMapper.js

@@ -1,6 +1,6 @@
 import { mat4, mat3 } from 'gl-matrix';
 import Constants from '../Core/ImageMapper/Constants.js';
-import { n as newInstance$1, e as setGet, o as obj, r as vtkErrorMacro$1, c as macro } from '../../macros2.js';
+import { n as newInstance$1, e as setGet, o as obj, r as vtkErrorMacro$1, h as chain, c as macro } from '../../macros2.js';
 import vtkDataArray from '../../Common/Core/DataArray.js';
 import { VtkDataTypes } from '../../Common/Core/DataArray/Constants.js';
 import vtkHelper from './Helper.js';
@@ -55,12 +55,23 @@ function splitStringOnEnter(inputString) {
 function vtkOpenGLImageMapper(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkOpenGLImageMapper');
+  function unregisterGraphicsResources(renderWindow) {
+    // The openGLTexture is not shared
+    model.openGLTexture.releaseGraphicsResources(renderWindow);
+    // All these other resources are shared
+    [model._colorTransferFunc, model._pwFunc, model._labelOutlineThicknessArray].forEach(coreObject => renderWindow.unregisterGraphicsResourceUser(coreObject, publicAPI));
+  }
   publicAPI.buildPass = prepass => {
     if (prepass) {
       model.currentRenderPass = null;
       model.openGLImageSlice = publicAPI.getFirstAncestorOfType('vtkOpenGLImageSlice');
       model._openGLRenderer = publicAPI.getFirstAncestorOfType('vtkOpenGLRenderer');
+      const oldOglRenderWindow = model._openGLRenderWindow;
       model._openGLRenderWindow = model._openGLRenderer.getLastAncestorOfType('vtkOpenGLRenderWindow');
+      if (oldOglRenderWindow && !oldOglRenderWindow.isDeleted() && oldOglRenderWindow !== model._openGLRenderWindow) {
+        // Unregister the mapper when the render window changes
+        unregisterGraphicsResources(oldOglRenderWindow);
+      }
       model.context = model._openGLRenderWindow.getContext();
       model.tris.setOpenGLRenderWindow(model._openGLRenderWindow);
       const ren = model._openGLRenderer.getRenderable();
@@ -571,17 +582,15 @@ function vtkOpenGLImageMapper(publicAPI, model) {
     const colorTransferFunc = actorProperty.getRGBTransferFunction();
     const cfunToString = computeFnToString(actorProperty, colorTransferFunc, numIComps);
     const cTex = model._openGLRenderWindow.getGraphicsResourceForObject(colorTransferFunc);
-    const reBuildC = !cTex?.vtkObj?.getHandle() || cTex?.hash !== cfunToString || model.colorTextureString !== cfunToString;
+    const reBuildC = !cTex?.oglObject?.getHandle() || cTex?.hash !== cfunToString;
     if (reBuildC) {
+      model.colorTexture = vtkOpenGLTexture.newInstance({
+        resizable: true
+      });
+      model.colorTexture.setOpenGLRenderWindow(model._openGLRenderWindow);
       const cWidth = 1024;
       const cSize = cWidth * textureHeight * 3;
       const cTable = new Uint8ClampedArray(cSize);
-      if (!model.colorTexture) {
-        model.colorTexture = vtkOpenGLTexture.newInstance({
-          resizable: true
-        });
-        model.colorTexture.setOpenGLRenderWindow(model._openGLRenderWindow);
-      }
       // set interpolation on the texture based on property setting
       if (iType === InterpolationType.NEAREST) {
         model.colorTexture.setMinificationFilter(Filter.NEAREST);
@@ -607,7 +616,6 @@ function vtkOpenGLImageMapper(publicAPI, model) {
             }
           }
         }
-        model.colorTexture.releaseGraphicsResources(model._openGLRenderWindow);
         model.colorTexture.resetFormatAndType();
         model.colorTexture.create2DFromRaw(cWidth, textureHeight, 3, VtkDataTypes.UNSIGNED_CHAR, cTable);
       } else {
@@ -618,13 +626,16 @@ function vtkOpenGLImageMapper(publicAPI, model) {
         }
         model.colorTexture.create2DFromRaw(cWidth, 1, 3, VtkDataTypes.UNSIGNED_CHAR, cTable);
       }
-      model.colorTextureString = cfunToString;
       if (colorTransferFunc) {
-        model._openGLRenderWindow.setGraphicsResourceForObject(colorTransferFunc, model.colorTexture, model.colorTextureString);
+        model._openGLRenderWindow.setGraphicsResourceForObject(colorTransferFunc, model.colorTexture, cfunToString);
+        if (colorTransferFunc !== model._colorTransferFunc) {
+          model._openGLRenderWindow.registerGraphicsResourceUser(colorTransferFunc, publicAPI);
+          model._openGLRenderWindow.unregisterGraphicsResourceUser(model._colorTransferFunc, publicAPI);
+        }
+        model._colorTransferFunc = colorTransferFunc;
       }
     } else {
-      model.colorTexture = cTex.vtkObj;
-      model.colorTextureString = cTex.hash;
+      model.colorTexture = cTex.oglObject;
     }
 
     // Build piecewise function buffer.  This buffer is used either
@@ -634,17 +645,15 @@ function vtkOpenGLImageMapper(publicAPI, model) {
     const pwfunToString = computeFnToString(actorProperty, pwFunc, numIComps);
     const pwfTex = model._openGLRenderWindow.getGraphicsResourceForObject(pwFunc);
     // rebuild opacity tfun?
-    const reBuildPwf = !pwfTex?.vtkObj?.getHandle() || pwfTex?.hash !== pwfunToString || model.pwfTextureString !== pwfunToString;
+    const reBuildPwf = !pwfTex?.oglObject?.getHandle() || pwfTex?.hash !== pwfunToString;
     if (reBuildPwf) {
       const pwfWidth = 1024;
       const pwfSize = pwfWidth * textureHeight;
       const pwfTable = new Uint8ClampedArray(pwfSize);
-      if (!model.pwfTexture) {
-        model.pwfTexture = vtkOpenGLTexture.newInstance({
-          resizable: true
-        });
-        model.pwfTexture.setOpenGLRenderWindow(model._openGLRenderWindow);
-      }
+      model.pwfTexture = vtkOpenGLTexture.newInstance({
+        resizable: true
+      });
+      model.pwfTexture.setOpenGLRenderWindow(model._openGLRenderWindow);
       // set interpolation on the texture based on property setting
       if (iType === InterpolationType.NEAREST) {
         model.pwfTexture.setMinificationFilter(Filter.NEAREST);
@@ -677,7 +686,6 @@ function vtkOpenGLImageMapper(publicAPI, model) {
             }
           }
         }
-        model.pwfTexture.releaseGraphicsResources(model._openGLRenderWindow);
         model.pwfTexture.resetFormatAndType();
         model.pwfTexture.create2DFromRaw(pwfWidth, textureHeight, 1, VtkDataTypes.FLOAT, pwfFloatTable);
       } else {
@@ -685,13 +693,16 @@ function vtkOpenGLImageMapper(publicAPI, model) {
         pwfTable.fill(255.0);
         model.pwfTexture.create2DFromRaw(pwfWidth, 1, 1, VtkDataTypes.UNSIGNED_CHAR, pwfTable);
       }
-      model.pwfTextureString = pwfunToString;
       if (pwFunc) {
-        model._openGLRenderWindow.setGraphicsResourceForObject(pwFunc, model.pwfTexture, model.pwfTextureString);
+        model._openGLRenderWindow.setGraphicsResourceForObject(pwFunc, model.pwfTexture, pwfunToString);
+        if (pwFunc !== model._pwFunc) {
+          model._openGLRenderWindow.registerGraphicsResourceUser(pwFunc, publicAPI);
+          model._openGLRenderWindow.unregisterGraphicsResourceUser(model._pwFunc, publicAPI);
+        }
+        model._pwFunc = pwFunc;
       }
     } else {
-      model.pwfTexture = pwfTex.vtkObj;
-      model.pwfTextureString = pwfTex.hash;
+      model.pwfTexture = pwfTex.oglObject;
     }
 
     // Build outline thickness buffer
@@ -736,8 +747,8 @@ function vtkOpenGLImageMapper(publicAPI, model) {
         model.openGLTexture = vtkOpenGLTexture.newInstance({
           resizable: true
         });
-        model.openGLTexture.setOpenGLRenderWindow(model._openGLRenderWindow);
       }
+      model.openGLTexture.setOpenGLRenderWindow(model._openGLRenderWindow);
       // Use norm16 for scalar texture if the extension is available
       model.openGLTexture.setOglNorm16Ext(model.context.getExtension('EXT_texture_norm16'));
       if (iType === InterpolationType.NEAREST) {
@@ -845,19 +856,11 @@ function vtkOpenGLImageMapper(publicAPI, model) {
       } else {
         vtkErrorMacro('Reformat slicing not yet supported.');
       }
-      const tex = model._openGLRenderWindow.getGraphicsResourceForObject(scalars);
-      if (!tex?.vtkObj?.getHandle()) {
-        if (model._scalars !== scalars) {
-          model._openGLRenderWindow.releaseGraphicsResourcesForObject(model._scalars);
-          model._scalars = scalars;
-        }
-        model.openGLTexture.resetFormatAndType();
-        model.openGLTexture.create2DFilterableFromRaw(dims[0], dims[1], numComp, imgScalars.getDataType(), scalars, model.renderable.getPreferSizeOverAccuracy?.());
-        model._openGLRenderWindow.setGraphicsResourceForObject(scalars, model.openGLTexture, model.VBOBuildString);
-      } else {
-        model.openGLTexture = tex.vtkObj;
-        model.VBOBuildString = tex.hash;
-      }
+
+      // Don't share this resource as `scalars` is created in this function
+      // so it is impossible to share
+      model.openGLTexture.resetFormatAndType();
+      model.openGLTexture.create2DFilterableFromRaw(dims[0], dims[1], numComp, imgScalars.getDataType(), scalars, model.renderable.getPreferSizeOverAccuracy?.());
       model.openGLTexture.activate();
       model.openGLTexture.sendParameters();
       model.openGLTexture.deactivate();
@@ -894,12 +897,6 @@ function vtkOpenGLImageMapper(publicAPI, model) {
     }
   };
   publicAPI.updatelabelOutlineThicknessTexture = image => {
-    if (!model.labelOutlineThicknessTexture) {
-      model.labelOutlineThicknessTexture = vtkOpenGLTexture.newInstance({
-        resizable: false
-      });
-      model.labelOutlineThicknessTexture.setOpenGLRenderWindow(model._openGLRenderWindow);
-    }
     const labelOutlineThicknessArray = image.getProperty().getLabelOutlineThickness();
     const lTex = model._openGLRenderWindow.getGraphicsResourceForObject(labelOutlineThicknessArray);
 
@@ -907,7 +904,7 @@ function vtkOpenGLImageMapper(publicAPI, model) {
     // we can use it to decide whether to rebuild the labelOutlineThicknessTexture
     // or not
     const toString = `${labelOutlineThicknessArray.join('-')}`;
-    const reBuildL = !lTex?.vtkObj?.getHandle() || lTex?.hash !== toString || model.labelOutlineThicknessTextureString !== toString;
+    const reBuildL = !lTex?.oglObject?.getHandle() || lTex?.hash !== toString;
     if (reBuildL) {
       const lWidth = 1024;
       const lHeight = 1;
@@ -921,20 +918,26 @@ function vtkOpenGLImageMapper(publicAPI, model) {
         const thickness = typeof labelOutlineThicknessArray[i] !== 'undefined' ? labelOutlineThicknessArray[i] : labelOutlineThicknessArray[0];
         lTable[i] = thickness;
       }
-      model.labelOutlineThicknessTexture.releaseGraphicsResources(model._openGLRenderWindow);
+      model.labelOutlineThicknessTexture = vtkOpenGLTexture.newInstance({
+        resizable: false
+      });
+      model.labelOutlineThicknessTexture.setOpenGLRenderWindow(model._openGLRenderWindow);
       model.labelOutlineThicknessTexture.resetFormatAndType();
       model.labelOutlineThicknessTexture.setMinificationFilter(Filter.NEAREST);
       model.labelOutlineThicknessTexture.setMagnificationFilter(Filter.NEAREST);
 
       // Create a 2D texture (acting as 1D) from the raw data
       model.labelOutlineThicknessTexture.create2DFromRaw(lWidth, lHeight, 1, VtkDataTypes.UNSIGNED_CHAR, lTable);
-      model.labelOutlineThicknessTextureString = toString;
       if (labelOutlineThicknessArray) {
-        model._openGLRenderWindow.setGraphicsResourceForObject(labelOutlineThicknessArray, model.labelOutlineThicknessTexture, model.labelOutlineThicknessTextureString);
+        model._openGLRenderWindow.setGraphicsResourceForObject(labelOutlineThicknessArray, model.labelOutlineThicknessTexture, toString);
+        if (labelOutlineThicknessArray !== model._labelOutlineThicknessArray) {
+          model._openGLRenderWindow.registerGraphicsResourceUser(labelOutlineThicknessArray, publicAPI);
+          model._openGLRenderWindow.unregisterGraphicsResourceUser(model._labelOutlineThicknessArray, publicAPI);
+        }
+        model._labelOutlineThicknessArray = labelOutlineThicknessArray;
       }
     } else {
-      model.labelOutlineThicknessTexture = lTex.vtkObj;
-      model.labelOutlineThicknessTextureString = lTex.hash;
+      model.labelOutlineThicknessTexture = lTex.oglObject;
     }
   };
   publicAPI.getRenderTargetSize = () => {
@@ -954,6 +957,11 @@ function vtkOpenGLImageMapper(publicAPI, model) {
     } = model._openGLRenderer.getTiledSizeAndOrigin();
     return [lowerLeftU, lowerLeftV];
   };
+  publicAPI.delete = chain(() => {
+    if (model._openGLRenderWindow) {
+      unregisterGraphicsResources(model._openGLRenderWindow);
+    }
+  }, publicAPI.delete);
 }
 
 // ----------------------------------------------------------------------------
@@ -973,8 +981,11 @@ const DEFAULT_VALUES = {
   labelOutlineThicknessTextureString: null,
   lastHaveSeenDepthRequest: false,
   haveSeenDepthRequest: false,
-  lastTextureComponents: 0,
-  _scalars: null
+  lastTextureComponents: 0
+  // _scalars: null,
+  // _colorTransferFunc: null,
+  // _pwFunc: null,
+  // _labelOutlineThicknessArray: null,
 };
 
 // ----------------------------------------------------------------------------

package/Rendering/OpenGL/ImageResliceMapper.js

@@ -1,4 +1,4 @@
-import { n as newInstance$1, o as obj, g as get, c as macro } from '../../macros2.js';
+import { n as newInstance$1, o as obj, g as get, h as chain, c as macro } from '../../macros2.js';
 import { mat4, mat3, vec3 } from 'gl-matrix';
 import vtkClosedPolyLineToSurfaceFilter from '../../Filters/General/ClosedPolyLineToSurfaceFilter.js';
 import vtkCutter from '../../Filters/Core/Cutter.js';
@@ -53,6 +53,9 @@ function safeMatrixMultiply(matrixArray, matrixType, tmpMat) {
 function vtkOpenGLImageResliceMapper(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkOpenGLImageResliceMapper');
+  function unregisterGraphicsResources(renderWindow) {
+    [model._scalars, model._colorTransferFunc, model._pwFunc].forEach(coreObject => renderWindow.unregisterGraphicsResourceUser(coreObject, publicAPI));
+  }
   publicAPI.buildPass = prepass => {
     if (prepass) {
       model.currentRenderPass = null;
@@ -60,7 +63,12 @@ function vtkOpenGLImageResliceMapper(publicAPI, model) {
       model._openGLRenderer = publicAPI.getFirstAncestorOfType('vtkOpenGLRenderer');
       const ren = model._openGLRenderer.getRenderable();
       model._openGLCamera = model._openGLRenderer.getViewNodeFor(ren.getActiveCamera());
+      const oldOglRenderWindow = model._openGLRenderWindow;
       model._openGLRenderWindow = model._openGLRenderer.getLastAncestorOfType('vtkOpenGLRenderWindow');
+      if (oldOglRenderWindow && !oldOglRenderWindow.isDeleted() && oldOglRenderWindow !== model._openGLRenderWindow) {
+        // Unregister the mapper when the render window changes
+        unregisterGraphicsResources(oldOglRenderWindow);
+      }
       model.context = model._openGLRenderWindow.getContext();
       model.tris.setOpenGLRenderWindow(model._openGLRenderWindow);
     }
@@ -174,31 +182,29 @@ function vtkOpenGLImageResliceMapper(publicAPI, model) {
     if (!scalars) {
       return;
     }
-    if (model._scalars !== scalars) {
-      model._openGLRenderWindow.releaseGraphicsResourcesForObject(model._scalars);
-      model._scalars = scalars;
-    }
     const numComp = scalars.getNumberOfComponents();
     let toString = `${image.getMTime()}A${scalars.getMTime()}`;
     const tex = model._openGLRenderWindow.getGraphicsResourceForObject(scalars);
-    const reBuildTex = !tex?.vtkObj?.getHandle() || tex?.hash !== toString;
+    const reBuildTex = !tex?.oglObject?.getHandle() || tex?.hash !== toString;
     if (reBuildTex) {
-      if (!model.openGLTexture) {
-        model.openGLTexture = vtkOpenGLTexture.newInstance();
-        model.openGLTexture.setOpenGLRenderWindow(model._openGLRenderWindow);
-      }
+      model.openGLTexture = vtkOpenGLTexture.newInstance();
+      model.openGLTexture.setOpenGLRenderWindow(model._openGLRenderWindow);
       // Build the image scalar texture
       const dims = image.getDimensions();
       // Use norm16 for the 3D texture if the extension is available
       model.openGLTexture.setOglNorm16Ext(model.context.getExtension('EXT_texture_norm16'));
-      model.openGLTexture.releaseGraphicsResources(model._openGLRenderWindow);
       model.openGLTexture.resetFormatAndType();
       model.openGLTexture.create3DFilterableFromDataArray(dims[0], dims[1], dims[2], scalars);
       if (scalars) {
         model._openGLRenderWindow.setGraphicsResourceForObject(scalars, model.openGLTexture, toString);
+        if (scalars !== model._scalars) {
+          model._openGLRenderWindow.registerGraphicsResourceUser(scalars, publicAPI);
+          model._openGLRenderWindow.unregisterGraphicsResourceUser(model._scalars, publicAPI);
+        }
+        model._scalars = scalars;
       }
     } else {
-      model.openGLTexture = tex.vtkObj;
+      model.openGLTexture = tex.oglObject;
     }
     const ppty = actor.getProperty();
     const iComps = ppty.getIndependentComponents();
@@ -207,15 +213,13 @@ function vtkOpenGLImageResliceMapper(publicAPI, model) {
     const colorTransferFunc = ppty.getRGBTransferFunction();
     toString = computeFnToString(ppty, colorTransferFunc, numIComps);
     const cTex = model._openGLRenderWindow.getGraphicsResourceForObject(colorTransferFunc);
-    const reBuildC = !cTex?.vtkObj?.getHandle() || cTex?.hash !== toString || model.colorTextureString !== toString;
+    const reBuildC = !cTex?.oglObject?.getHandle() || cTex?.hash !== toString;
     if (reBuildC) {
       const cWidth = 1024;
       const cSize = cWidth * textureHeight * 3;
       const cTable = new Uint8ClampedArray(cSize);
-      if (!model.colorTexture) {
-        model.colorTexture = vtkOpenGLTexture.newInstance();
-        model.colorTexture.setOpenGLRenderWindow(model._openGLRenderWindow);
-      }
+      model.colorTexture = vtkOpenGLTexture.newInstance();
+      model.colorTexture.setOpenGLRenderWindow(model._openGLRenderWindow);
       if (colorTransferFunc) {
         const tmpTable = new Float32Array(cWidth * 3);
         for (let c = 0; c < numIComps; c++) {
@@ -233,7 +237,6 @@ function vtkOpenGLImageResliceMapper(publicAPI, model) {
             }
           }
         }
-        model.colorTexture.releaseGraphicsResources(model._openGLRenderWindow);
         model.colorTexture.resetFormatAndType();
         model.colorTexture.create2DFromRaw(cWidth, textureHeight, 3, VtkDataTypes.UNSIGNED_CHAR, cTable);
       } else {
@@ -242,17 +245,19 @@ function vtkOpenGLImageResliceMapper(publicAPI, model) {
           cTable[i + 1] = 255.0 * i / ((cWidth - 1) * 3);
           cTable[i + 2] = 255.0 * i / ((cWidth - 1) * 3);
         }
-        model.colorTexture.releaseGraphicsResources(model._openGLRenderWindow);
         model.colorTexture.resetFormatAndType();
         model.colorTexture.create2DFromRaw(cWidth, 1, 3, VtkDataTypes.UNSIGNED_CHAR, cTable);
       }
-      model.colorTextureString = toString;
       if (colorTransferFunc) {
-        model._openGLRenderWindow.setGraphicsResourceForObject(colorTransferFunc, model.colorTexture, model.colorTextureString);
+        model._openGLRenderWindow.setGraphicsResourceForObject(colorTransferFunc, model.colorTexture, toString);
+        if (colorTransferFunc !== model._colorTransferFunc) {
+          model._openGLRenderWindow.registerGraphicsResourceUser(colorTransferFunc, publicAPI);
+          model._openGLRenderWindow.unregisterGraphicsResourceUser(model._colorTransferFunc, publicAPI);
+        }
+        model._colorTransferFunc = colorTransferFunc;
       }
     } else {
-      model.colorTexture = cTex.vtkObj;
-      model.colorTextureString = cTex.hash;
+      model.colorTexture = cTex.oglObject;
     }
 
     // Build piecewise function buffer.  This buffer is used either
@@ -262,15 +267,13 @@ function vtkOpenGLImageResliceMapper(publicAPI, model) {
     toString = computeFnToString(ppty, pwFunc, numIComps);
     const pwfTex = model._openGLRenderWindow.getGraphicsResourceForObject(pwFunc);
     // rebuild opacity tfun?
-    const reBuildPwf = !pwfTex?.vtkObj?.getHandle() || pwfTex?.hash !== toString || model.pwfTextureString !== toString;
+    const reBuildPwf = !pwfTex?.oglObject?.getHandle() || pwfTex?.hash !== toString;
     if (reBuildPwf) {
       const pwfWidth = 1024;
       const pwfSize = pwfWidth * textureHeight;
       const pwfTable = new Uint8ClampedArray(pwfSize);
-      if (!model.pwfTexture) {
-        model.pwfTexture = vtkOpenGLTexture.newInstance();
-        model.pwfTexture.setOpenGLRenderWindow(model._openGLRenderWindow);
-      }
+      model.pwfTexture = vtkOpenGLTexture.newInstance();
+      model.pwfTexture.setOpenGLRenderWindow(model._openGLRenderWindow);
       if (pwFunc) {
         const pwfFloatTable = new Float32Array(pwfSize);
         const tmpTable = new Float32Array(pwfWidth);
@@ -295,23 +298,24 @@ function vtkOpenGLImageResliceMapper(publicAPI, model) {
             }
           }
         }
-        model.pwfTexture.releaseGraphicsResources(model._openGLRenderWindow);
         model.pwfTexture.resetFormatAndType();
         model.pwfTexture.create2DFromRaw(pwfWidth, textureHeight, 1, VtkDataTypes.FLOAT, pwfFloatTable);
       } else {
         // default is opaque
         pwfTable.fill(255.0);
-        model.pwfTexture.releaseGraphicsResources(model._openGLRenderWindow);
         model.pwfTexture.resetFormatAndType();
         model.pwfTexture.create2DFromRaw(pwfWidth, 1, 1, VtkDataTypes.UNSIGNED_CHAR, pwfTable);
       }
-      model.pwfTextureString = toString;
       if (pwFunc) {
-        model._openGLRenderWindow.setGraphicsResourceForObject(pwFunc, model.pwfTexture, model.pwfTextureString);
+        model._openGLRenderWindow.setGraphicsResourceForObject(pwFunc, model.pwfTexture, toString);
+        if (pwFunc !== model._pwFunc) {
+          model._openGLRenderWindow.registerGraphicsResourceUser(pwFunc, publicAPI);
+          model._openGLRenderWindow.unregisterGraphicsResourceUser(model._pwFunc, publicAPI);
+        }
+        model._pwFunc = pwFunc;
       }
     } else {
-      model.pwfTexture = pwfTex.vtkObj;
-      model.pwfTextureString = pwfTex.hash;
+      model.pwfTexture = pwfTex.oglObject;
     }
     const vboString = `${model.resliceGeom.getMTime()}A${model.renderable.getSlabThickness()}`;
     if (!model.tris.getCABO().getElementCount() || model.VBOBuildString !== vboString) {
@@ -854,6 +858,11 @@ function vtkOpenGLImageResliceMapper(publicAPI, model) {
       model._externalOpenGLTexture = true;
     }
   };
+  publicAPI.delete = chain(() => {
+    if (model._openGLRenderWindow) {
+      unregisterGraphicsResources(model._openGLRenderWindow);
+    }
+  }, publicAPI.delete);
 }
 
 // ----------------------------------------------------------------------------
@@ -878,8 +887,10 @@ const DEFAULT_VALUES = {
   tris: null,
   colorTexture: null,
   pwfTexture: null,
-  _externalOpenGLTexture: false,
-  _scalars: null
+  _externalOpenGLTexture: false
+  // _scalars: null,
+  // _colorTransferFunc: null,
+  // _pwFunc: null,
 };
 
 // ----------------------------------------------------------------------------

package/Rendering/OpenGL/RenderWindow.d.ts

@@ -441,8 +441,8 @@ export interface vtkOpenGLRenderWindow extends vtkOpenGLRenderWindowBase {
    */
   setGraphicsResourceForObject(
     vtkObj: vtkCellArray | vtkDataArray | vtkPoints,
-    gObj: vtkOpenGLTexture | vtkBufferObject,
-    hash: string
+    gObj: Nullable<vtkOpenGLTexture | vtkBufferObject>,
+    hash: Nullable<string>
   ): void;
 
   /**
@@ -454,9 +454,17 @@ export interface vtkOpenGLRenderWindow extends vtkOpenGLRenderWindowBase {
    * the cached resource.
    * @return {Object} Dictionary with the graphics resource and string hash
    */
-  getGraphicsResourceForObject(
-    vtkObj: vtkCellArray | vtkDataArray | vtkPoints
-  ): { gObj: vtkOpenGLTexture | vtkBufferObject; hash: string };
+  getGraphicsResourceForObject<
+    T extends vtkCellArray | vtkDataArray | vtkPoints
+  >(
+    vtkObj: T
+  ):
+    | {
+        coreObject: T;
+        oglObject: Nullable<vtkOpenGLTexture | vtkBufferObject>;
+        hash: Nullable<string>;
+      }
+    | undefined;
 
   /**
    * Get approximate graphics memory usage, in bytes, for the context. This is a simple computation

package/Rendering/OpenGL/RenderWindow.js

@@ -21,7 +21,7 @@ const SCREENSHOT_PLACEHOLDER = {
   width: '100%',
   height: '100%'
 };
-const parentMethodsToProxy = ['activateTexture', 'deactivateTexture', 'disableCullFace', 'enableCullFace', 'get3DContext', 'getActiveFramebuffer', 'getContext', 'getDefaultTextureByteSize', 'getDefaultTextureInternalFormat', 'getDefaultToWebgl2', 'getGLInformations', 'getGraphicsMemoryInfo', 'getGraphicsResourceForObject', 'getHardwareMaximumLineWidth', 'getPixelData', 'getShaderCache', 'getTextureUnitForTexture', 'getTextureUnitManager', 'getWebgl2', 'makeCurrent', 'releaseGraphicsResources', 'releaseGraphicsResourcesForObject', 'restoreContext', 'setActiveFramebuffer', 'setContext', 'setDefaultToWebgl2', 'setGraphicsResourceForObject'];
+const parentMethodsToProxy = ['activateTexture', 'deactivateTexture', 'disableCullFace', 'enableCullFace', 'get3DContext', 'getActiveFramebuffer', 'getContext', 'getDefaultTextureByteSize', 'getDefaultTextureInternalFormat', 'getDefaultToWebgl2', 'getGLInformations', 'getGraphicsMemoryInfo', 'getGraphicsResourceForObject', 'getHardwareMaximumLineWidth', 'getPixelData', 'getShaderCache', 'getTextureUnitForTexture', 'getTextureUnitManager', 'getWebgl2', 'makeCurrent', 'releaseGraphicsResources', 'registerGraphicsResourceUser', 'unregisterGraphicsResourceUser', 'restoreContext', 'setActiveFramebuffer', 'setContext', 'setDefaultToWebgl2', 'setGraphicsResourceForObject'];
 function checkRenderTargetSupport(gl, format, type) {
   // create temporary frame buffer and texture
   const framebuffer = gl.createFramebuffer();
@@ -676,49 +676,66 @@ function vtkOpenGLRenderWindow(publicAPI, model) {
     }
     return modified;
   };
-  publicAPI.getGraphicsResourceForObject = vtkObj => {
-    if (!vtkObj) {
-      return null;
+  publicAPI.registerGraphicsResourceUser = (coreObject, newUser) => {
+    // Try to create the graphics resource if it doesn't exist
+    if (!model._graphicsResources.has(coreObject)) {
+      publicAPI.setGraphicsResourceForObject(coreObject, null, null);
+    }
+    // Add newUser to the set of users
+    const sharedResource = model._graphicsResources.get(coreObject);
+    sharedResource?.users.add(newUser);
+  };
+  publicAPI.unregisterGraphicsResourceUser = (coreObject, oldUser) => {
+    const sharedResource = model._graphicsResources.get(coreObject);
+    if (!sharedResource) {
+      return;
+    }
+    sharedResource.users.delete(oldUser);
+    // Release graphics resources when the number of users reaches 0
+    if (!sharedResource.users.size) {
+      sharedResource.oglObject?.releaseGraphicsResources(publicAPI);
+      model._graphicsResources.delete(coreObject);
     }
-    const vtko = model._graphicsResources.get(vtkObj);
-    const vtkh = model._graphicsResourceHash.get(vtkObj);
-    return {
-      vtkObj: vtko,
-      hash: vtkh
-    };
   };
-  publicAPI.setGraphicsResourceForObject = (vtkObj, gObj, hash) => {
-    if (!vtkObj) {
+  publicAPI.getGraphicsResourceForObject = coreObject => model._graphicsResources.get(coreObject);
+  publicAPI.setGraphicsResourceForObject = (coreObject, oglObject, hash) => {
+    if (!coreObject) {
       return;
     }
-    model._graphicsResources.set(vtkObj, gObj);
-    model._graphicsResourceHash.set(vtkObj, hash);
+    const sharedResource = model._graphicsResources.get(coreObject);
+    // Release the old resource
+    sharedResource?.oglObject?.releaseGraphicsResources(publicAPI);
+    // Keep the same users that have registered for this coreObject
+    model._graphicsResources.set(coreObject, {
+      coreObject,
+      oglObject,
+      hash,
+      users: sharedResource?.users ?? new Set()
+    });
   };
   publicAPI.getGraphicsMemoryInfo = () => {
     let memUsed = 0;
-    model._graphicsResources.forEach((gObj, vtkObj) => {
-      memUsed += gObj.getAllocatedGPUMemoryInBytes();
+    model._graphicsResources.forEach(_ref3 => {
+      let {
+        oglObject
+      } = _ref3;
+      memUsed += oglObject.getAllocatedGPUMemoryInBytes();
     });
     return memUsed;
   };
-  publicAPI.releaseGraphicsResourcesForObject = vtkObj => {
-    if (!vtkObj) {
-      return false;
-    }
-    model._graphicsResources.get(vtkObj)?.releaseGraphicsResources(publicAPI);
-    return model._graphicsResources.delete(vtkObj) && model._graphicsResourceHash.delete(vtkObj);
-  };
   publicAPI.releaseGraphicsResources = () => {
     // Clear the shader cache
     if (model.shaderCache !== null) {
       model.shaderCache.releaseGraphicsResources(publicAPI);
     }
     // Free cached graphics resources at the context level
-    model._graphicsResources.forEach((gObj, vtkObj) => {
-      gObj.releaseGraphicsResources(publicAPI);
+    model._graphicsResources.forEach(_ref4 => {
+      let {
+        oglObject
+      } = _ref4;
+      oglObject.releaseGraphicsResources(publicAPI);
     });
     model._graphicsResources.clear();
-    model._graphicsResourceHash.clear();
     if (model.textureUnitManager !== null) {
       model.textureUnitManager.freeAll();
     }
@@ -800,7 +817,6 @@ function extend(publicAPI, model) {
   model.bgImage.style.zIndex = '-1';
   model._textureResourceIds = new Map();
   model._graphicsResources = new Map();
-  model._graphicsResourceHash = new Map();
   model._glInformation = null;
   model.myFactory = vtkViewNodeFactory.newInstance();
   model.shaderCache = vtkShaderCache.newInstance();

package/Rendering/OpenGL/VolumeMapper.js

@@ -114,6 +114,9 @@ function getColorCodeFromPreset(colorMixPreset) {
 function vtkOpenGLVolumeMapper(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkOpenGLVolumeMapper');
+  function unregisterGraphicsResources(renderWindow) {
+    [model._scalars, model._scalarOpacityFunc, model._colorTransferFunc, model._labelOutlineThicknessArray].forEach(coreObject => renderWindow.unregisterGraphicsResourceUser(coreObject, publicAPI));
+  }
   publicAPI.buildPass = () => {
     model.zBufferTexture = null;
   };
@@ -133,17 +136,16 @@ function vtkOpenGLVolumeMapper(publicAPI, model) {
   // Renders myself
   publicAPI.volumePass = (prepass, renderPass) => {
     if (prepass) {
+      const oldOglRenderWindow = model._openGLRenderWindow;
       model._openGLRenderWindow = publicAPI.getLastAncestorOfType('vtkOpenGLRenderWindow');
+      if (oldOglRenderWindow && !oldOglRenderWindow.isDeleted() && oldOglRenderWindow !== model._openGLRenderWindow) {
+        // Unregister the mapper when the render window changes
+        unregisterGraphicsResources(oldOglRenderWindow);
+      }
       model.context = model._openGLRenderWindow.getContext();
       model.tris.setOpenGLRenderWindow(model._openGLRenderWindow);
       model.jitterTexture.setOpenGLRenderWindow(model._openGLRenderWindow);
       model.framebuffer.setOpenGLRenderWindow(model._openGLRenderWindow);
-
-      // Per Component?
-      model.scalarTexture.setOpenGLRenderWindow(model._openGLRenderWindow);
-      model.colorTexture.setOpenGLRenderWindow(model._openGLRenderWindow);
-      model.opacityTexture.setOpenGLRenderWindow(model._openGLRenderWindow);
-      model.labelOutlineThicknessTexture.setOpenGLRenderWindow(model._openGLRenderWindow);
       model.openGLVolume = publicAPI.getFirstAncestorOfType('vtkOpenGLVolume');
       const actor = model.openGLVolume.getRenderable();
       model._openGLRenderer = publicAPI.getFirstAncestorOfType('vtkOpenGLRenderer');
@@ -796,6 +798,10 @@ function vtkOpenGLVolumeMapper(publicAPI, model) {
       model._animationRateSubscription.unsubscribe();
       model._animationRateSubscription = null;
     }
+  }, () => {
+    if (model._openGLRenderWindow) {
+      unregisterGraphicsResources(model._openGLRenderWindow);
+    }
   }, publicAPI.delete);
   publicAPI.getRenderTargetSize = () => {
     if (model._useSmallViewport) {
@@ -1018,10 +1024,6 @@ function vtkOpenGLVolumeMapper(publicAPI, model) {
     if (!scalars) {
       return;
     }
-    if (model._scalars !== scalars) {
-      model._openGLRenderWindow.releaseGraphicsResourcesForObject(model._scalars);
-      model._scalars = scalars;
-    }
     const vprop = actor.getProperty();
     if (!model.jitterTexture.getHandle()) {
       const oTable = new Uint8Array(32 * 32);
@@ -1038,8 +1040,10 @@ function vtkOpenGLVolumeMapper(publicAPI, model) {
     const scalarOpacityFunc = vprop.getScalarOpacity();
     const opTex = model._openGLRenderWindow.getGraphicsResourceForObject(scalarOpacityFunc);
     let toString = computeFnToString(scalarOpacityFunc, useIndependentComps, numIComps);
-    const reBuildOp = !opTex.vtkObj || opTex.hash !== toString || model.opacityTextureString !== toString;
+    const reBuildOp = !opTex?.oglObject || opTex.hash !== toString;
     if (reBuildOp) {
+      model.opacityTexture = vtkOpenGLTexture.newInstance();
+      model.opacityTexture.setOpenGLRenderWindow(model._openGLRenderWindow);
       // rebuild opacity tfun?
       const oWidth = 1024;
       const oSize = oWidth * 2 * numIComps;
@@ -1056,7 +1060,6 @@ function vtkOpenGLVolumeMapper(publicAPI, model) {
           ofTable[c * oWidth * 2 + i + oWidth] = ofTable[c * oWidth * 2 + i];
         }
       }
-      model.opacityTexture.releaseGraphicsResources(model._openGLRenderWindow);
       model.opacityTexture.resetFormatAndType();
       model.opacityTexture.setMinificationFilter(Filter.LINEAR);
       model.opacityTexture.setMagnificationFilter(Filter.LINEAR);
@@ -1074,21 +1077,26 @@ function vtkOpenGLVolumeMapper(publicAPI, model) {
         }
         model.opacityTexture.create2DFromRaw(oWidth, 2 * numIComps, 1, VtkDataTypes.UNSIGNED_CHAR, oTable);
       }
-      model.opacityTextureString = toString;
       if (scalarOpacityFunc) {
-        model._openGLRenderWindow.setGraphicsResourceForObject(scalarOpacityFunc, model.opacityTexture, model.opacityTextureString);
+        model._openGLRenderWindow.setGraphicsResourceForObject(scalarOpacityFunc, model.opacityTexture, toString);
+        if (scalarOpacityFunc !== model._scalarOpacityFunc) {
+          model._openGLRenderWindow.registerGraphicsResourceUser(scalarOpacityFunc, publicAPI);
+          model._openGLRenderWindow.unregisterGraphicsResourceUser(model._scalarOpacityFunc, publicAPI);
+        }
+        model._scalarOpacityFunc = scalarOpacityFunc;
       }
     } else {
-      model.opacityTexture = opTex.vtkObj;
-      model.opacityTextureString = opTex.hash;
+      model.opacityTexture = opTex.oglObject;
     }
 
     // rebuild color tfun?
     const colorTransferFunc = vprop.getRGBTransferFunction();
     toString = computeFnToString(colorTransferFunc, useIndependentComps, numIComps);
     const cTex = model._openGLRenderWindow.getGraphicsResourceForObject(colorTransferFunc);
-    const reBuildC = !cTex?.vtkObj?.getHandle() || cTex?.hash !== toString || model.colorTextureString !== toString;
+    const reBuildC = !cTex?.oglObject?.getHandle() || cTex?.hash !== toString;
     if (reBuildC) {
+      model.colorTexture = vtkOpenGLTexture.newInstance();
+      model.colorTexture.setOpenGLRenderWindow(model._openGLRenderWindow);
       const cWidth = 1024;
       const cSize = cWidth * 2 * numIComps * 3;
       const cTable = new Uint8ClampedArray(cSize);
@@ -1102,37 +1110,45 @@ function vtkOpenGLVolumeMapper(publicAPI, model) {
           cTable[c * cWidth * 6 + i + cWidth * 3] = 255.0 * tmpTable[i];
         }
       }
-      model.colorTexture.releaseGraphicsResources(model._openGLRenderWindow);
       model.colorTexture.resetFormatAndType();
       model.colorTexture.setMinificationFilter(Filter.LINEAR);
       model.colorTexture.setMagnificationFilter(Filter.LINEAR);
       model.colorTexture.create2DFromRaw(cWidth, 2 * numIComps, 3, VtkDataTypes.UNSIGNED_CHAR, cTable);
-      model.colorTextureString = toString;
       if (colorTransferFunc) {
-        model._openGLRenderWindow.setGraphicsResourceForObject(colorTransferFunc, model.colorTexture, model.colorTextureString);
+        model._openGLRenderWindow.setGraphicsResourceForObject(colorTransferFunc, model.colorTexture, toString);
+        if (colorTransferFunc !== model._colorTransferFunc) {
+          model._openGLRenderWindow.registerGraphicsResourceUser(colorTransferFunc, publicAPI);
+          model._openGLRenderWindow.unregisterGraphicsResourceUser(model._colorTransferFunc, publicAPI);
+        }
+        model._colorTransferFunc = colorTransferFunc;
       }
     } else {
-      model.colorTexture = cTex.vtkObj;
-      model.colorTextureString = cTex.hash;
+      model.colorTexture = cTex.oglObject;
     }
     publicAPI.updateLabelOutlineThicknessTexture(actor);
     const tex = model._openGLRenderWindow.getGraphicsResourceForObject(scalars);
     // rebuild the scalarTexture if the data has changed
     toString = `${image.getMTime()}A${scalars.getMTime()}`;
-    const reBuildTex = !tex?.vtkObj?.getHandle() || tex?.hash !== toString;
+    const reBuildTex = !tex?.oglObject?.getHandle() || tex?.hash !== toString;
     if (reBuildTex) {
+      model.scalarTexture = vtkOpenGLTexture.newInstance();
+      model.scalarTexture.setOpenGLRenderWindow(model._openGLRenderWindow);
       // Build the textures
       const dims = image.getDimensions();
       // Use norm16 for scalar texture if the extension is available
       model.scalarTexture.setOglNorm16Ext(model.context.getExtension('EXT_texture_norm16'));
-      model.scalarTexture.releaseGraphicsResources(model._openGLRenderWindow);
       model.scalarTexture.resetFormatAndType();
       model.scalarTexture.create3DFilterableFromDataArray(dims[0], dims[1], dims[2], scalars, model.renderable.getPreferSizeOverAccuracy());
       if (scalars) {
         model._openGLRenderWindow.setGraphicsResourceForObject(scalars, model.scalarTexture, toString);
+        if (scalars !== model._scalars) {
+          model._openGLRenderWindow.registerGraphicsResourceUser(scalars, publicAPI);
+          model._openGLRenderWindow.unregisterGraphicsResourceUser(model._scalars, publicAPI);
+        }
+        model._scalars = scalars;
       }
     } else {
-      model.scalarTexture = tex.vtkObj;
+      model.scalarTexture = tex.oglObject;
     }
     if (!model.tris.getCABO().getElementCount()) {
       // build the CABO
@@ -1202,8 +1218,10 @@ function vtkOpenGLVolumeMapper(publicAPI, model) {
     // we can use it to decide whether to rebuild the labelOutlineThicknessTexture
     // or not
     const toString = `${labelOutlineThicknessArray.join('-')}`;
-    const reBuildL = !lTex?.vtkObj?.getHandle() || lTex?.hash !== toString || model.labelOutlineThicknessTextureString !== toString;
+    const reBuildL = !lTex?.oglObject?.getHandle() || lTex?.hash !== toString;
     if (reBuildL) {
+      model.labelOutlineThicknessTexture = vtkOpenGLTexture.newInstance();
+      model.labelOutlineThicknessTexture.setOpenGLRenderWindow(model._openGLRenderWindow);
       const lWidth = 1024;
       const lHeight = 1;
       const lSize = lWidth * lHeight;
@@ -1216,20 +1234,22 @@ function vtkOpenGLVolumeMapper(publicAPI, model) {
         const thickness = typeof labelOutlineThicknessArray[i] !== 'undefined' ? labelOutlineThicknessArray[i] : labelOutlineThicknessArray[0];
         lTable[i] = thickness;
       }
-      model.labelOutlineThicknessTexture.releaseGraphicsResources(model._openGLRenderWindow);
       model.labelOutlineThicknessTexture.resetFormatAndType();
       model.labelOutlineThicknessTexture.setMinificationFilter(Filter.NEAREST);
       model.labelOutlineThicknessTexture.setMagnificationFilter(Filter.NEAREST);
 
       // Create a 2D texture (acting as 1D) from the raw data
       model.labelOutlineThicknessTexture.create2DFromRaw(lWidth, lHeight, 1, VtkDataTypes.UNSIGNED_CHAR, lTable);
-      model.labelOutlineThicknessTextureString = toString;
       if (labelOutlineThicknessArray) {
-        model._openGLRenderWindow.setGraphicsResourceForObject(labelOutlineThicknessArray, model.labelOutlineThicknessTexture, model.labelOutlineThicknessTextureString);
+        model._openGLRenderWindow.setGraphicsResourceForObject(labelOutlineThicknessArray, model.labelOutlineThicknessTexture, toString);
+        if (labelOutlineThicknessArray !== model._labelOutlineThicknessArray) {
+          model._openGLRenderWindow.registerGraphicsResourceUser(labelOutlineThicknessArray, publicAPI);
+          model._openGLRenderWindow.unregisterGraphicsResourceUser(model._labelOutlineThicknessArray, publicAPI);
+        }
+        model._labelOutlineThicknessArray = labelOutlineThicknessArray;
       }
     } else {
-      model.labelOutlineThicknessTexture = lTex.vtkObj;
-      model.labelOutlineThicknessTextureString = lTex.hash;
+      model.labelOutlineThicknessTexture = lTex.oglObject;
     }
   };
 }
@@ -1264,8 +1284,11 @@ const DEFAULT_VALUES = {
   modelToView: null,
   projectionToView: null,
   avgWindowArea: 0.0,
-  avgFrameTime: 0.0,
-  _scalars: null
+  avgFrameTime: 0.0
+  // _scalars: null,
+  // _scalarOpacityFunc: null,
+  // _colorTransferFunc: null,
+  // _labelOutlineThicknessArray: null,
 };
 
 // ----------------------------------------------------------------------------
@@ -1282,13 +1305,9 @@ function extend(publicAPI, model) {
     mtime: 0
   });
   model.tris = vtkHelper.newInstance();
-  model.scalarTexture = vtkOpenGLTexture.newInstance();
-  model.opacityTexture = vtkOpenGLTexture.newInstance();
-  model.colorTexture = vtkOpenGLTexture.newInstance();
   model.jitterTexture = vtkOpenGLTexture.newInstance();
   model.jitterTexture.setWrapS(Wrap.REPEAT);
   model.jitterTexture.setWrapT(Wrap.REPEAT);
-  model.labelOutlineThicknessTexture = vtkOpenGLTexture.newInstance();
   model.framebuffer = vtkOpenGLFramebuffer.newInstance();
   model.idxToView = mat4.identity(new Float64Array(16));
   model.idxNormalMatrix = mat3.identity(new Float64Array(9));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kitware/vtk.js",
-  "version": "30.9.3",
+  "version": "31.0.0",
   "description": "Visualization Toolkit for the Web",
   "keywords": [
     "3d",