@kitware/vtk.js 28.12.5 → 28.13.1

package/Interaction/UI/FPSMonitor.js

@@ -123,6 +123,7 @@ function vtkFPSMonitor(publicAPI, model) {
       model.fpsSum -= model.buffer.shift();
     }
     renderTitle();
+    renderInfo();
     renderCanvas();
   }
 

package/Proxy/Core/View2DProxy.js

@@ -257,6 +257,9 @@ function vtkView2DProxy(publicAPI, model) {
   }
   publicAPI.bindRepresentationToManipulator = representation => {
     let nbListeners = 0;
+    if (!representation.getProxyId) {
+      return nbListeners;
+    }
     model.rangeManipulator.removeAllListeners();
     model.sliceRepresentation = representation;
     while (model.sliceRepresentationSubscriptions.length) {

package/Rendering/Core/ImageProperty.js

@@ -38,7 +38,9 @@ function vtkImageProperty(publicAPI, model) {
   };
 
   // Set the color of a volume to an RGB transfer function
-  publicAPI.setRGBTransferFunction = (index, func) => {
+  publicAPI.setRGBTransferFunction = function () {
+    let index = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
+    let func = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
     // backwards compatible call without the component index
     let idx = index;
     let transferFunc = func;
@@ -61,7 +63,9 @@ function vtkImageProperty(publicAPI, model) {
   };
 
   // Set the piecewise function
-  publicAPI.setPiecewiseFunction = (index, func) => {
+  publicAPI.setPiecewiseFunction = function () {
+    let index = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
+    let func = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
     let idx = index;
     let transferFunc = func;
     if (!Number.isInteger(index)) {
@@ -83,7 +87,9 @@ function vtkImageProperty(publicAPI, model) {
   };
 
   // Alias to set the piecewise function
-  publicAPI.setScalarOpacity = (index, func) => {
+  publicAPI.setScalarOpacity = function () {
+    let index = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
+    let func = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
     // backwards compatible call without the component index
     let idx = index;
     let transferFunc = func;
@@ -99,7 +105,9 @@ function vtkImageProperty(publicAPI, model) {
     let idx = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
     return publicAPI.getPiecewiseFunction(idx);
   };
-  publicAPI.setComponentWeight = (index, value) => {
+  publicAPI.setComponentWeight = function () {
+    let index = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
+    let value = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1;
     if (index < 0 || index >= VTK_MAX_VRCOMP) {
       vtkErrorMacro('Invalid index');
       return false;
@@ -112,7 +120,8 @@ function vtkImageProperty(publicAPI, model) {
     }
     return false;
   };
-  publicAPI.getComponentWeight = index => {
+  publicAPI.getComponentWeight = function () {
+    let index = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
     if (index < 0 || index >= VTK_MAX_VRCOMP) {
       vtkErrorMacro('Invalid index');
       return 0.0;

package/Rendering/Core/Mapper2D.js

@@ -116,6 +116,16 @@ function vtkMapper2D(publicAPI, model) {
     }
     model.colorBuildString = `${publicAPI.getMTime()}${scalars.getMTime()}${alpha}`;
   };
+  publicAPI.getPrimitiveCount = () => {
+    const input = publicAPI.getInputData();
+    const pcount = {
+      points: input.getPoints().getNumberOfValues() / 3,
+      verts: input.getVerts().getNumberOfValues() - input.getVerts().getNumberOfCells(),
+      lines: input.getLines().getNumberOfValues() - 2 * input.getLines().getNumberOfCells(),
+      triangles: input.getPolys().getNumberOfValues() - 3 * input.getPolys().getNumberOfCells()
+    };
+    return pcount;
+  };
 }
 
 // ----------------------------------------------------------------------------

package/Rendering/Core/RenderWindow.js

@@ -94,22 +94,31 @@ function vtkRenderWindow(publicAPI, model) {
   publicAPI.getStatistics = () => {
     const results = {
       propCount: 0,
-      invisiblePropCount: 0
+      invisiblePropCount: 0,
+      gpuMemoryMB: 0
     };
+    model._views.forEach(v => {
+      results.gpuMemoryMB += v.getGraphicsMemoryInfo() / 1e6;
+    });
     model.renderers.forEach(ren => {
       const props = ren.getViewProps();
+      const gren = model._views[0].getViewNodeFor(ren);
       props.forEach(prop => {
         if (prop.getVisibility()) {
           results.propCount += 1;
           const mpr = prop.getMapper && prop.getMapper();
           if (mpr && mpr.getPrimitiveCount) {
-            const pcount = mpr.getPrimitiveCount();
-            Object.keys(pcount).forEach(keyName => {
-              if (!results[keyName]) {
-                results[keyName] = 0;
-              }
-              results[keyName] += pcount[keyName];
-            });
+            const gmpr = gren.getViewNodeFor(mpr);
+            if (gmpr) {
+              results.gpuMemoryMB += gmpr.getAllocatedGPUMemoryInBytes() / 1e6;
+              const pcount = mpr.getPrimitiveCount();
+              Object.keys(pcount).forEach(keyName => {
+                if (!results[keyName]) {
+                  results[keyName] = 0;
+                }
+                results[keyName] += pcount[keyName];
+              });
+            }
           }
         } else {
           results.invisiblePropCount += 1;

package/Rendering/Core/VolumeProperty.js

@@ -63,7 +63,9 @@ function vtkVolumeProperty(publicAPI, model) {
   };
 
   // Set the color of a volume to a gray transfer function
-  publicAPI.setGrayTransferFunction = (index, func) => {
+  publicAPI.setGrayTransferFunction = function () {
+    let index = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
+    let func = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
     let modified = false;
     if (model.componentData[index].grayTransferFunction !== func) {
       model.componentData[index].grayTransferFunction = func;
@@ -80,7 +82,8 @@ function vtkVolumeProperty(publicAPI, model) {
   };
 
   // Get the currently set gray transfer function. Create one if none set.
-  publicAPI.getGrayTransferFunction = index => {
+  publicAPI.getGrayTransferFunction = function () {
+    let index = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
     if (model.componentData[index].grayTransferFunction === null) {
       model.componentData[index].grayTransferFunction = vtkPiecewiseFunction.newInstance();
       model.componentData[index].grayTransferFunction.addPoint(0, 0.0);
@@ -94,7 +97,9 @@ function vtkVolumeProperty(publicAPI, model) {
   };
 
   // Set the color of a volume to an RGB transfer function
-  publicAPI.setRGBTransferFunction = (index, func) => {
+  publicAPI.setRGBTransferFunction = function () {
+    let index = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
+    let func = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
     let modified = false;
     if (model.componentData[index].rGBTransferFunction !== func) {
       model.componentData[index].rGBTransferFunction = func;
@@ -111,7 +116,8 @@ function vtkVolumeProperty(publicAPI, model) {
   };
 
   // Get the currently set RGB transfer function. Create one if none set.
-  publicAPI.getRGBTransferFunction = index => {
+  publicAPI.getRGBTransferFunction = function () {
+    let index = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
     if (model.componentData[index].rGBTransferFunction === null) {
       model.componentData[index].rGBTransferFunction = vtkColorTransferFunction.newInstance();
       model.componentData[index].rGBTransferFunction.addRGBPoint(0, 0.0, 0.0, 0.0);
@@ -125,7 +131,9 @@ function vtkVolumeProperty(publicAPI, model) {
   };
 
   // Set the scalar opacity of a volume to a transfer function
-  publicAPI.setScalarOpacity = (index, func) => {
+  publicAPI.setScalarOpacity = function () {
+    let index = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
+    let func = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
     if (model.componentData[index].scalarOpacity !== func) {
       model.componentData[index].scalarOpacity = func;
       publicAPI.modified();
@@ -135,7 +143,8 @@ function vtkVolumeProperty(publicAPI, model) {
   };
 
   // Get the scalar opacity transfer function. Create one if none set.
-  publicAPI.getScalarOpacity = index => {
+  publicAPI.getScalarOpacity = function () {
+    let index = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
     if (model.componentData[index].scalarOpacity === null) {
       model.componentData[index].scalarOpacity = vtkPiecewiseFunction.newInstance();
       model.componentData[index].scalarOpacity.addPoint(0, 1.0);
@@ -144,7 +153,9 @@ function vtkVolumeProperty(publicAPI, model) {
     }
     return model.componentData[index].scalarOpacity;
   };
-  publicAPI.setComponentWeight = (index, value) => {
+  publicAPI.setComponentWeight = function () {
+    let index = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
+    let value = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1;
     if (index < 0 || index >= VTK_MAX_VRCOMP) {
       vtkErrorMacro('Invalid index');
       return false;
@@ -157,7 +168,8 @@ function vtkVolumeProperty(publicAPI, model) {
     }
     return false;
   };
-  publicAPI.getComponentWeight = index => {
+  publicAPI.getComponentWeight = function () {
+    let index = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
     if (index < 0 || index >= VTK_MAX_VRCOMP) {
       vtkErrorMacro('Invalid index');
       return 0.0;

package/Rendering/OpenGL/BufferObject.js

@@ -70,6 +70,7 @@ function vtkOpenGLBufferObject(publicAPI, model) {
     }
     model.context.bindBuffer(convertType(internalType), internalHandle);
     model.context.bufferData(convertType(internalType), data, model.context.STATIC_DRAW);
+    model.allocatedGPUMemoryInBytes = data.length * data.BYTES_PER_ELEMENT;
     dirty = false;
     return true;
   };
@@ -92,6 +93,7 @@ function vtkOpenGLBufferObject(publicAPI, model) {
       model.context.bindBuffer(convertType(internalType), null);
       model.context.deleteBuffer(internalHandle);
       internalHandle = null;
+      model.allocatedGPUMemoryInBytes = 0;
     }
   };
   publicAPI.setOpenGLRenderWindow = rw => {
@@ -115,7 +117,8 @@ function vtkOpenGLBufferObject(publicAPI, model) {
 const DEFAULT_VALUES = {
   objectType: ObjectType.ARRAY_BUFFER,
   // _openGLRenderWindow: null,
-  context: null
+  context: null,
+  allocatedGPUMemoryInBytes: 0
 };
 
 // ----------------------------------------------------------------------------
@@ -126,7 +129,7 @@ function extend(publicAPI, model) {
 
   // Object methods
   macro.obj(publicAPI, model);
-  macro.get(publicAPI, model, ['_openGLRenderWindow']);
+  macro.get(publicAPI, model, ['_openGLRenderWindow', 'allocatedGPUMemoryInBytes']);
   macro.moveToProtected(publicAPI, model, ['openGLRenderWindow']);
   vtkOpenGLBufferObject(publicAPI, model);
 }

package/Rendering/OpenGL/Helper.js

@@ -168,6 +168,7 @@ function vtkOpenGLHelper(publicAPI, model) {
     }
     return 6;
   };
+  publicAPI.getAllocatedGPUMemoryInBytes = () => publicAPI.getCABO().getAllocatedGPUMemoryInBytes();
 }
 
 // ----------------------------------------------------------------------------

package/Rendering/OpenGL/ImageMapper.js

@@ -27,11 +27,10 @@ const {
 // helper methods
 // ----------------------------------------------------------------------------
 
-function computeFnToString(property, fn, numberOfComponents) {
-  const pwfun = fn.apply(property);
+function computeFnToString(property, pwfun, numberOfComponents) {
   if (pwfun) {
     const iComps = property.getIndependentComponents();
-    return `${property.getMTime()}-${iComps}-${numberOfComponents}`;
+    return `${pwfun.getMTime()}-${iComps}-${numberOfComponents}`;
   }
   return '0';
 }
@@ -51,9 +50,6 @@ function vtkOpenGLImageMapper(publicAPI, model) {
       model._openGLRenderWindow = model._openGLRenderer.getParent();
       model.context = model._openGLRenderWindow.getContext();
       model.tris.setOpenGLRenderWindow(model._openGLRenderWindow);
-      model.openGLTexture.setOpenGLRenderWindow(model._openGLRenderWindow);
-      model.colorTexture.setOpenGLRenderWindow(model._openGLRenderWindow);
-      model.pwfTexture.setOpenGLRenderWindow(model._openGLRenderWindow);
       const ren = model._openGLRenderer.getRenderable();
       model.openGLCamera = model._openGLRenderer.getViewNodeFor(ren.getActiveCamera());
       // is slice set by the camera
@@ -226,7 +222,7 @@ function vtkOpenGLImageMapper(publicAPI, model) {
     if (!model.currentRenderPass && model.lastRenderPassShaderReplacement || model.currentRenderPass && model.currentRenderPass.getShaderReplacement() !== model.lastRenderPassShaderReplacement) {
       needRebuild = true;
     }
-    if (needRebuild || model.lastHaveSeenDepthRequest !== model.haveSeenDepthRequest || cellBO.getProgram() === 0 || model.lastTextureComponents !== tNumComp || model.lastIndependentComponents !== iComp) {
+    if (needRebuild || model.lastHaveSeenDepthRequest !== model.haveSeenDepthRequest || cellBO.getProgram()?.getHandle() === 0 || model.lastTextureComponents !== tNumComp || model.lastIndependentComponents !== iComp) {
       model.lastHaveSeenDepthRequest = model.haveSeenDepthRequest;
       model.lastTextureComponents = tNumComp;
       model.lastIndependentComponents = iComp;
@@ -474,33 +470,36 @@ function vtkOpenGLImageMapper(publicAPI, model) {
     const dataType = imgScalars.getDataType();
     const numComp = imgScalars.getNumberOfComponents();
     const actorProperty = actor.getProperty();
-
-    // set interpolation on the texture based on property setting
     const iType = actorProperty.getInterpolationType();
-    if (iType === InterpolationType.NEAREST) {
-      model.colorTexture.setMinificationFilter(Filter.NEAREST);
-      model.colorTexture.setMagnificationFilter(Filter.NEAREST);
-      model.pwfTexture.setMinificationFilter(Filter.NEAREST);
-      model.pwfTexture.setMagnificationFilter(Filter.NEAREST);
-    } else {
-      model.colorTexture.setMinificationFilter(Filter.LINEAR);
-      model.colorTexture.setMagnificationFilter(Filter.LINEAR);
-      model.pwfTexture.setMinificationFilter(Filter.LINEAR);
-      model.pwfTexture.setMagnificationFilter(Filter.LINEAR);
-    }
     const iComps = actorProperty.getIndependentComponents();
     const numIComps = iComps ? numComp : 1;
     const textureHeight = iComps ? 2 * numIComps : 1;
-    const cfunToString = computeFnToString(actorProperty, actorProperty.getRGBTransferFunction, numIComps);
-    if (model.colorTextureString !== cfunToString) {
+    const colorTransferFunc = actorProperty.getRGBTransferFunction();
+    const cfunToString = computeFnToString(actorProperty, colorTransferFunc, numIComps);
+    const cTex = model._openGLRenderWindow.getGraphicsResourceForObject(colorTransferFunc);
+    const reBuildC = !cTex?.vtkObj || cTex?.hash !== cfunToString || model.colorTextureString !== cfunToString;
+    if (reBuildC) {
       const cWidth = 1024;
       const cSize = cWidth * textureHeight * 3;
       const cTable = new Uint8Array(cSize);
-      let cfun = actorProperty.getRGBTransferFunction();
-      if (cfun) {
+      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);
+        model.colorTexture.setMagnificationFilter(Filter.NEAREST);
+      } else {
+        model.colorTexture.setMinificationFilter(Filter.LINEAR);
+        model.colorTexture.setMagnificationFilter(Filter.LINEAR);
+      }
+      if (colorTransferFunc) {
         const tmpTable = new Float32Array(cWidth * 3);
         for (let c = 0; c < numIComps; c++) {
-          cfun = actorProperty.getRGBTransferFunction(c);
+          const cfun = actorProperty.getRGBTransferFunction(c);
           const cRange = cfun.getRange();
           cfun.getTable(cRange[0], cRange[1], cWidth, tmpTable, 1);
           if (iComps) {
@@ -514,6 +513,8 @@ function vtkOpenGLImageMapper(publicAPI, model) {
             }
           }
         }
+        model.colorTexture.releaseGraphicsResources(model._openGLRenderWindow);
+        model.colorTexture.resetFormatAndType();
         model.colorTexture.create2DFromRaw(cWidth, textureHeight, 3, VtkDataTypes.UNSIGNED_CHAR, cTable);
       } else {
         for (let i = 0; i < cWidth * 3; ++i) {
@@ -524,24 +525,45 @@ 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);
+      }
+    } else {
+      model.colorTexture = cTex.vtkObj;
+      model.colorTextureString = cTex.hash;
     }
 
     // Build piecewise function buffer.  This buffer is used either
     // for component weighting or opacity, depending on whether we're
     // rendering components independently or not.
-    const pwfunToString = computeFnToString(actorProperty, actorProperty.getPiecewiseFunction, numIComps);
-    if (model.pwfTextureString !== pwfunToString) {
+    const pwFunc = actorProperty.getPiecewiseFunction();
+    const pwfunToString = computeFnToString(actorProperty, pwFunc, numIComps);
+    const pwfTex = model._openGLRenderWindow.getGraphicsResourceForObject(pwFunc);
+    // rebuild opacity tfun?
+    const reBuildPwf = !pwfTex?.vtkObj || pwfTex?.hash !== pwfunToString || model.pwfTextureString !== pwfunToString;
+    if (reBuildPwf) {
       const pwfWidth = 1024;
       const pwfSize = pwfWidth * textureHeight;
       const pwfTable = new Uint8Array(pwfSize);
-      let pwfun = actorProperty.getPiecewiseFunction();
-      // support case where pwfun is added/removed
-      model.pwfTexture.resetFormatAndType();
-      if (pwfun) {
+      if (!model.pwfTexture) {
+        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);
+        model.pwfTexture.setMagnificationFilter(Filter.NEAREST);
+      } else {
+        model.pwfTexture.setMinificationFilter(Filter.LINEAR);
+        model.pwfTexture.setMagnificationFilter(Filter.LINEAR);
+      }
+      if (pwFunc) {
         const pwfFloatTable = new Float32Array(pwfSize);
         const tmpTable = new Float32Array(pwfWidth);
         for (let c = 0; c < numIComps; ++c) {
-          pwfun = actorProperty.getPiecewiseFunction(c);
+          const pwfun = actorProperty.getPiecewiseFunction(c);
           if (pwfun === null) {
             // Piecewise constant max if no function supplied for this component
             pwfFloatTable.fill(1.0);
@@ -561,6 +583,8 @@ function vtkOpenGLImageMapper(publicAPI, model) {
             }
           }
         }
+        model.pwfTexture.releaseGraphicsResources(model._openGLRenderWindow);
+        model.pwfTexture.resetFormatAndType();
         model.pwfTexture.create2DFromRaw(pwfWidth, textureHeight, 1, VtkDataTypes.FLOAT, pwfFloatTable);
       } else {
         // default is opaque
@@ -568,6 +592,12 @@ function vtkOpenGLImageMapper(publicAPI, model) {
         model.pwfTexture.create2DFromRaw(pwfWidth, 1, 1, VtkDataTypes.UNSIGNED_CHAR, pwfTable);
       }
       model.pwfTextureString = pwfunToString;
+      if (pwFunc) {
+        model._openGLRenderWindow.setGraphicsResourceForObject(pwFunc, model.pwfTexture, model.pwfTextureString);
+      }
+    } else {
+      model.pwfTexture = pwfTex.vtkObj;
+      model.pwfTextureString = pwfTex.hash;
     }
 
     // Find what IJK axis and what direction to slice along
@@ -605,6 +635,12 @@ function vtkOpenGLImageMapper(publicAPI, model) {
     if (model.VBOBuildString !== toString) {
       // Build the VBOs
       const dims = image.getDimensions();
+      if (!model.openGLTexture) {
+        model.openGLTexture = vtkOpenGLTexture.newInstance({
+          resizable: true
+        });
+        model.openGLTexture.setOpenGLRenderWindow(model._openGLRenderWindow);
+      }
       if (iType === InterpolationType.NEAREST) {
         if (new Set([1, 3, 4]).has(numComp) && dataType === VtkDataTypes.UNSIGNED_CHAR && !iComps) {
           model.openGLTexture.setGenerateMipmap(true);
@@ -710,7 +746,19 @@ function vtkOpenGLImageMapper(publicAPI, model) {
       } else {
         vtkErrorMacro('Reformat slicing not yet supported.');
       }
-      model.openGLTexture.create2DFilterableFromRaw(dims[0], dims[1], numComp, imgScalars.getDataType(), scalars, model.renderable.getPreferSizeOverAccuracy?.());
+      const tex = model._openGLRenderWindow.getGraphicsResourceForObject(scalars);
+      if (!tex?.vtkObj) {
+        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;
+      }
       model.openGLTexture.activate();
       model.openGLTexture.sendParameters();
       model.openGLTexture.deactivate();
@@ -763,7 +811,8 @@ const DEFAULT_VALUES = {
   pwfTexture: null,
   lastHaveSeenDepthRequest: false,
   haveSeenDepthRequest: false,
-  lastTextureComponents: 0
+  lastTextureComponents: 0,
+  _scalars: null
 };
 
 // ----------------------------------------------------------------------------
@@ -777,15 +826,6 @@ function extend(publicAPI, model) {
   vtkReplacementShaderMapper.implementReplaceShaderCoincidentOffset(publicAPI, model, initialValues);
   vtkReplacementShaderMapper.implementBuildShadersWithReplacements(publicAPI, model, initialValues);
   model.tris = vtkHelper.newInstance();
-  model.openGLTexture = vtkOpenGLTexture.newInstance({
-    resizable: true
-  });
-  model.colorTexture = vtkOpenGLTexture.newInstance({
-    resizable: true
-  });
-  model.pwfTexture = vtkOpenGLTexture.newInstance({
-    resizable: true
-  });
   model.imagemat = mat4.identity(new Float64Array(16));
   model.imagematinv = mat4.identity(new Float64Array(16));
 

package/Rendering/OpenGL/ImageResliceMapper.js

@@ -29,11 +29,10 @@ const {
 // helper methods
 // ----------------------------------------------------------------------------
 
-function computeFnToString(property, fn, numberOfComponents) {
-  const pwfun = fn.apply(property);
+function computeFnToString(property, pwfun, numberOfComponents) {
   if (pwfun) {
     const iComps = property.getIndependentComponents();
-    return `${property.getMTime()}-${iComps}-${numberOfComponents}`;
+    return `${pwfun.getMTime()}-${iComps}-${numberOfComponents}`;
   }
   return '0';
 }
@@ -64,12 +63,6 @@ function vtkOpenGLImageResliceMapper(publicAPI, model) {
       model._openGLRenderWindow = model._openGLRenderer.getParent();
       model.context = model._openGLRenderWindow.getContext();
       model.tris.setOpenGLRenderWindow(model._openGLRenderWindow);
-      if (!model.openGLTexture) {
-        model.openGLTexture = vtkOpenGLTexture.newInstance();
-      }
-      model.openGLTexture.setOpenGLRenderWindow(model._openGLRenderWindow);
-      model.colorTexture.setOpenGLRenderWindow(model._openGLRenderWindow);
-      model.pwfTexture.setOpenGLRenderWindow(model._openGLRenderWindow);
     }
   };
   publicAPI.translucentPass = (prepass, renderPass) => {
@@ -181,34 +174,54 @@ function vtkOpenGLImageResliceMapper(publicAPI, model) {
     if (!scalars) {
       return;
     }
+    if (model._scalars !== scalars) {
+      model._openGLRenderWindow.releaseGraphicsResourcesForObject(model._scalars);
+      model._scalars = scalars;
+    }
     const numComp = scalars.getNumberOfComponents();
-    if (!model._externalOpenGLTexture) {
-      const toString = `${image.getMTime()}A${scalars.getMTime()}`;
-      if (model.openGLTextureString !== toString) {
-        // Build the image scalar texture
-        const dims = image.getDimensions();
-        // Use norm16 for the 3D texture if the extension is available
-        model.openGLTexture.getOglNorm16Ext(model.context.getExtension('EXT_texture_norm16'));
-        model.openGLTexture.releaseGraphicsResources(model._openGLRenderWindow);
-        model.openGLTexture.resetFormatAndType();
-        model.openGLTexture.create3DFilterableFromDataArray(dims[0], dims[1], dims[2], scalars);
-        model.openGLTextureString = toString;
+    let toString = `${image.getMTime()}A${scalars.getMTime()}`;
+    const tex = model._openGLRenderWindow.getGraphicsResourceForObject(scalars);
+    const reBuildTex = !tex?.vtkObj || tex?.hash !== toString || model.openGLTextureString !== toString;
+    if (reBuildTex) {
+      if (!model.openGLTexture) {
+        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);
+      model.openGLTextureString = toString;
+      if (scalars) {
+        model._openGLRenderWindow.setGraphicsResourceForObject(scalars, model.openGLTexture, model.openGLTextureString);
       }
+    } else {
+      model.openGLTexture = tex.vtkObj;
+      model.openGLTextureString = tex.hash;
     }
     const ppty = actor.getProperty();
     const iComps = ppty.getIndependentComponents();
     const numIComps = iComps ? numComp : 1;
     const textureHeight = iComps ? 2 * numIComps : 1;
-    const cfunToString = computeFnToString(ppty, ppty.getRGBTransferFunction, numIComps);
-    if (model.colorTextureString !== cfunToString) {
+    const colorTransferFunc = ppty.getRGBTransferFunction();
+    toString = computeFnToString(ppty, colorTransferFunc, numIComps);
+    const cTex = model._openGLRenderWindow.getGraphicsResourceForObject(colorTransferFunc);
+    const reBuildC = !cTex?.vtkObj || cTex?.hash !== toString || model.colorTextureString !== toString;
+    if (reBuildC) {
       const cWidth = 1024;
       const cSize = cWidth * textureHeight * 3;
       const cTable = new Uint8Array(cSize);
-      let cfun = ppty.getRGBTransferFunction();
-      if (cfun) {
+      if (!model.colorTexture) {
+        model.colorTexture = vtkOpenGLTexture.newInstance();
+        model.colorTexture.setOpenGLRenderWindow(model._openGLRenderWindow);
+      }
+      if (colorTransferFunc) {
         const tmpTable = new Float32Array(cWidth * 3);
         for (let c = 0; c < numIComps; c++) {
-          cfun = ppty.getRGBTransferFunction(c);
+          const cfun = ppty.getRGBTransferFunction(c);
           const cRange = cfun.getRange();
           cfun.getTable(cRange[0], cRange[1], cWidth, tmpTable, 1);
           if (iComps) {
@@ -231,28 +244,40 @@ 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 = cfunToString;
+      model.colorTextureString = toString;
+      if (colorTransferFunc) {
+        model._openGLRenderWindow.setGraphicsResourceForObject(colorTransferFunc, model.colorTexture, model.colorTextureString);
+      }
+    } else {
+      model.colorTexture = cTex.vtkObj;
+      model.colorTextureString = cTex.hash;
     }
 
     // Build piecewise function buffer.  This buffer is used either
     // for component weighting or opacity, depending on whether we're
     // rendering components independently or not.
-    const pwfunToString = computeFnToString(ppty, ppty.getPiecewiseFunction, numIComps);
-    if (model.pwfTextureString !== pwfunToString) {
+    const pwFunc = ppty.getPiecewiseFunction();
+    toString = computeFnToString(ppty, pwFunc, numIComps);
+    const pwfTex = model._openGLRenderWindow.getGraphicsResourceForObject(pwFunc);
+    // rebuild opacity tfun?
+    const reBuildPwf = !pwfTex?.vtkObj || pwfTex?.hash !== toString || model.pwfTextureString !== toString;
+    if (reBuildPwf) {
       const pwfWidth = 1024;
       const pwfSize = pwfWidth * textureHeight;
       const pwfTable = new Uint8Array(pwfSize);
-      let pwfun = ppty.getPiecewiseFunction();
-      // support case where pwfun is added/removed
-      model.pwfTexture.releaseGraphicsResources(model._openGLRenderWindow);
-      model.pwfTexture.resetFormatAndType();
-      if (pwfun) {
+      if (!model.pwfTexture) {
+        model.pwfTexture = vtkOpenGLTexture.newInstance();
+        model.pwfTexture.setOpenGLRenderWindow(model._openGLRenderWindow);
+      }
+      if (pwFunc) {
         const pwfFloatTable = new Float32Array(pwfSize);
         const tmpTable = new Float32Array(pwfWidth);
         for (let c = 0; c < numIComps; ++c) {
-          pwfun = ppty.getPiecewiseFunction(c);
+          const pwfun = ppty.getPiecewiseFunction(c);
           if (pwfun === null) {
             // Piecewise constant max if no function supplied for this component
             pwfFloatTable.fill(1.0);
@@ -272,13 +297,23 @@ 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 = pwfunToString;
+      model.pwfTextureString = toString;
+      if (pwFunc) {
+        model._openGLRenderWindow.setGraphicsResourceForObject(pwFunc, model.pwfTexture, model.pwfTextureString);
+      }
+    } else {
+      model.pwfTexture = pwfTex.vtkObj;
+      model.pwfTextureString = pwfTex.hash;
     }
     const vboString = `${model.resliceGeom.getMTime()}A${model.renderable.getSlabThickness()}`;
     if (!model.tris.getCABO().getElementCount() || model.VBOBuildString !== vboString) {
@@ -510,7 +545,7 @@ function vtkOpenGLImageResliceMapper(publicAPI, model) {
     if (!model.currentRenderPass && model.lastRenderPassShaderReplacement || model.currentRenderPass && model.currentRenderPass.getShaderReplacement() !== model.lastRenderPassShaderReplacement) {
       needRebuild = true;
     }
-    if (needRebuild || model.lastHaveSeenDepthRequest !== model.haveSeenDepthRequest || cellBO.getProgram() === 0 || model.lastTextureComponents !== tNumComp || model.lastIndependentComponents !== iComp || model.lastSlabThickness !== slabTh || model.lastSlabType !== slabType || model.lastSlabTrapezoidIntegration !== slabTrap) {
+    if (needRebuild || model.lastHaveSeenDepthRequest !== model.haveSeenDepthRequest || cellBO.getProgram()?.getHandle() === 0 || model.lastTextureComponents !== tNumComp || model.lastIndependentComponents !== iComp || model.lastSlabThickness !== slabTh || model.lastSlabType !== slabType || model.lastSlabTrapezoidIntegration !== slabTrap) {
       model.lastHaveSeenDepthRequest = model.haveSeenDepthRequest;
       model.lastTextureComponents = tNumComp;
       model.lastIndependentComponents = iComp;
@@ -846,7 +881,8 @@ const DEFAULT_VALUES = {
   tris: null,
   colorTexture: null,
   pwfTexture: null,
-  _externalOpenGLTexture: false
+  _externalOpenGLTexture: false,
+  _scalars: null
 };
 
 // ----------------------------------------------------------------------------
@@ -860,9 +896,9 @@ function extend(publicAPI, model) {
   vtkReplacementShaderMapper.implementReplaceShaderCoincidentOffset(publicAPI, model, initialValues);
   vtkReplacementShaderMapper.implementBuildShadersWithReplacements(publicAPI, model, initialValues);
   model.tris = vtkHelper.newInstance();
-  model.openGLTexture = vtkOpenGLTexture.newInstance();
-  model.colorTexture = vtkOpenGLTexture.newInstance();
-  model.pwfTexture = vtkOpenGLTexture.newInstance();
+  model.openGLTexture = null;
+  model.colorTexture = null;
+  model.pwfTexture = null;
   model.VBOBuildTime = {};
   obj(model.VBOBuildTime);
   model.tmpMat4 = mat4.identity(new Float64Array(16));

package/Rendering/OpenGL/PolyDataMapper.js

@@ -1089,6 +1089,14 @@ function vtkOpenGLPolyDataMapper(publicAPI, model) {
       model.VBOBuildString = toString;
     }
   };
+  publicAPI.getAllocatedGPUMemoryInBytes = () => {
+    let memUsed = 0;
+    model.primitives.forEach(prim => {
+      memUsed += prim.getAllocatedGPUMemoryInBytes();
+    });
+    // Return in MB
+    return memUsed;
+  };
 }
 
 // ----------------------------------------------------------------------------

package/Rendering/OpenGL/PolyDataMapper2D.js

@@ -406,6 +406,14 @@ function vtkOpenGLPolyDataMapper2D(publicAPI, model) {
     mat4.transpose(tmpMat4, tmpMat4);
     program.setUniformMatrix('WCVCMatrix', safeMatrixMultiply([tmpMat4, inverseShiftScaleMatrix], mat4, model.tmpMat4));
   };
+  publicAPI.getAllocatedGPUMemoryInBytes = () => {
+    let memUsed = 0;
+    model.primitives.forEach(prim => {
+      memUsed += prim.getAllocatedGPUMemoryInBytes();
+    });
+    // Return in MB
+    return memUsed;
+  };
 }
 
 // ----------------------------------------------------------------------------

package/Rendering/OpenGL/RenderWindow.d.ts

@@ -1,6 +1,11 @@
-import { vtkAlgorithm, vtkObject } from './../../interfaces';
 import { Nullable, Size, Vector2, Vector3 } from './../../types';
 import { VtkDataTypes } from './../../Common/Core/DataArray';
+import { vtkAlgorithm, vtkObject } from './../../interfaces';
+import vtkBufferObject from './BufferObject';
+import vtkCellArray from './../../Common/Core/CellArray';
+import vtkDataArray from './../../Common/Core/DataArray';
+import vtkOpenGLTexture from './Texture';
+import vtkPoints from './../../Common/Core/Points';
 import vtkRenderer from './../Core/Renderer';
 import vtkTexture from './../Core/Texture';
 import vtkViewStream from './../../IO/Core/ImageStream/ViewStream';
@@ -389,6 +394,37 @@ export interface vtkOpenGLRenderWindow extends vtkOpenGLRenderWindowBase {
 	 * @see getContainerSize()
 	 */
 	getComputedDevicePixelRatio(): number;
+
+	/**
+	 * Set graphics resources for vtk objects to be cached at the context level.
+	 * This provides mappers with a convenient API to re-use allocated GPU resources
+	 * without duplication.
+	 *
+	 * @param {Object} vtkObj VTK data object / array with resources on the GPU
+	 * @param {Object} gObj Container object that maintains a handle to the graphics resource on the GPU
+	 * @param {String} hash String hash that can be used by mappers to decide whether to discard or re-allocate
+	 * the cached resource.
+	 */
+	setGraphicsResourceForObject(vtkObj: vtkCellArray | vtkDataArray | vtkPoints, gObj: vtkOpenGLTexture | vtkBufferObject, hash: string): void;
+
+	/**
+	 * Get graphics resources for vtk objects cached at the context level.
+	 * This provides mappers with a convenient API to re-use allocated GPU resources
+	 * without duplication.
+	 *
+	 * @param {Object} vtkObj VTK data object / array with resources on the GPU
+	 * the cached resource.
+	 * @return {Object} Dictionary with the graphics resource and string hash
+	 */
+	getGraphicsResourceForObject(vtkObj: vtkCellArray | vtkDataArray | vtkPoints): {gObj: vtkOpenGLTexture | vtkBufferObject, hash: string};
+
+	/**
+	 * Get approximate graphics memory usage, in bytes, for the context. This is a simple computation
+	 * that analyzes how much memory is allocated on the GPU for textures, VBOs, etc. to give an
+	 * application a view of its graphics memory consumption.
+	 * Note that this ignores page resources.
+	 */
+	getGraphicsMemoryInfo(): number;
 }
 
 /**

package/Rendering/OpenGL/RenderWindow.js

@@ -424,6 +424,31 @@ function vtkOpenGLRenderWindow(publicAPI, model) {
     }
     return -1;
   };
+  publicAPI.getDefaultTextureByteSize = function (vtkType) {
+    let oglNorm16Ext = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
+    let useHalfFloat = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+    if (model.webgl2) {
+      switch (vtkType) {
+        case VtkDataTypes.CHAR:
+        case VtkDataTypes.SIGNED_CHAR:
+        case VtkDataTypes.UNSIGNED_CHAR:
+          return 1;
+        case oglNorm16Ext:
+        case useHalfFloat:
+        case VtkDataTypes.UNSIGNED_SHORT:
+        case VtkDataTypes.SHORT:
+        case VtkDataTypes.VOID:
+          // Used for unsigned int depth
+          return 2;
+        default:
+          // For all other cases, assume float
+          return 4;
+      }
+    }
+
+    // webgl1 type support is limited to 1 byte
+    return 1;
+  };
   publicAPI.getDefaultTextureInternalFormat = function (vtktype, numComps) {
     let oglNorm16Ext = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;
     let useHalfFloat = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
@@ -658,6 +683,9 @@ function vtkOpenGLRenderWindow(publicAPI, model) {
     return lineWidthRange[1];
   };
   publicAPI.getGLInformations = () => {
+    if (model._glInformation) {
+      return model._glInformation;
+    }
     const gl = publicAPI.get3DContext();
     const glTextureFloat = gl.getExtension('OES_texture_float');
     const glTextureHalfFloat = gl.getExtension('OES_texture_half_float');
@@ -675,6 +703,7 @@ function vtkOpenGLRenderWindow(publicAPI, model) {
         };
       }
     }
+    model._glInformation = result;
     return result;
   };
   publicAPI.traverseAllPasses = () => {
@@ -751,6 +780,58 @@ function vtkOpenGLRenderWindow(publicAPI, model) {
     }
     return modified;
   };
+  publicAPI.getGraphicsResourceForObject = vtkObj => {
+    if (!vtkObj) {
+      return null;
+    }
+    const vtko = model._graphicsResources.get(vtkObj);
+    const vtkh = model._graphicsResourceHash.get(vtkObj);
+    return {
+      vtkObj: vtko,
+      hash: vtkh
+    };
+  };
+  publicAPI.setGraphicsResourceForObject = (vtkObj, gObj, hash) => {
+    if (!vtkObj) {
+      return;
+    }
+    model._graphicsResources.set(vtkObj, gObj);
+    model._graphicsResourceHash.set(vtkObj, hash);
+  };
+  publicAPI.getGraphicsMemoryInfo = () => {
+    let memUsed = 0;
+    model._graphicsResources.forEach((gObj, vtkObj) => {
+      memUsed += gObj.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.clear();
+    model._graphicsResourceHash.clear();
+    if (model.textureUnitManager !== null) {
+      model.textureUnitManager.freeAll();
+    }
+    // Finally, ask the renderers to release prop resources
+    model.renderable.getRenderersByReference().forEach(ren => {
+      const glRen = publicAPI.getViewNodeFor(ren);
+      glRen?.releaseGraphicsResources();
+    });
+  };
 }
 
 // ----------------------------------------------------------------------------
@@ -809,6 +890,9 @@ function extend(publicAPI, model) {
   model.bgImage.style.height = '100%';
   model.bgImage.style.zIndex = '-1';
   model._textureResourceIds = new Map();
+  model._graphicsResources = new Map();
+  model._graphicsResourceHash = new Map();
+  model._glInformation = null;
   model.myFactory = vtkViewNodeFactory.newInstance();
   /* eslint-disable no-use-before-define */
   model.myFactory.registerOverride('vtkRenderWindow', newInstance);

package/Rendering/OpenGL/Renderer.js

@@ -148,6 +148,12 @@ function vtkOpenGLRenderer(publicAPI, model) {
     if (model.selector !== null) {
       model.selector.releaseGraphicsResources();
     }
+    // Releasing resources means that the next render should re-create resources
+    if (model.renderable) {
+      model.renderable.getViewProps().forEach(prop => {
+        prop.modified();
+      });
+    }
   };
   publicAPI.setOpenGLRenderWindow = rw => {
     if (model._openGLRenderWindow === rw) {
@@ -168,7 +174,7 @@ function vtkOpenGLRenderer(publicAPI, model) {
 
 const DEFAULT_VALUES = {
   context: null,
-  // _openGLRenderWindow: null,
+  _openGLRenderWindow: null,
   selector: null
 };
 

package/Rendering/OpenGL/ShaderCache.js

@@ -4,7 +4,7 @@ import vtkShaderProgram from './ShaderProgram.js';
 
 // ----------------------------------------------------------------------------
 
-const SET_GET_FIELDS = ['lastShaderBound', 'context', '_openGLRenderWindow'];
+const SET_GET_FIELDS = ['lastShaderProgramBound', 'context', '_openGLRenderWindow'];
 
 // ----------------------------------------------------------------------------
 // vtkShaderCache methods
@@ -67,24 +67,24 @@ function vtkShaderCache(publicAPI, model) {
   // return NULL if there is an issue
   publicAPI.readyShaderProgramArray = (vertexCode, fragmentCode, geometryCode) => {
     const data = publicAPI.replaceShaderValues(vertexCode, fragmentCode, geometryCode);
-    const shader = publicAPI.getShaderProgram(data.VSSource, data.FSSource, data.GSSource);
-    return publicAPI.readyShaderProgram(shader);
+    const shaderProgram = publicAPI.getShaderProgram(data.VSSource, data.FSSource, data.GSSource);
+    return publicAPI.readyShaderProgram(shaderProgram);
   };
-  publicAPI.readyShaderProgram = shader => {
-    if (!shader) {
+  publicAPI.readyShaderProgram = program => {
+    if (!program) {
       return null;
     }
 
     // compile if needed
-    if (!shader.getCompiled() && !shader.compileShader()) {
+    if (!program.getCompiled() && !program.compileShader()) {
       return null;
     }
 
     // bind if needed
-    if (!publicAPI.bindShader(shader)) {
+    if (!publicAPI.bindShaderProgram(program)) {
       return null;
     }
-    return shader;
+    return program;
   };
   publicAPI.getShaderProgram = (vertexCode, fragmentCode, geometryCode) => {
     // compute the MD5 and the check the map
@@ -116,27 +116,28 @@ function vtkShaderCache(publicAPI, model) {
     // have to loop over all the programs were in use and invoke
     // release graphics resources individually.
 
-    publicAPI.releaseCurrentShader();
-    Object.keys(model.shaderPrograms).map(key => model.shaderPrograms[key]).forEach(sp => sp.releaseGraphicsResources(win));
+    publicAPI.releaseCurrentShaderProgram();
+    Object.keys(model.shaderPrograms).map(key => model.shaderPrograms[key]).forEach(sp => sp.cleanup());
+    model.shaderPrograms = {};
   };
-  publicAPI.releaseGraphicsResources = () => {
+  publicAPI.releaseCurrentShaderProgram = () => {
     // release prior shader
-    if (model.astShaderBound) {
-      model.lastShaderBound.release();
-      model.lastShaderBound = null;
+    if (model.lastShaderProgramBound) {
+      model.lastShaderProgramBound.cleanup();
+      model.lastShaderProgramBound = null;
     }
   };
-  publicAPI.bindShader = shader => {
-    if (model.lastShaderBound === shader) {
+  publicAPI.bindShaderProgram = program => {
+    if (model.lastShaderProgramBound === program) {
       return 1;
     }
 
-    // release prior shader
-    if (model.lastShaderBound) {
-      model.lastShaderBound.release();
+    // release prior program
+    if (model.lastShaderProgramBound) {
+      model.lastShaderProgramBound.release();
     }
-    shader.bind();
-    model.lastShaderBound = shader;
+    program.bind();
+    model.lastShaderProgramBound = program;
     return 1;
   };
 }
@@ -146,7 +147,7 @@ function vtkShaderCache(publicAPI, model) {
 // ----------------------------------------------------------------------------
 
 const DEFAULT_VALUES = {
-  lastShaderBound: null,
+  lastShaderProgramBound: null,
   shaderPrograms: null,
   context: null
   // _openGLRenderWindow: null,

package/Rendering/OpenGL/ShaderProgram.js

@@ -64,8 +64,18 @@ function vtkShaderProgram(publicAPI, model) {
     if (model.shaderType === 'Unknown' || model.handle === 0) {
       return;
     }
-    model.context.deleteShader(model.handle);
+    publicAPI.release();
+    if (model.vertexShaderHandle !== 0) {
+      model.context.detachShader(model.handle, model.vertexShaderHandle);
+      model.vertexShaderHandle = 0;
+    }
+    if (model.fragmentShaderHandle !== 0) {
+      model.context.detachShader(model.handle, model.fragmentShaderHandle);
+      model.fragmentShaderHandle = 0;
+    }
+    model.context.deleteProgram(model.handle);
     model.handle = 0;
+    publicAPI.setCompiled(false);
   };
   publicAPI.bind = () => {
     if (!model.linked && !publicAPI.link()) {
@@ -406,7 +416,7 @@ function vtkShaderProgram(publicAPI, model) {
     }
     if (shader.getShaderType() === 'Vertex') {
       if (model.vertexShaderHandle !== 0) {
-        model.comntext.detachShader(model.handle, model.vertexShaderHandle);
+        model.context.detachShader(model.handle, model.vertexShaderHandle);
       }
       model.vertexShaderHandle = shader.getHandle();
     }

package/Rendering/OpenGL/Texture.js

@@ -212,6 +212,7 @@ function vtkOpenGLTexture(publicAPI, model) {
       model.width = 0;
       model.height = 0;
       model.depth = 0;
+      model.allocatedGPUMemoryInBytes = 0;
     }
     if (model.shaderProgram) {
       model.shaderProgram.releaseGraphicsResources(rwin);
@@ -701,6 +702,7 @@ function vtkOpenGLTexture(publicAPI, model) {
     if (flip) {
       model.context.pixelStorei(model.context.UNPACK_FLIP_Y_WEBGL, false);
     }
+    model.allocatedGPUMemoryInBytes = model.width * model.height * model.depth * numComps * model._openGLRenderWindow.getDefaultTextureByteSize(dataType, model.oglNorm16Ext, model.useHalfFloat);
     publicAPI.deactivate();
     return true;
   };
@@ -778,7 +780,7 @@ function vtkOpenGLTexture(publicAPI, model) {
         h /= 2;
       }
     }
-
+    model.allocatedGPUMemoryInBytes = model.width * model.height * model.depth * numComps * model._openGLRenderWindow.getDefaultTextureByteSize(dataType, model.oglNorm16Ext, model.useHalfFloat);
     // generateMipmap must not be called here because we manually upload all levels
     // if it is called, all levels will be overwritten
 
@@ -828,6 +830,7 @@ function vtkOpenGLTexture(publicAPI, model) {
     if (model.generateMipmap) {
       model.context.generateMipmap(model.target);
     }
+    model.allocatedGPUMemoryInBytes = model.width * model.height * model.depth * model.components * model._openGLRenderWindow.getDefaultTextureByteSize(dataType, model.oglNorm16Ext, model.useHalfFloat);
     publicAPI.deactivate();
     return true;
   };
@@ -877,6 +880,7 @@ function vtkOpenGLTexture(publicAPI, model) {
     if (model.generateMipmap) {
       model.context.generateMipmap(model.target);
     }
+    model.allocatedGPUMemoryInBytes = model.width * model.height * model.depth * model.components * model._openGLRenderWindow.getDefaultTextureByteSize(VtkDataTypes.UNSIGNED_CHAR, model.oglNorm16Ext, model.useHalfFloat);
     publicAPI.deactivate();
     return true;
   };
@@ -1016,6 +1020,7 @@ function vtkOpenGLTexture(publicAPI, model) {
     if (model.generateMipmap) {
       model.context.generateMipmap(model.target);
     }
+    model.allocatedGPUMemoryInBytes = model.width * model.height * model.depth * model.components * model._openGLRenderWindow.getDefaultTextureByteSize(dataType, model.oglNorm16Ext, model.useHalfFloat);
     publicAPI.deactivate();
     return true;
   };
@@ -1296,7 +1301,8 @@ const DEFAULT_VALUES = {
   // the voxel intensity range is out of the accurate
   // range of half float
   useHalfFloat: true,
-  oglNorm16Ext: null
+  oglNorm16Ext: null,
+  allocatedGPUMemoryInBytes: 0
 };
 
 // ----------------------------------------------------------------------------
@@ -1319,7 +1325,7 @@ function extend(publicAPI, model) {
   // Build VTK API
   set(publicAPI, model, ['format', 'openGLDataType']);
   setGet(publicAPI, model, ['keyMatrixTime', 'minificationFilter', 'magnificationFilter', 'wrapS', 'wrapT', 'wrapR', 'generateMipmap', 'oglNorm16Ext']);
-  get(publicAPI, model, ['width', 'height', 'volumeInfo', 'components', 'handle', 'target']);
+  get(publicAPI, model, ['width', 'height', 'volumeInfo', 'components', 'handle', 'target', 'allocatedGPUMemoryInBytes']);
   moveToProtected(publicAPI, model, ['openGLRenderWindow']);
 
   // Object methods

package/Rendering/OpenGL/TextureUnitManager.js

@@ -81,6 +81,11 @@ function vtkOpenGLTextureUnitManager(publicAPI, model) {
   publicAPI.free = val => {
     model.textureUnits[val] = false;
   };
+  publicAPI.freeAll = () => {
+    for (let i = 0; i < model.numberOfTextureUnits; ++i) {
+      model.textureUnits[i] = false;
+    }
+  };
 }
 
 // ----------------------------------------------------------------------------

package/Rendering/OpenGL/VolumeMapper.js

@@ -22,6 +22,9 @@ const {
   vtkErrorMacro
 } = macro;
 
+// ----------------------------------------------------------------------------
+// helper methods
+// ----------------------------------------------------------------------------
 // TODO: Do we want this in some shared utility? Shouldwe just use lodash.isEqual
 function arrayEquals(a, b) {
   if (a.length !== b.length) {
@@ -34,6 +37,13 @@ function arrayEquals(a, b) {
   }
   return true;
 }
+function computeFnToString(property, pwfun, numberOfComponents) {
+  if (pwfun) {
+    const iComps = property.getIndependentComponents();
+    return `${pwfun.getMTime()}-${iComps}-${numberOfComponents}`;
+  }
+  return '0';
+}
 
 // ----------------------------------------------------------------------------
 // vtkOpenGLVolumeMapper methods
@@ -283,7 +293,7 @@ function vtkOpenGLVolumeMapper(publicAPI, model) {
     }
 
     // has something changed that would require us to recreate the shader?
-    if (cellBO.getProgram() === 0 || needRebuild || model.lastHaveSeenDepthRequest !== model.haveSeenDepthRequest || !!model.lastZBufferTexture !== !!model.zBufferTexture || cellBO.getShaderSourceTime().getMTime() < publicAPI.getMTime() || cellBO.getShaderSourceTime().getMTime() < model.renderable.getMTime()) {
+    if (cellBO.getProgram()?.getHandle() === 0 || needRebuild || model.lastHaveSeenDepthRequest !== model.haveSeenDepthRequest || !!model.lastZBufferTexture !== !!model.zBufferTexture || cellBO.getShaderSourceTime().getMTime() < publicAPI.getMTime() || cellBO.getShaderSourceTime().getMTime() < model.renderable.getMTime()) {
       model.lastZBufferTexture = model.zBufferTexture;
       return true;
     }
@@ -944,6 +954,10 @@ 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);
@@ -957,10 +971,12 @@ function vtkOpenGLVolumeMapper(publicAPI, model) {
     const numComp = scalars.getNumberOfComponents();
     const iComps = vprop.getIndependentComponents();
     const numIComps = iComps ? numComp : 1;
-
-    // rebuild opacity tfun?
-    let toString = `${vprop.getMTime()}`;
-    if (model.opacityTextureString !== toString) {
+    const scalarOpacityFunc = vprop.getScalarOpacity();
+    const opTex = model._openGLRenderWindow.getGraphicsResourceForObject(scalarOpacityFunc);
+    let toString = computeFnToString(vprop, scalarOpacityFunc, numIComps);
+    const reBuildOp = !opTex.vtkObj || opTex.hash !== toString || model.opacityTextureString !== toString;
+    if (reBuildOp) {
+      // rebuild opacity tfun?
       const oWidth = 1024;
       const oSize = oWidth * 2 * numIComps;
       const ofTable = new Float32Array(oSize);
@@ -977,6 +993,7 @@ function vtkOpenGLVolumeMapper(publicAPI, model) {
         }
       }
       model.opacityTexture.releaseGraphicsResources(model._openGLRenderWindow);
+      model.opacityTexture.resetFormatAndType();
       model.opacityTexture.setMinificationFilter(Filter.LINEAR);
       model.opacityTexture.setMagnificationFilter(Filter.LINEAR);
 
@@ -994,11 +1011,20 @@ 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);
+      }
+    } else {
+      model.opacityTexture = opTex.vtkObj;
+      model.opacityTextureString = opTex.hash;
     }
 
     // rebuild color tfun?
-    toString = `${vprop.getMTime()}`;
-    if (model.colorTextureString !== toString) {
+    const colorTransferFunc = vprop.getRGBTransferFunction();
+    toString = computeFnToString(vprop, colorTransferFunc, numIComps);
+    const cTex = model._openGLRenderWindow.getGraphicsResourceForObject(colorTransferFunc);
+    const reBuildC = !cTex?.vtkObj || cTex?.hash !== toString || model.colorTextureString !== toString;
+    if (reBuildC) {
       const cWidth = 1024;
       const cSize = cWidth * 2 * numIComps * 3;
       const cTable = new Uint8Array(cSize);
@@ -1013,15 +1039,23 @@ function vtkOpenGLVolumeMapper(publicAPI, model) {
         }
       }
       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);
+      }
+    } else {
+      model.colorTexture = cTex.vtkObj;
+      model.colorTextureString = cTex.hash;
     }
-
+    const tex = model._openGLRenderWindow.getGraphicsResourceForObject(scalars);
     // rebuild the scalarTexture if the data has changed
-    toString = `${image.getMTime()}`;
-    if (model.scalarTextureString !== toString) {
+    toString = `${image.getMTime()}A${scalars.getMTime()}`;
+    const reBuildTex = !tex?.vtkObj || tex?.hash !== toString || model.scalarTextureString !== toString;
+    if (reBuildTex) {
       // Build the textures
       const dims = image.getDimensions();
       // Use norm16 for scalar texture if the extension is available
@@ -1030,6 +1064,12 @@ function vtkOpenGLVolumeMapper(publicAPI, model) {
       model.scalarTexture.resetFormatAndType();
       model.scalarTexture.create3DFilterableFromDataArray(dims[0], dims[1], dims[2], scalars, model.renderable.getPreferSizeOverAccuracy());
       model.scalarTextureString = toString;
+      if (scalars) {
+        model._openGLRenderWindow.setGraphicsResourceForObject(scalars, model.scalarTexture, model.scalarTextureString);
+      }
+    } else {
+      model.scalarTexture = tex.vtkObj;
+      model.scalarTextureString = tex.hash;
     }
     if (!model.tris.getCABO().getElementCount()) {
       // build the CABO
@@ -1122,7 +1162,8 @@ const DEFAULT_VALUES = {
   modelToView: null,
   projectionToView: null,
   avgWindowArea: 0.0,
-  avgFrameTime: 0.0
+  avgFrameTime: 0.0,
+  _scalars: null
 };
 
 // ----------------------------------------------------------------------------

package/package.json

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