@kitware/vtk.js 28.12.4 → 28.13.0

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;
+    }
+  };
 }
 
 // ----------------------------------------------------------------------------