@kitware/vtk.js 32.0.1 → 32.1.0

package/Rendering/OpenGL/ImageCPRMapper.js

@@ -11,6 +11,7 @@ import vtkOpenGLTexture from './Texture.js';
 import vtkReplacementShaderMapper from './ReplacementShaderMapper.js';
 import vtkShaderProgram from './ShaderProgram.js';
 import vtkViewNode from '../SceneGraph/ViewNode.js';
+import { getImageDataHash, getTransferFunctionHash } from './RenderWindow/resourceSharingHelper.js';
 import { v as vtkPolyDataVS } from './glsl/vtkPolyDataVS.glsl.js';
 import { v as vtkPolyDataFS } from './glsl/vtkPolyDataFS.glsl.js';
 import { registerOverride } from './ViewNodeFactory.js';
@@ -21,19 +22,6 @@ const {
   vtkErrorMacro
 } = macro;
 
-// ----------------------------------------------------------------------------
-// helper methods
-// ----------------------------------------------------------------------------
-
-function computeFnToString(property, fn, numberOfComponents) {
-  const pwfun = fn.apply(property);
-  if (pwfun) {
-    const iComps = property.getIndependentComponents();
-    return `${property.getMTime()}-${iComps}-${numberOfComponents}`;
-  }
-  return '0';
-}
-
 // ----------------------------------------------------------------------------
 // vtkOpenGLImageCPRMapper methods
 // ----------------------------------------------------------------------------
@@ -41,18 +29,22 @@ function computeFnToString(property, fn, numberOfComponents) {
 function vtkOpenGLImageCPRMapper(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkOpenGLImageCPRMapper');
+  function unregisterGraphicsResources(renderWindow) {
+    [model._scalars, model._colorTransferFunc, model._pwFunc].forEach(coreObject => renderWindow.unregisterGraphicsResourceUser(coreObject, publicAPI));
+  }
   publicAPI.buildPass = prepass => {
     if (prepass) {
       model.currentRenderPass = null;
       model.openGLImageSlice = publicAPI.getFirstAncestorOfType('vtkOpenGLImageSlice');
       model._openGLRenderer = publicAPI.getFirstAncestorOfType('vtkOpenGLRenderer');
+      const oldOglRenderWindow = model._openGLRenderWindow;
       model._openGLRenderWindow = model._openGLRenderer.getLastAncestorOfType('vtkOpenGLRenderWindow');
+      if (oldOglRenderWindow && !oldOglRenderWindow.isDeleted() && oldOglRenderWindow !== model._openGLRenderWindow) {
+        unregisterGraphicsResources(oldOglRenderWindow);
+      }
       model.context = model._openGLRenderWindow.getContext();
       model.openGLCamera = model._openGLRenderer.getViewNodeFor(model._openGLRenderer.getRenderable().getActiveCamera());
       model.tris.setOpenGLRenderWindow(model._openGLRenderWindow);
-      model.volumeTexture.setOpenGLRenderWindow(model._openGLRenderWindow);
-      model.colorTexture.setOpenGLRenderWindow(model._openGLRenderWindow);
-      model.pwfTexture.setOpenGLRenderWindow(model._openGLRenderWindow);
     }
   };
   publicAPI.opaquePass = (prepass, renderPass) => {
@@ -128,22 +120,8 @@ function vtkOpenGLImageCPRMapper(publicAPI, model) {
     if (publicAPI.getNeedToRebuildBufferObjects(ren, actor)) {
       publicAPI.buildBufferObjects(ren, actor);
     }
-  };
-  publicAPI.getNeedToRebuildBufferObjects = (ren, actor) => {
-    // first do a coarse check
-    // Note that the actor's mtime includes it's properties mtime
-    const vmtime = model.VBOBuildTime.getMTime();
-    if (vmtime < publicAPI.getMTime() || vmtime < model.renderable.getMTime() || vmtime < actor.getMTime() || vmtime < model.currentImageDataInput.getMTime() || vmtime < model.currentCenterlineInput.getMTime()) {
-      return true;
-    }
-    return false;
-  };
-  publicAPI.buildBufferObjects = (ren, actor) => {
-    const image = model.currentImageDataInput;
-    const centerline = model.currentCenterlineInput;
-    const actorProperty = actor.getProperty();
-
     // Set interpolation on the texture based on property setting
+    const actorProperty = actor.getProperty();
     if (actorProperty.getInterpolationType() === InterpolationType.NEAREST) {
       model.volumeTexture.setMinificationFilter(Filter.NEAREST);
       model.volumeTexture.setMagnificationFilter(Filter.NEAREST);
@@ -159,44 +137,64 @@ function vtkOpenGLImageCPRMapper(publicAPI, model) {
       model.pwfTexture.setMinificationFilter(Filter.LINEAR);
       model.pwfTexture.setMagnificationFilter(Filter.LINEAR);
     }
+  };
+  publicAPI.getNeedToRebuildBufferObjects = (ren, actor) => {
+    // first do a coarse check
+    // Note that the actor's mtime includes it's properties mtime
+    const vmtime = model.VBOBuildTime.getMTime();
+    return vmtime < publicAPI.getMTime() || vmtime < model.renderable.getMTime() || vmtime < actor.getMTime() || vmtime < model.currentImageDataInput.getMTime() || vmtime < model.currentCenterlineInput.getMTime() || !model.volumeTexture?.getHandle();
+  };
+  publicAPI.buildBufferObjects = (ren, actor) => {
+    const image = model.currentImageDataInput;
+    const centerline = model.currentCenterlineInput;
 
     // Rebuild the volumeTexture if the data has changed
-    const imageTime = image.getMTime();
-    if (model.volumeTextureTime !== imageTime) {
+    const scalars = image?.getPointData()?.getScalars();
+    if (!scalars) {
+      return;
+    }
+    const cachedScalarsEntry = model._openGLRenderWindow.getGraphicsResourceForObject(scalars);
+    const volumeTextureHash = getImageDataHash(image, scalars);
+    const reBuildTex = !cachedScalarsEntry?.oglObject?.getHandle() || cachedScalarsEntry?.hash !== volumeTextureHash;
+    if (reBuildTex) {
+      model.volumeTexture = vtkOpenGLTexture.newInstance();
+      model.volumeTexture.setOpenGLRenderWindow(model._openGLRenderWindow);
       // Build the textures
       const dims = image.getDimensions();
-      const scalars = image.getPointData().getScalars();
-      if (!scalars) {
-        return;
-      }
       // Use norm16 for scalar texture if the extension is available
       model.volumeTexture.setOglNorm16Ext(model.context.getExtension('EXT_texture_norm16'));
-      model.volumeTexture.releaseGraphicsResources(model._openGLRenderWindow);
       model.volumeTexture.resetFormatAndType();
-      model.volumeTexture.create3DFilterableFromRaw(dims[0], dims[1], dims[2], scalars.getNumberOfComponents(), scalars.getDataType(), scalars.getData(), model.renderable.getPreferSizeOverAccuracy());
-      model.volumeTextureTime = imageTime;
+      model.volumeTexture.create3DFilterableFromDataArray(dims[0], dims[1], dims[2], scalars, model.renderable.getPreferSizeOverAccuracy());
+      model._openGLRenderWindow.setGraphicsResourceForObject(scalars, model.volumeTexture, volumeTextureHash);
+      if (scalars !== model._scalars) {
+        model._openGLRenderWindow.registerGraphicsResourceUser(scalars, publicAPI);
+        model._openGLRenderWindow.unregisterGraphicsResourceUser(model._scalars, publicAPI);
+      }
+      model._scalars = scalars;
+    } else {
+      model.volumeTexture = cachedScalarsEntry.oglObject;
     }
 
     // Rebuild the color texture if needed
-    const scalars = image.getPointData() && image.getPointData().getScalars();
-    if (!scalars) {
-      return;
-    }
     const numComp = scalars.getNumberOfComponents();
     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();
+    const colorTextureHash = getTransferFunctionHash(colorTransferFunc, iComps, numIComps);
+    const cachedColorEntry = model._openGLRenderWindow.getGraphicsResourceForObject(colorTransferFunc);
+    const reBuildColorTexture = !cachedColorEntry?.oglObject?.getHandle() || cachedColorEntry?.hash !== colorTextureHash;
+    if (reBuildColorTexture) {
       const cWidth = 1024;
       const cSize = cWidth * textureHeight * 3;
       const cTable = new Uint8ClampedArray(cSize);
-      let cfun = ppty.getRGBTransferFunction();
-      if (cfun) {
+      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) {
@@ -210,7 +208,6 @@ function vtkOpenGLImageCPRMapper(publicAPI, model) {
             }
           }
         }
-        model.colorTexture.releaseGraphicsResources(model._openGLRenderWindow);
         model.colorTexture.resetFormatAndType();
         model.colorTexture.create2DFromRaw(cWidth, textureHeight, 3, VtkDataTypes.UNSIGNED_CHAR, cTable);
       } else {
@@ -219,28 +216,39 @@ function vtkOpenGLImageCPRMapper(publicAPI, model) {
           cTable[i + 1] = 255.0 * i / ((cWidth - 1) * 3);
           cTable[i + 2] = 255.0 * i / ((cWidth - 1) * 3);
         }
+        model.colorTexture.resetFormatAndType();
         model.colorTexture.create2DFromRaw(cWidth, 1, 3, VtkDataTypes.UNSIGNED_CHAR, cTable);
       }
-      model.colorTextureString = cfunToString;
+      if (colorTransferFunc) {
+        model._openGLRenderWindow.setGraphicsResourceForObject(colorTransferFunc, model.colorTexture, colorTextureHash);
+        if (colorTransferFunc !== model._colorTransferFunc) {
+          model._openGLRenderWindow.registerGraphicsResourceUser(colorTransferFunc, publicAPI);
+          model._openGLRenderWindow.unregisterGraphicsResourceUser(model._colorTransferFunc, publicAPI);
+        }
+        model._colorTransferFunc = colorTransferFunc;
+      }
+    } else {
+      model.colorTexture = cachedColorEntry.oglObject;
     }
 
     // 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();
+    const pwfTextureHash = getTransferFunctionHash(pwFunc, iComps, numIComps);
+    const cachedPwfEntry = model._openGLRenderWindow.getGraphicsResourceForObject(pwFunc);
+    const reBuildPwf = !cachedPwfEntry?.oglObject?.getHandle() || cachedPwfEntry?.hash !== pwfTextureHash;
+    if (reBuildPwf) {
       const pwfWidth = 1024;
       const pwfSize = pwfWidth * textureHeight;
       const pwfTable = new Uint8ClampedArray(pwfSize);
-      let pwfun = ppty.getPiecewiseFunction();
-      // support case where pwfun is added/removed
-      model.pwfTexture.releaseGraphicsResources(model._openGLRenderWindow);
-      model.pwfTexture.resetFormatAndType();
-      if (pwfun) {
+      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);
@@ -260,13 +268,24 @@ function vtkOpenGLImageCPRMapper(publicAPI, model) {
             }
           }
         }
+        model.pwfTexture.resetFormatAndType();
         model.pwfTexture.create2DFromRaw(pwfWidth, textureHeight, 1, VtkDataTypes.FLOAT, pwfFloatTable);
       } else {
         // default is opaque
         pwfTable.fill(255.0);
+        model.pwfTexture.resetFormatAndType();
         model.pwfTexture.create2DFromRaw(pwfWidth, 1, 1, VtkDataTypes.UNSIGNED_CHAR, pwfTable);
       }
-      model.pwfTextureString = pwfunToString;
+      if (pwFunc) {
+        model._openGLRenderWindow.setGraphicsResourceForObject(pwFunc, model.pwfTexture, pwfTextureHash);
+        if (pwFunc !== model._pwFunc) {
+          model._openGLRenderWindow.registerGraphicsResourceUser(pwFunc, publicAPI);
+          model._openGLRenderWindow.unregisterGraphicsResourceUser(model._pwFunc, publicAPI);
+        }
+        model._pwFunc = pwFunc;
+      }
+    } else {
+      model.pwfTexture = cachedPwfEntry.oglObject;
     }
 
     // Rebuild the image vertices if needed
@@ -873,6 +892,11 @@ function vtkOpenGLImageCPRMapper(publicAPI, model) {
     publicAPI.setCameraShaderParameters(cellBO, ren, actor);
     publicAPI.setPropertyShaderParameters(cellBO, ren, actor);
   };
+  publicAPI.delete = macro.chain(() => {
+    if (model._openGLRenderWindow) {
+      unregisterGraphicsResources(model._openGLRenderWindow);
+    }
+  }, publicAPI.delete);
 }
 
 // ----------------------------------------------------------------------------
@@ -882,11 +906,8 @@ function vtkOpenGLImageCPRMapper(publicAPI, model) {
 const DEFAULT_VALUES = {
   currentRenderPass: null,
   volumeTexture: null,
-  volumeTextureTime: 0,
   colorTexture: null,
-  colorTextureString: null,
   pwfTexture: null,
-  pwfTextureString: null,
   tris: null,
   lastHaveSeenDepthRequest: false,
   haveSeenDepthRequest: false,
@@ -894,6 +915,9 @@ const DEFAULT_VALUES = {
   lastIndependentComponents: 0,
   imagemat: null,
   imagematinv: null
+  // _scalars: null,
+  // _colorTransferFunc: null,
+  // _pwFunc: null,
 };
 
 // ----------------------------------------------------------------------------
@@ -909,9 +933,9 @@ function extend(publicAPI, model) {
   // Two inputs: one for the ImageData/Texture and one for the PolyData (centerline)
   macro.algo(publicAPI, model, 2, 0);
   model.tris = vtkHelper.newInstance();
-  model.volumeTexture = vtkOpenGLTexture.newInstance();
-  model.colorTexture = vtkOpenGLTexture.newInstance();
-  model.pwfTexture = vtkOpenGLTexture.newInstance();
+  model.volumeTexture = null;
+  model.colorTexture = null;
+  model.pwfTexture = null;
   model.imagemat = mat4.identity(new Float64Array(16));
   model.imagematinv = mat4.identity(new Float64Array(16));
   model.VBOBuildTime = {};

package/Rendering/OpenGL/ImageMapper.js

@@ -11,6 +11,7 @@ import vtkViewNode from '../SceneGraph/ViewNode.js';
 import { Representation } from '../Core/Property/Constants.js';
 import { Filter, Wrap } from './Texture/Constants.js';
 import { InterpolationType } from '../Core/ImageProperty/Constants.js';
+import { getTransferFunctionHash } from './RenderWindow/resourceSharingHelper.js';
 import { v as vtkPolyDataVS } from './glsl/vtkPolyDataVS.glsl.js';
 import { v as vtkPolyDataFS } from './glsl/vtkPolyDataFS.glsl.js';
 import vtkReplacementShaderMapper from './ReplacementShaderMapper.js';
@@ -29,13 +30,6 @@ const {
 // helper methods
 // ----------------------------------------------------------------------------
 
-function computeFnToString(property, pwfun, numberOfComponents) {
-  if (pwfun) {
-    const iComps = property.getIndependentComponents();
-    return `${pwfun.getMTime()}-${iComps}-${numberOfComponents}`;
-  }
-  return '0';
-}
 function splitStringOnEnter(inputString) {
   // Split the input string into an array of lines based on "Enter" (newline) characters
   // Remove any leading or trailing whitespace from each line and filter out empty lines
@@ -585,7 +579,7 @@ function vtkOpenGLImageMapper(publicAPI, model) {
     const numIComps = iComps ? numComp : 1;
     const textureHeight = iComps ? 2 * numIComps : 1;
     const colorTransferFunc = actorProperty.getRGBTransferFunction();
-    const cfunToString = computeFnToString(actorProperty, colorTransferFunc, numIComps);
+    const cfunToString = getTransferFunctionHash(colorTransferFunc, iComps, numIComps);
     const cTex = model._openGLRenderWindow.getGraphicsResourceForObject(colorTransferFunc);
     const reBuildC = !cTex?.oglObject?.getHandle() || cTex?.hash !== cfunToString;
     if (reBuildC) {
@@ -647,7 +641,7 @@ function vtkOpenGLImageMapper(publicAPI, model) {
     // for component weighting or opacity, depending on whether we're
     // rendering components independently or not.
     const pwFunc = actorProperty.getPiecewiseFunction();
-    const pwfunToString = computeFnToString(actorProperty, pwFunc, numIComps);
+    const pwfunToString = getTransferFunctionHash(pwFunc, iComps, numIComps);
     const pwfTex = model._openGLRenderWindow.getGraphicsResourceForObject(pwFunc);
     // rebuild opacity tfun?
     const reBuildPwf = !pwfTex?.oglObject?.getHandle() || pwfTex?.hash !== pwfunToString;

package/Rendering/OpenGL/ImageResliceMapper.js

@@ -13,6 +13,7 @@ import vtkReplacementShaderMapper from './ReplacementShaderMapper.js';
 import vtkShaderProgram from './ShaderProgram.js';
 import vtkTransform from '../../Common/Transform/Transform.js';
 import vtkViewNode from '../SceneGraph/ViewNode.js';
+import { getImageDataHash, getTransferFunctionHash } from './RenderWindow/resourceSharingHelper.js';
 import { v as vtkImageResliceMapperVS } from './glsl/vtkImageResliceMapperVS.glsl.js';
 import { v as vtkImageResliceMapperFS } from './glsl/vtkImageResliceMapperFS.glsl.js';
 import { Filter } from './Texture/Constants.js';
@@ -31,13 +32,6 @@ const {
 // helper methods
 // ----------------------------------------------------------------------------
 
-function computeFnToString(property, pwfun, numberOfComponents) {
-  if (pwfun) {
-    const iComps = property.getIndependentComponents();
-    return `${pwfun.getMTime()}-${iComps}-${numberOfComponents}`;
-  }
-  return '0';
-}
 function safeMatrixMultiply(matrixArray, matrixType, tmpMat) {
   matrixType.identity(tmpMat);
   return matrixArray.reduce((res, matrix, index) => {
@@ -188,7 +182,7 @@ function vtkOpenGLImageResliceMapper(publicAPI, model) {
       return;
     }
     const numComp = scalars.getNumberOfComponents();
-    let toString = `${image.getMTime()}A${scalars.getMTime()}`;
+    let toString = getImageDataHash(image, scalars);
     const tex = model._openGLRenderWindow.getGraphicsResourceForObject(scalars);
     const reBuildTex = !tex?.oglObject?.getHandle() || tex?.hash !== toString;
     if (reBuildTex) {
@@ -200,14 +194,12 @@ function vtkOpenGLImageResliceMapper(publicAPI, model) {
       model.openGLTexture.setOglNorm16Ext(model.context.getExtension('EXT_texture_norm16'));
       model.openGLTexture.resetFormatAndType();
       model.openGLTexture.create3DFilterableFromDataArray(dims[0], dims[1], dims[2], scalars);
-      if (scalars) {
-        model._openGLRenderWindow.setGraphicsResourceForObject(scalars, model.openGLTexture, toString);
-        if (scalars !== model._scalars) {
-          model._openGLRenderWindow.registerGraphicsResourceUser(scalars, publicAPI);
-          model._openGLRenderWindow.unregisterGraphicsResourceUser(model._scalars, publicAPI);
-        }
-        model._scalars = scalars;
+      model._openGLRenderWindow.setGraphicsResourceForObject(scalars, model.openGLTexture, toString);
+      if (scalars !== model._scalars) {
+        model._openGLRenderWindow.registerGraphicsResourceUser(scalars, publicAPI);
+        model._openGLRenderWindow.unregisterGraphicsResourceUser(model._scalars, publicAPI);
       }
+      model._scalars = scalars;
     } else {
       model.openGLTexture = tex.oglObject;
     }
@@ -216,7 +208,7 @@ function vtkOpenGLImageResliceMapper(publicAPI, model) {
     const numIComps = iComps ? numComp : 1;
     const textureHeight = iComps ? 2 * numIComps : 1;
     const colorTransferFunc = ppty.getRGBTransferFunction();
-    toString = computeFnToString(ppty, colorTransferFunc, numIComps);
+    toString = getTransferFunctionHash(colorTransferFunc, iComps, numIComps);
     const cTex = model._openGLRenderWindow.getGraphicsResourceForObject(colorTransferFunc);
     const reBuildC = !cTex?.oglObject?.getHandle() || cTex?.hash !== toString;
     if (reBuildC) {
@@ -269,7 +261,7 @@ function vtkOpenGLImageResliceMapper(publicAPI, model) {
     // for component weighting or opacity, depending on whether we're
     // rendering components independently or not.
     const pwFunc = ppty.getPiecewiseFunction();
-    toString = computeFnToString(ppty, pwFunc, numIComps);
+    toString = getTransferFunctionHash(pwFunc, iComps, numIComps);
     const pwfTex = model._openGLRenderWindow.getGraphicsResourceForObject(pwFunc);
     // rebuild opacity tfun?
     const reBuildPwf = !pwfTex?.oglObject?.getHandle() || pwfTex?.hash !== toString;

package/Rendering/OpenGL/RenderWindow/resourceSharingHelper.d.ts

@@ -0,0 +1,34 @@
+import vtkImageData from '../../../Common/DataModel/ImageData';
+import vtkDataArray from '../../../Common/Core/DataArray';
+import { vtkObject } from '../../../interfaces';
+
+/**
+ * Compute and return a hash than can be used for caching resources
+ *
+ * @param transferFunction The transfer function, it can be any vtkObject, but is usually a vtkTransferFunction
+ * @param useIndependentComponents A boolean taken from the image or volume property, using getIndependentComponents()
+ * @param numberOfComponents Taken from the data array, using getNumberOfComponents()
+ */
+export function getTransferFunctionHash(
+  transferFunction: vtkObject | undefined,
+  useIndependentComponents: boolean,
+  numberOfComponents: number
+): string;
+
+/**
+ * Compute and return a hash than can be used for caching resources
+ *
+ * @param image The image data that contains the scalars
+ * @param scalars The scalars used for rendering
+ */
+export function getImageDataHash(
+  image: vtkImageData,
+  scalars: vtkDataArray
+): string;
+
+declare const defaultExport: {
+  getTransferFunctionHash: typeof getTransferFunctionHash;
+  getImageDataHash: typeof getImageDataHash;
+};
+
+export default defaultExport;

package/Rendering/OpenGL/RenderWindow/resourceSharingHelper.js

@@ -0,0 +1,14 @@
+// See typescript header for documentation
+
+function getTransferFunctionHash(transferFunction, useIndependentComponents, numberOfComponents) {
+  return transferFunction ? `${transferFunction.getMTime()}-${useIndependentComponents}-${numberOfComponents}` : '0';
+}
+function getImageDataHash(image, scalars) {
+  return `${image.getMTime()}A${scalars.getMTime()}`;
+}
+var resourceSharingHelper = {
+  getTransferFunctionHash,
+  getImageDataHash
+};
+
+export { resourceSharingHelper as default, getImageDataHash, getTransferFunctionHash };

package/Rendering/OpenGL/Texture.d.ts

@@ -175,6 +175,23 @@ export interface vtkOpenGLTexture extends vtkViewNode {
    */
   getOpenGLWrapMode(vtktype: Wrap): any;
 
+  /**
+   * 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.
+   */
+  updateArrayDataTypeForGL(
+    dataType: VtkDataTypes,
+    data: any,
+    depth?: boolean
+  ): void;
+
   /**
    * Creates a 2D texture from raw data.
    * @param width The width of the texture.
@@ -323,6 +340,15 @@ export interface vtkOpenGLTexture extends vtkViewNode {
    * @returns {number} The maximum texture size.
    */
   getMaximumTextureSize(ctx: any): number;
+
+  /**
+   * Public API to disable half float usage.
+   * Half float is automatically enabled when creating the texture,
+   * but users may want to disable it in certain cases
+   * (e.g., streaming data where the full range is not yet available).
+   * @param useHalfFloat - whether to use half float
+   */
+  enableUseHalfFloat(useHalfFloat: boolean): void;
 }
 
 /**