@kitware/vtk.js 32.0.1 → 32.1.1

package/Rendering/OpenGL/Texture.js

@@ -285,7 +285,7 @@ function vtkOpenGLTexture(publicAPI, model) {
   publicAPI.getDefaultInternalFormat = (vtktype, numComps) => {
     let result = 0;
     // try default next
-    result = model._openGLRenderWindow.getDefaultTextureInternalFormat(vtktype, numComps, model.oglNorm16Ext, model.useHalfFloat);
+    result = model._openGLRenderWindow.getDefaultTextureInternalFormat(vtktype, numComps, model.oglNorm16Ext, publicAPI.useHalfFloat());
     if (result) {
       return result;
     }
@@ -295,6 +295,7 @@ function vtkOpenGLTexture(publicAPI, model) {
     }
     return result;
   };
+  publicAPI.useHalfFloat = () => model.enableUseHalfFloat && model.canUseHalfFloat;
 
   //----------------------------------------------------------------------------
   publicAPI.setInternalFormat = iFormat => {
@@ -353,6 +354,7 @@ function vtkOpenGLTexture(publicAPI, model) {
 
   //----------------------------------------------------------------------------
   publicAPI.getDefaultDataType = vtkScalarType => {
+    const useHalfFloat = publicAPI.useHalfFloat();
     // DON'T DEAL with VTK_CHAR as this is platform dependent.
     if (model._openGLRenderWindow.getWebgl2()) {
       switch (vtkScalarType) {
@@ -362,14 +364,14 @@ function vtkOpenGLTexture(publicAPI, model) {
           return model.context.UNSIGNED_BYTE;
         // prefer norm16 since that is accurate compared to
         // half float which is not
-        case model.oglNorm16Ext && !model.useHalfFloat && VtkDataTypes.SHORT:
+        case model.oglNorm16Ext && !useHalfFloat && VtkDataTypes.SHORT:
           return model.context.SHORT;
-        case model.oglNorm16Ext && !model.useHalfFloat && VtkDataTypes.UNSIGNED_SHORT:
+        case model.oglNorm16Ext && !useHalfFloat && VtkDataTypes.UNSIGNED_SHORT:
           return model.context.UNSIGNED_SHORT;
         // use half float type
-        case model.useHalfFloat && VtkDataTypes.SHORT:
+        case useHalfFloat && VtkDataTypes.SHORT:
           return model.context.HALF_FLOAT;
-        case model.useHalfFloat && VtkDataTypes.UNSIGNED_SHORT:
+        case useHalfFloat && VtkDataTypes.UNSIGNED_SHORT:
           return model.context.HALF_FLOAT;
         // case VtkDataTypes.INT:
         //   return model.context.INT;
@@ -490,8 +492,18 @@ function vtkOpenGLTexture(publicAPI, model) {
     }
   };
 
-  //----------------------------------------------------------------------------
-  function updateArrayDataType(dataType, data) {
+  /**
+   * Updates the data array to match the required data type for OpenGL.
+   *
+   * This function takes the input data and converts it to the appropriate
+   * format required by the OpenGL texture, based on the specified data type.
+   *
+   * @param {string} dataType - The original data type of the input data.
+   * @param {Array} data - The input data array that needs to be updated.
+   * @param {boolean} [depth=false] - Indicates whether the data is a 3D array.
+   * @returns {Array} The updated data array that matches the OpenGL data type.
+   */
+  publicAPI.updateArrayDataTypeForGL = function (dataType, data) {
     let depth = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
     const pixData = [];
     let pixCount = model.width * model.height * model.components;
@@ -556,7 +568,7 @@ function vtkOpenGLTexture(publicAPI, model) {
       }
     }
     return pixData;
-  }
+  };
 
   //----------------------------------------------------------------------------
   function scaleTextureToHighestPowerOfTwo(data) {
@@ -683,7 +695,7 @@ function vtkOpenGLTexture(publicAPI, model) {
 
     // Create an array of texture with one texture
     const dataArray = [data];
-    const pixData = updateArrayDataType(dataType, dataArray);
+    const pixData = publicAPI.updateArrayDataTypeForGL(dataType, dataArray);
     const scaledData = scaleTextureToHighestPowerOfTwo(pixData);
 
     // Source texture data from the PBO.
@@ -705,7 +717,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);
+    model.allocatedGPUMemoryInBytes = model.width * model.height * model.depth * numComps * model._openGLRenderWindow.getDefaultTextureByteSize(dataType, model.oglNorm16Ext, publicAPI.useHalfFloat());
     publicAPI.deactivate();
     return true;
   };
@@ -730,7 +742,7 @@ function vtkOpenGLTexture(publicAPI, model) {
     model.maxLevel = data.length / 6 - 1;
     publicAPI.createTexture();
     publicAPI.bind();
-    const pixData = updateArrayDataType(dataType, data);
+    const pixData = publicAPI.updateArrayDataTypeForGL(dataType, data);
     const scaledData = scaleTextureToHighestPowerOfTwo(pixData);
 
     // invert the data because opengl is messed up with cube maps
@@ -783,7 +795,7 @@ function vtkOpenGLTexture(publicAPI, model) {
         h /= 2;
       }
     }
-    model.allocatedGPUMemoryInBytes = model.width * model.height * model.depth * numComps * model._openGLRenderWindow.getDefaultTextureByteSize(dataType, model.oglNorm16Ext, model.useHalfFloat);
+    model.allocatedGPUMemoryInBytes = model.width * model.height * model.depth * numComps * model._openGLRenderWindow.getDefaultTextureByteSize(dataType, model.oglNorm16Ext, publicAPI.useHalfFloat());
     // generateMipmap must not be called here because we manually upload all levels
     // if it is called, all levels will be overwritten
 
@@ -833,7 +845,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);
+    model.allocatedGPUMemoryInBytes = model.width * model.height * model.depth * model.components * model._openGLRenderWindow.getDefaultTextureByteSize(dataType, model.oglNorm16Ext, publicAPI.useHalfFloat());
     publicAPI.deactivate();
     return true;
   };
@@ -883,7 +895,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);
+    model.allocatedGPUMemoryInBytes = model.width * model.height * model.depth * model.components * model._openGLRenderWindow.getDefaultTextureByteSize(VtkDataTypes.UNSIGNED_CHAR, model.oglNorm16Ext, publicAPI.useHalfFloat());
     publicAPI.deactivate();
     return true;
   };
@@ -915,20 +927,23 @@ function vtkOpenGLTexture(publicAPI, model) {
     }
     return true;
   }
-  function setUseHalfFloat(dataType, offset, scale, preferSizeOverAccuracy) {
+  function setCanUseHalfFloat(dataType, offset, scale, preferSizeOverAccuracy) {
     publicAPI.getOpenGLDataType(dataType);
+
+    // Don't consider halfFloat and convert back to Float when the range of data does not generate an accurate halfFloat
+    // AND it is not preferable to have a smaller texture than an exact texture.
+    const isExactHalfFloat = hasExactHalfFloat(offset, scale) || preferSizeOverAccuracy;
     let useHalfFloat = false;
     if (model._openGLRenderWindow.getWebgl2()) {
-      useHalfFloat = model.openGLDataType === model.context.HALF_FLOAT;
+      // If OES_texture_float_linear is not available, and using a half float would still be exact, force half floats
+      // This is because half floats are always texture filterable in webgl2, while full *32F floats are not (unless the extension is present)
+      const forceHalfFloat = model.openGLDataType === model.context.FLOAT && model.context.getExtension('OES_texture_float_linear') === null && isExactHalfFloat;
+      useHalfFloat = forceHalfFloat || model.openGLDataType === model.context.HALF_FLOAT;
     } else {
       const halfFloatExt = model.context.getExtension('OES_texture_half_float');
       useHalfFloat = halfFloatExt && model.openGLDataType === halfFloatExt.HALF_FLOAT_OES;
     }
-
-    // Don't consider halfFloat and convert back to Float when the range of data does not generate an accurate halfFloat
-    // AND it is not preferable to have a smaller texture than an exact texture.
-    const isHalfFloat = useHalfFloat && (hasExactHalfFloat(offset, scale) || preferSizeOverAccuracy);
-    model.useHalfFloat = isHalfFloat;
+    model.canUseHalfFloat = useHalfFloat && isExactHalfFloat;
   }
   function processDataArray(dataArray, preferSizeOverAccuracy) {
     const numComps = dataArray.getNumberOfComponents();
@@ -948,11 +963,11 @@ function vtkOpenGLTexture(publicAPI, model) {
 
     // preferSizeOverAccuracy will override norm16 due to bug with norm16 implementation
     // https://bugs.chromium.org/p/chromium/issues/detail?id=1408247
-    setUseHalfFloat(dataType, scaleOffsets.offset, scaleOffsets.scale, preferSizeOverAccuracy);
+    setCanUseHalfFloat(dataType, scaleOffsets.offset, scaleOffsets.scale, preferSizeOverAccuracy);
 
     // since our default is to use half float, in case that we can't use it
     // we need to use another type
-    if (!model.useHalfFloat) {
+    if (!publicAPI.useHalfFloat()) {
       publicAPI.getOpenGLDataType(dataType, true);
     }
     return {
@@ -979,14 +994,88 @@ function vtkOpenGLTexture(publicAPI, model) {
     } = processDataArray(dataArray, preferSizeOverAccuracy);
     publicAPI.create2DFromRaw(width, height, numComps, dataType, data);
   };
+  publicAPI.updateVolumeInfoForGL = (dataType, numComps) => {
+    let isScalingApplied = false;
+    const useHalfFloat = publicAPI.useHalfFloat();
+
+    // Initialize volume info if it doesn't exist
+    if (!model.volumeInfo?.scale || !model.volumeInfo?.offset) {
+      model.volumeInfo = {
+        scale: new Array(numComps),
+        offset: new Array(numComps)
+      };
+    }
+
+    // Default scaling and offset
+    for (let c = 0; c < numComps; ++c) {
+      model.volumeInfo.scale[c] = 1.0;
+      model.volumeInfo.offset[c] = 0.0;
+    }
+
+    // Handle SHORT data type with EXT_texture_norm16 extension
+    if (model.oglNorm16Ext && !useHalfFloat && dataType === VtkDataTypes.SHORT) {
+      for (let c = 0; c < numComps; ++c) {
+        model.volumeInfo.scale[c] = 32767.0; // Scale to [-1, 1] range
+      }
+
+      isScalingApplied = true;
+    }
+
+    // Handle UNSIGNED_SHORT data type with EXT_texture_norm16 extension
+    if (model.oglNorm16Ext && !useHalfFloat && dataType === VtkDataTypes.UNSIGNED_SHORT) {
+      for (let c = 0; c < numComps; ++c) {
+        model.volumeInfo.scale[c] = 65535.0; // Scale to [0, 1] range
+      }
+
+      isScalingApplied = true;
+    }
+
+    // Handle UNSIGNED_CHAR data type
+    if (dataType === VtkDataTypes.UNSIGNED_CHAR) {
+      for (let c = 0; c < numComps; ++c) {
+        model.volumeInfo.scale[c] = 255.0; // Scale to [0, 1] range
+      }
+
+      isScalingApplied = true;
+    }
+
+    // No scaling needed for FLOAT or HalfFloat (SHORT/UNSIGNED_SHORT)
+    if (dataType === VtkDataTypes.FLOAT || useHalfFloat && (dataType === VtkDataTypes.SHORT || dataType === VtkDataTypes.UNSIGNED_SHORT)) {
+      isScalingApplied = true;
+    }
+    return isScalingApplied;
+  };
+
   //----------------------------------------------------------------------------
   publicAPI.create3DFromRaw = (width, height, depth, numComps, dataType, data) => {
+    let dataTypeToUse = dataType;
+    let dataToUse = data;
+    if (!publicAPI.updateVolumeInfoForGL(dataTypeToUse, numComps) && dataToUse) {
+      const numPixelsIn = width * height * depth;
+      const scaleOffsetsCopy = structuredClone(model.volumeInfo);
+      // otherwise convert to float
+      const newArray = new Float32Array(numPixelsIn * numComps);
+      // use computed scale and offset
+      model.volumeInfo.offset = scaleOffsetsCopy.offset;
+      model.volumeInfo.scale = scaleOffsetsCopy.scale;
+      let count = 0;
+      const scaleInverse = scaleOffsetsCopy.scale.map(s => 1 / s);
+      for (let i = 0; i < numPixelsIn; i++) {
+        for (let nc = 0; nc < numComps; nc++) {
+          newArray[count] = (dataToUse[count] - scaleOffsetsCopy.offset[nc]) * scaleInverse[nc];
+          count++;
+        }
+      }
+      dataTypeToUse = VtkDataTypes.FLOAT;
+      dataToUse = newArray;
+    }
+
     // Permit OpenGLDataType to be half float, if applicable, for 3D
-    publicAPI.getOpenGLDataType(dataType);
+    publicAPI.getOpenGLDataType(dataTypeToUse);
 
     // Now determine the texture parameters using the arguments.
-    publicAPI.getInternalFormat(dataType, numComps);
-    publicAPI.getFormat(dataType, numComps);
+    publicAPI.getInternalFormat(dataTypeToUse, numComps);
+    publicAPI.getFormat(dataTypeToUse, numComps);
     if (!model.internalFormat || !model.format || !model.openGLDataType) {
       vtkErrorMacro('Failed to determine texture parameters.');
       return false;
@@ -1001,9 +1090,9 @@ function vtkOpenGLTexture(publicAPI, model) {
     publicAPI.createTexture();
     publicAPI.bind();
     // Create an array of texture with one texture
-    const dataArray = [data];
+    const dataArray = [dataToUse];
     const is3DArray = true;
-    const pixData = updateArrayDataType(dataType, dataArray, is3DArray);
+    const pixData = publicAPI.updateArrayDataTypeForGL(dataTypeToUse, dataArray, is3DArray);
     const scaledData = scaleTextureToHighestPowerOfTwo(pixData);
 
     // Source texture data from the PBO.
@@ -1012,7 +1101,7 @@ function vtkOpenGLTexture(publicAPI, model) {
 
     // openGLDataType
 
-    if (useTexStorage(dataType)) {
+    if (useTexStorage(dataTypeToUse)) {
       model.context.texStorage3D(model.target, 1, model.internalFormat, model.width, model.height, model.depth);
       if (scaledData[0] != null) {
         model.context.texSubImage3D(model.target, 0, 0, 0, 0, model.width, model.height, model.depth, model.format, model.openGLDataType, scaledData[0]);
@@ -1023,7 +1112,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);
+    model.allocatedGPUMemoryInBytes = model.width * model.height * model.depth * model.components * model._openGLRenderWindow.getDefaultTextureByteSize(dataTypeToUse, model.oglNorm16Ext, publicAPI.useHalfFloat());
     publicAPI.deactivate();
     return true;
   };
@@ -1050,7 +1139,6 @@ function vtkOpenGLTexture(publicAPI, model) {
       data,
       scaleOffsets
     } = processDataArray(dataArray, preferSizeOverAccuracy);
-    const numPixelsIn = width * height * depth;
     const offset = [];
     const scale = [];
     for (let c = 0; c < numComps; ++c) {
@@ -1076,46 +1164,13 @@ function vtkOpenGLTexture(publicAPI, model) {
     // Create a copy of scale and offset to avoid aliasing issues
     // Original is read only, copy is read/write
     // Use the copy as volumeInfo.scale and volumeInfo.offset
-    const scaleOffsetsCopy = structuredClone(scaleOffsets);
 
     // WebGL2 path, we have 3d textures etc
     if (model._openGLRenderWindow.getWebgl2()) {
-      if (model.oglNorm16Ext && !model.useHalfFloat && dataType === VtkDataTypes.SHORT) {
-        for (let c = 0; c < numComps; ++c) {
-          model.volumeInfo.scale[c] = 32767.0;
-        }
-        return publicAPI.create3DFromRaw(width, height, depth, numComps, dataType, data);
-      }
-      if (model.oglNorm16Ext && !model.useHalfFloat && dataType === VtkDataTypes.UNSIGNED_SHORT) {
-        for (let c = 0; c < numComps; ++c) {
-          model.volumeInfo.scale[c] = 65535.0;
-        }
-        return publicAPI.create3DFromRaw(width, height, depth, numComps, dataType, data);
-      }
-      if (dataType === VtkDataTypes.FLOAT || model.useHalfFloat && (dataType === VtkDataTypes.SHORT || dataType === VtkDataTypes.UNSIGNED_SHORT)) {
-        return publicAPI.create3DFromRaw(width, height, depth, numComps, dataType, data);
-      }
-      if (dataType === VtkDataTypes.UNSIGNED_CHAR) {
-        for (let c = 0; c < numComps; ++c) {
-          model.volumeInfo.scale[c] = 255.0;
-        }
-        return publicAPI.create3DFromRaw(width, height, depth, numComps, dataType, data);
-      }
-      // otherwise convert to float
-      const newArray = new Float32Array(numPixelsIn * numComps);
-      // use computed scale and offset
-      model.volumeInfo.offset = scaleOffsetsCopy.offset;
-      model.volumeInfo.scale = scaleOffsetsCopy.scale;
-      let count = 0;
-      const scaleInverse = scaleOffsetsCopy.scale.map(s => 1 / s);
-      for (let i = 0; i < numPixelsIn; i++) {
-        for (let nc = 0; nc < numComps; nc++) {
-          newArray[count] = (data[count] - scaleOffsetsCopy.offset[nc]) * scaleInverse[nc];
-          count++;
-        }
-      }
-      return publicAPI.create3DFromRaw(width, height, depth, numComps, VtkDataTypes.FLOAT, newArray);
+      return publicAPI.create3DFromRaw(width, height, depth, numComps, dataType, data);
     }
+    const numPixelsIn = width * height * depth;
+    const scaleOffsetsCopy = structuredClone(scaleOffsets);
 
     // not webgl2, deal with webgl1, no 3d textures
     // and maybe no float textures
@@ -1267,6 +1322,11 @@ function vtkOpenGLTexture(publicAPI, model) {
     }
     return -1;
   };
+
+  // set use half float
+  publicAPI.enableUseHalfFloat = use => {
+    model.enableUseHalfFloat = use;
+  };
 }
 
 // ----------------------------------------------------------------------------
@@ -1299,13 +1359,12 @@ const DEFAULT_VALUES = {
   baseLevel: 0,
   maxLevel: 1000,
   generateMipmap: false,
-  // use half float by default, but it will get set
-  // to false if the context does not support it or
-  // the voxel intensity range is out of the accurate
-  // range of half float
-  useHalfFloat: true,
   oglNorm16Ext: null,
-  allocatedGPUMemoryInBytes: 0
+  allocatedGPUMemoryInBytes: 0,
+  // by default it is enabled
+  enableUseHalfFloat: true,
+  // but by default we don't know if we can use half float base on the data range
+  canUseHalfFloat: false
 };
 
 // ----------------------------------------------------------------------------

package/Rendering/OpenGL/VolumeMapper.js

@@ -15,6 +15,7 @@ import { Representation } from '../Core/Property/Constants.js';
 import { Wrap, Filter } from './Texture/Constants.js';
 import { InterpolationType, OpacityMode, ColorMixPreset } from '../Core/VolumeProperty/Constants.js';
 import { BlendMode } from '../Core/VolumeMapper/Constants.js';
+import { getTransferFunctionHash, getImageDataHash } from './RenderWindow/resourceSharingHelper.js';
 import { v as vtkVolumeVS } from './glsl/vtkVolumeVS.glsl.js';
 import { v as vtkVolumeFS } from './glsl/vtkVolumeFS.glsl.js';
 import { registerOverride } from './ViewNodeFactory.js';
@@ -28,9 +29,6 @@ const {
 // helper methods
 // ----------------------------------------------------------------------------
 
-function computeFnToString(pwfun, useIComps, numberOfComponents) {
-  return pwfun ? `${pwfun.getMTime()}-${useIComps}-${numberOfComponents}` : '0';
-}
 function getColorCodeFromPreset(colorMixPreset) {
   switch (colorMixPreset) {
     case ColorMixPreset.CUSTOM:
@@ -417,18 +415,23 @@ function vtkOpenGLVolumeMapper(publicAPI, model) {
     program.setUniformf('sampleDistance', publicAPI.getCurrentSampleDistance(ren));
     const volInfo = model.scalarTexture.getVolumeInfo();
     const ipScalarRange = model.renderable.getIpScalarRange();
-    const minVals = [];
-    const maxVals = [];
-    for (let i = 0; i < 4; i++) {
-      // convert iprange from 0-1 into data range values
-      minVals[i] = ipScalarRange[0] * volInfo.dataComputedScale[i] + volInfo.dataComputedOffset[i];
-      maxVals[i] = ipScalarRange[1] * volInfo.dataComputedScale[i] + volInfo.dataComputedOffset[i];
-      // convert data ranges into texture values
-      minVals[i] = (minVals[i] - volInfo.offset[i]) / volInfo.scale[i];
-      maxVals[i] = (maxVals[i] - volInfo.offset[i]) / volInfo.scale[i];
-    }
-    program.setUniform4f('ipScalarRangeMin', minVals[0], minVals[1], minVals[2], minVals[3]);
-    program.setUniform4f('ipScalarRangeMax', maxVals[0], maxVals[1], maxVals[2], maxVals[3]);
+
+    // In some situations, we might not have computed the scale and offset
+    // for the data range, or it might not be needed.
+    if (volInfo?.dataComputedScale?.length) {
+      const minVals = [];
+      const maxVals = [];
+      for (let i = 0; i < 4; i++) {
+        // convert iprange from 0-1 into data range values
+        minVals[i] = ipScalarRange[0] * volInfo.dataComputedScale[i] + volInfo.dataComputedOffset[i];
+        maxVals[i] = ipScalarRange[1] * volInfo.dataComputedScale[i] + volInfo.dataComputedOffset[i];
+        // convert data ranges into texture values
+        minVals[i] = (minVals[i] - volInfo.offset[i]) / volInfo.scale[i];
+        maxVals[i] = (maxVals[i] - volInfo.offset[i]) / volInfo.scale[i];
+      }
+      program.setUniform4f('ipScalarRangeMin', minVals[0], minVals[1], minVals[2], minVals[3]);
+      program.setUniform4f('ipScalarRangeMax', maxVals[0], maxVals[1], maxVals[2], maxVals[3]);
+    }
 
     // if we have a zbuffer texture then set it
     if (model.zBufferTexture !== null) {
@@ -1044,7 +1047,7 @@ function vtkOpenGLVolumeMapper(publicAPI, model) {
     const numIComps = useIndependentComps ? numComp : 1;
     const scalarOpacityFunc = vprop.getScalarOpacity();
     const opTex = model._openGLRenderWindow.getGraphicsResourceForObject(scalarOpacityFunc);
-    let toString = computeFnToString(scalarOpacityFunc, useIndependentComps, numIComps);
+    let toString = getTransferFunctionHash(scalarOpacityFunc, useIndependentComps, numIComps);
     const reBuildOp = !opTex?.oglObject || opTex.hash !== toString;
     if (reBuildOp) {
       model.opacityTexture = vtkOpenGLTexture.newInstance();
@@ -1096,7 +1099,7 @@ function vtkOpenGLVolumeMapper(publicAPI, model) {
 
     // rebuild color tfun?
     const colorTransferFunc = vprop.getRGBTransferFunction();
-    toString = computeFnToString(colorTransferFunc, useIndependentComps, numIComps);
+    toString = getTransferFunctionHash(colorTransferFunc, useIndependentComps, numIComps);
     const cTex = model._openGLRenderWindow.getGraphicsResourceForObject(colorTransferFunc);
     const reBuildC = !cTex?.oglObject?.getHandle() || cTex?.hash !== toString;
     if (reBuildC) {
@@ -1133,7 +1136,7 @@ function vtkOpenGLVolumeMapper(publicAPI, model) {
     publicAPI.updateLabelOutlineThicknessTexture(actor);
     const tex = model._openGLRenderWindow.getGraphicsResourceForObject(scalars);
     // rebuild the scalarTexture if the data has changed
-    toString = `${image.getMTime()}A${scalars.getMTime()}`;
+    toString = getImageDataHash(image, scalars);
     const reBuildTex = !tex?.oglObject?.getHandle() || tex?.hash !== toString;
     if (reBuildTex) {
       model.scalarTexture = vtkOpenGLTexture.newInstance();

package/index.d.ts

@@ -31,6 +31,7 @@
 /// <reference path="./Common/DataModel/EdgeLocator.d.ts" />
 /// <reference path="./Common/DataModel/ITKHelper.d.ts" />
 /// <reference path="./Common/DataModel/ImageData.d.ts" />
+/// <reference path="./Common/DataModel/ImplicitFunction.d.ts" />
 /// <reference path="./Common/DataModel/IncrementalOctreeNode.d.ts" />
 /// <reference path="./Common/DataModel/IncrementalOctreePointLocator.d.ts" />
 /// <reference path="./Common/DataModel/KochanekSpline1D.d.ts" />
@@ -216,6 +217,7 @@
 /// <reference path="./Rendering/OpenGL/HardwareSelector/Constants.d.ts" />
 /// <reference path="./Rendering/OpenGL/HardwareSelector.d.ts" />
 /// <reference path="./Rendering/OpenGL/RenderWindow.d.ts" />
+/// <reference path="./Rendering/OpenGL/RenderWindow/resourceSharingHelper.d.ts" />
 /// <reference path="./Rendering/OpenGL/Texture/Constants.d.ts" />
 /// <reference path="./Rendering/OpenGL/Texture.d.ts" />
 /// <reference path="./Rendering/SceneGraph/RenderPass.d.ts" />

package/package.json

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