@kitware/vtk.js 33.0.0-beta.3 → 33.0.0

package/Rendering/OpenGL/ImageResliceMapper.js

@@ -13,7 +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, getTransferFunctionsHash } from './RenderWindow/resourceSharingHelper.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';
@@ -49,43 +49,8 @@ function safeMatrixMultiply(matrixArray, matrixType, tmpMat) {
 function vtkOpenGLImageResliceMapper(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkOpenGLImageResliceMapper');
-
-  // Associate a reference counter to each graphics resource
-  const graphicsResourceReferenceCount = new Map();
-  function decreaseGraphicsResourceCount(openGLRenderWindow, coreObject) {
-    if (!coreObject) {
-      return;
-    }
-    const oldCount = graphicsResourceReferenceCount.get(coreObject) ?? 0;
-    const newCount = oldCount - 1;
-    if (newCount <= 0) {
-      openGLRenderWindow.unregisterGraphicsResourceUser(coreObject, publicAPI);
-      graphicsResourceReferenceCount.delete(coreObject);
-    } else {
-      graphicsResourceReferenceCount.set(coreObject, newCount);
-    }
-  }
-  function increaseGraphicsResourceCount(openGLRenderWindow, coreObject) {
-    if (!coreObject) {
-      return;
-    }
-    const oldCount = graphicsResourceReferenceCount.get(coreObject) ?? 0;
-    const newCount = oldCount + 1;
-    graphicsResourceReferenceCount.set(coreObject, newCount);
-    if (oldCount <= 0) {
-      openGLRenderWindow.registerGraphicsResourceUser(coreObject, publicAPI);
-    }
-  }
-  function replaceGraphicsResource(openGLRenderWindow, oldResourceCoreObject, newResourceCoreObject) {
-    if (oldResourceCoreObject === newResourceCoreObject) {
-      return;
-    }
-    decreaseGraphicsResourceCount(openGLRenderWindow, oldResourceCoreObject);
-    increaseGraphicsResourceCount(openGLRenderWindow, newResourceCoreObject);
-  }
   function unregisterGraphicsResources(renderWindow) {
-    // Convert to an array using the spread operator as Firefox doesn't support Iterator.forEach()
-    [...graphicsResourceReferenceCount.keys()].forEach(coreObject => renderWindow.unregisterGraphicsResourceUser(coreObject, publicAPI));
+    [model._scalars, model._colorTransferFunc, model._pwFunc].forEach(coreObject => renderWindow.unregisterGraphicsResourceUser(coreObject, publicAPI));
   }
   publicAPI.buildPass = prepass => {
     if (prepass) {
@@ -145,28 +110,11 @@ function vtkOpenGLImageResliceMapper(publicAPI, model) {
       type: 'StartEvent'
     });
     model.renderable.update();
-    const numberOfInputs = model.renderable.getNumberOfInputPorts();
-    model.currentValidInputs = [];
-    for (let inputIndex = 0; inputIndex < numberOfInputs; ++inputIndex) {
-      const imageData = model.renderable.getInputData(inputIndex);
-      if (imageData && !imageData.isDeleted()) {
-        model.currentValidInputs.push({
-          imageData,
-          inputIndex
-        });
-      }
-    }
-    const numberOfValidInputs = model.currentValidInputs.length;
-    if (numberOfValidInputs <= 0) {
+    model.currentInput = model.renderable.getInputData();
+    if (!model.currentInput) {
       vtkErrorMacro('No input!');
       return;
     }
-
-    // Number of components
-    const firstImageData = model.currentValidInputs[0].imageData;
-    const firstScalars = firstImageData.getPointData().getScalars();
-    model.multiTexturePerVolumeEnabled = numberOfValidInputs > 1;
-    model.numberOfComponents = model.multiTexturePerVolumeEnabled ? numberOfValidInputs : firstScalars.getNumberOfComponents();
     publicAPI.updateResliceGeometry();
     publicAPI.renderPieceStart(ren, actor);
     publicAPI.renderPieceDraw(ren, actor);
@@ -178,35 +126,17 @@ function vtkOpenGLImageResliceMapper(publicAPI, model) {
   publicAPI.renderPieceStart = (ren, actor) => {
     // make sure the BOs are up to date
     publicAPI.updateBufferObjects(ren, actor);
-
-    // Update filters for scalar textures
-    const actorProperties = actor.getProperties();
-    model.currentValidInputs.forEach(_ref => {
-      let {
-        inputIndex
-      } = _ref;
-      const actorProperty = actorProperties[inputIndex];
-      const interpolationType = actorProperty.getInterpolationType();
-      const scalarTexture = model.scalarTextures[inputIndex];
-      if (interpolationType === InterpolationType.NEAREST) {
-        scalarTexture.setMinificationFilter(Filter.NEAREST);
-        scalarTexture.setMagnificationFilter(Filter.NEAREST);
-      } else {
-        scalarTexture.setMinificationFilter(Filter.LINEAR);
-        scalarTexture.setMagnificationFilter(Filter.LINEAR);
-      }
-    });
-
-    // Update color and opacity texture filters
-    const firstValidInput = model.currentValidInputs[0];
-    const firstProperty = actorProperties[firstValidInput.inputIndex];
-    const iType = firstProperty.getInterpolationType();
+    const iType = actor.getProperty().getInterpolationType();
     if (iType === InterpolationType.NEAREST) {
+      model.openGLTexture.setMinificationFilter(Filter.NEAREST);
+      model.openGLTexture.setMagnificationFilter(Filter.NEAREST);
       model.colorTexture.setMinificationFilter(Filter.NEAREST);
       model.colorTexture.setMagnificationFilter(Filter.NEAREST);
       model.pwfTexture.setMinificationFilter(Filter.NEAREST);
       model.pwfTexture.setMagnificationFilter(Filter.NEAREST);
     } else {
+      model.openGLTexture.setMinificationFilter(Filter.LINEAR);
+      model.openGLTexture.setMagnificationFilter(Filter.LINEAR);
       model.colorTexture.setMinificationFilter(Filter.LINEAR);
       model.colorTexture.setMagnificationFilter(Filter.LINEAR);
       model.pwfTexture.setMinificationFilter(Filter.LINEAR);
@@ -220,8 +150,9 @@ function vtkOpenGLImageResliceMapper(publicAPI, model) {
     const gl = model.context;
 
     // render the texture
-    const allTextures = [...model.scalarTextures, model.colorTexture, model.pwfTexture];
-    allTextures.forEach(texture => texture.activate());
+    model.openGLTexture.activate();
+    model.colorTexture.activate();
+    model.pwfTexture.activate();
 
     // update shaders if required
     publicAPI.updateShaders(model.tris, ren, actor);
@@ -229,7 +160,9 @@ function vtkOpenGLImageResliceMapper(publicAPI, model) {
     // Finally draw
     gl.drawArrays(gl.TRIANGLES, 0, model.tris.getCABO().getElementCount());
     model.tris.getVAO().release();
-    allTextures.forEach(texture => texture.deactivate());
+    model.openGLTexture.deactivate();
+    model.colorTexture.deactivate();
+    model.pwfTexture.deactivate();
   };
   publicAPI.renderPieceFinish = (ren, actor) => {};
   publicAPI.updateBufferObjects = (ren, actor) => {
@@ -238,63 +171,70 @@ function vtkOpenGLImageResliceMapper(publicAPI, model) {
       publicAPI.buildBufferObjects(ren, actor);
     }
   };
-  publicAPI.getNeedToRebuildBufferObjects = (ren, actor) => model.VBOBuildTime.getMTime() < publicAPI.getMTime() || model.VBOBuildTime.getMTime() < actor.getMTime() || model.VBOBuildTime.getMTime() < model.renderable.getMTime() || model.VBOBuildTime.getMTime() < actor.getProperty(model.currentValidInputs[0].inputIndex)?.getMTime() || model.currentValidInputs.some(_ref2 => {
-    let {
-      imageData
-    } = _ref2;
-    return model.VBOBuildTime.getMTime() < imageData.getMTime();
-  }) || model.VBOBuildTime.getMTime() < model.resliceGeom.getMTime() || model.scalarTextures.length !== model.currentValidInputs.length || !model.scalarTextures.every(texture => !!texture?.getHandle()) || !model.colorTexture?.getHandle() || !model.pwfTexture?.getHandle();
+  publicAPI.getNeedToRebuildBufferObjects = (ren, actor) => model.VBOBuildTime.getMTime() < publicAPI.getMTime() || model.VBOBuildTime.getMTime() < actor.getMTime() || model.VBOBuildTime.getMTime() < model.renderable.getMTime() || model.VBOBuildTime.getMTime() < actor.getProperty().getMTime() || model.VBOBuildTime.getMTime() < model.currentInput.getMTime() || model.VBOBuildTime.getMTime() < model.resliceGeom.getMTime() || !model.openGLTexture?.getHandle() || !model.colorTexture?.getHandle() || !model.pwfTexture?.getHandle();
   publicAPI.buildBufferObjects = (ren, actor) => {
-    model.currentValidInputs.forEach((_ref3, component) => {
-      let {
-        imageData
-      } = _ref3;
-      // rebuild the scalarTexture if the data has changed
-      const scalars = imageData.getPointData().getScalars();
-      const tex = model._openGLRenderWindow.getGraphicsResourceForObject(scalars);
-      const scalarsHash = getImageDataHash(imageData, scalars);
-      const reBuildTex = !tex?.oglObject?.getHandle() || tex?.hash !== scalarsHash;
-      if (reBuildTex) {
-        const newScalarTexture = vtkOpenGLTexture.newInstance();
-        newScalarTexture.setOpenGLRenderWindow(model._openGLRenderWindow);
-        // Build the textures
-        const dims = imageData.getDimensions();
-        // Use norm16 for scalar texture if the extension is available
-        newScalarTexture.setOglNorm16Ext(model.context.getExtension('EXT_texture_norm16'));
-        newScalarTexture.resetFormatAndType();
-        newScalarTexture.create3DFilterableFromDataArray(dims[0], dims[1], dims[2], scalars);
-        model._openGLRenderWindow.setGraphicsResourceForObject(scalars, newScalarTexture, scalarsHash);
-        model.scalarTextures[component] = newScalarTexture;
-      } else {
-        model.scalarTextures[component] = tex.oglObject;
-      }
-      replaceGraphicsResource(model._openGLRenderWindow, model._scalarTexturesCore[component], scalars);
-      model._scalarTexturesCore[component] = scalars;
-    });
-    const firstValidInput = model.currentValidInputs[0];
-    const actorProperties = actor.getProperties();
-    const firstActorProperty = actorProperties[firstValidInput.inputIndex];
-    const iComps = firstActorProperty.getIndependentComponents();
-    const numIComps = iComps ? model.numberOfComponents : 1;
-    const textureHeight = iComps ? 2 * numIComps : 1;
-    const colorTransferFunctions = [];
-    for (let component = 0; component < numIComps; ++component) {
-      colorTransferFunctions.push(firstActorProperty.getRGBTransferFunction(component));
+    const image = model.currentInput;
+    if (!image) {
+      return;
     }
-    const colorFuncHash = getTransferFunctionsHash(colorTransferFunctions, iComps, numIComps);
-    const firstColorTransferFunc = firstActorProperty.getRGBTransferFunction();
-    const cTex = model._openGLRenderWindow.getGraphicsResourceForObject(firstColorTransferFunc);
-    const reBuildC = !cTex?.oglObject?.getHandle() || cTex?.hash !== colorFuncHash;
+    const scalars = image.getPointData()?.getScalars();
+    if (!scalars) {
+      return;
+    }
+    const numComp = scalars.getNumberOfComponents();
+    let toString = getImageDataHash(image, scalars);
+    const tex = model._openGLRenderWindow.getGraphicsResourceForObject(scalars);
+    const reBuildTex = !tex?.oglObject?.getHandle() || tex?.hash !== toString;
+    const updatedExtents = model.renderable.getUpdatedExtents();
+    const hasUpdatedExtents = !!updatedExtents.length;
+    if (reBuildTex && !hasUpdatedExtents) {
+      model.openGLTexture = vtkOpenGLTexture.newInstance();
+      model.openGLTexture.setOpenGLRenderWindow(model._openGLRenderWindow);
+      // Build the image scalar texture
+      // Use norm16 for the 3D texture if the extension is available
+      model.openGLTexture.setOglNorm16Ext(model.context.getExtension('EXT_texture_norm16'));
+      model.openGLTexture.resetFormatAndType();
+
+      // Build the image scalar texture
+      const dims = image.getDimensions();
+      model.openGLTexture.create3DFilterableFromDataArray(dims[0], dims[1], dims[2], scalars, false, updatedExtents);
+      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;
+    }
+    if (hasUpdatedExtents) {
+      // If hasUpdatedExtents, then the texture is partially updated.
+      // clear the array to acknowledge the update.
+      model.renderable.setUpdatedExtents([]);
+      const dims = image.getDimensions();
+      model.openGLTexture.create3DFilterableFromDataArray(dims[0], dims[1], dims[2], scalars, false, updatedExtents);
+    }
+    const ppty = actor.getProperty();
+    const iComps = ppty.getIndependentComponents();
+    const numIComps = iComps ? numComp : 1;
+    const textureHeight = iComps ? 2 * numIComps : 1;
+    const colorTransferFunc = ppty.getRGBTransferFunction();
+    toString = getTransferFunctionHash(colorTransferFunc, iComps, numIComps);
+    const cTex = model._openGLRenderWindow.getGraphicsResourceForObject(colorTransferFunc);
+    const reBuildC = !cTex?.oglObject?.getHandle() || cTex?.hash !== toString;
     if (reBuildC) {
-      const cWidth = 1024;
+      let cWidth = model.renderable.getColorTextureWidth();
+      if (cWidth <= 0) {
+        cWidth = model.context.getParameter(model.context.MAX_TEXTURE_SIZE);
+      }
       const cSize = cWidth * textureHeight * 3;
       const cTable = new Uint8ClampedArray(cSize);
-      const newColorTexture = vtkOpenGLTexture.newInstance();
-      newColorTexture.setOpenGLRenderWindow(model._openGLRenderWindow);
-      if (firstColorTransferFunc) {
+      model.colorTexture = vtkOpenGLTexture.newInstance();
+      model.colorTexture.setOpenGLRenderWindow(model._openGLRenderWindow);
+      if (colorTransferFunc) {
         const tmpTable = new Float32Array(cWidth * 3);
         for (let c = 0; c < numIComps; c++) {
-          const cfun = firstActorProperty.getRGBTransferFunction(c);
+          const cfun = ppty.getRGBTransferFunction(c);
           const cRange = cfun.getRange();
           cfun.getTable(cRange[0], cRange[1], cWidth, tmpTable, 1);
           if (iComps) {
@@ -304,57 +244,55 @@ function vtkOpenGLImageResliceMapper(publicAPI, model) {
             }
           } else {
             for (let i = 0; i < cWidth * 3; i++) {
-              cTable[c * cWidth * 3 + i] = 255.0 * tmpTable[i];
+              cTable[c * cWidth * 6 + i] = 255.0 * tmpTable[i];
             }
           }
         }
-        newColorTexture.resetFormatAndType();
-        newColorTexture.create2DFromRaw(cWidth, textureHeight, 3, VtkDataTypes.UNSIGNED_CHAR, cTable);
+        model.colorTexture.resetFormatAndType();
+        model.colorTexture.create2DFromRaw(cWidth, textureHeight, 3, VtkDataTypes.UNSIGNED_CHAR, cTable);
       } else {
-        for (let column = 0; column < cWidth * 3; ++column) {
-          const opacity = 255.0 * column / ((cWidth - 1) * 3);
-          for (let row = 0; row < textureHeight; ++row) {
-            // R, G, B
-            cTable[row * cWidth * 3 + column + 0] = opacity;
-            cTable[row * cWidth * 3 + column + 1] = opacity;
-            cTable[row * cWidth * 3 + column + 2] = opacity;
-          }
+        for (let i = 0; i < cWidth * 3; ++i) {
+          cTable[i] = 255.0 * i / ((cWidth - 1) * 3);
+          cTable[i + 1] = 255.0 * i / ((cWidth - 1) * 3);
+          cTable[i + 2] = 255.0 * i / ((cWidth - 1) * 3);
         }
-        newColorTexture.resetFormatAndType();
-        newColorTexture.create2DFromRaw(cWidth, 1, 3, VtkDataTypes.UNSIGNED_CHAR, cTable);
-      }
-      if (firstColorTransferFunc) {
-        model._openGLRenderWindow.setGraphicsResourceForObject(firstColorTransferFunc, newColorTexture, colorFuncHash);
+        model.colorTexture.resetFormatAndType();
+        model.colorTexture.create2DFromRaw(cWidth, 1, 3, VtkDataTypes.UNSIGNED_CHAR, cTable);
+      }
+      if (colorTransferFunc) {
+        model._openGLRenderWindow.setGraphicsResourceForObject(colorTransferFunc, model.colorTexture, toString);
+        if (colorTransferFunc !== model._colorTransferFunc) {
+          model._openGLRenderWindow.registerGraphicsResourceUser(colorTransferFunc, publicAPI);
+          model._openGLRenderWindow.unregisterGraphicsResourceUser(model._colorTransferFunc, publicAPI);
+        }
+        model._colorTransferFunc = colorTransferFunc;
       }
-      model.colorTexture = newColorTexture;
     } else {
       model.colorTexture = cTex.oglObject;
     }
-    replaceGraphicsResource(model._openGLRenderWindow, model._colorTextureCore, firstColorTransferFunc);
-    model._colorTextureCore = firstColorTransferFunc;
 
     // 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 opacityFunctions = [];
-    for (let component = 0; component < numIComps; ++component) {
-      opacityFunctions.push(firstActorProperty.getPiecewiseFunction(component));
-    }
-    const opacityFuncHash = getTransferFunctionsHash(opacityFunctions, iComps, numIComps);
-    const firstPwFunc = firstActorProperty.getPiecewiseFunction();
-    const pwfTex = model._openGLRenderWindow.getGraphicsResourceForObject(firstPwFunc);
-    const reBuildPwf = !pwfTex?.oglObject?.getHandle() || pwfTex?.hash !== opacityFuncHash;
+    const pwFunc = ppty.getPiecewiseFunction();
+    toString = getTransferFunctionHash(pwFunc, iComps, numIComps);
+    const pwfTex = model._openGLRenderWindow.getGraphicsResourceForObject(pwFunc);
+    // rebuild opacity tfun?
+    const reBuildPwf = !pwfTex?.oglObject?.getHandle() || pwfTex?.hash !== toString;
     if (reBuildPwf) {
-      const pwfWidth = 1024;
+      let pwfWidth = model.renderable.getOpacityTextureWidth();
+      if (pwfWidth <= 0) {
+        pwfWidth = model.context.getParameter(model.context.MAX_TEXTURE_SIZE);
+      }
       const pwfSize = pwfWidth * textureHeight;
       const pwfTable = new Uint8ClampedArray(pwfSize);
-      const newOpacityTexture = vtkOpenGLTexture.newInstance();
-      newOpacityTexture.setOpenGLRenderWindow(model._openGLRenderWindow);
-      if (firstPwFunc) {
+      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) {
-          const pwfun = firstActorProperty.getPiecewiseFunction(c);
+          const pwfun = ppty.getPiecewiseFunction(c);
           if (pwfun === null) {
             // Piecewise constant max if no function supplied for this component
             pwfFloatTable.fill(1.0);
@@ -369,28 +307,30 @@ function vtkOpenGLImageResliceMapper(publicAPI, model) {
               }
             } else {
               for (let i = 0; i < pwfWidth; i++) {
-                pwfFloatTable[i] = tmpTable[i];
+                pwfFloatTable[c * pwfWidth * 2 + i] = tmpTable[i];
               }
             }
           }
         }
-        newOpacityTexture.resetFormatAndType();
-        newOpacityTexture.create2DFromRaw(pwfWidth, textureHeight, 1, VtkDataTypes.FLOAT, pwfFloatTable);
+        model.pwfTexture.resetFormatAndType();
+        model.pwfTexture.create2DFromRaw(pwfWidth, textureHeight, 1, VtkDataTypes.FLOAT, pwfFloatTable);
       } else {
         // default is opaque
         pwfTable.fill(255.0);
-        newOpacityTexture.resetFormatAndType();
-        newOpacityTexture.create2DFromRaw(pwfWidth, textureHeight, 1, VtkDataTypes.UNSIGNED_CHAR, pwfTable);
-      }
-      if (firstPwFunc) {
-        model._openGLRenderWindow.setGraphicsResourceForObject(firstPwFunc, newOpacityTexture, opacityFuncHash);
+        model.pwfTexture.resetFormatAndType();
+        model.pwfTexture.create2DFromRaw(pwfWidth, 1, 1, VtkDataTypes.UNSIGNED_CHAR, pwfTable);
+      }
+      if (pwFunc) {
+        model._openGLRenderWindow.setGraphicsResourceForObject(pwFunc, model.pwfTexture, toString);
+        if (pwFunc !== model._pwFunc) {
+          model._openGLRenderWindow.registerGraphicsResourceUser(pwFunc, publicAPI);
+          model._openGLRenderWindow.unregisterGraphicsResourceUser(model._pwFunc, publicAPI);
+        }
+        model._pwFunc = pwFunc;
       }
-      model.pwfTexture = newOpacityTexture;
     } else {
       model.pwfTexture = pwfTex.oglObject;
     }
-    replaceGraphicsResource(model._openGLRenderWindow, model._pwfTextureCore, firstPwFunc);
-    model._pwfTextureCore = firstPwFunc;
     const vboString = `${model.resliceGeom.getMTime()}A${model.renderable.getSlabThickness()}`;
     if (!model.tris.getCABO().getElementCount() || model.VBOBuildString !== vboString) {
       const points = vtkDataArray.newInstance({
@@ -451,12 +391,11 @@ function vtkOpenGLImageResliceMapper(publicAPI, model) {
   };
   publicAPI.setMapperShaderParameters = (cellBO, ren, actor) => {
     const program = cellBO.getProgram();
-    const firstImageData = model.currentValidInputs[0].imageData;
     if (cellBO.getCABO().getElementCount() && (model.VBOBuildTime.getMTime() > cellBO.getAttributeUpdateTime().getMTime() || cellBO.getShaderSourceTime().getMTime() > cellBO.getAttributeUpdateTime().getMTime())) {
       // Set the 3D texture
-      model.scalarTextures.forEach((scalarTexture, component) => {
-        program.setUniformi(`volumeTexture[${component}]`, scalarTexture.getTextureUnit());
-      });
+      if (program.isUniformUsed('texture1')) {
+        program.setUniformi('texture1', model.openGLTexture.getTextureUnit());
+      }
 
       // Set the plane vertex attributes
       if (program.isAttributeUsed('vertexWC')) {
@@ -475,7 +414,7 @@ function vtkOpenGLImageResliceMapper(publicAPI, model) {
         program.setUniformf('slabThickness', model.renderable.getSlabThickness());
       }
       if (program.isUniformUsed('spacing')) {
-        program.setUniform3fv('spacing', firstImageData.getSpacing());
+        program.setUniform3fv('spacing', model.currentInput.getSpacing());
       }
       if (program.isUniformUsed('slabType')) {
         program.setUniformi('slabType', model.renderable.getSlabType());
@@ -491,8 +430,9 @@ function vtkOpenGLImageResliceMapper(publicAPI, model) {
 
       // Set the world->texture matrix
       if (program.isUniformUsed('WCTCMatrix')) {
-        const dim = firstImageData.getDimensions();
-        mat4.copy(model.tmpMat4, firstImageData.getIndexToWorld());
+        const image = model.currentInput;
+        const dim = image.getDimensions();
+        mat4.copy(model.tmpMat4, image.getIndexToWorld());
         mat4.translate(model.tmpMat4, model.tmpMat4, [-0.5, -0.5, -0.5]);
         mat4.scale(model.tmpMat4, model.tmpMat4, dim);
         mat4.invert(model.tmpMat4, model.tmpMat4);
@@ -541,8 +481,8 @@ function vtkOpenGLImageResliceMapper(publicAPI, model) {
   };
   publicAPI.setPropertyShaderParameters = (cellBO, ren, actor) => {
     const program = cellBO.getProgram();
-    const firstPpty = actor.getProperty(model.currentValidInputs[0].inputIndex);
-    const opacity = firstPpty.getOpacity();
+    const ppty = actor.getProperty();
+    const opacity = ppty.getOpacity();
     program.setUniformf('opacity', opacity);
 
     // Component mix
@@ -551,56 +491,53 @@ function vtkOpenGLImageResliceMapper(publicAPI, model) {
     //    - 2 comps => LA
     //    - 3 comps => RGB + opacity from pwf
     //    - 4 comps => RGBA
-    const numComp = model.numberOfComponents;
-    const iComps = firstPpty.getIndependentComponents();
+    const numComp = model.openGLTexture.getComponents();
+    const iComps = ppty.getIndependentComponents();
     if (iComps) {
       for (let i = 0; i < numComp; ++i) {
-        program.setUniformf(`mix${i}`, firstPpty.getComponentWeight(i));
+        program.setUniformf(`mix${i}`, ppty.getComponentWeight(i));
       }
     }
 
+    // Color opacity map
+    const volInfo = model.openGLTexture.getVolumeInfo();
+
     // three levels of shift scale combined into one
     // for performance in the fragment shader
-    for (let component = 0; component < numComp; component++) {
-      const useMultiTexture = model.multiTexturePerVolumeEnabled;
-      const textureIndex = useMultiTexture ? component : 0;
-      const volInfoIndex = useMultiTexture ? 0 : component;
-      const scalarTexture = model.scalarTextures[textureIndex];
-      const volInfo = scalarTexture.getVolumeInfo();
-      const volScale = volInfo.scale[volInfoIndex];
-      const volOffset = volInfo.offset[volInfoIndex];
-      const target = iComps ? component : 0;
-
-      // color shift/scale
-      let cw = firstPpty.getColorWindow();
-      let cl = firstPpty.getColorLevel();
-      const cfun = firstPpty.getRGBTransferFunction(target);
-      if (cfun && firstPpty.getUseLookupTableScalarRange()) {
+    for (let i = 0; i < numComp; i++) {
+      let cw = ppty.getColorWindow();
+      let cl = ppty.getColorLevel();
+      const target = iComps ? i : 0;
+      const cfun = ppty.getRGBTransferFunction(target);
+      if (cfun && ppty.getUseLookupTableScalarRange()) {
         const cRange = cfun.getRange();
         cw = cRange[1] - cRange[0];
         cl = 0.5 * (cRange[1] + cRange[0]);
       }
-      const colorScale = volScale / cw;
-      const colorShift = (volOffset - cl) / cw + 0.5;
-      program.setUniformf(`cshift${component}`, colorShift);
-      program.setUniformf(`cscale${component}`, colorScale);
+      const scale = volInfo.scale[i] / cw;
+      const shift = (volInfo.offset[i] - cl) / cw + 0.5;
+      program.setUniformf(`cshift${i}`, shift);
+      program.setUniformf(`cscale${i}`, scale);
+    }
+    const texColorUnit = model.colorTexture.getTextureUnit();
+    program.setUniformi('colorTexture1', texColorUnit);
 
-      // pwf shift/scale
+    // pwf shift/scale
+    for (let i = 0; i < numComp; i++) {
       let pwfScale = 1.0;
       let pwfShift = 0.0;
-      const pwfun = firstPpty.getPiecewiseFunction(target);
+      const target = iComps ? i : 0;
+      const pwfun = ppty.getPiecewiseFunction(target);
       if (pwfun) {
         const pwfRange = pwfun.getRange();
         const length = pwfRange[1] - pwfRange[0];
         const mid = 0.5 * (pwfRange[0] + pwfRange[1]);
-        pwfScale = volScale / length;
-        pwfShift = (volOffset - mid) / length + 0.5;
+        pwfScale = volInfo.scale[i] / length;
+        pwfShift = (volInfo.offset[i] - mid) / length + 0.5;
       }
-      program.setUniformf(`pwfshift${component}`, pwfShift);
-      program.setUniformf(`pwfscale${component}`, pwfScale);
+      program.setUniformf(`pwfshift${i}`, pwfShift);
+      program.setUniformf(`pwfscale${i}`, pwfScale);
     }
-    const texColorUnit = model.colorTexture.getTextureUnit();
-    program.setUniformi('colorTexture1', texColorUnit);
     const texOpacityUnit = model.pwfTexture.getTextureUnit();
     program.setUniformi('pwfTexture1', texOpacityUnit);
 
@@ -614,7 +551,8 @@ function vtkOpenGLImageResliceMapper(publicAPI, model) {
     // input modified
     // light complexity changed
     // render pass shader replacement changed
-    const iComp = actor.getProperty(model.currentValidInputs[0].inputIndex).getIndependentComponents();
+    const tNumComp = model.openGLTexture.getComponents();
+    const iComp = actor.getProperty().getIndependentComponents();
     const slabTh = model.renderable.getSlabThickness();
     const slabType = model.renderable.getSlabType();
     const slabTrap = model.renderable.getSlabTrapezoidIntegration();
@@ -624,10 +562,9 @@ function vtkOpenGLImageResliceMapper(publicAPI, model) {
     if (!model.currentRenderPass && model.lastRenderPassShaderReplacement || model.currentRenderPass && model.currentRenderPass.getShaderReplacement() !== model.lastRenderPassShaderReplacement) {
       needRebuild = true;
     }
-    if (needRebuild || model.lastHaveSeenDepthRequest !== model.haveSeenDepthRequest || model.lastNumberOfComponents !== model.numberOfComponents || model.lastMultiTexturePerVolumeEnabled !== model.multiTexturePerVolumeEnabled || cellBO.getProgram()?.getHandle() === 0 || 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.lastNumberOfComponents = model.numberOfComponents;
-      model.lastMultiTexturePerVolumeEnabled = model.multiTexturePerVolumeEnabled;
+      model.lastTextureComponents = tNumComp;
       model.lastIndependentComponents = iComp;
       model.lastSlabThickness = slabTh;
       model.lastSlabType = slabType;
@@ -661,9 +598,9 @@ function vtkOpenGLImageResliceMapper(publicAPI, model) {
     VSSource = vtkShaderProgram.substitute(VSSource, '//VTK::TCoord::Dec', tcoordVSDec).result;
     const tcoordVSImpl = ['fragTexCoord = (WCTCMatrix * vertexWC).xyz;'];
     VSSource = vtkShaderProgram.substitute(VSSource, '//VTK::TCoord::Impl', tcoordVSImpl).result;
-    const tNumComp = model.numberOfComponents;
-    const iComps = actor.getProperty(model.currentValidInputs[0].inputIndex).getIndependentComponents();
-    let tcoordFSDec = ['in vec3 fragTexCoord;', `uniform highp sampler3D volumeTexture[${model.scalarTextures.length}];`, 'uniform mat4 WCTCMatrix;',
+    const tNumComp = model.openGLTexture.getComponents();
+    const iComps = actor.getProperty().getIndependentComponents();
+    let tcoordFSDec = ['in vec3 fragTexCoord;', 'uniform highp sampler3D texture1;', 'uniform mat4 WCTCMatrix;',
     // color shift and scale
     'uniform float cshift0;', 'uniform float cscale0;',
     // pwf shift and scale
@@ -674,18 +611,6 @@ function vtkOpenGLImageResliceMapper(publicAPI, model) {
     'uniform float opacity;',
     // background color
     'uniform vec4 backgroundColor;'];
-
-    // Function to sample texture
-    tcoordFSDec.push('vec4 rawSampleTexture(vec3 pos) {');
-    if (!model.multiTexturePerVolumeEnabled) {
-      tcoordFSDec.push('return texture(volumeTexture[0], pos);', '}');
-    } else {
-      tcoordFSDec.push('vec4 rawSample;');
-      for (let component = 0; component < model.scalarTextures.length; ++component) {
-        tcoordFSDec.push(`rawSample[${component}] = texture(volumeTexture[${component}], pos)[0];`);
-      }
-      tcoordFSDec.push('return rawSample;', '}');
-    }
     if (iComps) {
       for (let comp = 1; comp < tNumComp; comp++) {
         tcoordFSDec = tcoordFSDec.concat([
@@ -721,14 +646,14 @@ function vtkOpenGLImageResliceMapper(publicAPI, model) {
       tcoordFSDec = tcoordFSDec.concat(['vec4 compositeValue(vec4 currVal, vec4 valToComp, int trapezoid)', '{', '  vec4 retVal = vec4(1.0);', '  if (slabType == 0) // min', '  {', '    retVal = min(currVal, valToComp);', '  }', '  else if (slabType == 1) // max', '  {', '    retVal = max(currVal, valToComp);', '  }', '  else if (slabType == 3) // sum', '  {', '    retVal = currVal + (trapezoid > 0 ? 0.5 * valToComp : valToComp); ', '  }', '  else // mean', '  {', '    retVal = currVal + (trapezoid > 0 ? 0.5 * valToComp : valToComp); ', '  }', '  return retVal;', '}']);
     }
     FSSource = vtkShaderProgram.substitute(FSSource, '//VTK::TCoord::Dec', tcoordFSDec).result;
-    let tcoordFSImpl = ['if (any(greaterThan(fragTexCoord, vec3(1.0))) || any(lessThan(fragTexCoord, vec3(0.0))))', '{', '  // set the background color and exit', '  gl_FragData[0] = backgroundColor;', '  return;', '}', 'vec4 tvalue = rawSampleTexture(fragTexCoord);'];
+    let tcoordFSImpl = ['if (any(greaterThan(fragTexCoord, vec3(1.0))) || any(lessThan(fragTexCoord, vec3(0.0))))', '{', '  // set the background color and exit', '  gl_FragData[0] = backgroundColor;', '  return;', '}', 'vec4 tvalue = texture(texture1, fragTexCoord);'];
     if (slabThickness > 0.0) {
-      tcoordFSImpl = tcoordFSImpl.concat(['// Get the first and last samples', 'int numSlices = 1;', 'float scaling = min(min(spacing.x, spacing.y), spacing.z) * 0.5;', 'vec3 normalxspacing = scaling * normalWCVSOutput;', 'float distTraveled = length(normalxspacing);', 'int trapezoid = 0;', 'while (distTraveled < slabThickness * 0.5)', '{', '  distTraveled += length(normalxspacing);', '  float fnumSlices = float(numSlices);', '  if (distTraveled > slabThickness * 0.5)', '  {', '    // Before stepping outside the slab, sample at the boundaries', '    normalxspacing = normalWCVSOutput * slabThickness * 0.5 / fnumSlices;', '    trapezoid = slabTrapezoid;', '  }', '  vec3 fragTCoordNeg = (WCTCMatrix * vec4(vertexWCVSOutput.xyz - fnumSlices * normalxspacing * vboScaling, 1.0)).xyz;', '  if (!any(greaterThan(fragTCoordNeg, vec3(1.0))) && !any(lessThan(fragTCoordNeg, vec3(0.0))))', '  {', '    vec4 newVal = rawSampleTexture(fragTCoordNeg);', '    tvalue = compositeValue(tvalue, newVal, trapezoid);', '    numSlices += 1;', '  }', '  vec3 fragTCoordPos = (WCTCMatrix * vec4(vertexWCVSOutput.xyz + fnumSlices * normalxspacing * vboScaling, 1.0)).xyz;', '  if (!any(greaterThan(fragTCoordNeg, vec3(1.0))) && !any(lessThan(fragTCoordNeg, vec3(0.0))))', '  {', '    vec4 newVal = rawSampleTexture(fragTCoordPos);', '    tvalue = compositeValue(tvalue, newVal, trapezoid);', '    numSlices += 1;', '  }', '}', '// Finally, if slab type is *mean*, divide the sum by the numSlices', 'if (slabType == 2)', '{', '  tvalue = tvalue / float(numSlices);', '}']);
+      tcoordFSImpl = tcoordFSImpl.concat(['// Get the first and last samples', 'int numSlices = 1;', 'float scaling = min(min(spacing.x, spacing.y), spacing.z) * 0.5;', 'vec3 normalxspacing = scaling * normalWCVSOutput;', 'float distTraveled = length(normalxspacing);', 'int trapezoid = 0;', 'while (distTraveled < slabThickness * 0.5)', '{', '  distTraveled += length(normalxspacing);', '  float fnumSlices = float(numSlices);', '  if (distTraveled > slabThickness * 0.5)', '  {', '    // Before stepping outside the slab, sample at the boundaries', '    normalxspacing = normalWCVSOutput * slabThickness * 0.5 / fnumSlices;', '    trapezoid = slabTrapezoid;', '  }', '  vec3 fragTCoordNeg = (WCTCMatrix * vec4(vertexWCVSOutput.xyz - fnumSlices * normalxspacing * vboScaling, 1.0)).xyz;', '  if (!any(greaterThan(fragTCoordNeg, vec3(1.0))) && !any(lessThan(fragTCoordNeg, vec3(0.0))))', '  {', '    vec4 newVal = texture(texture1, fragTCoordNeg);', '    tvalue = compositeValue(tvalue, newVal, trapezoid);', '    numSlices += 1;', '  }', '  vec3 fragTCoordPos = (WCTCMatrix * vec4(vertexWCVSOutput.xyz + fnumSlices * normalxspacing * vboScaling, 1.0)).xyz;', '  if (!any(greaterThan(fragTCoordNeg, vec3(1.0))) && !any(lessThan(fragTCoordNeg, vec3(0.0))))', '  {', '    vec4 newVal = texture(texture1, fragTCoordPos);', '    tvalue = compositeValue(tvalue, newVal, trapezoid);', '    numSlices += 1;', '  }', '}', '// Finally, if slab type is *mean*, divide the sum by the numSlices', 'if (slabType == 2)', '{', '  tvalue = tvalue / float(numSlices);', '}']);
     }
     if (iComps) {
       const rgba = ['r', 'g', 'b', 'a'];
       for (let comp = 0; comp < tNumComp; ++comp) {
-        tcoordFSImpl = tcoordFSImpl.concat([`vec3 tcolor${comp} = texture2D(colorTexture1, vec2(tvalue.${rgba[comp]} * cscale${comp} + cshift${comp}, height${comp})).rgb;`, `float compWeight${comp} = mix${comp} * texture2D(pwfTexture1, vec2(tvalue.${rgba[comp]} * pwfscale${comp} + pwfshift${comp}, height${comp})).r;`]);
+        tcoordFSImpl = tcoordFSImpl.concat([`vec3 tcolor${comp} = mix${comp} * texture2D(colorTexture1, vec2(tvalue.${rgba[comp]} * cscale${comp} + cshift${comp}, height${comp})).rgb;`, `float compWeight${comp} = mix${comp} * texture2D(pwfTexture1, vec2(tvalue.${rgba[comp]} * pwfscale${comp} + pwfshift${comp}, height${comp})).r;`]);
       }
       switch (tNumComp) {
         case 1:
@@ -814,8 +739,8 @@ function vtkOpenGLImageResliceMapper(publicAPI, model) {
   }
   publicAPI.updateResliceGeometry = () => {
     let resGeomString = '';
-    const firstImageData = model.currentValidInputs[0].imageData;
-    const imageBounds = firstImageData?.getBounds();
+    const image = model.currentInput;
+    const imageBounds = image?.getBounds();
     // Orthogonal slicing by default
     let orthoSlicing = true;
     let orthoAxis = 2;
@@ -827,11 +752,11 @@ function vtkOpenGLImageResliceMapper(publicAPI, model) {
       resGeomString = resGeomString.concat(`Plane${slicePlane.getMTime()}`);
       // Compute a world-to-image-orientation matrix.
       const w2io = mat3.create();
-      if (firstImageData) {
-        resGeomString = resGeomString.concat(`Image${firstImageData.getMTime()}`);
+      if (image) {
+        resGeomString = resGeomString.concat(`Image${image.getMTime()}`);
         // Ignore the translation component since we are
         // using it on vectors rather than positions.
-        mat3.set(w2io, ...firstImageData.getDirection());
+        mat3.set(w2io, ...image.getDirection());
         mat3.invert(w2io, w2io);
       }
       // Check to see if we can bypass oblique slicing related bounds computation
@@ -844,14 +769,14 @@ function vtkOpenGLImageResliceMapper(publicAPI, model) {
       const plane = vtkPlane.newInstance();
       plane.setNormal(0, 0, 1);
       let bds = [0, 1, 0, 1, 0, 1];
-      if (firstImageData) {
+      if (image) {
         bds = imageBounds;
       }
       plane.setOrigin(bds[0], bds[2], 0.5 * (bds[5] + bds[4]));
       model.renderable.setSlicePlane(plane);
       resGeomString = resGeomString.concat(`Plane${slicePlane?.getMTime()}`);
-      if (firstImageData) {
-        resGeomString = resGeomString.concat(`Image${firstImageData.getMTime()}`);
+      if (image) {
+        resGeomString = resGeomString.concat(`Image${image.getMTime()}`);
       }
     }
     if (!model.resliceGeom || model.resliceGeomUpdateString !== resGeomString) {
@@ -864,7 +789,7 @@ function vtkOpenGLImageResliceMapper(publicAPI, model) {
         model.resliceGeom.getPointData().setNormals(slicePD.getPointData().getNormals());
       } else if (slicePlane) {
         if (!orthoSlicing) {
-          model.outlineFilter.setInputData(firstImageData);
+          model.outlineFilter.setInputData(image);
           model.cutter.setInputConnection(model.outlineFilter.getOutputPort());
           model.cutter.setCutFunction(slicePlane);
           model.lineToSurfaceFilter.setInputConnection(model.cutter.getOutputPort());
@@ -897,9 +822,9 @@ function vtkOpenGLImageResliceMapper(publicAPI, model) {
           // Since the image-local normal is axis-aligned, we
           // can quickly construct the cutting plane using indexToWorld transforms.
           const ptsArray = new Float32Array(12);
-          const indexSpacePlaneOrigin = firstImageData.worldToIndex(slicePlane.getOrigin(), [0, 0, 0]);
+          const indexSpacePlaneOrigin = image.worldToIndex(slicePlane.getOrigin(), [0, 0, 0]);
           const otherAxes = [(orthoAxis + 1) % 3, (orthoAxis + 2) % 3].sort();
-          const ext = firstImageData.getSpatialExtent();
+          const ext = image.getSpatialExtent();
           let ptIdx = 0;
           for (let i = 0; i < 2; ++i) {
             for (let j = 0; j < 2; ++j) {
@@ -909,7 +834,7 @@ function vtkOpenGLImageResliceMapper(publicAPI, model) {
               ptIdx += 3;
             }
           }
-          model.transform.setMatrix(firstImageData.getIndexToWorld());
+          model.transform.setMatrix(image.getIndexToWorld());
           model.transform.transformPoints(ptsArray, ptsArray);
           const cellArray = new Uint16Array(8);
           cellArray[0] = 3;
@@ -947,9 +872,11 @@ function vtkOpenGLImageResliceMapper(publicAPI, model) {
       model.resliceGeom?.modified();
     }
   };
-  publicAPI.setScalarTextures = scalarTextures => {
-    model.scalarTextures = [...scalarTextures];
-    model._externalOpenGLTexture = true;
+  publicAPI.setOpenGLTexture = oglTex => {
+    if (oglTex) {
+      model.openGLTexture = oglTex;
+      model._externalOpenGLTexture = true;
+    }
   };
   publicAPI.delete = chain(() => {
     if (model._openGLRenderWindow) {
@@ -968,21 +895,22 @@ const DEFAULT_VALUES = {
   haveSeenDepthRequest: false,
   lastHaveSeenDepthRequest: false,
   lastIndependentComponents: false,
-  lastNumberOfComponents: 0,
-  lastMultiTexturePerVolumeEnabled: false,
+  lastTextureComponents: 0,
   lastSlabThickness: 0,
   lastSlabTrapezoidIntegration: 0,
   lastSlabType: -1,
-  scalarTextures: [],
-  _scalarTexturesCore: [],
-  colorTexture: null,
-  _colorTextureCore: null,
-  pwfTexture: null,
-  _pwfTextureCore: null,
-  _externalOpenGLTexture: false,
+  openGLTexture: null,
+  colorTextureString: null,
+  pwfTextureString: null,
   resliceGeom: null,
   resliceGeomUpdateString: null,
-  tris: null
+  tris: null,
+  colorTexture: null,
+  pwfTexture: null,
+  _externalOpenGLTexture: false
+  // _scalars: null,
+  // _colorTransferFunc: null,
+  // _pwFunc: null,
 };
 
 // ----------------------------------------------------------------------------
@@ -996,7 +924,7 @@ function extend(publicAPI, model) {
   vtkReplacementShaderMapper.implementReplaceShaderCoincidentOffset(publicAPI, model, initialValues);
   vtkReplacementShaderMapper.implementBuildShadersWithReplacements(publicAPI, model, initialValues);
   model.tris = vtkHelper.newInstance();
-  model.scalarTextures = [];
+  model.openGLTexture = null;
   model.colorTexture = null;
   model.pwfTexture = null;
   model.VBOBuildTime = {};
@@ -1011,7 +939,7 @@ function extend(publicAPI, model) {
   model.cutter = vtkCutter.newInstance();
   model.lineToSurfaceFilter = vtkClosedPolyLineToSurfaceFilter.newInstance();
   model.transform = vtkTransform.newInstance();
-  get(publicAPI, model, ['scalarTextures']);
+  get(publicAPI, model, ['openGLTexture']);
 
   // Object methods
   vtkOpenGLImageResliceMapper(publicAPI, model);