@cornerstonejs/core 3.29.5 → 3.30.0

package/dist/esm/RenderingEngine/BaseRenderingEngine.d.ts

@@ -2,12 +2,13 @@ import type IStackViewport from '../types/IStackViewport';
 import type IVolumeViewport from '../types/IVolumeViewport';
 import type * as EventTypes from '../types/EventTypes';
 import type { PublicViewportInput, InternalViewportInput, NormalizedViewportInput, IViewport } from '../types/IViewport';
+import type { VtkOffscreenMultiRenderWindow } from '../types';
 export declare const VIEWPORT_MIN_SIZE = 2;
 declare abstract class BaseRenderingEngine {
     readonly id: string;
     hasBeenDestroyed: boolean;
-    offscreenMultiRenderWindow: any;
-    readonly offScreenCanvasContainer: HTMLDivElement;
+    offscreenMultiRenderWindow: VtkOffscreenMultiRenderWindow;
+    offScreenCanvasContainer: HTMLDivElement;
     protected _viewports: Map<string, IViewport>;
     protected _needsRender: Set<string>;
     protected _animationFrameSet: boolean;
@@ -34,6 +35,8 @@ declare abstract class BaseRenderingEngine {
     private _resizeUsingCustomResizeHandler;
     private _removeViewport;
     private addCustomViewport;
+    getRenderer(viewportId: any): import("@kitware/vtk.js/Rendering/Core/Renderer").vtkRenderer;
+    getOffscreenMultiRenderWindow(viewportId?: string): VtkOffscreenMultiRenderWindow;
     private setCustomViewports;
     protected _getViewportsAsArray(): IViewport[];
     private _setViewportsToBeRenderedNextFrame;
@@ -47,7 +50,6 @@ declare abstract class BaseRenderingEngine {
     protected abstract addVtkjsDrivenViewport(viewportInputEntry: InternalViewportInput, offscreenCanvasProperties?: unknown): void;
     protected abstract _renderFlaggedViewports(): void;
     protected abstract setVtkjsDrivenViewports(viewportInputEntries: NormalizedViewportInput[]): void;
-    protected abstract renderViewportUsingCustomOrVtkPipeline(viewport: IViewport): EventTypes.ImageRenderedEventDetail;
     protected abstract _renderViewportFromVtkCanvasToOnscreenCanvas(viewport: IViewport, offScreenCanvas: HTMLCanvasElement): EventTypes.ImageRenderedEventDetail;
 }
 export default BaseRenderingEngine;

package/dist/esm/RenderingEngine/BaseRenderingEngine.js

@@ -3,7 +3,6 @@ import renderingEngineCache from './renderingEngineCache';
 import eventTarget from '../eventTarget';
 import uuidv4 from '../utilities/uuidv4';
 import triggerEvent from '../utilities/triggerEvent';
-import { vtkOffscreenMultiRenderWindow } from './vtkClasses';
 import ViewportType from '../enums/ViewportType';
 import BaseVolumeViewport from './BaseVolumeViewport';
 import StackViewport from './StackViewport';
@@ -33,12 +32,6 @@ class BaseRenderingEngine {
         if (!isCornerstoneInitialized()) {
             throw new Error('@cornerstonejs/core is not initialized, run init() first');
         }
-        if (!this.useCPURendering) {
-            this.offscreenMultiRenderWindow =
-                vtkOffscreenMultiRenderWindow.newInstance();
-            this.offScreenCanvasContainer = document.createElement('div');
-            this.offscreenMultiRenderWindow.setContainer(this.offScreenCanvasContainer);
-        }
         this._viewports = new Map();
         this.hasBeenDestroyed = false;
     }
@@ -75,7 +68,9 @@ class BaseRenderingEngine {
         this._resetViewport(viewport);
         if (!viewportTypeUsesCustomRenderingPipeline(viewport.type) &&
             !this.useCPURendering) {
-            this.offscreenMultiRenderWindow.removeRenderer(viewportId);
+            if (this.offscreenMultiRenderWindow) {
+                this.offscreenMultiRenderWindow.removeRenderer(viewportId);
+            }
         }
         this._removeViewport(viewportId);
         viewport.isDisabled = true;
@@ -177,9 +172,13 @@ class BaseRenderingEngine {
         if (!this.useCPURendering) {
             const viewports = this._getViewportsAsArray();
             viewports.forEach((vp) => {
-                this.offscreenMultiRenderWindow.removeRenderer(vp.id);
+                if (this.offscreenMultiRenderWindow) {
+                    this.offscreenMultiRenderWindow.removeRenderer(vp.id);
+                }
             });
-            this.offscreenMultiRenderWindow.delete();
+            if (this.offscreenMultiRenderWindow) {
+                this.offscreenMultiRenderWindow.delete();
+            }
             delete this.offscreenMultiRenderWindow;
         }
         this._reset();
@@ -283,6 +282,15 @@ class BaseRenderingEngine {
         };
         triggerEvent(eventTarget, Events.ELEMENT_ENABLED, eventDetail);
     }
+    getRenderer(viewportId) {
+        return this.offscreenMultiRenderWindow.getRenderer(viewportId);
+    }
+    getOffscreenMultiRenderWindow(viewportId) {
+        if (this.useCPURendering) {
+            throw new Error('Offscreen multi render window is not available when using CPU rendering.');
+        }
+        return this.offscreenMultiRenderWindow;
+    }
     setCustomViewports(viewportInputEntries) {
         viewportInputEntries.forEach((vpie) => {
             this.addCustomViewport(vpie);

package/dist/esm/RenderingEngine/BaseVolumeViewport.d.ts

@@ -5,6 +5,7 @@ import type { VoiModifiedEventDetail } from '../types/EventTypes';
 import type { ViewportInput } from '../types/IViewport';
 import type { TransferFunctionNodes } from '../types/ITransferFunctionNode';
 import Viewport from './Viewport';
+import type vtkRenderer from '@kitware/vtk.js/Rendering/Core/Renderer';
 declare abstract class BaseVolumeViewport extends Viewport {
     useCPURendering: boolean;
     private _FrameOfReferenceUID;
@@ -68,12 +69,14 @@ declare abstract class BaseVolumeViewport extends Viewport {
     getSliceIndex(): number;
     setCamera(cameraInterface: ICamera, storeAsInitialCamera?: boolean): void;
     private _setVolumeActors;
-    canvasToWorld: (canvasPos: Point2) => Point3;
-    canvasToWorldSequential: (canvasPos: Point2) => Point3;
-    getVtkDisplayCoords: (canvasPos: Point2) => Point3;
-    getVtkDisplayCoordsSequential: (canvasPos: Point2) => Point3;
-    worldToCanvas: (worldPos: Point3) => Point2;
-    worldToCanvasSequential: (worldPos: Point3) => Point2;
+    canvasToWorldTiled: (canvasPos: Point2) => Point3;
+    canvasToWorldContextPool: (canvasPos: Point2) => Point3;
+    getVtkDisplayCoordsTiled: (canvasPos: Point2) => Point3;
+    getVtkDisplayCoordsContextPool: (canvasPos: Point2) => Point3;
+    worldToCanvasTiled: (worldPos: Point3) => Point2;
+    worldToCanvasContextPool: (worldPos: Point3) => Point2;
+    getRendererContextPool(): vtkRenderer;
+    getRendererTiled(): vtkRenderer;
     hasImageURI: (imageURI: string) => boolean;
     protected _getOrientationVectors(orientation: OrientationAxis | OrientationVectors): OrientationVectors;
     protected _getAcquisitionPlaneOrientation(): OrientationVectors;
@@ -92,16 +95,20 @@ declare abstract class BaseVolumeViewport extends Viewport {
     private _configureRenderingPipeline;
     protected renderingPipelineFunctions: {
         worldToCanvas: {
-            default: (worldPos: Point3) => Point2;
-            sequential: (worldPos: Point3) => Point2;
+            tiled: (worldPos: Point3) => Point2;
+            contextPool: (worldPos: Point3) => Point2;
         };
         canvasToWorld: {
-            default: (canvasPos: Point2) => Point3;
-            sequential: (canvasPos: Point2) => Point3;
+            tiled: (canvasPos: Point2) => Point3;
+            contextPool: (canvasPos: Point2) => Point3;
         };
         getVtkDisplayCoords: {
-            default: (canvasPos: Point2) => Point3;
-            sequential: (canvasPos: Point2) => Point3;
+            tiled: (canvasPos: Point2) => Point3;
+            contextPool: (canvasPos: Point2) => Point3;
+        };
+        getRenderer: {
+            tiled: () => vtkRenderer;
+            contextPool: () => vtkRenderer;
         };
     };
 }

package/dist/esm/RenderingEngine/BaseVolumeViewport.js

@@ -29,7 +29,7 @@ import imageIdToURI from '../utilities/imageIdToURI';
 import uuidv4 from '../utilities/uuidv4';
 import * as metaData from '../metaData';
 import { getCameraVectors } from './helpers/getCameraVectors';
-import { isSequentialRenderingEngine } from './helpers/isSequentialRenderingEngine';
+import { isContextPoolRenderingEngine } from './helpers/isContextPoolRenderingEngine';
 class BaseVolumeViewport extends Viewport {
     constructor(props) {
         super(props);
@@ -154,18 +154,18 @@ class BaseVolumeViewport extends Viewport {
         this.getFrameOfReferenceUID = () => {
             return this._FrameOfReferenceUID;
         };
-        this.canvasToWorld = (canvasPos) => {
+        this.canvasToWorldTiled = (canvasPos) => {
             const vtkCamera = this.getVtkActiveCamera();
             vtkCamera.setIsPerformingCoordinateTransformation?.(true);
             const renderer = this.getRenderer();
-            const displayCoords = this.getVtkDisplayCoords(canvasPos);
+            const displayCoords = this.getVtkDisplayCoordsTiled(canvasPos);
             const offscreenMultiRenderWindow = this.getRenderingEngine().offscreenMultiRenderWindow;
             const openGLRenderWindow = offscreenMultiRenderWindow.getOpenGLRenderWindow();
             const worldCoord = openGLRenderWindow.displayToWorld(displayCoords[0], displayCoords[1], displayCoords[2], renderer);
             vtkCamera.setIsPerformingCoordinateTransformation?.(false);
             return [worldCoord[0], worldCoord[1], worldCoord[2]];
         };
-        this.canvasToWorldSequential = (canvasPos) => {
+        this.canvasToWorldContextPool = (canvasPos) => {
             const vtkCamera = this.getVtkActiveCamera();
             vtkCamera.setIsPerformingCoordinateTransformation?.(true);
             const renderer = this.getRenderer();
@@ -187,7 +187,7 @@ class BaseVolumeViewport extends Viewport {
             vtkCamera.setIsPerformingCoordinateTransformation?.(false);
             return [worldCoord[0], worldCoord[1], worldCoord[2]];
         };
-        this.getVtkDisplayCoords = (canvasPos) => {
+        this.getVtkDisplayCoordsTiled = (canvasPos) => {
             const devicePixelRatio = window.devicePixelRatio || 1;
             const canvasPosWithDPR = [
                 canvasPos[0] * devicePixelRatio,
@@ -203,7 +203,7 @@ class BaseVolumeViewport extends Viewport {
             displayCoord[1] = size[1] - displayCoord[1];
             return [displayCoord[0], displayCoord[1], 0];
         };
-        this.getVtkDisplayCoordsSequential = (canvasPos) => {
+        this.getVtkDisplayCoordsContextPool = (canvasPos) => {
             const devicePixelRatio = window.devicePixelRatio || 1;
             const canvasPosWithDPR = [
                 canvasPos[0] * devicePixelRatio,
@@ -213,7 +213,7 @@ class BaseVolumeViewport extends Viewport {
             const displayCoord = [canvasPosWithDPR[0], height - canvasPosWithDPR[1]];
             return [displayCoord[0], displayCoord[1], 0];
         };
-        this.worldToCanvas = (worldPos) => {
+        this.worldToCanvasTiled = (worldPos) => {
             const vtkCamera = this.getVtkActiveCamera();
             vtkCamera.setIsPerformingCoordinateTransformation?.(true);
             const renderer = this.getRenderer();
@@ -234,7 +234,7 @@ class BaseVolumeViewport extends Viewport {
             vtkCamera.setIsPerformingCoordinateTransformation(false);
             return canvasCoordWithDPR;
         };
-        this.worldToCanvasSequential = (worldPos) => {
+        this.worldToCanvasContextPool = (worldPos) => {
             const vtkCamera = this.getVtkActiveCamera();
             vtkCamera.setIsPerformingCoordinateTransformation?.(true);
             const renderer = this.getRenderer();
@@ -278,16 +278,20 @@ class BaseVolumeViewport extends Viewport {
         };
         this.renderingPipelineFunctions = {
             worldToCanvas: {
-                default: this.worldToCanvas,
-                sequential: this.worldToCanvasSequential,
+                tiled: this.worldToCanvasTiled,
+                contextPool: this.worldToCanvasContextPool,
             },
             canvasToWorld: {
-                default: this.canvasToWorld,
-                sequential: this.canvasToWorldSequential,
+                tiled: this.canvasToWorldTiled,
+                contextPool: this.canvasToWorldContextPool,
             },
             getVtkDisplayCoords: {
-                default: this.getVtkDisplayCoords,
-                sequential: this.getVtkDisplayCoordsSequential,
+                tiled: this.getVtkDisplayCoordsTiled,
+                contextPool: this.getVtkDisplayCoordsContextPool,
+            },
+            getRenderer: {
+                tiled: this.getRendererTiled,
+                contextPool: this.getRendererContextPool,
             },
         };
         this.useCPURendering = getShouldUseCPURendering();
@@ -954,6 +958,17 @@ class BaseVolumeViewport extends Viewport {
         }
         this.setActors(volumeActorEntries);
     }
+    getRendererContextPool() {
+        const renderingEngine = this.getRenderingEngine();
+        return renderingEngine.getRenderer(this.id);
+    }
+    getRendererTiled() {
+        const renderingEngine = this.getRenderingEngine();
+        if (!renderingEngine || renderingEngine.hasBeenDestroyed) {
+            throw new Error('Rendering engine has been destroyed');
+        }
+        return renderingEngine.offscreenMultiRenderWindow?.getRenderer(this.id);
+    }
     _getOrientationVectors(orientation) {
         if (typeof orientation === 'object') {
             if (orientation.viewPlaneNormal && orientation.viewUp) {
@@ -1054,12 +1069,11 @@ class BaseVolumeViewport extends Viewport {
         return Array.from(this.volumeIds);
     }
     _configureRenderingPipeline() {
-        const renderingEngine = this.getRenderingEngine();
-        const isSequential = isSequentialRenderingEngine(renderingEngine);
+        const isContextPool = isContextPoolRenderingEngine();
         for (const key in this.renderingPipelineFunctions) {
             if (Object.prototype.hasOwnProperty.call(this.renderingPipelineFunctions, key)) {
                 const functions = this.renderingPipelineFunctions[key];
-                this[key] = isSequential ? functions.sequential : functions.default;
+                this[key] = isContextPool ? functions.contextPool : functions.tiled;
             }
         }
     }

package/dist/esm/RenderingEngine/{SequentialRenderingEngine.d.ts → ContextPoolRenderingEngine.d.ts}

@@ -3,16 +3,26 @@ import type IStackViewport from '../types/IStackViewport';
 import type IVolumeViewport from '../types/IVolumeViewport';
 import type * as EventTypes from '../types/EventTypes';
 import type { InternalViewportInput, NormalizedViewportInput, IViewport } from '../types/IViewport';
-declare class SequentialRenderingEngine extends BaseRenderingEngine {
+import type vtkRenderer from '@kitware/vtk.js/Rendering/Core/Renderer';
+import type { VtkOffscreenMultiRenderWindow } from '../types';
+declare class ContextPoolRenderingEngine extends BaseRenderingEngine {
+    private contextPool;
+    constructor(id?: string);
     protected enableVTKjsDrivenViewport(viewportInputEntry: NormalizedViewportInput): void;
     protected addVtkjsDrivenViewport(viewportInputEntry: InternalViewportInput): void;
     protected setVtkjsDrivenViewports(viewportInputEntries: NormalizedViewportInput[]): void;
     protected _resizeVTKViewports(vtkDrivenViewports: (IStackViewport | IVolumeViewport)[], keepCamera?: boolean, immediate?: boolean): void;
     protected _renderFlaggedViewports: () => void;
-    protected renderViewportUsingCustomOrVtkPipeline(viewport: IViewport): EventTypes.ImageRenderedEventDetail;
+    private renderViewportUsingCustomOrVtkPipeline;
+    private _renderViewportWithContext;
     protected _renderViewportFromVtkCanvasToOnscreenCanvas(viewport: IViewport, offScreenCanvas: HTMLCanvasElement): EventTypes.ImageRenderedEventDetail;
-    private _resizeOffScreenCanvasForSingleViewport;
+    private _resizeOffScreenCanvasForViewport;
+    private _copyToOnscreenCanvas;
     private _resize;
     private getWidgetRenderers;
+    getRenderer(viewportId: string): vtkRenderer | undefined;
+    disableElement(viewportId: string): void;
+    destroy(): void;
+    getOffscreenMultiRenderWindow(viewportId: string): VtkOffscreenMultiRenderWindow;
 }
-export default SequentialRenderingEngine;
+export default ContextPoolRenderingEngine;

package/dist/esm/RenderingEngine/{SequentialRenderingEngine.js → ContextPoolRenderingEngine.js}

@@ -1,41 +1,46 @@
 import BaseRenderingEngine, { VIEWPORT_MIN_SIZE } from './BaseRenderingEngine';
+import WebGLContextPool from './WebGLContextPool';
+import { getConfiguration } from '../init';
 import Events from '../enums/Events';
 import eventTarget from '../eventTarget';
 import triggerEvent from '../utilities/triggerEvent';
 import ViewportType from '../enums/ViewportType';
 import VolumeViewport from './VolumeViewport';
 import StackViewport from './StackViewport';
+import VolumeViewport3D from './VolumeViewport3D';
 import viewportTypeUsesCustomRenderingPipeline from './helpers/viewportTypeUsesCustomRenderingPipeline';
 import getOrCreateCanvas from './helpers/getOrCreateCanvas';
-import VolumeViewport3D from './VolumeViewport3D';
-class SequentialRenderingEngine extends BaseRenderingEngine {
-    constructor() {
-        super(...arguments);
+class ContextPoolRenderingEngine extends BaseRenderingEngine {
+    constructor(id) {
+        super(id);
         this._renderFlaggedViewports = () => {
             this._throwIfDestroyed();
             const viewports = this._getViewportsAsArray();
-            const eventDetailArray = [];
-            for (let i = 0; i < viewports.length; i++) {
-                const viewport = viewports[i];
-                if (this._needsRender.has(viewport.id)) {
-                    const eventDetail = this.renderViewportUsingCustomOrVtkPipeline(viewport);
-                    eventDetailArray.push(eventDetail);
-                    viewport.setRendered();
-                    this._needsRender.delete(viewport.id);
-                    if (this._needsRender.size === 0) {
-                        break;
-                    }
-                }
+            const viewportsToRender = viewports.filter((vp) => this._needsRender.has(vp.id));
+            if (viewportsToRender.length === 0) {
+                this._animationFrameSet = false;
+                this._animationFrameHandle = null;
+                return;
             }
+            const eventDetails = viewportsToRender.map((viewport) => {
+                const eventDetail = this.renderViewportUsingCustomOrVtkPipeline(viewport);
+                viewport.setRendered();
+                this._needsRender.delete(viewport.id);
+                return eventDetail;
+            });
             this._animationFrameSet = false;
             this._animationFrameHandle = null;
-            eventDetailArray.forEach((eventDetail) => {
-                if (!eventDetail?.element) {
-                    return;
+            eventDetails.forEach((eventDetail) => {
+                if (eventDetail?.element) {
+                    triggerEvent(eventDetail.element, Events.IMAGE_RENDERED, eventDetail);
                 }
-                triggerEvent(eventDetail.element, Events.IMAGE_RENDERED, eventDetail);
             });
         };
+        const { rendering } = getConfiguration();
+        const { webGlContextCount } = rendering;
+        if (!this.useCPURendering) {
+            this.contextPool = new WebGLContextPool(webGlContextCount);
+        }
     }
     enableVTKjsDrivenViewport(viewportInputEntry) {
         const viewports = this._getViewportsAsArray();
@@ -49,7 +54,15 @@ class SequentialRenderingEngine extends BaseRenderingEngine {
     addVtkjsDrivenViewport(viewportInputEntry) {
         const { element, canvas, viewportId, type, defaultOptions } = viewportInputEntry;
         element.tabIndex = -1;
-        this.offscreenMultiRenderWindow.addRenderer({
+        let contextIndex = 0;
+        if (type === ViewportType.STACK) {
+            const contexts = this.contextPool.getAllContexts();
+            contextIndex = this._viewports.size % contexts.length;
+        }
+        this.contextPool.assignViewportToContext(viewportId, contextIndex);
+        const contextData = this.contextPool.getContextByIndex(contextIndex);
+        const { context: offscreenMultiRenderWindow } = contextData;
+        offscreenMultiRenderWindow.addRenderer({
             viewport: [0, 0, 1, 1],
             id: viewportId,
             background: defaultOptions.background
@@ -149,43 +162,69 @@ class SequentialRenderingEngine extends BaseRenderingEngine {
         }
     }
     renderViewportUsingCustomOrVtkPipeline(viewport) {
-        let eventDetail;
+        if (viewportTypeUsesCustomRenderingPipeline(viewport.type)) {
+            const eventDetail = viewport.customRenderViewportToCanvas();
+            return eventDetail;
+        }
+        if (this.useCPURendering) {
+            throw new Error('GPU not available, and using a viewport with no custom render pipeline.');
+        }
+        const assignedContextIndex = this.contextPool.getContextIndexForViewport(viewport.id);
+        const contextData = this.contextPool.getContextByIndex(assignedContextIndex);
+        const { context, container } = contextData;
+        const eventDetail = this._renderViewportWithContext(viewport, context, container);
+        return eventDetail;
+    }
+    _renderViewportWithContext(viewport, offscreenMultiRenderWindow, offScreenCanvasContainer) {
         if (viewport.sWidth < VIEWPORT_MIN_SIZE ||
             viewport.sHeight < VIEWPORT_MIN_SIZE) {
             console.warn('Viewport is too small', viewport.sWidth, viewport.sHeight);
             return;
         }
-        if (viewportTypeUsesCustomRenderingPipeline(viewport.type) === true) {
-            eventDetail =
-                viewport.customRenderViewportToCanvas();
+        if (viewportTypeUsesCustomRenderingPipeline(viewport.type)) {
+            return viewport.customRenderViewportToCanvas();
         }
-        else {
-            if (this.useCPURendering) {
-                throw new Error('GPU not available, and using a viewport with no custom render pipeline.');
-            }
-            const { offscreenMultiRenderWindow } = this;
-            const renderWindow = offscreenMultiRenderWindow.getRenderWindow();
-            this._resizeOffScreenCanvasForSingleViewport(viewport.canvas);
-            const renderer = offscreenMultiRenderWindow.getRenderer(viewport.id);
-            renderer.setViewport([0, 0, 1, 1]);
-            const allRenderers = offscreenMultiRenderWindow.getRenderers();
-            allRenderers.forEach(({ renderer: r, id }) => {
-                r.setDraw(id === viewport.id);
-            });
-            const widgetRenderers = this.getWidgetRenderers();
-            widgetRenderers.forEach((viewportId, renderer) => {
-                renderer.setDraw(viewportId === viewport.id);
+        if (this.useCPURendering) {
+            throw new Error('GPU not available, and using a viewport with no custom render pipeline.');
+        }
+        if (!offscreenMultiRenderWindow.getRenderer(viewport.id)) {
+            offscreenMultiRenderWindow.addRenderer({
+                viewport: [0, 0, 1, 1],
+                id: viewport.id,
+                background: viewport.defaultOptions?.background || [0, 0, 0],
             });
-            renderWindow.render();
-            allRenderers.forEach(({ renderer: r }) => r.setDraw(false));
-            const openGLRenderWindow = offscreenMultiRenderWindow.getOpenGLRenderWindow();
-            const context = openGLRenderWindow.get3DContext();
-            const offScreenCanvas = context.canvas;
-            eventDetail = this._renderViewportFromVtkCanvasToOnscreenCanvas(viewport, offScreenCanvas);
         }
+        const renderWindow = offscreenMultiRenderWindow.getRenderWindow();
+        this._resizeOffScreenCanvasForViewport(viewport.canvas, offScreenCanvasContainer, offscreenMultiRenderWindow);
+        const renderer = offscreenMultiRenderWindow.getRenderer(viewport.id);
+        renderer.setViewport(0, 0, 1, 1);
+        const allRenderers = offscreenMultiRenderWindow.getRenderers();
+        allRenderers.forEach(({ renderer: r, id }) => {
+            r.setDraw(id === viewport.id);
+        });
+        const widgetRenderers = this.getWidgetRenderers();
+        widgetRenderers.forEach((viewportId, renderer) => {
+            renderer.setDraw(viewportId === viewport.id);
+        });
+        renderWindow.render();
+        allRenderers.forEach(({ renderer: r }) => r.setDraw(false));
+        const openGLRenderWindow = offscreenMultiRenderWindow.getOpenGLRenderWindow();
+        const context = openGLRenderWindow.get3DContext();
+        const offScreenCanvas = context.canvas;
+        const eventDetail = this._copyToOnscreenCanvas(viewport, offScreenCanvas);
         return eventDetail;
     }
     _renderViewportFromVtkCanvasToOnscreenCanvas(viewport, offScreenCanvas) {
+        return this._copyToOnscreenCanvas(viewport, offScreenCanvas);
+    }
+    _resizeOffScreenCanvasForViewport(viewportCanvas, offScreenCanvasContainer, offscreenMultiRenderWindow) {
+        const offScreenCanvasWidth = viewportCanvas.width;
+        const offScreenCanvasHeight = viewportCanvas.height;
+        offScreenCanvasContainer.width = offScreenCanvasWidth;
+        offScreenCanvasContainer.height = offScreenCanvasHeight;
+        offscreenMultiRenderWindow.resize();
+    }
+    _copyToOnscreenCanvas(viewport, offScreenCanvas) {
         const { element, canvas, id: viewportId, renderingEngineId, suppressEvents, } = viewport;
         const { width: dWidth, height: dHeight } = canvas;
         const onScreenContext = canvas.getContext('2d');
@@ -198,23 +237,17 @@ class SequentialRenderingEngine extends BaseRenderingEngine {
             viewportStatus: viewport.viewportStatus,
         };
     }
-    _resizeOffScreenCanvasForSingleViewport(currentViewport) {
-        const { offScreenCanvasContainer, offscreenMultiRenderWindow } = this;
-        const offScreenCanvasWidth = currentViewport.width;
-        const offScreenCanvasHeight = currentViewport.height;
-        offScreenCanvasContainer.width = offScreenCanvasWidth;
-        offScreenCanvasContainer.height = offScreenCanvasHeight;
-        offscreenMultiRenderWindow.resize();
-        return { offScreenCanvasWidth, offScreenCanvasHeight };
-    }
     _resize(viewportsDrivenByVtkJs) {
         for (const viewport of viewportsDrivenByVtkJs) {
             viewport.sx = 0;
             viewport.sy = 0;
             viewport.sWidth = viewport.canvas.width;
             viewport.sHeight = viewport.canvas.height;
-            const renderer = this.offscreenMultiRenderWindow.getRenderer(viewport.id);
-            renderer.setViewport([0, 0, 1, 1]);
+            const contextIndex = this.contextPool.getContextIndexForViewport(viewport.id);
+            const contextData = this.contextPool.getContextByIndex(contextIndex);
+            const { context: offscreenMultiRenderWindow } = contextData;
+            const renderer = offscreenMultiRenderWindow.getRenderer(viewport.id);
+            renderer.setViewport(0, 0, 1, 1);
         }
     }
     getWidgetRenderers() {
@@ -231,5 +264,43 @@ class SequentialRenderingEngine extends BaseRenderingEngine {
         });
         return widgetRenderers;
     }
+    getRenderer(viewportId) {
+        const contextIndex = this.contextPool?.getContextIndexForViewport(viewportId);
+        const contextData = this.contextPool.getContextByIndex(contextIndex);
+        const { context: offscreenMultiRenderWindow } = contextData;
+        return offscreenMultiRenderWindow.getRenderer(viewportId);
+    }
+    disableElement(viewportId) {
+        const viewport = this.getViewport(viewportId);
+        if (!viewport) {
+            return;
+        }
+        super.disableElement(viewportId);
+        if (!viewportTypeUsesCustomRenderingPipeline(viewport.type) &&
+            !this.useCPURendering) {
+            const contextIndex = this.contextPool.getContextIndexForViewport(viewportId);
+            if (contextIndex !== undefined) {
+                const contextData = this.contextPool.getContextByIndex(contextIndex);
+                if (contextData) {
+                    const { context: offscreenMultiRenderWindow } = contextData;
+                    offscreenMultiRenderWindow.removeRenderer(viewportId);
+                }
+            }
+        }
+    }
+    destroy() {
+        if (this.contextPool) {
+            this.contextPool.destroy();
+        }
+        super.destroy();
+    }
+    getOffscreenMultiRenderWindow(viewportId) {
+        if (this.useCPURendering) {
+            throw new Error('Offscreen multi render window is not available when using CPU rendering.');
+        }
+        const contextIndex = this.contextPool.getContextIndexForViewport(viewportId);
+        const contextData = this.contextPool.getContextByIndex(contextIndex);
+        return contextData.context;
+    }
 }
-export default SequentialRenderingEngine;
+export default ContextPoolRenderingEngine;

package/dist/esm/RenderingEngine/RenderingEngine.d.ts

@@ -1,7 +1,7 @@
-import type { IStackViewport, IVolumeViewport, IViewport, PublicViewportInput } from '../types';
+import type { IStackViewport, IVolumeViewport, IViewport, PublicViewportInput, VtkOffscreenMultiRenderWindow } from '../types';
 declare class RenderingEngine {
     hasBeenDestroyed: boolean;
-    offscreenMultiRenderWindow: any;
+    offscreenMultiRenderWindow: VtkOffscreenMultiRenderWindow;
     private _implementation?;
     constructor(id?: string);
     get id(): string;
@@ -14,10 +14,12 @@ declare class RenderingEngine {
     getStackViewport(viewportId: string): IStackViewport;
     getStackViewports(): IStackViewport[];
     getVolumeViewports(): IVolumeViewport[];
+    getRenderer(viewportId: string): import("@kitware/vtk.js/Rendering/Core/Renderer").vtkRenderer;
     fillCanvasWithBackgroundColor(canvas: HTMLCanvasElement, backgroundColor: [number, number, number]): void;
     render(): void;
     renderViewports(viewportIds: string[]): void;
     renderViewport(viewportId: string): void;
     destroy(): void;
+    getOffscreenMultiRenderWindow(viewportId?: string): VtkOffscreenMultiRenderWindow;
 }
 export default RenderingEngine;

package/dist/esm/RenderingEngine/RenderingEngine.js

@@ -1,21 +1,21 @@
 import { getConfiguration } from '../init';
-import StandardRenderingEngine from './StandardRenderingEngine';
-import SequentialRenderingEngine from './SequentialRenderingEngine';
+import TiledRenderingEngine from './TiledRenderingEngine';
+import ContextPoolRenderingEngine from './ContextPoolRenderingEngine';
 import { RenderingEngineModeEnum } from '../enums';
 class RenderingEngine {
     constructor(id) {
         const config = getConfiguration();
         const renderingEngineMode = config?.rendering?.renderingEngineMode;
         switch (renderingEngineMode) {
-            case RenderingEngineModeEnum.Standard:
-                this._implementation = new StandardRenderingEngine(id);
+            case RenderingEngineModeEnum.Tiled:
+                this._implementation = new TiledRenderingEngine(id);
                 break;
-            case RenderingEngineModeEnum.Next:
-                this._implementation = new SequentialRenderingEngine(id);
+            case RenderingEngineModeEnum.ContextPool:
+                this._implementation = new ContextPoolRenderingEngine(id);
                 break;
             default:
                 console.warn(`RenderingEngine: Unknown rendering engine mode "${renderingEngineMode}". Defaulting to Next rendering engine.`);
-                this._implementation = new SequentialRenderingEngine(id);
+                this._implementation = new ContextPoolRenderingEngine(id);
                 break;
         }
     }
@@ -49,6 +49,9 @@ class RenderingEngine {
     getVolumeViewports() {
         return this._implementation.getVolumeViewports();
     }
+    getRenderer(viewportId) {
+        return this._implementation.getRenderer(viewportId);
+    }
     fillCanvasWithBackgroundColor(canvas, backgroundColor) {
         return this._implementation.fillCanvasWithBackgroundColor(canvas, backgroundColor);
     }
@@ -64,5 +67,8 @@ class RenderingEngine {
     destroy() {
         return this._implementation.destroy();
     }
+    getOffscreenMultiRenderWindow(viewportId) {
+        return this._implementation.getOffscreenMultiRenderWindow(viewportId);
+    }
 }
 export default RenderingEngine;

package/dist/esm/RenderingEngine/StackViewport.d.ts

@@ -65,7 +65,6 @@ declare class StackViewport extends Viewport {
     }) => boolean;
     canvasToWorld: (canvasPos: Point2) => Point3;
     worldToCanvas: (worldPos: Point3) => Point2;
-    getRenderer: () => vtkRenderer;
     getDefaultActor: () => ActorEntry;
     getActors: () => ActorEntry[];
     getActor: (actorUID: string) => ActorEntry;
@@ -181,10 +180,12 @@ declare class StackViewport extends Viewport {
     jumpToWorld(worldPos: Point3): boolean;
     private canvasToWorldCPU;
     private worldToCanvasCPU;
-    private canvasToWorldGPUSequential;
-    private canvasToWorldGPU;
-    private worldToCanvasGPUSequential;
-    private worldToCanvasGPU;
+    private canvasToWorldGPUContextPool;
+    private canvasToWorldGPUTiled;
+    private worldToCanvasGPUContextPool;
+    private worldToCanvasGPUTiled;
+    getRendererContextPool(): vtkRenderer;
+    getRendererTiled(): vtkRenderer;
     private _getVOIRangeForCurrentImage;
     private _getValidVOILUTFunction;
     getCurrentImageIdIndex: () => number;

package/dist/esm/RenderingEngine/StackViewport.js

@@ -43,7 +43,7 @@ import uuidv4 from '../utilities/uuidv4';
 import getSpacingInNormalDirection from '../utilities/getSpacingInNormalDirection';
 import getClosestImageId from '../utilities/getClosestImageId';
 import { adjustInitialViewUp } from '../utilities/adjustInitialViewUp';
-import { isSequentialRenderingEngine } from './helpers/isSequentialRenderingEngine';
+import { isContextPoolRenderingEngine } from './helpers/isContextPoolRenderingEngine';
 const EPSILON = 1;
 const log = coreLog.getLogger('RenderingEngine', 'StackViewport');
 class StackViewport extends Viewport {
@@ -196,7 +196,7 @@ class StackViewport extends Viewport {
             const canvasPoint = pixelToCanvas(this._cpuFallbackEnabledElement, indexPoint);
             return canvasPoint;
         };
-        this.canvasToWorldGPUSequential = (canvasPos) => {
+        this.canvasToWorldGPUContextPool = (canvasPos) => {
             const renderer = this.getRenderer();
             const vtkCamera = this.getVtkActiveCamera();
             const crange = vtkCamera.getClippingRange();
@@ -220,7 +220,7 @@ class StackViewport extends Viewport {
             vtkCamera.setClippingRange(crange[0], crange[1]);
             return [worldCoord[0], worldCoord[1], worldCoord[2]];
         };
-        this.canvasToWorldGPU = (canvasPos) => {
+        this.canvasToWorldGPUTiled = (canvasPos) => {
             const renderer = this.getRenderer();
             const vtkCamera = this.getVtkActiveCamera();
             const crange = vtkCamera.getClippingRange();
@@ -243,7 +243,7 @@ class StackViewport extends Viewport {
             vtkCamera.setClippingRange(crange[0], crange[1]);
             return [worldCoord[0], worldCoord[1], worldCoord[2]];
         };
-        this.worldToCanvasGPUSequential = (worldPos) => {
+        this.worldToCanvasGPUContextPool = (worldPos) => {
             const renderer = this.getRenderer();
             const vtkCamera = this.getVtkActiveCamera();
             const crange = vtkCamera.getClippingRange();
@@ -264,7 +264,7 @@ class StackViewport extends Viewport {
             ];
             return canvasCoordWithDPR;
         };
-        this.worldToCanvasGPU = (worldPos) => {
+        this.worldToCanvasGPUTiled = (worldPos) => {
             const renderer = this.getRenderer();
             const vtkCamera = this.getVtkActiveCamera();
             const crange = vtkCamera.getClippingRange();
@@ -391,20 +391,23 @@ class StackViewport extends Viewport {
             canvasToWorld: {
                 cpu: this.canvasToWorldCPU,
                 gpu: {
-                    sequential: this.canvasToWorldGPUSequential,
-                    default: this.canvasToWorldGPU,
+                    tiled: this.canvasToWorldGPUTiled,
+                    contextPool: this.canvasToWorldGPUContextPool,
                 },
             },
             worldToCanvas: {
                 cpu: this.worldToCanvasCPU,
                 gpu: {
-                    sequential: this.worldToCanvasGPUSequential,
-                    default: this.worldToCanvasGPU,
+                    tiled: this.worldToCanvasGPUTiled,
+                    contextPool: this.worldToCanvasGPUContextPool,
                 },
             },
             getRenderer: {
                 cpu: () => this.getCPUFallbackError('getRenderer'),
-                gpu: super.getRenderer,
+                gpu: {
+                    tiled: this.getRendererTiled,
+                    contextPool: this.getRendererContextPool,
+                },
             },
             getDefaultActor: {
                 cpu: () => this.getCPUFallbackError('getDefaultActor'),
@@ -459,8 +462,7 @@ class StackViewport extends Viewport {
         return getShouldUseCPURendering();
     }
     _configureRenderingPipeline(value) {
-        const renderingEngine = this.getRenderingEngine();
-        const isSequential = isSequentialRenderingEngine(renderingEngine);
+        const isContextPool = isContextPoolRenderingEngine();
         this.useCPURendering = value ?? getShouldUseCPURendering();
         for (const key in this.renderingPipelineFunctions) {
             if (Object.prototype.hasOwnProperty.call(this.renderingPipelineFunctions, key)) {
@@ -470,11 +472,11 @@ class StackViewport extends Viewport {
                 }
                 else {
                     if (typeof functions.gpu === 'object' &&
-                        functions.gpu.sequential &&
-                        functions.gpu.default) {
-                        this[key] = isSequential
-                            ? functions.gpu.sequential
-                            : functions.gpu.default;
+                        functions.gpu.tiled &&
+                        functions.gpu.contextPool) {
+                        this[key] = isContextPool
+                            ? functions.gpu.contextPool
+                            : functions.gpu.tiled;
                     }
                     else {
                         this[key] = functions.gpu;
@@ -1731,6 +1733,17 @@ class StackViewport extends Viewport {
         this.render();
         return true;
     }
+    getRendererContextPool() {
+        const renderingEngine = this.getRenderingEngine();
+        return renderingEngine.getRenderer(this.id);
+    }
+    getRendererTiled() {
+        const renderingEngine = this.getRenderingEngine();
+        if (!renderingEngine || renderingEngine.hasBeenDestroyed) {
+            throw new Error('Rendering engine has been destroyed');
+        }
+        return renderingEngine.offscreenMultiRenderWindow?.getRenderer(this.id);
+    }
     _getVOIRangeForCurrentImage() {
         const { windowCenter, windowWidth, voiLUTFunction } = this.csImage;
         return this._getVOIRangeFromWindowLevel(windowWidth, windowCenter, voiLUTFunction);

package/dist/esm/RenderingEngine/{StandardRenderingEngine.d.ts → TiledRenderingEngine.d.ts}

@@ -3,7 +3,8 @@ import type IStackViewport from '../types/IStackViewport';
 import type IVolumeViewport from '../types/IVolumeViewport';
 import type * as EventTypes from '../types/EventTypes';
 import type { InternalViewportInput, NormalizedViewportInput, IViewport } from '../types/IViewport';
-declare class StandardRenderingEngine extends BaseRenderingEngine {
+declare class TiledRenderingEngine extends BaseRenderingEngine {
+    constructor(id?: string);
     protected enableVTKjsDrivenViewport(viewportInputEntry: NormalizedViewportInput): void;
     protected addVtkjsDrivenViewport(viewportInputEntry: InternalViewportInput, offscreenCanvasProperties?: {
         offScreenCanvasWidth: number;
@@ -20,4 +21,4 @@ declare class StandardRenderingEngine extends BaseRenderingEngine {
     private _resize;
     private _getViewportCoordsOnOffScreenCanvas;
 }
-export default StandardRenderingEngine;
+export default TiledRenderingEngine;

package/dist/esm/RenderingEngine/{StandardRenderingEngine.js → TiledRenderingEngine.js}

@@ -8,9 +8,10 @@ import StackViewport from './StackViewport';
 import viewportTypeUsesCustomRenderingPipeline from './helpers/viewportTypeUsesCustomRenderingPipeline';
 import getOrCreateCanvas from './helpers/getOrCreateCanvas';
 import VolumeViewport3D from './VolumeViewport3D';
-class StandardRenderingEngine extends BaseRenderingEngine {
-    constructor() {
-        super(...arguments);
+import { vtkOffscreenMultiRenderWindow } from './vtkClasses';
+class TiledRenderingEngine extends BaseRenderingEngine {
+    constructor(id) {
+        super(id);
         this._renderFlaggedViewports = () => {
             this._throwIfDestroyed();
             if (!this.useCPURendering) {
@@ -39,6 +40,12 @@ class StandardRenderingEngine extends BaseRenderingEngine {
                 triggerEvent(eventDetail.element, Events.IMAGE_RENDERED, eventDetail);
             });
         };
+        if (!this.useCPURendering) {
+            this.offscreenMultiRenderWindow =
+                vtkOffscreenMultiRenderWindow.newInstance();
+            this.offScreenCanvasContainer = document.createElement('div');
+            this.offscreenMultiRenderWindow.setContainer(this.offScreenCanvasContainer);
+        }
     }
     enableVTKjsDrivenViewport(viewportInputEntry) {
         const viewports = this._getViewportsAsArray();
@@ -252,12 +259,7 @@ class StandardRenderingEngine extends BaseRenderingEngine {
             viewport.sWidth = sWidth;
             viewport.sHeight = sHeight;
             const renderer = this.offscreenMultiRenderWindow.getRenderer(viewport.id);
-            renderer.setViewport([
-                sxStartDisplayCoords,
-                syStartDisplayCoords,
-                sxEndDisplayCoords,
-                syEndDisplayCoords,
-            ]);
+            renderer.setViewport(sxStartDisplayCoords, syStartDisplayCoords, sxEndDisplayCoords, syEndDisplayCoords);
         }
         return _xOffset;
     }
@@ -282,4 +284,4 @@ class StandardRenderingEngine extends BaseRenderingEngine {
         };
     }
 }
-export default StandardRenderingEngine;
+export default TiledRenderingEngine;

package/dist/esm/RenderingEngine/WebGLContextPool.d.ts

@@ -0,0 +1,17 @@
+import type { VtkOffscreenMultiRenderWindow } from '../types';
+declare class WebGLContextPool {
+    private contexts;
+    private offScreenCanvasContainers;
+    private viewportToContext;
+    constructor(count: number);
+    getContextByIndex(index: number): {
+        context: VtkOffscreenMultiRenderWindow;
+        container: HTMLDivElement;
+    } | null;
+    assignViewportToContext(viewportId: string, contextIndex: number): void;
+    getContextIndexForViewport(viewportId: string): number | undefined;
+    getAllContexts(): VtkOffscreenMultiRenderWindow[];
+    getContextCount(): number;
+    destroy(): void;
+}
+export default WebGLContextPool;

package/dist/esm/RenderingEngine/WebGLContextPool.js

@@ -0,0 +1,45 @@
+import { vtkOffscreenMultiRenderWindow } from './vtkClasses';
+class WebGLContextPool {
+    constructor(count) {
+        this.contexts = [];
+        this.offScreenCanvasContainers = [];
+        this.viewportToContext = new Map();
+        for (let i = 0; i < count; i++) {
+            const offscreenMultiRenderWindow = vtkOffscreenMultiRenderWindow.newInstance();
+            const container = document.createElement('div');
+            offscreenMultiRenderWindow.setContainer(container);
+            this.contexts.push(offscreenMultiRenderWindow);
+            this.offScreenCanvasContainers.push(container);
+        }
+    }
+    getContextByIndex(index) {
+        if (index >= 0 && index < this.contexts.length) {
+            return {
+                context: this.contexts[index],
+                container: this.offScreenCanvasContainers[index],
+            };
+        }
+        return null;
+    }
+    assignViewportToContext(viewportId, contextIndex) {
+        this.viewportToContext.set(viewportId, contextIndex);
+    }
+    getContextIndexForViewport(viewportId) {
+        return this.viewportToContext.get(viewportId);
+    }
+    getAllContexts() {
+        return this.contexts;
+    }
+    getContextCount() {
+        return this.contexts.length;
+    }
+    destroy() {
+        this.contexts.forEach((context) => {
+            context.delete();
+        });
+        this.contexts = [];
+        this.offScreenCanvasContainers = [];
+        this.viewportToContext.clear();
+    }
+}
+export default WebGLContextPool;

package/dist/esm/RenderingEngine/helpers/isContextPoolRenderingEngine.d.ts

@@ -0,0 +1 @@
+export declare function isContextPoolRenderingEngine(): boolean;

package/dist/esm/RenderingEngine/helpers/isContextPoolRenderingEngine.js

@@ -0,0 +1,7 @@
+import { getConfiguration } from '../../init';
+import { RenderingEngineModeEnum } from '../../enums';
+export function isContextPoolRenderingEngine() {
+    const config = getConfiguration();
+    return (config?.rendering?.renderingEngineMode ===
+        RenderingEngineModeEnum.ContextPool);
+}

package/dist/esm/RenderingEngine/index.d.ts

@@ -1,11 +1,11 @@
 import RenderingEngine from './RenderingEngine';
 import BaseRenderingEngine from './BaseRenderingEngine';
-import StandardRenderingEngine from './StandardRenderingEngine';
-import SequentialRenderingEngine from './SequentialRenderingEngine';
+import TiledRenderingEngine from './TiledRenderingEngine';
+import ContextPoolRenderingEngine from './ContextPoolRenderingEngine';
 import getRenderingEngine from './getRenderingEngine';
 import VolumeViewport from './VolumeViewport';
 import StackViewport from './StackViewport';
 import VolumeViewport3D from './VolumeViewport3D';
 export * from './helpers';
-export { getRenderingEngine, RenderingEngine, BaseRenderingEngine, StandardRenderingEngine, SequentialRenderingEngine, VolumeViewport, VolumeViewport3D, StackViewport, };
+export { getRenderingEngine, RenderingEngine, BaseRenderingEngine, TiledRenderingEngine, ContextPoolRenderingEngine, VolumeViewport, VolumeViewport3D, StackViewport, };
 export default RenderingEngine;

package/dist/esm/RenderingEngine/index.js

@@ -1,11 +1,11 @@
 import RenderingEngine from './RenderingEngine';
 import BaseRenderingEngine from './BaseRenderingEngine';
-import StandardRenderingEngine from './StandardRenderingEngine';
-import SequentialRenderingEngine from './SequentialRenderingEngine';
+import TiledRenderingEngine from './TiledRenderingEngine';
+import ContextPoolRenderingEngine from './ContextPoolRenderingEngine';
 import getRenderingEngine from './getRenderingEngine';
 import VolumeViewport from './VolumeViewport';
 import StackViewport from './StackViewport';
 import VolumeViewport3D from './VolumeViewport3D';
 export * from './helpers';
-export { getRenderingEngine, RenderingEngine, BaseRenderingEngine, StandardRenderingEngine, SequentialRenderingEngine, VolumeViewport, VolumeViewport3D, StackViewport, };
+export { getRenderingEngine, RenderingEngine, BaseRenderingEngine, TiledRenderingEngine, ContextPoolRenderingEngine, VolumeViewport, VolumeViewport3D, StackViewport, };
 export default RenderingEngine;

package/dist/esm/enums/RenderingEngineModeEnum.d.ts

@@ -1,5 +1,5 @@
 declare enum RenderingEngineModeEnum {
-    Standard = "standard",
-    Next = "next"
+    Tiled = "tiled",
+    ContextPool = "contextPool"
 }
 export default RenderingEngineModeEnum;

package/dist/esm/enums/RenderingEngineModeEnum.js

@@ -1,6 +1,6 @@
 var RenderingEngineModeEnum;
 (function (RenderingEngineModeEnum) {
-    RenderingEngineModeEnum["Standard"] = "standard";
-    RenderingEngineModeEnum["Next"] = "next";
+    RenderingEngineModeEnum["Tiled"] = "tiled";
+    RenderingEngineModeEnum["ContextPool"] = "contextPool";
 })(RenderingEngineModeEnum || (RenderingEngineModeEnum = {}));
 export default RenderingEngineModeEnum;

package/dist/esm/index.d.ts

@@ -1,7 +1,7 @@
 import * as Enums from './enums';
 import * as CONSTANTS from './constants';
 import { Events } from './enums';
-import RenderingEngine, { BaseRenderingEngine, StandardRenderingEngine, SequentialRenderingEngine } from './RenderingEngine';
+import RenderingEngine, { BaseRenderingEngine, TiledRenderingEngine, ContextPoolRenderingEngine } from './RenderingEngine';
 import createVolumeActor from './RenderingEngine/helpers/createVolumeActor';
 import createVolumeMapper, { convertMapperToNotSharedMapper } from './RenderingEngine/helpers/createVolumeMapper';
 export * from './RenderingEngine/helpers/getOrCreateCanvas';
@@ -37,4 +37,4 @@ import { cornerstoneStreamingDynamicImageVolumeLoader } from './loaders/cornerst
 import { cornerstoneMeshLoader } from './loaders/cornerstoneMeshLoader';
 import { setVolumesForViewports, addVolumesToViewports, addImageSlicesToViewports } from './RenderingEngine/helpers';
 export type { Types, IRetrieveConfiguration, RetrieveOptions, RetrieveStage, ImageLoadListener, IImagesLoader, };
-export { init, isCornerstoneInitialized, peerImport, resetInitialization, getConfiguration, setConfiguration, getWebWorkerManager, canRenderFloatTextures, Enums, CONSTANTS, Events as EVENTS, Settings, BaseVolumeViewport, VolumeViewport, VolumeViewport3D, Viewport, StackViewport, VideoViewport, WSIViewport, RenderingEngine, BaseRenderingEngine, StandardRenderingEngine, SequentialRenderingEngine, ImageVolume, Surface, getRenderingEngine, getRenderingEngines, getEnabledElement, getEnabledElementByIds, getEnabledElements, getEnabledElementByViewportId, createVolumeActor, createVolumeMapper, cache, eventTarget, triggerEvent, imageLoader, registerImageLoader, volumeLoader, metaData, utilities, setVolumesForViewports, addVolumesToViewports, addImageSlicesToViewports, imageLoadPoolManager as requestPoolManager, imageRetrievalPoolManager, imageLoadPoolManager, getShouldUseCPURendering, setUseCPURendering, setPreferSizeOverAccuracy, resetUseCPURendering, geometryLoader, cornerstoneMeshLoader, ProgressiveRetrieveImages, cornerstoneStreamingImageVolumeLoader, cornerstoneStreamingDynamicImageVolumeLoader, StreamingDynamicImageVolume, StreamingImageVolume, convertMapperToNotSharedMapper, version, };
+export { init, isCornerstoneInitialized, peerImport, resetInitialization, getConfiguration, setConfiguration, getWebWorkerManager, canRenderFloatTextures, Enums, CONSTANTS, Events as EVENTS, Settings, BaseVolumeViewport, VolumeViewport, VolumeViewport3D, Viewport, StackViewport, VideoViewport, WSIViewport, RenderingEngine, BaseRenderingEngine, TiledRenderingEngine, ContextPoolRenderingEngine, ImageVolume, Surface, getRenderingEngine, getRenderingEngines, getEnabledElement, getEnabledElementByIds, getEnabledElements, getEnabledElementByViewportId, createVolumeActor, createVolumeMapper, cache, eventTarget, triggerEvent, imageLoader, registerImageLoader, volumeLoader, metaData, utilities, setVolumesForViewports, addVolumesToViewports, addImageSlicesToViewports, imageLoadPoolManager as requestPoolManager, imageRetrievalPoolManager, imageLoadPoolManager, getShouldUseCPURendering, setUseCPURendering, setPreferSizeOverAccuracy, resetUseCPURendering, geometryLoader, cornerstoneMeshLoader, ProgressiveRetrieveImages, cornerstoneStreamingImageVolumeLoader, cornerstoneStreamingDynamicImageVolumeLoader, StreamingDynamicImageVolume, StreamingImageVolume, convertMapperToNotSharedMapper, version, };

package/dist/esm/index.js

@@ -1,7 +1,7 @@
 import * as Enums from './enums';
 import * as CONSTANTS from './constants';
 import { Events } from './enums';
-import RenderingEngine, { BaseRenderingEngine, StandardRenderingEngine, SequentialRenderingEngine, } from './RenderingEngine';
+import RenderingEngine, { BaseRenderingEngine, TiledRenderingEngine, ContextPoolRenderingEngine, } from './RenderingEngine';
 import createVolumeActor from './RenderingEngine/helpers/createVolumeActor';
 import createVolumeMapper, { convertMapperToNotSharedMapper, } from './RenderingEngine/helpers/createVolumeMapper';
 export * from './RenderingEngine/helpers/getOrCreateCanvas';
@@ -34,4 +34,4 @@ import { cornerstoneStreamingImageVolumeLoader } from './loaders/cornerstoneStre
 import { cornerstoneStreamingDynamicImageVolumeLoader } from './loaders/cornerstoneStreamingDynamicImageVolumeLoader';
 import { cornerstoneMeshLoader } from './loaders/cornerstoneMeshLoader';
 import { setVolumesForViewports, addVolumesToViewports, addImageSlicesToViewports, } from './RenderingEngine/helpers';
-export { init, isCornerstoneInitialized, peerImport, resetInitialization, getConfiguration, setConfiguration, getWebWorkerManager, canRenderFloatTextures, Enums, CONSTANTS, Events as EVENTS, Settings, BaseVolumeViewport, VolumeViewport, VolumeViewport3D, Viewport, StackViewport, VideoViewport, WSIViewport, RenderingEngine, BaseRenderingEngine, StandardRenderingEngine, SequentialRenderingEngine, ImageVolume, Surface, getRenderingEngine, getRenderingEngines, getEnabledElement, getEnabledElementByIds, getEnabledElements, getEnabledElementByViewportId, createVolumeActor, createVolumeMapper, cache, eventTarget, triggerEvent, imageLoader, registerImageLoader, volumeLoader, metaData, utilities, setVolumesForViewports, addVolumesToViewports, addImageSlicesToViewports, imageLoadPoolManager as requestPoolManager, imageRetrievalPoolManager, imageLoadPoolManager, getShouldUseCPURendering, setUseCPURendering, setPreferSizeOverAccuracy, resetUseCPURendering, geometryLoader, cornerstoneMeshLoader, ProgressiveRetrieveImages, cornerstoneStreamingImageVolumeLoader, cornerstoneStreamingDynamicImageVolumeLoader, StreamingDynamicImageVolume, StreamingImageVolume, convertMapperToNotSharedMapper, version, };
+export { init, isCornerstoneInitialized, peerImport, resetInitialization, getConfiguration, setConfiguration, getWebWorkerManager, canRenderFloatTextures, Enums, CONSTANTS, Events as EVENTS, Settings, BaseVolumeViewport, VolumeViewport, VolumeViewport3D, Viewport, StackViewport, VideoViewport, WSIViewport, RenderingEngine, BaseRenderingEngine, TiledRenderingEngine, ContextPoolRenderingEngine, ImageVolume, Surface, getRenderingEngine, getRenderingEngines, getEnabledElement, getEnabledElementByIds, getEnabledElements, getEnabledElementByViewportId, createVolumeActor, createVolumeMapper, cache, eventTarget, triggerEvent, imageLoader, registerImageLoader, volumeLoader, metaData, utilities, setVolumesForViewports, addVolumesToViewports, addImageSlicesToViewports, imageLoadPoolManager as requestPoolManager, imageRetrievalPoolManager, imageLoadPoolManager, getShouldUseCPURendering, setUseCPURendering, setPreferSizeOverAccuracy, resetUseCPURendering, geometryLoader, cornerstoneMeshLoader, ProgressiveRetrieveImages, cornerstoneStreamingImageVolumeLoader, cornerstoneStreamingDynamicImageVolumeLoader, StreamingDynamicImageVolume, StreamingImageVolume, convertMapperToNotSharedMapper, version, };

package/dist/esm/init.js

@@ -11,7 +11,8 @@ const defaultConfig = {
         useCPURendering: false,
         preferSizeOverAccuracy: false,
         strictZSpacingForVolumeViewport: true,
-        renderingEngineMode: RenderingEngineModeEnum.Next,
+        renderingEngineMode: RenderingEngineModeEnum.ContextPool,
+        webGlContextCount: 7,
     },
     peerImport: (moduleId) => null,
 };
@@ -52,6 +53,9 @@ function init(configuration = config) {
     }
     canUseNorm16Texture = _hasNorm16TextureSupport();
     config = deepMerge(defaultConfig, configuration);
+    if (config.isMobile) {
+        config.rendering.webGlContextCount = 1;
+    }
     if (isIOS()) {
         if (configuration.rendering?.preferSizeOverAccuracy) {
             config.rendering.preferSizeOverAccuracy = true;

package/dist/esm/types/Cornerstone3DConfig.d.ts

@@ -9,6 +9,7 @@ interface Cornerstone3DConfig {
         useCPURendering?: boolean;
         strictZSpacingForVolumeViewport?: boolean;
         renderingEngineMode?: RenderingEngineModeType;
+        webGlContextCount?: number;
     };
     peerImport?: (moduleId: string) => Promise<any>;
 }

package/dist/esm/types/RenderingEngineMode.d.ts

@@ -1,2 +1,2 @@
-type RenderingEngineModeType = 'standard' | 'next';
+type RenderingEngineModeType = 'tiled' | 'contextPool';
 export type { RenderingEngineModeType };

package/dist/esm/types/VtkOffscreenMultiRenderWindow.d.ts

@@ -0,0 +1,37 @@
+import type { vtkObject } from '@kitware/vtk.js/interfaces';
+import type vtkStreamingOpenGLRenderWindow from '../RenderingEngine/vtkClasses/vtkStreamingOpenGLRenderWindow';
+import type vtkRenderer from '@kitware/vtk.js/Rendering/Core/Renderer';
+import type vtkRenderWindow from '@kitware/vtk.js/Rendering/Core/RenderWindow';
+import type vtkRenderWindowInteractor from '@kitware/vtk.js/Rendering/Core/RenderWindowInteractor';
+import '@kitware/vtk.js/Common/Core/Points';
+import '@kitware/vtk.js/Common/Core/DataArray';
+import '@kitware/vtk.js/Common/DataModel/PolyData';
+import '@kitware/vtk.js/Rendering/Core/Actor';
+import '@kitware/vtk.js/Rendering/Core/Mapper';
+type Viewport = [number, number, number, number];
+interface RendererConfig {
+    id: string;
+    viewport: Viewport;
+    background?: [number, number, number];
+}
+export interface VtkOffscreenMultiRenderWindow extends vtkObject {
+    renderWindow: vtkRenderWindow;
+    getRenderWindow: () => vtkRenderWindow;
+    openGLRenderWindow: ReturnType<typeof vtkStreamingOpenGLRenderWindow.newInstance>;
+    getOpenGLRenderWindow: () => ReturnType<typeof vtkStreamingOpenGLRenderWindow.newInstance>;
+    interactor: vtkRenderWindowInteractor;
+    getInteractor: () => vtkRenderWindowInteractor;
+    container: HTMLDivElement | null;
+    getContainer: () => HTMLDivElement | null;
+    addRenderer: (config: RendererConfig) => void;
+    removeRenderer: (id: string) => void;
+    getRenderer: (id: string) => vtkRenderer;
+    getRenderers: () => Array<{
+        id: string;
+        renderer: vtkRenderer;
+    }>;
+    resize: () => void;
+    setContainer: (el: HTMLDivElement) => void;
+    destroy: () => void;
+}
+export {};

package/dist/esm/types/VtkOffscreenMultiRenderWindow.js

@@ -0,0 +1,5 @@
+import '@kitware/vtk.js/Common/Core/Points';
+import '@kitware/vtk.js/Common/Core/DataArray';
+import '@kitware/vtk.js/Common/DataModel/PolyData';
+import '@kitware/vtk.js/Rendering/Core/Actor';
+import '@kitware/vtk.js/Rendering/Core/Mapper';

package/dist/esm/types/index.d.ts

@@ -102,4 +102,5 @@ import type ScrollOptions from './ScrollOptions';
 import type JumpToSliceOptions from './JumpToSliceOptions';
 import type GeometryLoaderFn from './GeometryLoaderFn';
 import type { RenderingEngineModeType } from './RenderingEngineMode';
-export type { Cornerstone3DConfig, ICamera, IStackViewport, IVideoViewport, IWSIViewport, IVolumeViewport, IEnabledElement, ICache, IVolume, IViewportId, IImageVolume, ImageVolumeProps, IDynamicImageVolume, IRenderingEngine, ScalingParameters, PTScaling, IPointsManager, PolyDataPointConfiguration, Scaling, IStreamingImageVolume, IImage, IImageData, IImageCalibration, CPUIImageData, CPUImageData, EventTypes, ImageLoaderFn, VolumeLoaderFn, IRegisterImageLoader, IStreamingVolumeProperties, IViewport, ViewReference, DataSetOptions as ImageSetOptions, ViewPresentation, ViewPresentationSelector, ReferenceCompatibleOptions, ViewReferenceSpecifier, StackViewportProperties, VolumeViewportProperties, ViewportProperties, PublicViewportInput, VolumeActor, Actor, ActorEntry, ImageActor, ICanvasActor, IImageLoadObject, IVolumeLoadObject, IVolumeInput, VolumeInputCallback, IStackInput, StackInputCallback, ViewportPreset, Metadata, OrientationVectors, AABB2, AABB3, Point2, Point3, PointsXYZ, Point4, Mat3, Plane, ViewportInputOptions, VideoViewportProperties, WSIViewportProperties, VOIRange, VOI, DisplayArea, FlipDirection, ICachedImage, ICachedVolume, CPUFallbackEnabledElement, CPUFallbackViewport, CPUFallbackTransform, CPUFallbackColormapData, CPUFallbackViewportDisplayedArea, CPUFallbackColormapsData, CPUFallbackColormap, TransformMatrix2D, CPUFallbackLookupTable, CPUFallbackLUT, CPUFallbackRenderingTools, CustomEventType, ActorSliceRange, ImageSliceData, IGeometry, IGeometryLoadObject, ICachedGeometry, PublicContourSetData, ContourSetData, ContourData, IContourSet, IContour, PublicSurfaceData, SurfaceData, ISurface, PublicMeshData, MeshData, IMesh, RGB, ColormapPublic, ColormapRegistration, PixelDataTypedArray, PixelDataTypedArrayString, ImagePixelModule, ImagePlaneModule, AffineMatrix, ImageLoadListener, InternalVideoCamera, VideoViewportInput, BoundsIJK, BoundsLPS, Color, ColorLUT, VolumeProps, IImageFrame, DicomDateObject, DicomTimeObject, GeneralSeriesModuleMetadata, ImagePlaneModuleMetadata, SopCommonModuleMetadata, ImagePixelModuleMetadata, PatientStudyModuleMetadata, TransferSyntaxMetadata, LocalVolumeOptions, IVoxelManager, IRLEVoxelMap, RLERun, ViewportInput, ImageLoadRequests, IBaseVolumeViewport, GeometryLoaderFn, ScrollOptions, JumpToSliceOptions, Memo, HistoryMemo, VoxelManager, RLEVoxelMap, RenderingEngineModeType, };
+import type { VtkOffscreenMultiRenderWindow } from './VtkOffscreenMultiRenderWindow';
+export type { Cornerstone3DConfig, ICamera, IStackViewport, IVideoViewport, IWSIViewport, IVolumeViewport, IEnabledElement, ICache, IVolume, IViewportId, IImageVolume, ImageVolumeProps, IDynamicImageVolume, IRenderingEngine, ScalingParameters, PTScaling, IPointsManager, PolyDataPointConfiguration, Scaling, IStreamingImageVolume, IImage, IImageData, IImageCalibration, CPUIImageData, CPUImageData, EventTypes, ImageLoaderFn, VolumeLoaderFn, IRegisterImageLoader, IStreamingVolumeProperties, IViewport, ViewReference, DataSetOptions as ImageSetOptions, ViewPresentation, ViewPresentationSelector, ReferenceCompatibleOptions, ViewReferenceSpecifier, StackViewportProperties, VolumeViewportProperties, ViewportProperties, PublicViewportInput, VolumeActor, Actor, ActorEntry, ImageActor, ICanvasActor, IImageLoadObject, IVolumeLoadObject, IVolumeInput, VolumeInputCallback, IStackInput, StackInputCallback, ViewportPreset, Metadata, OrientationVectors, AABB2, AABB3, Point2, Point3, PointsXYZ, Point4, Mat3, Plane, ViewportInputOptions, VideoViewportProperties, WSIViewportProperties, VOIRange, VOI, DisplayArea, FlipDirection, ICachedImage, ICachedVolume, CPUFallbackEnabledElement, CPUFallbackViewport, CPUFallbackTransform, CPUFallbackColormapData, CPUFallbackViewportDisplayedArea, CPUFallbackColormapsData, CPUFallbackColormap, TransformMatrix2D, CPUFallbackLookupTable, CPUFallbackLUT, CPUFallbackRenderingTools, CustomEventType, ActorSliceRange, ImageSliceData, IGeometry, IGeometryLoadObject, ICachedGeometry, PublicContourSetData, ContourSetData, ContourData, IContourSet, IContour, PublicSurfaceData, SurfaceData, ISurface, PublicMeshData, MeshData, IMesh, RGB, ColormapPublic, ColormapRegistration, PixelDataTypedArray, PixelDataTypedArrayString, ImagePixelModule, ImagePlaneModule, AffineMatrix, ImageLoadListener, InternalVideoCamera, VideoViewportInput, BoundsIJK, BoundsLPS, Color, ColorLUT, VolumeProps, IImageFrame, DicomDateObject, DicomTimeObject, GeneralSeriesModuleMetadata, ImagePlaneModuleMetadata, SopCommonModuleMetadata, ImagePixelModuleMetadata, PatientStudyModuleMetadata, TransferSyntaxMetadata, LocalVolumeOptions, IVoxelManager, IRLEVoxelMap, RLERun, ViewportInput, ImageLoadRequests, IBaseVolumeViewport, GeometryLoaderFn, ScrollOptions, JumpToSliceOptions, Memo, HistoryMemo, VoxelManager, RLEVoxelMap, RenderingEngineModeType, VtkOffscreenMultiRenderWindow, };

package/dist/esm/utilities/renderToCanvasGPU.js

@@ -2,7 +2,7 @@ import { vec3 } from 'gl-matrix';
 import getOrCreateCanvas, { EPSILON, } from '../RenderingEngine/helpers/getOrCreateCanvas';
 import { ViewportType, Events } from '../enums';
 import { getRenderingEngine } from '../RenderingEngine/getRenderingEngine';
-import RenderingEngine from '../RenderingEngine';
+import TiledRenderingEngine from '../RenderingEngine/TiledRenderingEngine';
 import isPTPrescaledWithSUV from './isPTPrescaledWithSUV';
 export default function renderToCanvasGPU(canvas, imageOrVolume, modality = undefined, renderingEngineId = '_thumbnails', viewportOptions = {
     displayArea: { imageArea: [1, 1] },
@@ -31,7 +31,7 @@ export default function renderToCanvasGPU(canvas, imageOrVolume, modality = unde
     element.setAttribute('viewport-id-for-remove', uniqueId);
     const temporaryCanvas = getOrCreateCanvas(element);
     const renderingEngine = getRenderingEngine(renderingEngineId) ||
-        new RenderingEngine(renderingEngineId);
+        new TiledRenderingEngine(renderingEngineId);
     let viewport = renderingEngine.getViewport(viewportId);
     if (!viewport) {
         const viewportInput = {

package/dist/esm/version.d.ts

@@ -1 +1 @@
-export declare const version = "3.29.5";
+export declare const version = "3.30.0";

package/dist/esm/version.js

@@ -1 +1 @@
-export const version = '3.29.5';
+export const version = '3.30.0';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cornerstonejs/core",
-  "version": "3.29.5",
+  "version": "3.30.0",
   "description": "Cornerstone3D Core",
   "module": "./dist/esm/index.js",
   "types": "./dist/esm/index.d.ts",
@@ -97,5 +97,5 @@
     "type": "individual",
     "url": "https://ohif.org/donate"
   },
-  "gitHead": "1396a52e3ace22acf8f5f0d21f4d4dd03612a802"
+  "gitHead": "f1bc10daabe26e00c716747b29365ed040e402cd"
 }

package/dist/esm/RenderingEngine/helpers/isSequentialRenderingEngine.d.ts

@@ -1 +0,0 @@
-export declare function isSequentialRenderingEngine(renderingEngine: any): boolean;

package/dist/esm/RenderingEngine/helpers/isSequentialRenderingEngine.js

@@ -1,6 +0,0 @@
-import { getConfiguration } from '../../init';
-import { RenderingEngineModeEnum } from '../../enums';
-export function isSequentialRenderingEngine(renderingEngine) {
-    const config = getConfiguration();
-    return (config?.rendering?.renderingEngineMode === RenderingEngineModeEnum.Next);
-}