@kitware/vtk.js 30.3.3 → 30.4.1

package/Rendering/Core/RenderWindow.d.ts

@@ -9,6 +9,7 @@ export interface IRenderWindowInitialValues {
 	interactor?: any,
 	neverRendered?: boolean,
 	numberOfLayers?: number
+	childRenderWindows?: vtkRenderWindow[],
 }
 
 interface IStatistics {
@@ -42,6 +43,12 @@ export interface vtkRenderWindow extends vtkObject {
 	 */
 	addRenderer(renderer: vtkRenderer): void;
 
+	/**
+	 * Add a child render window
+	 * @param {vtkRenderWindow} renderWindow The vtkRenderWindow instance.
+	 */
+	addRenderWindow(renderWindow: vtkRenderWindow): void;
+
 	/**
 	 * Add renderer
 	 * @param view 
@@ -87,6 +94,16 @@ export interface vtkRenderWindow extends vtkObject {
 	 */
 	getRenderersByReference(): vtkRenderer[];
 
+	/**
+	 * 
+	 */
+	getChildRenderWindows(): vtkRenderWindow[];
+
+	/**
+	 * 
+	 */
+	getChildRenderWindowsByReference(): vtkRenderWindow[];
+
 	/**
 	 * 
 	 */

package/Rendering/Core/RenderWindow.js

@@ -136,6 +136,14 @@ function vtkRenderWindow(publicAPI, model) {
     macro.setImmediate(publicAPI.render);
     return model._views.map(view => view.captureNextImage ? view.captureNextImage(format, opts) : undefined).filter(i => !!i);
   };
+  publicAPI.addRenderWindow = child => {
+    if (model.childRenderWindows.includes(child)) {
+      return false;
+    }
+    model.childRenderWindows.push(child);
+    publicAPI.modified();
+    return true;
+  };
 }
 
 // ----------------------------------------------------------------------------
@@ -148,7 +156,8 @@ const DEFAULT_VALUES = {
   views: [],
   interactor: null,
   neverRendered: true,
-  numberOfLayers: 1
+  numberOfLayers: 1,
+  childRenderWindows: []
 };
 
 // ----------------------------------------------------------------------------
@@ -161,7 +170,7 @@ function extend(publicAPI, model) {
   macro.obj(publicAPI, model);
   macro.setGet(publicAPI, model, ['interactor', 'numberOfLayers', '_views', 'defaultViewAPI']);
   macro.get(publicAPI, model, ['neverRendered']);
-  macro.getArray(publicAPI, model, ['renderers']);
+  macro.getArray(publicAPI, model, ['renderers', 'childRenderWindows']);
   macro.moveToProtected(publicAPI, model, ['views']);
   macro.event(publicAPI, model, 'completion');
 

package/Rendering/OpenGL/ForwardPass.js

@@ -28,11 +28,11 @@ function vtkForwardPass(publicAPI, model) {
     const numlayers = viewNode.getRenderable().getNumberOfLayers();
 
     // iterate over renderers
-    const renderers = viewNode.getChildren();
+    const renderers = viewNode.getRenderable().getRenderersByReference();
     for (let i = 0; i < numlayers; i++) {
       for (let index = 0; index < renderers.length; index++) {
-        const renNode = renderers[index];
-        const ren = viewNode.getRenderable().getRenderers()[index];
+        const ren = renderers[index];
+        const renNode = viewNode.getViewNodeFor(ren);
         if (ren.getDraw() && ren.getLayer() === i) {
           // check for both opaque and volume actors
           model.opaqueActorCount = 0;

package/Rendering/OpenGL/ImageMapper.js

@@ -923,8 +923,8 @@ function vtkOpenGLImageMapper(publicAPI, model) {
       // Assuming labelOutlineThicknessArray contains the thickness for each segment
       for (let i = 0; i < lWidth; ++i) {
         // Retrieve the thickness value for the current segment index.
-        // If the value is undefined, null, or 0, use the first element's value as a default.
-        const thickness = labelOutlineThicknessArray[i] || labelOutlineThicknessArray[0];
+        // If the value is undefined, use the first element's value as a default, otherwise use the value (even if 0)
+        const thickness = typeof labelOutlineThicknessArray[i] !== 'undefined' ? labelOutlineThicknessArray[i] : labelOutlineThicknessArray[0];
         lTable[i] = thickness;
       }
       model.labelOutlineThicknessTexture.releaseGraphicsResources(model._openGLRenderWindow);

package/Rendering/OpenGL/RenderWindow.d.ts

@@ -18,6 +18,7 @@ export interface IOpenGLRenderWindowInitialValues {
 	shaderCache?: null;
 	initialized?: boolean;
 	context?: WebGLRenderingContext | WebGL2RenderingContext;
+	context2D?: CanvasRenderingContext2D;
 	canvas?: HTMLCanvasElement;
 	cursorVisibility?: boolean;
 	cursor?: string;
@@ -40,13 +41,6 @@ export interface ICaptureOptions {
 	scale?: number
 }
 
-export interface I3DContextOptions {
-    preserveDrawingBuffer?: boolean;
-    depth?: boolean;
-    alpha?: boolean;
-    powerPreference?: string;
-}
-
 type vtkOpenGLRenderWindowBase = vtkObject & Omit<vtkAlgorithm,
 	| 'getInputData'
 	| 'setInputData'
@@ -228,9 +222,44 @@ export interface vtkOpenGLRenderWindow extends vtkOpenGLRenderWindowBase {
 
 	/**
 	 *
-	 * @param {I3DContextOptions} options
+	 * @param {WebGLContextAttributes} options
+	 */
+	get3DContext(options: WebGLContextAttributes): Nullable<WebGLRenderingContext>;
+
+	/**
+	 *
+	 * @param {CanvasRenderingContext2DSettings} options
+	 */
+	get2DContext(options: CanvasRenderingContext2DSettings): Nullable<CanvasRenderingContext2D>;
+
+	/**
+	 * Copy the content of the root parent, if there is one, to the canvas
+	 */
+	copyParentContent(): void;
+
+	/**
+	 * Resize this render window using the size of its children
+	 * The new size of the renderwindow is the size of the bounding box
+	 * containing all the child render windows
+	 */
+	resizeFromChildRenderWindows(): void;
+
+	/**
+	 * Returns the last ancestor of type vtkOpenGLRenderWindow if there is one
+	 * If there is no parent vtkOpenGLRenderWindow, returns undefined
+	 */
+	getRootOpenGLRenderWindow(): vtkOpenGLRenderWindow | undefined;
+
+	/**
+	 * The context 2D is created during initialization instead of the WebGL context
+	 * when there is a parent render window
+	 */
+	getContext2D(): CanvasRenderingContext2D | undefined;
+
+	/**
+	 *
 	 */
-	get3DContext(options: I3DContextOptions): Nullable<WebGLRenderingContext>;
+	setContext2D(context2D: CanvasRenderingContext2D | undefined): boolean;
 
 	/**
 	 *

package/Rendering/OpenGL/RenderWindow.js

@@ -5,7 +5,7 @@ import vtkForwardPass from './ForwardPass.js';
 import vtkHardwareSelector from './HardwareSelector.js';
 import vtkShaderCache from './ShaderCache.js';
 import vtkTextureUnitManager from './TextureUnitManager.js';
-import vtkViewNodeFactory from './ViewNodeFactory.js';
+import vtkViewNodeFactory, { registerOverride } from './ViewNodeFactory.js';
 import vtkRenderPass from '../SceneGraph/RenderPass.js';
 import vtkRenderWindowViewNode from '../SceneGraph/RenderWindowViewNode.js';
 import { createContextProxyHandler } from './RenderWindow/ContextProxy.js';
@@ -21,6 +21,7 @@ const SCREENSHOT_PLACEHOLDER = {
   width: '100%',
   height: '100%'
 };
+const parentMethodsToProxy = ['activateTexture', 'deactivateTexture', 'disableCullFace', 'enableCullFace', 'get3DContext', 'getActiveFramebuffer', 'getContext', 'getDefaultTextureByteSize', 'getDefaultTextureInternalFormat', 'getDefaultToWebgl2', 'getGLInformations', 'getGraphicsMemoryInfo', 'getGraphicsResourceForObject', 'getHardwareMaximumLineWidth', 'getPixelData', 'getShaderCache', 'getTextureUnitForTexture', 'getTextureUnitManager', 'getWebgl2', 'makeCurrent', 'releaseGraphicsResources', 'releaseGraphicsResourcesForObject', 'restoreContext', 'setActiveFramebuffer', 'setContext', 'setDefaultToWebgl2', 'setGraphicsResourceForObject'];
 function checkRenderTargetSupport(gl, format, type) {
   // create temporary frame buffer and texture
   const framebuffer = gl.createFramebuffer();
@@ -70,7 +71,15 @@ function _preventDefault(e) {
 function vtkOpenGLRenderWindow(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkOpenGLRenderWindow');
-  const cachingContextHandler = createContextProxyHandler();
+
+  // Only create a cachingContextHandler if needed
+  let cachingContextHandler;
+  function getCachingContextHandler() {
+    if (!cachingContextHandler) {
+      cachingContextHandler = createContextProxyHandler();
+    }
+    return cachingContextHandler;
+  }
   publicAPI.getViewNodeFactory = () => model.myFactory;
 
   // prevent default context lost handler
@@ -117,24 +126,40 @@ function vtkOpenGLRenderWindow(publicAPI, model) {
       }
       publicAPI.prepareNodes();
       publicAPI.addMissingNodes(model.renderable.getRenderersByReference());
+      publicAPI.addMissingNodes(model.renderable.getChildRenderWindowsByReference());
       publicAPI.removeUnusedNodes();
       publicAPI.initialize();
       model.children.forEach(child => {
-        child.setOpenGLRenderWindow(publicAPI);
+        // Children can be openGl renderer or openGl render windows
+        // Only openGl renderers have a method setOpenGLRenderWindow
+        child.setOpenGLRenderWindow?.(publicAPI);
       });
     }
   };
   publicAPI.initialize = () => {
     if (!model.initialized) {
-      model.context = publicAPI.get3DContext();
-      model.textureUnitManager = vtkTextureUnitManager.newInstance();
-      model.textureUnitManager.setContext(model.context);
-      model.shaderCache.setContext(model.context);
-      // initialize blending for transparency
-      const gl = model.context;
-      gl.blendFuncSeparate(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA, gl.ONE, gl.ONE_MINUS_SRC_ALPHA);
-      gl.depthFunc(gl.LEQUAL);
-      gl.enable(gl.BLEND);
+      // Set root parent if there is one
+      // Some methods of the root parent are proxied (see parentMethodsToProxy)
+      model.rootOpenGLRenderWindow = publicAPI.getLastAncestorOfType('vtkOpenGLRenderWindow');
+      if (model.rootOpenGLRenderWindow) {
+        // Initialize a 2D context that will copy the content of the root parent
+        model.context2D = publicAPI.get2DContext();
+      } else {
+        // Initialize a 3D context that may be used by child render windows
+        model.context = publicAPI.get3DContext();
+        publicAPI.resizeFromChildRenderWindows();
+        if (model.context) {
+          createGLContext();
+        }
+        model.textureUnitManager = vtkTextureUnitManager.newInstance();
+        model.textureUnitManager.setContext(model.context);
+        model.shaderCache.setContext(model.context);
+        // initialize blending for transparency
+        const gl = model.context;
+        gl.blendFuncSeparate(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA, gl.ONE, gl.ONE_MINUS_SRC_ALPHA);
+        gl.depthFunc(gl.LEQUAL);
+        gl.enable(gl.BLEND);
+      }
       model.initialized = true;
     }
   };
@@ -213,7 +238,11 @@ function vtkOpenGLRenderWindow(publicAPI, model) {
       vtkDebugMacro('using webgl1');
       result = model.canvas.getContext('webgl', options) || model.canvas.getContext('experimental-webgl', options);
     }
-    return new Proxy(result, cachingContextHandler);
+    return new Proxy(result, getCachingContextHandler());
+  };
+  publicAPI.get2DContext = function () {
+    let options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    return model.canvas.getContext('2d', options);
   };
   publicAPI.restoreContext = () => {
     const rp = vtkRenderPass.newInstance();
@@ -545,6 +574,37 @@ function vtkOpenGLRenderWindow(publicAPI, model) {
     if (model.notifyStartCaptureImage) {
       getCanvasDataURL();
     }
+    publicAPI.copyParentContent();
+    const childrenRW = model.renderable.getChildRenderWindowsByReference();
+    for (let i = 0; i < childrenRW.length; ++i) {
+      publicAPI.getViewNodeFor(childrenRW[i])?.traverseAllPasses();
+    }
+  };
+  publicAPI.copyParentContent = () => {
+    const rootParent = model.rootOpenGLRenderWindow;
+    if (!rootParent || !model.context2D) {
+      return;
+    }
+    const parentCanvas = rootParent.getCanvas();
+    const selfCanvas = model.canvas;
+    model.context2D.drawImage(parentCanvas, 0, parentCanvas.height - selfCanvas.height,
+    // source y axis is inverted
+    selfCanvas.width, selfCanvas.height, 0, 0, selfCanvas.width, selfCanvas.height);
+  };
+  publicAPI.resizeFromChildRenderWindows = () => {
+    // Adapt the size of the parent render window to the child render windows
+    const childrenRW = model.renderable.getChildRenderWindowsByReference();
+    if (childrenRW.length > 0) {
+      const maxSize = [0, 0];
+      for (let i = 0; i < childrenRW.length; ++i) {
+        const childSize = publicAPI.getViewNodeFor(childrenRW[i])?.getSize();
+        if (childSize) {
+          maxSize[0] = childSize[0] > maxSize[0] ? childSize[0] : maxSize[0];
+          maxSize[1] = childSize[1] > maxSize[1] ? childSize[1] : maxSize[1];
+        }
+      }
+      publicAPI.setSize(...maxSize);
+    }
   };
   publicAPI.disableCullFace = () => {
     if (model.cullFaceEnabled) {
@@ -593,7 +653,11 @@ function vtkOpenGLRenderWindow(publicAPI, model) {
     model.canvas.removeEventListener('webglcontextlost', _preventDefault);
     model.canvas.removeEventListener('webglcontextrestored', publicAPI.restoreContext);
   }
-  publicAPI.delete = macro.chain(clearEvents, publicAPI.delete, publicAPI.setViewStream, deleteGLContext);
+  publicAPI.delete = macro.chain(() => {
+    if (model.context) {
+      deleteGLContext();
+    }
+  }, clearEvents, publicAPI.delete, publicAPI.setViewStream);
 
   // Do not trigger modified for performance reasons
   publicAPI.setActiveFramebuffer = newActiveFramebuffer => {
@@ -662,6 +726,20 @@ function vtkOpenGLRenderWindow(publicAPI, model) {
       glRen?.releaseGraphicsResources();
     });
   };
+
+  // Proxy some methods if needed
+  const publicAPIBeforeProxy = {
+    ...publicAPI
+  };
+  parentMethodsToProxy.forEach(methodName => {
+    publicAPI[methodName] = function () {
+      if (model.rootOpenGLRenderWindow) {
+        // Proxy only methods when the render window has a parent
+        return model.rootOpenGLRenderWindow[methodName](...arguments);
+      }
+      return publicAPIBeforeProxy[methodName](...arguments);
+    };
+  });
 }
 
 // ----------------------------------------------------------------------------
@@ -673,6 +751,7 @@ const DEFAULT_VALUES = {
   shaderCache: null,
   initialized: false,
   context: null,
+  context2D: null,
   canvas: null,
   cursorVisibility: true,
   cursor: 'pointer',
@@ -700,9 +779,10 @@ function extend(publicAPI, model) {
   vtkRenderWindowViewNode.extend(publicAPI, model, initialValues);
 
   // Create internal instances
-  model.canvas = document.createElement('canvas');
-  model.canvas.style.width = '100%';
-  createGLContext();
+  if (!model.canvas) {
+    model.canvas = document.createElement('canvas');
+    model.canvas.style.width = '100%';
+  }
   if (!model.selector) {
     model.selector = vtkHardwareSelector.newInstance();
     model.selector.setOpenGLRenderWindow(publicAPI);
@@ -721,21 +801,17 @@ function extend(publicAPI, model) {
   model._graphicsResourceHash = new Map();
   model._glInformation = null;
   model.myFactory = vtkViewNodeFactory.newInstance();
-  /* eslint-disable no-use-before-define */
-  model.myFactory.registerOverride('vtkRenderWindow', newInstance);
-  /* eslint-enable no-use-before-define */
-
   model.shaderCache = vtkShaderCache.newInstance();
   model.shaderCache.setOpenGLRenderWindow(publicAPI);
 
   // setup default forward pass rendering
   model.renderPasses[0] = vtkForwardPass.newInstance();
-  macro.event(publicAPI, model, 'imageReady');
 
   // Build VTK API
-  macro.get(publicAPI, model, ['shaderCache', 'textureUnitManager', 'webgl2', 'useBackgroundImage', 'activeFramebuffer']);
-  macro.setGet(publicAPI, model, ['initialized', 'context', 'canvas', 'renderPasses', 'notifyStartCaptureImage', 'defaultToWebgl2', 'cursor', 'useOffScreen']);
+  macro.get(publicAPI, model, ['shaderCache', 'textureUnitManager', 'webgl2', 'useBackgroundImage', 'activeFramebuffer', 'rootOpenGLRenderWindow']);
+  macro.setGet(publicAPI, model, ['initialized', 'context', 'context2D', 'canvas', 'renderPasses', 'notifyStartCaptureImage', 'defaultToWebgl2', 'cursor', 'useOffScreen']);
   macro.setGetArray(publicAPI, model, ['size'], 2);
+  macro.event(publicAPI, model, 'imageReady');
   macro.event(publicAPI, model, 'windowResizeEvent');
 
   // Object methods
@@ -761,4 +837,7 @@ var vtkRenderWindow = {
   popMonitorGLContextCount
 };
 
+// Register ourself to OpenGL backend if imported
+registerOverride('vtkRenderWindow', newInstance);
+
 export { vtkRenderWindow as default, extend, newInstance, popMonitorGLContextCount, pushMonitorGLContextCount };

package/Rendering/OpenGL/Renderer.js

@@ -124,13 +124,13 @@ function vtkOpenGLRenderer(publicAPI, model) {
     if (!model.renderable.getTransparent()) {
       const background = model.renderable.getBackgroundByReference();
       // renderable ensures that background has 4 entries.
-      model.context.clearColor(background[0], background[1], background[2], background[3]);
+      gl.clearColor(background[0], background[1], background[2], background[3]);
       clearMask |= gl.COLOR_BUFFER_BIT;
     }
     if (!model.renderable.getPreserveDepthBuffer()) {
       gl.clearDepth(1.0);
       clearMask |= gl.DEPTH_BUFFER_BIT;
-      model.context.depthMask(true);
+      gl.depthMask(true);
     }
     gl.colorMask(true, true, true, true);
     const ts = publicAPI.getTiledSizeAndOrigin();

package/Rendering/OpenGL/VolumeMapper.js

@@ -1119,7 +1119,7 @@ function vtkOpenGLVolumeMapper(publicAPI, model) {
     const tex = model._openGLRenderWindow.getGraphicsResourceForObject(scalars);
     // rebuild the scalarTexture if the data has changed
     toString = `${image.getMTime()}A${scalars.getMTime()}`;
-    const reBuildTex = !tex?.vtkObj || tex?.hash !== toString || model.scalarTextureString !== toString;
+    const reBuildTex = !tex?.vtkObj || tex?.hash !== toString;
     if (reBuildTex) {
       // Build the textures
       const dims = image.getDimensions();
@@ -1128,13 +1128,11 @@ function vtkOpenGLVolumeMapper(publicAPI, model) {
       model.scalarTexture.releaseGraphicsResources(model._openGLRenderWindow);
       model.scalarTexture.resetFormatAndType();
       model.scalarTexture.create3DFilterableFromDataArray(dims[0], dims[1], dims[2], scalars, model.renderable.getPreferSizeOverAccuracy());
-      model.scalarTextureString = toString;
       if (scalars) {
-        model._openGLRenderWindow.setGraphicsResourceForObject(scalars, model.scalarTexture, model.scalarTextureString);
+        model._openGLRenderWindow.setGraphicsResourceForObject(scalars, model.scalarTexture, toString);
       }
     } else {
       model.scalarTexture = tex.vtkObj;
-      model.scalarTextureString = tex.hash;
     }
     if (!model.tris.getCABO().getElementCount()) {
       // build the CABO
@@ -1214,8 +1212,8 @@ function vtkOpenGLVolumeMapper(publicAPI, model) {
       // Assuming labelOutlineThicknessArray contains the thickness for each segment
       for (let i = 0; i < lWidth; ++i) {
         // Retrieve the thickness value for the current segment index.
-        // If the value is undefined, null, or 0, use the first element's value as a default.
-        const thickness = labelOutlineThicknessArray[i] || labelOutlineThicknessArray[0];
+        // If the value is undefined, use the first element's value as a default, otherwise use the value (even if 0)
+        const thickness = typeof labelOutlineThicknessArray[i] !== 'undefined' ? labelOutlineThicknessArray[i] : labelOutlineThicknessArray[0];
         lTable[i] = thickness;
       }
       model.labelOutlineThicknessTexture.releaseGraphicsResources(model._openGLRenderWindow);

package/Rendering/SceneGraph/ViewNode.d.ts

@@ -20,10 +20,12 @@ export interface IViewNodeInitialValues {
 export interface vtkViewNode extends vtkObject {
 
 	/**
-	 * 
+	 * Add a child view node to this node, created from the renderable given as argument
+	 * If the node creation fails or the argument is falsy, returns undefined
+	 * Otherwise, returns the newly created node or the existing node
 	 * @param dobj 
 	 */
-	addMissingNode(dobj: any): void;
+	addMissingNode(dobj: any): vtkViewNode | undefined;
 
 	/**
 	 * 
@@ -66,6 +68,12 @@ export interface vtkViewNode extends vtkObject {
 	 */
 	getFirstAncestorOfType(type: any): void;
 
+	/**
+	 * Find the last parent/grandparent of the desired type
+	 * @param type 
+	 */
+	getLastAncestorOfType(type: any): void;
+
 	/**
 	 * 
 	 */

package/Rendering/SceneGraph/ViewNode.js

@@ -63,27 +63,44 @@ function vtkViewNode(publicAPI, model) {
     }
     return model._parent.getFirstAncestorOfType(type);
   };
+  publicAPI.getLastAncestorOfType = type => {
+    if (!model._parent) {
+      return null;
+    }
+    const lastAncestor = model._parent.getLastAncestorOfType(type);
+    if (lastAncestor) {
+      return lastAncestor;
+    }
+    if (model._parent.isA(type)) {
+      return model._parent;
+    }
+    return null;
+  };
 
   // add a missing node/child for the passed in renderables. This should
   // be called only in between prepareNodes and removeUnusedNodes
   publicAPI.addMissingNode = dobj => {
     if (!dobj) {
-      return;
+      return undefined;
     }
-    const result = model._renderableChildMap.get(dobj);
+
     // if found just mark as visited
+    const result = model._renderableChildMap.get(dobj);
     if (result !== undefined) {
       result.setVisited(true);
-    } else {
-      // otherwise create a node
-      const newNode = publicAPI.createViewNode(dobj);
-      if (newNode) {
-        newNode.setParent(publicAPI);
-        newNode.setVisited(true);
-        model._renderableChildMap.set(dobj, newNode);
-        model.children.push(newNode);
-      }
+      return result;
+    }
+
+    // otherwise create a node
+    const newNode = publicAPI.createViewNode(dobj);
+    if (newNode) {
+      newNode.setParent(publicAPI);
+      newNode.setVisited(true);
+      model._renderableChildMap.set(dobj, newNode);
+      model.children.push(newNode);
+      return newNode;
     }
+    return undefined;
   };
 
   // add missing nodes/children for the passed in renderables. This should
@@ -94,20 +111,7 @@ function vtkViewNode(publicAPI, model) {
     }
     for (let index = 0; index < dataObjs.length; ++index) {
       const dobj = dataObjs[index];
-      const result = model._renderableChildMap.get(dobj);
-      // if found just mark as visited
-      if (result !== undefined) {
-        result.setVisited(true);
-      } else {
-        // otherwise create a node
-        const newNode = publicAPI.createViewNode(dobj);
-        if (newNode) {
-          newNode.setParent(publicAPI);
-          newNode.setVisited(true);
-          model._renderableChildMap.set(dobj, newNode);
-          model.children.push(newNode);
-        }
-      }
+      publicAPI.addMissingNode(dobj);
     }
   };
 
@@ -125,6 +129,10 @@ function vtkViewNode(publicAPI, model) {
       if (cindex === -1) {
         child.setParent(publicAPI);
         model.children.push(child);
+        const childRenderable = child.getRenderable();
+        if (childRenderable) {
+          model._renderableChildMap.set(childRenderable, child);
+        }
       }
       child.setVisited(true);
     }

package/Rendering/SceneGraph/ViewNodeFactory.d.ts

@@ -12,14 +12,6 @@ export interface vtkViewNodeFactory extends vtkObject {
 	 * @param dataObject 
 	 */
 	createNode(dataObject: any): void;
-
-	/**
-	 * Give a function pointer to a class that will manufacture a vtkViewNode
-	 * when given a class name string.
-	 * @param className 
-	 * @param func 
-	 */
-	registerOverride(className: any, func: any): void;
 }
 
 /**

package/Rendering/SceneGraph/ViewNodeFactory.js

@@ -34,9 +34,6 @@ function vtkViewNodeFactory(publicAPI, model) {
     vn.setMyFactory(publicAPI);
     return vn;
   };
-  publicAPI.registerOverride = (className, func) => {
-    model.overrides[className] = func;
-  };
 }
 
 // ----------------------------------------------------------------------------

package/Rendering/WebGPU/RenderWindow.js

@@ -4,7 +4,7 @@ import vtkForwardPass from './ForwardPass.js';
 import vtkWebGPUBuffer from './Buffer.js';
 import vtkWebGPUDevice from './Device.js';
 import vtkWebGPUHardwareSelector from './HardwareSelector.js';
-import vtkWebGPUViewNodeFactory from './ViewNodeFactory.js';
+import vtkWebGPUViewNodeFactory, { registerOverride } from './ViewNodeFactory.js';
 import vtkRenderPass from '../SceneGraph/RenderPass.js';
 import vtkRenderWindowViewNode from '../SceneGraph/RenderWindowViewNode.js';
 import HalfFloat from '../../Common/Core/HalfFloat.js';
@@ -549,9 +549,6 @@ function extend(publicAPI, model) {
   // Inheritance
   vtkRenderWindowViewNode.extend(publicAPI, model, initialValues);
   model.myFactory = vtkWebGPUViewNodeFactory.newInstance();
-  /* eslint-disable no-use-before-define */
-  model.myFactory.registerOverride('vtkRenderWindow', newInstance);
-  /* eslint-enable no-use-before-define */
 
   // setup default forward pass rendering
   model.renderPasses[0] = vtkForwardPass.newInstance();
@@ -589,4 +586,7 @@ var vtkRenderWindow = {
   extend
 };
 
+// Register ourself to WebGPU backend if imported
+registerOverride('vtkRenderWindow', newInstance);
+
 export { vtkRenderWindow as default, extend, newInstance };

package/package.json

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