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

package/Rendering/Core/VolumeProperty.js

@@ -228,7 +228,7 @@ function vtkVolumeProperty(publicAPI, model) {
 // Object factory
 // ----------------------------------------------------------------------------
 
-const DEFAULT_VALUES = {
+const defaultValues = initialValues => ({
   colorMixPreset: ColorMixPreset.DEFAULT,
   independentComponents: true,
   interpolationType: InterpolationType.FAST_LINEAR,
@@ -254,14 +254,16 @@ const DEFAULT_VALUES = {
   // local ambient occlusion
   localAmbientOcclusion: false,
   LAOKernelSize: 15,
-  LAOKernelRadius: 7
-};
+  LAOKernelRadius: 7,
+  updatedExtents: [],
+  ...initialValues
+});
 
 // ----------------------------------------------------------------------------
 
 function extend(publicAPI, model) {
   let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-  Object.assign(model, DEFAULT_VALUES, initialValues);
+  Object.assign(model, defaultValues(initialValues));
 
   // Build VTK API
   macro.obj(publicAPI, model);
@@ -287,7 +289,7 @@ function extend(publicAPI, model) {
   }
   macro.setGet(publicAPI, model, ['colorMixPreset', 'independentComponents', 'interpolationType', 'shade', 'ambient', 'diffuse', 'specular', 'specularPower', 'useLabelOutline', 'labelOutlineOpacity',
   // Properties moved from volume mapper
-  'filterMode', 'preferSizeOverAccuracy', 'computeNormalFromOpacity', 'volumetricScatteringBlending', 'globalIlluminationReach', 'anisotropy', 'localAmbientOcclusion', 'LAOKernelSize', 'LAOKernelRadius']);
+  'filterMode', 'preferSizeOverAccuracy', 'computeNormalFromOpacity', 'volumetricScatteringBlending', 'globalIlluminationReach', 'anisotropy', 'localAmbientOcclusion', 'LAOKernelSize', 'LAOKernelRadius', 'updatedExtents']);
 
   // Property moved from volume mapper
   macro.setGetArray(publicAPI, model, ['ipScalarRange'], 2);

package/Rendering/Misc/SynchronizableRenderWindow/BehaviorManager/CameraSynchronizer.js

@@ -33,8 +33,8 @@ function vtkCameraSynchronizer(publicAPI, model) {
   }
 
   // Update listeners automatically
-  model._srcRendererChanged = updateListeners;
-  model._dstRendererChanged = updateListeners;
+  model._onSrcRendererChanged = updateListeners;
+  model._onDstRendererChanged = updateListeners;
   function updatePreviousValues(position, focalPoint, viewUp) {
     if (cameraState[0] !== position[0] || cameraState[1] !== position[1] || cameraState[2] !== position[2] || cameraState[3] !== focalPoint[0] || cameraState[4] !== focalPoint[1] || cameraState[5] !== focalPoint[2] || cameraState[6] !== viewUp[0] || cameraState[7] !== viewUp[1] || cameraState[8] !== viewUp[2]) {
       cameraState[0] = position[0];

package/Rendering/OpenGL/Framebuffer.js

@@ -162,7 +162,13 @@ function vtkFramebuffer(publicAPI, model) {
     texture.setOpenGLRenderWindow(model._openGLRenderWindow);
     texture.setMinificationFilter(Filter.LINEAR);
     texture.setMagnificationFilter(Filter.LINEAR);
-    texture.create2DFromRaw(model.glFramebuffer.width, model.glFramebuffer.height, 4, VtkDataTypes.UNSIGNED_CHAR, null);
+    texture.create2DFromRaw({
+      width: model.glFramebuffer.width,
+      height: model.glFramebuffer.height,
+      numComps: 4,
+      dataType: VtkDataTypes.UNSIGNED_CHAR,
+      data: null
+    });
     publicAPI.setColorBuffer(texture);
 
     // for now do not count on having a depth buffer texture

package/Rendering/OpenGL/ImageCPRMapper.js

@@ -147,6 +147,7 @@ function vtkOpenGLImageCPRMapper(publicAPI, model) {
   publicAPI.buildBufferObjects = (ren, actor) => {
     const image = model.currentImageDataInput;
     const centerline = model.currentCenterlineInput;
+    const property = actor.getProperty();
 
     // Rebuild the volumeTexture if the data has changed
     const scalars = image?.getPointData()?.getScalars();
@@ -156,6 +157,8 @@ function vtkOpenGLImageCPRMapper(publicAPI, model) {
     const cachedScalarsEntry = model._openGLRenderWindow.getGraphicsResourceForObject(scalars);
     const volumeTextureHash = getImageDataHash(image, scalars);
     const reBuildTex = !cachedScalarsEntry?.oglObject?.getHandle() || cachedScalarsEntry?.hash !== volumeTextureHash;
+    const updatedExtents = property.getUpdatedExtents();
+    const hasUpdatedExtents = !!updatedExtents.length;
     if (reBuildTex) {
       model.volumeTexture = vtkOpenGLTexture.newInstance();
       model.volumeTexture.setOpenGLRenderWindow(model._openGLRenderWindow);
@@ -164,7 +167,13 @@ function vtkOpenGLImageCPRMapper(publicAPI, model) {
       // Use norm16 for scalar texture if the extension is available
       model.volumeTexture.setOglNorm16Ext(model.context.getExtension('EXT_texture_norm16'));
       model.volumeTexture.resetFormatAndType();
-      model.volumeTexture.create3DFilterableFromDataArray(dims[0], dims[1], dims[2], scalars, model.renderable.getPreferSizeOverAccuracy());
+      model.volumeTexture.create3DFilterableFromDataArray({
+        width: dims[0],
+        height: dims[1],
+        depth: dims[2],
+        dataArray: scalars,
+        preferSizeOverAccuracy: model.renderable.getPreferSizeOverAccuracy()
+      });
       model._openGLRenderWindow.setGraphicsResourceForObject(scalars, model.volumeTexture, volumeTextureHash);
       if (scalars !== model._scalars) {
         model._openGLRenderWindow.registerGraphicsResourceUser(scalars, publicAPI);
@@ -174,6 +183,19 @@ function vtkOpenGLImageCPRMapper(publicAPI, model) {
     } else {
       model.volumeTexture = cachedScalarsEntry.oglObject;
     }
+    if (hasUpdatedExtents) {
+      // If hasUpdatedExtents, then the texture is partially updated.
+      // clear the array to acknowledge the update.
+      property.setUpdatedExtents([]);
+      const dims = image.getDimensions();
+      model.volumeTexture.create3DFilterableFromDataArray({
+        width: dims[0],
+        height: dims[1],
+        depth: dims[2],
+        dataArray: scalars,
+        updatedExtents
+      });
+    }
 
     // Rebuild the color texture if needed
     const numComp = scalars.getNumberOfComponents();
@@ -190,7 +212,10 @@ function vtkOpenGLImageCPRMapper(publicAPI, model) {
     const cachedColorEntry = model._openGLRenderWindow.getGraphicsResourceForObject(firstColorTransferFunc);
     const reBuildColorTexture = !cachedColorEntry?.oglObject?.getHandle() || cachedColorEntry?.hash !== colorTextureHash;
     if (reBuildColorTexture) {
-      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);
       model.colorTexture = vtkOpenGLTexture.newInstance();
@@ -213,7 +238,13 @@ function vtkOpenGLImageCPRMapper(publicAPI, model) {
           }
         }
         model.colorTexture.resetFormatAndType();
-        model.colorTexture.create2DFromRaw(cWidth, textureHeight, 3, VtkDataTypes.UNSIGNED_CHAR, cTable);
+        model.colorTexture.create2DFromRaw({
+          width: cWidth,
+          height: textureHeight,
+          numComps: 3,
+          dataType: VtkDataTypes.UNSIGNED_CHAR,
+          data: cTable
+        });
       } else {
         for (let i = 0; i < cWidth * 3; ++i) {
           cTable[i] = 255.0 * i / ((cWidth - 1) * 3);
@@ -221,7 +252,13 @@ function vtkOpenGLImageCPRMapper(publicAPI, model) {
           cTable[i + 2] = 255.0 * i / ((cWidth - 1) * 3);
         }
         model.colorTexture.resetFormatAndType();
-        model.colorTexture.create2DFromRaw(cWidth, 1, 3, VtkDataTypes.UNSIGNED_CHAR, cTable);
+        model.colorTexture.create2DFromRaw({
+          width: cWidth,
+          height: 1,
+          numComps: 3,
+          dataType: VtkDataTypes.UNSIGNED_CHAR,
+          data: cTable
+        });
       }
       if (firstColorTransferFunc) {
         model._openGLRenderWindow.setGraphicsResourceForObject(firstColorTransferFunc, model.colorTexture, colorTextureHash);
@@ -247,7 +284,10 @@ function vtkOpenGLImageCPRMapper(publicAPI, model) {
     const cachedPwfEntry = model._openGLRenderWindow.getGraphicsResourceForObject(firstPwFunc);
     const reBuildPwf = !cachedPwfEntry?.oglObject?.getHandle() || cachedPwfEntry?.hash !== pwfTextureHash;
     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);
       model.pwfTexture = vtkOpenGLTexture.newInstance();
@@ -277,12 +317,24 @@ function vtkOpenGLImageCPRMapper(publicAPI, model) {
           }
         }
         model.pwfTexture.resetFormatAndType();
-        model.pwfTexture.create2DFromRaw(pwfWidth, textureHeight, 1, VtkDataTypes.FLOAT, pwfFloatTable);
+        model.pwfTexture.create2DFromRaw({
+          width: pwfWidth,
+          height: textureHeight,
+          numComps: 1,
+          dataType: VtkDataTypes.FLOAT,
+          data: pwfFloatTable
+        });
       } else {
         // default is opaque
         pwfTable.fill(255.0);
         model.pwfTexture.resetFormatAndType();
-        model.pwfTexture.create2DFromRaw(pwfWidth, 1, 1, VtkDataTypes.UNSIGNED_CHAR, pwfTable);
+        model.pwfTexture.create2DFromRaw({
+          width: pwfWidth,
+          height: 1,
+          numComps: 1,
+          dataType: VtkDataTypes.UNSIGNED_CHAR,
+          data: pwfTable
+        });
       }
       if (firstPwFunc) {
         model._openGLRenderWindow.setGraphicsResourceForObject(firstPwFunc, model.pwfTexture, pwfTextureHash);

package/Rendering/OpenGL/ImageMapper.js

@@ -590,7 +590,10 @@ function vtkOpenGLImageMapper(publicAPI, model) {
         resizable: true
       });
       model.colorTexture.setOpenGLRenderWindow(model._openGLRenderWindow);
-      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);
       // set interpolation on the texture based on property setting
@@ -619,14 +622,26 @@ function vtkOpenGLImageMapper(publicAPI, model) {
           }
         }
         model.colorTexture.resetFormatAndType();
-        model.colorTexture.create2DFromRaw(cWidth, textureHeight, 3, VtkDataTypes.UNSIGNED_CHAR, cTable);
+        model.colorTexture.create2DFromRaw({
+          width: cWidth,
+          height: textureHeight,
+          numComps: 3,
+          dataType: VtkDataTypes.UNSIGNED_CHAR,
+          data: cTable
+        });
       } else {
         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);
         }
-        model.colorTexture.create2DFromRaw(cWidth, 1, 3, VtkDataTypes.UNSIGNED_CHAR, cTable);
+        model.colorTexture.create2DFromRaw({
+          width: cWidth,
+          height: 1,
+          numComps: 3,
+          dataType: VtkDataTypes.UNSIGNED_CHAR,
+          data: cTable
+        });
       }
       if (firstColorTransferFunc) {
         model._openGLRenderWindow.setGraphicsResourceForObject(firstColorTransferFunc, model.colorTexture, cfunToString);
@@ -653,7 +668,10 @@ function vtkOpenGLImageMapper(publicAPI, model) {
     // rebuild opacity tfun?
     const reBuildPwf = !pwfTex?.oglObject?.getHandle() || pwfTex?.hash !== pwfunToString;
     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);
       model.pwfTexture = vtkOpenGLTexture.newInstance({
@@ -693,11 +711,23 @@ function vtkOpenGLImageMapper(publicAPI, model) {
           }
         }
         model.pwfTexture.resetFormatAndType();
-        model.pwfTexture.create2DFromRaw(pwfWidth, textureHeight, 1, VtkDataTypes.FLOAT, pwfFloatTable);
+        model.pwfTexture.create2DFromRaw({
+          width: pwfWidth,
+          height: textureHeight,
+          numComps: 1,
+          dataType: VtkDataTypes.FLOAT,
+          data: pwfFloatTable
+        });
       } else {
         // default is opaque
         pwfTable.fill(255.0);
-        model.pwfTexture.create2DFromRaw(pwfWidth, 1, 1, VtkDataTypes.UNSIGNED_CHAR, pwfTable);
+        model.pwfTexture.create2DFromRaw({
+          width: pwfWidth,
+          height: 1,
+          numComps: 1,
+          dataType: VtkDataTypes.UNSIGNED_CHAR,
+          data: pwfTable
+        });
       }
       if (firstPwFunc) {
         model._openGLRenderWindow.setGraphicsResourceForObject(firstPwFunc, model.pwfTexture, pwfunToString);
@@ -863,10 +893,33 @@ function vtkOpenGLImageMapper(publicAPI, model) {
         vtkErrorMacro('Reformat slicing not yet supported.');
       }
 
+      /**
+       *
+       * Fetch the ranges of the source volume, `imgScalars`, and use them when
+       * creating the texture. Whilst the pre-calculated ranges may not be
+       * strictly correct for the slice, it is guaranteed to be within the
+       * source volume's range.
+       *
+       * There is a significant performance improvement by pre-setting the range
+       * of the scalars array particularly when scrolling through the source
+       * volume as there is no need to calculate the range of the slice scalar.
+       *
+       * @type{ import("../../../interfaces").vtkRange[] }
+       */
+      const ranges = imgScalars.getRanges();
+
       // Don't share this resource as `scalars` is created in this function
       // so it is impossible to share
       model.openGLTexture.resetFormatAndType();
-      model.openGLTexture.create2DFilterableFromRaw(dims[0], dims[1], numComp, imgScalars.getDataType(), scalars, model.renderable.getPreferSizeOverAccuracy?.());
+      model.openGLTexture.create2DFilterableFromRaw({
+        width: dims[0],
+        height: dims[1],
+        numComps: numComp,
+        dataType: imgScalars.getDataType(),
+        data: scalars,
+        preferSizeOverAccuracy: !!model.renderable.getPreferSizeOverAccuracy?.(),
+        ranges
+      });
       model.openGLTexture.activate();
       model.openGLTexture.sendParameters();
       model.openGLTexture.deactivate();
@@ -912,7 +965,10 @@ function vtkOpenGLImageMapper(publicAPI, model) {
     const toString = `${labelOutlineThicknessArray.join('-')}`;
     const reBuildL = !lTex?.oglObject?.getHandle() || lTex?.hash !== toString;
     if (reBuildL) {
-      const lWidth = 1024;
+      let lWidth = model.renderable.getLabelOutlineTextureWidth();
+      if (lWidth <= 0) {
+        lWidth = model.context.getParameter(model.context.MAX_TEXTURE_SIZE);
+      }
       const lHeight = 1;
       const lSize = lWidth * lHeight;
       const lTable = new Uint8Array(lSize);
@@ -933,7 +989,13 @@ function vtkOpenGLImageMapper(publicAPI, model) {
       model.labelOutlineThicknessTexture.setMagnificationFilter(Filter.NEAREST);
 
       // Create a 2D texture (acting as 1D) from the raw data
-      model.labelOutlineThicknessTexture.create2DFromRaw(lWidth, lHeight, 1, VtkDataTypes.UNSIGNED_CHAR, lTable);
+      model.labelOutlineThicknessTexture.create2DFromRaw({
+        width: lWidth,
+        height: lHeight,
+        numComps: 1,
+        dataType: VtkDataTypes.UNSIGNED_CHAR,
+        data: lTable
+      });
       if (labelOutlineThicknessArray) {
         model._openGLRenderWindow.setGraphicsResourceForObject(labelOutlineThicknessArray, model.labelOutlineThicknessTexture, toString);
         if (labelOutlineThicknessArray !== model._labelOutlineThicknessArray) {

package/Rendering/OpenGL/ImageResliceMapper.js

@@ -245,6 +245,7 @@ function vtkOpenGLImageResliceMapper(publicAPI, model) {
     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.buildBufferObjects = (ren, actor) => {
+    const actorProperties = actor.getProperties();
     model.currentValidInputs.forEach((_ref3, component) => {
       let {
         imageData
@@ -254,7 +255,10 @@ function vtkOpenGLImageResliceMapper(publicAPI, model) {
       const tex = model._openGLRenderWindow.getGraphicsResourceForObject(scalars);
       const scalarsHash = getImageDataHash(imageData, scalars);
       const reBuildTex = !tex?.oglObject?.getHandle() || tex?.hash !== scalarsHash;
-      if (reBuildTex) {
+      const actorProperty = actorProperties[component];
+      const updatedExtents = actorProperty.getUpdatedExtents();
+      const hasUpdatedExtents = !!updatedExtents.length;
+      if (reBuildTex && !hasUpdatedExtents) {
         const newScalarTexture = vtkOpenGLTexture.newInstance();
         newScalarTexture.setOpenGLRenderWindow(model._openGLRenderWindow);
         // Build the textures
@@ -262,17 +266,34 @@ function vtkOpenGLImageResliceMapper(publicAPI, model) {
         // 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);
+        newScalarTexture.create3DFilterableFromDataArray({
+          width: dims[0],
+          height: dims[1],
+          depth: dims[2],
+          dataArray: scalars
+        });
         model._openGLRenderWindow.setGraphicsResourceForObject(scalars, newScalarTexture, scalarsHash);
         model.scalarTextures[component] = newScalarTexture;
       } else {
         model.scalarTextures[component] = tex.oglObject;
       }
+      if (hasUpdatedExtents) {
+        // If hasUpdatedExtents, then the texture is partially updated.
+        // clear the array to acknowledge the update.
+        actorProperty.setUpdatedExtents([]);
+        const dims = imageData.getDimensions();
+        model.scalarTextures[component].create3DFilterableFromDataArray({
+          width: dims[0],
+          height: dims[1],
+          depth: dims[2],
+          dataArray: scalars,
+          updatedExtents
+        });
+      }
       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;
@@ -286,7 +307,10 @@ function vtkOpenGLImageResliceMapper(publicAPI, model) {
     const cTex = model._openGLRenderWindow.getGraphicsResourceForObject(firstColorTransferFunc);
     const reBuildC = !cTex?.oglObject?.getHandle() || cTex?.hash !== colorFuncHash;
     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();
@@ -309,7 +333,13 @@ function vtkOpenGLImageResliceMapper(publicAPI, model) {
           }
         }
         newColorTexture.resetFormatAndType();
-        newColorTexture.create2DFromRaw(cWidth, textureHeight, 3, VtkDataTypes.UNSIGNED_CHAR, cTable);
+        newColorTexture.create2DFromRaw({
+          width: cWidth,
+          height: textureHeight,
+          numComps: 3,
+          dataType: VtkDataTypes.UNSIGNED_CHAR,
+          data: cTable
+        });
       } else {
         for (let column = 0; column < cWidth * 3; ++column) {
           const opacity = 255.0 * column / ((cWidth - 1) * 3);
@@ -321,7 +351,13 @@ function vtkOpenGLImageResliceMapper(publicAPI, model) {
           }
         }
         newColorTexture.resetFormatAndType();
-        newColorTexture.create2DFromRaw(cWidth, 1, 3, VtkDataTypes.UNSIGNED_CHAR, cTable);
+        newColorTexture.create2DFromRaw({
+          width: cWidth,
+          height: 1,
+          numComps: 3,
+          dataType: VtkDataTypes.UNSIGNED_CHAR,
+          data: cTable
+        });
       }
       if (firstColorTransferFunc) {
         model._openGLRenderWindow.setGraphicsResourceForObject(firstColorTransferFunc, newColorTexture, colorFuncHash);
@@ -345,7 +381,10 @@ function vtkOpenGLImageResliceMapper(publicAPI, model) {
     const pwfTex = model._openGLRenderWindow.getGraphicsResourceForObject(firstPwFunc);
     const reBuildPwf = !pwfTex?.oglObject?.getHandle() || pwfTex?.hash !== opacityFuncHash;
     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();
@@ -375,12 +414,24 @@ function vtkOpenGLImageResliceMapper(publicAPI, model) {
           }
         }
         newOpacityTexture.resetFormatAndType();
-        newOpacityTexture.create2DFromRaw(pwfWidth, textureHeight, 1, VtkDataTypes.FLOAT, pwfFloatTable);
+        newOpacityTexture.create2DFromRaw({
+          width: pwfWidth,
+          height: textureHeight,
+          numComps: 1,
+          dataType: VtkDataTypes.FLOAT,
+          data: pwfFloatTable
+        });
       } else {
         // default is opaque
         pwfTable.fill(255.0);
         newOpacityTexture.resetFormatAndType();
-        newOpacityTexture.create2DFromRaw(pwfWidth, textureHeight, 1, VtkDataTypes.UNSIGNED_CHAR, pwfTable);
+        newOpacityTexture.create2DFromRaw({
+          width: pwfWidth,
+          height: textureHeight,
+          numComps: 1,
+          dataType: VtkDataTypes.UNSIGNED_CHAR,
+          data: pwfTable
+        });
       }
       if (firstPwFunc) {
         model._openGLRenderWindow.setGraphicsResourceForObject(firstPwFunc, newOpacityTexture, opacityFuncHash);

package/Rendering/OpenGL/OrderIndependentTranslucentPass.js

@@ -91,16 +91,33 @@ function vtkOpenGLOrderIndependentTranslucentPass(publicAPI, model) {
     model.translucentRGBATexture.setFormat(gl.RGBA);
     model.translucentRGBATexture.setOpenGLDataType(gl.HALF_FLOAT);
     model.translucentRGBATexture.setOpenGLRenderWindow(viewNode);
-    model.translucentRGBATexture.create2DFromRaw(size[0], size[1], 4, 'Float32Array', null);
+    model.translucentRGBATexture.create2DFromRaw({
+      width: size[0],
+      height: size[1],
+      numComps: 4,
+      dataType: 'Float32Array',
+      data: null
+    });
     model.translucentRTexture = vtkOpenGLTexture.newInstance();
     model.translucentRTexture.setInternalFormat(gl.R16F);
     model.translucentRTexture.setFormat(gl.RED);
     model.translucentRTexture.setOpenGLDataType(gl.HALF_FLOAT);
     model.translucentRTexture.setOpenGLRenderWindow(viewNode);
-    model.translucentRTexture.create2DFromRaw(size[0], size[1], 1, 'Float32Array', null);
+    model.translucentRTexture.create2DFromRaw({
+      width: size[0],
+      height: size[1],
+      numComps: 1,
+      dataType: 'Float32Array',
+      data: null
+    });
     model.translucentZTexture = vtkOpenGLTexture.newInstance();
     model.translucentZTexture.setOpenGLRenderWindow(viewNode);
-    model.translucentZTexture.createDepthFromRaw(size[0], size[1], 'Float32Array', null);
+    model.translucentZTexture.createDepthFromRaw({
+      width: size[0],
+      height: size[1],
+      dataType: 'Float32Array',
+      data: null
+    });
     model.framebuffer.setColorBuffer(model.translucentRGBATexture, 0);
     model.framebuffer.setColorBuffer(model.translucentRTexture, 1);
     model.framebuffer.setDepthBuffer(model.translucentZTexture);

package/Rendering/OpenGL/PolyDataMapper.js

@@ -1014,7 +1014,13 @@ function vtkOpenGLPolyDataMapper(publicAPI, model) {
       const input = model.renderable.getColorTextureMap();
       const ext = input.getExtent();
       const inScalars = input.getPointData().getScalars();
-      tex.create2DFromRaw(ext[1] - ext[0] + 1, ext[3] - ext[2] + 1, inScalars.getNumberOfComponents(), inScalars.getDataType(), inScalars.getData());
+      tex.create2DFromRaw({
+        width: ext[1] - ext[0] + 1,
+        height: ext[3] - ext[2] + 1,
+        numComps: inScalars.getNumberOfComponents(),
+        dataType: inScalars.getDataType(),
+        data: inScalars.getData()
+      });
       tex.activate();
       tex.sendParameters();
       tex.deactivate();

package/Rendering/OpenGL/Renderer.js

@@ -24,7 +24,7 @@ function vtkOpenGLRenderer(publicAPI, model) {
       publicAPI.updateLights();
       publicAPI.prepareNodes();
       publicAPI.addMissingNode(model.renderable.getActiveCamera());
-      publicAPI.addMissingNodes(model.renderable.getViewPropsWithNestedProps());
+      publicAPI.addMissingNodes(model.renderable.getViewPropsWithNestedProps(), true);
       publicAPI.removeUnusedNodes();
     }
   };

package/Rendering/OpenGL/SurfaceLIC/LineIntegralConvolution2D/pingpong.js

@@ -64,7 +64,13 @@ function allocateBuffer(openGLRenderWindow, _ref, filter, wrapping) {
   });
   texture.setOpenGLRenderWindow(openGLRenderWindow);
   texture.setInternalFormat(gl.RGBA32F);
-  texture.create2DFromRaw(width, height, 4, 'Float32Array', null);
+  texture.create2DFromRaw({
+    width,
+    height,
+    numComps: 4,
+    dataType: 'Float32Array',
+    data: null
+  });
   texture.activate();
   texture.sendParameters();
   texture.deactivate();

package/Rendering/OpenGL/SurfaceLIC/SurfaceLICInterface.js

@@ -206,7 +206,13 @@ function vtkOpenGLSurfaceLICInterface(publicAPI, model) {
         autoParameters: false
       });
       texture.setOpenGLRenderWindow(model._openGLRenderWindow);
-      texture.create2DFromRaw(length, length, 4, 'Float32Array', values);
+      texture.create2DFromRaw({
+        width: length,
+        height: length,
+        numComps: 4,
+        dataType: 'Float32Array',
+        data: values
+      });
       texture.activate();
       texture.sendParameters();
       texture.deactivate();
@@ -255,7 +261,13 @@ function vtkOpenGLSurfaceLICInterface(publicAPI, model) {
     });
     texture.setOpenGLRenderWindow(openGLRenderWindow);
     texture.setInternalFormat(gl.RGBA32F);
-    texture.create2DFromRaw(...model.size, 4, 'Float32Array', null);
+    texture.create2DFromRaw({
+      width: model.size[0],
+      height: model.size[1],
+      numComps: 4,
+      dataType: 'Float32Array',
+      data: null
+    });
     texture.activate();
     texture.sendParameters();
     texture.deactivate();
@@ -269,7 +281,12 @@ function vtkOpenGLSurfaceLICInterface(publicAPI, model) {
       autoParameters: false
     });
     texture.setOpenGLRenderWindow(openGLRenderWindow);
-    texture.createDepthFromRaw(...model.size, 'Float32Array', null);
+    texture.createDepthFromRaw({
+      width: model.size[0],
+      height: model.size[1],
+      dataType: 'Float32Array',
+      data: null
+    });
     texture.activate();
     texture.sendParameters();
     texture.deactivate();