@kitware/vtk.js 29.4.6 → 29.5.1

package/Common/Core/DataArray.d.ts

@@ -62,6 +62,15 @@ export interface vtkDataArray extends vtkObject {
 	 */
 	getData(): number[]|TypedArray;
 
+	/**
+	 * Call this method when the underlying data has changed
+	 * This method calls `modified()`
+	 * For example, when you need to modify chunks of the array, it is faster
+	 * to get the underlying array with `getData()`, modify it, and then call
+	 * `dataChange()`.
+	 */
+	dataChange(): void;
+
 	/**
 	 * Get the range of the given component.
 	 *

package/Common/DataModel/SelectionNode.d.ts

@@ -54,7 +54,7 @@ export interface vtkSelectionNode extends vtkObject {
 	/**
 	 * This functions is called internally by VTK.js and is not intended for public use.
 	 */
-	setProperties(properties: ISelectionNodeProperties);
+	setProperties(properties: ISelectionNodeProperties): boolean;
 	
 	/**
 	 * Get the list of the underlying selected attribute IDs.
@@ -64,7 +64,7 @@ export interface vtkSelectionNode extends vtkObject {
 	/**
 	 * This functions is called internally by VTK.js and is not intended for public use.
 	 */
-	setSelectionList(selectionAttributeIDs: ISelectionNodeProperties);
+	setSelectionList(selectionAttributeIDs: ISelectionNodeProperties): boolean;
 }
 
 /**

package/IO/Core/HttpDataSetReader.d.ts

@@ -148,6 +148,46 @@ export interface vtkHttpDataSetReader extends vtkHttpDataSetReaderBase {
 	 */
 	getUrl(): string;
 
+	/**
+	 * Gets an array of all cached array ids.
+	 */
+	getCachedArrayIds(): string[];
+
+
+	/**
+	 * Gets the maximum size cached arrays are allowed to occupy.
+	 * Size is given in MiB.
+	 * If cache size is exceeded, the arrays that where not accessed
+	 * the longest are removed.
+	 * 
+	 * Special settings:
+	 * -1 -> Cache unlimited
+	 *  0 -> Cache disabled
+	 *  null -> Cache disabled
+	 *  undefined -> Cache disabled
+	 */
+	getMaxCacheSize(): number | null | undefined;
+
+	/**
+	 * Sets the maximum size cached arrays are allowed to occupy.
+	 * Size is given in MiB.
+	 * If cache size is exceeded, the arrays that where not accessed
+	 * the longest are removed.
+	 * If set to "undefined" the cache is unlimited.
+	 * 
+	 * Special settings:
+	 * -1 -> Cache unlimited
+	 *  0 -> Cache disabled
+	 *  null -> Cache disabled
+	 *  undefined -> Cache disabled
+	 */
+	setMaxCacheSize(value: number | null | undefined): void;
+
+	/**
+	 * Clears all cached entries.
+	 */
+	clearCache(): void;
+
 	/**
 	 * 
 	 * @param {Boolean} busy 

package/IO/Core/HttpDataSetReader.js

@@ -22,7 +22,9 @@ const ARRAY_BUILDERS = {
 // Global methods
 // ----------------------------------------------------------------------------
 
-const cachedArrays = {};
+const cachedArraysAndPromises = {};
+const cachedArraysMetaData = {};
+const MiB = 1024 * 1024;
 const GEOMETRY_ARRAYS = {
   vtkPolyData(dataset) {
     const arrayToDownload = [];
@@ -131,23 +133,68 @@ function vtkHttpDataSetReader(publicAPI, model) {
   function fetchArray(array) {
     let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
     const arrayId = `${array.ref.id}|${array.vtkClass}`;
-    if (!cachedArrays[arrayId]) {
+    if (!cachedArraysAndPromises[arrayId]) {
       // Cache the promise while fetching
-      cachedArrays[arrayId] = model.dataAccessHelper.fetchArray(publicAPI, model.baseURL, array, options).then(newArray => {
+      cachedArraysAndPromises[arrayId] = model.dataAccessHelper.fetchArray(publicAPI, model.baseURL, array, options).then(newArray => {
+        // Remove promise and return here if caching is disabled
+        if (!model.maxCacheSize) {
+          delete cachedArraysAndPromises[arrayId];
+          return newArray;
+        }
+
         // Replace the promise with the array in cache once downloaded
-        cachedArrays[arrayId] = newArray;
+        cachedArraysAndPromises[arrayId] = newArray;
+        cachedArraysMetaData[arrayId] = {
+          lastAccess: new Date()
+        };
+
+        // If maxCacheSize is set to -1 the cache is unlimited
+        if (model.maxCacheSize < 0) {
+          return newArray;
+        }
+
+        // sort cache according to access times (potentially needed for creating space)
+        const cachedArrays = {};
+        Object.keys(cachedArraysMetaData).forEach(arrId => {
+          cachedArrays[arrId] = {
+            array: cachedArraysAndPromises[arrId],
+            lastAccess: cachedArraysMetaData[arrId].lastAccess
+          };
+        });
+        const sortedArrayCache = Object.entries(cachedArrays).sort((a, b) => Math.sign(b[1].lastAccess - a[1].lastAccess));
+
+        // Check cache size
+        const cacheSizeLimit = model.maxCacheSize * MiB;
+        let cacheSize = Object.values(cachedArrays).reduce((accSize, entry) => accSize + entry.array.values.byteLength, 0);
+
+        // Delete cache entries until size is below the limit
+        while (cacheSize > cacheSizeLimit && sortedArrayCache.length > 0) {
+          const [oldId, entry] = sortedArrayCache.pop();
+          delete cachedArraysAndPromises[oldId];
+          delete cachedArraysMetaData[oldId];
+          cacheSize -= entry.array.values.byteLength;
+        }
+
+        // Edge case: If the new entry is bigger than the cache limit
+        if (!cachedArraysMetaData[arrayId]) {
+          macro.vtkWarningMacro('Cache size is too small for the dataset');
+        }
         return newArray;
       });
     } else {
       // cacheArrays[arrayId] can be a promise or value
-      Promise.resolve(cachedArrays[arrayId]).then(cachedArray => {
+      Promise.resolve(cachedArraysAndPromises[arrayId]).then(cachedArray => {
         if (array !== cachedArray) {
+          //  Update last access for cache retention rules
+          cachedArraysMetaData[arrayId].lastAccess = new Date();
+
+          // Assign cached array as result
           Object.assign(array, cachedArray);
           delete array.ref;
         }
       });
     }
-    return Promise.resolve(cachedArrays[arrayId]);
+    return Promise.resolve(cachedArraysAndPromises[arrayId]);
   }
 
   // Fetch dataset (metadata)
@@ -268,6 +315,15 @@ function vtkHttpDataSetReader(publicAPI, model) {
     }
   };
 
+  // return id's of cached arrays
+  publicAPI.getCachedArrayIds = () => Object.keys(cachedArraysMetaData);
+
+  // clear global array cache
+  publicAPI.clearCache = () => Object.keys(cachedArraysMetaData).forEach(k => {
+    delete cachedArraysAndPromises[k];
+    delete cachedArraysMetaData[k];
+  });
+
   // return Busy state
   publicAPI.isBusy = () => !!model.requestCount;
 }
@@ -282,7 +338,9 @@ const DEFAULT_VALUES = {
   arrays: [],
   url: null,
   baseURL: null,
-  requestCount: 0
+  requestCount: 0,
+  arrayCachingEnabled: true,
+  maxCacheSize: 2048
   // dataAccessHelper: null,
 };
 
@@ -294,8 +352,8 @@ function extend(publicAPI, model) {
 
   // Build VTK API
   macro.obj(publicAPI, model);
-  macro.get(publicAPI, model, ['enableArray', 'fetchGzip', 'url', 'baseURL', 'dataAccessHelper']);
-  macro.set(publicAPI, model, ['dataAccessHelper', 'progressCallback']);
+  macro.get(publicAPI, model, ['enableArray', 'fetchGzip', 'url', 'baseURL', 'dataAccessHelper', 'maxCacheSize']);
+  macro.set(publicAPI, model, ['dataAccessHelper', 'progressCallback', 'maxCacheSize']);
   macro.getArray(publicAPI, model, ['arrays']);
   macro.algo(publicAPI, model, 0, 1);
   macro.event(publicAPI, model, 'busy');

package/Rendering/Core/PixelSpaceCallbackMapper.d.ts

@@ -1,3 +1,4 @@
+import { Vector3 } from './../../types';
 import vtkCamera from './Camera';
 import vtkMapper, { IMapperInitialValues } from './Mapper';
 
@@ -65,9 +66,30 @@ export interface vtkPixelSpaceCallbackMapper extends vtkMapper {
 	 * 
 	 * depthBuffer: Uint8Array
 	 * 
-	 * @param callback 
+	 * @example
+	 * ```js
+	 * // there is some text canvas and label data
+	 * const textCtx = textCanvas.getContext('2d');
+	 * const psMapper = vtkPixelSpaceCallbackMapper.newInstance();
+	 * psMapper.setInputData(pointPoly);
+	 * psMapper.setCallback((coords, camera, aspect, depthBuffer) => {
+	 *   textCtx.clearRect(0, 0, oglCtx.drawingBufferWidth, oglCtx.drawingBufferHeight);
+	 *   coords.forEach((xy, idx) => {
+	 * 	   let label = data.labels[idx]
+	 * 	   textCtx.fillStyle = "white";
+	 * 	   textCtx.font = "12px Arial";
+	 * 	   textCtx.fillText(label, xy[0], oglCtx.drawingBufferHeight - xy[1]);
+	 * 	 })
+	 * })
+	 * 
+	 * const textActor = vtkActor.newInstance();
+	 * textActor.setMapper(psMapper);
+	 * renderer.addActor(textActor);
+	 * ```
+	 * 
+	 * @param callback called with coords, camera, aspect and depthBuffer
 	 */
-	setCallback(callback: () => any): boolean
+	setCallback(callback: (coords: Vector3[], camera: vtkCamera, aspect: number, depthBuffer: Uint8Array) => any): boolean
 	
 
 	/**

package/Rendering/Core/RenderWindow.js

@@ -98,7 +98,7 @@ function vtkRenderWindow(publicAPI, model) {
       gpuMemoryMB: 0
     };
     model._views.forEach(v => {
-      results.gpuMemoryMB += v.getGraphicsMemoryInfo() / 1e6;
+      if (v.getGraphicsMemoryInfo) results.gpuMemoryMB += v.getGraphicsMemoryInfo() / 1e6;
     });
     model.renderers.forEach(ren => {
       const props = ren.getViewProps();
@@ -110,7 +110,9 @@ function vtkRenderWindow(publicAPI, model) {
           if (mpr && mpr.getPrimitiveCount) {
             const gmpr = gren.getViewNodeFor(mpr);
             if (gmpr) {
-              results.gpuMemoryMB += gmpr.getAllocatedGPUMemoryInBytes() / 1e6;
+              if (gmpr.getAllocatedGPUMemoryInBytes) {
+                results.gpuMemoryMB += gmpr.getAllocatedGPUMemoryInBytes() / 1e6;
+              }
               const pcount = mpr.getPrimitiveCount();
               Object.keys(pcount).forEach(keyName => {
                 if (!results[keyName]) {

package/Rendering/OpenGL/BufferObject/Constants.d.ts

@@ -0,0 +1,11 @@
+export declare enum ObjectType {
+  ARRAY_BUFFER = 0,
+  ELEMENT_ARRAY_BUFFER = 1,
+  TEXTURE_BUFFER = 2,
+}
+
+declare const _default: {
+  ObjectType: typeof ObjectType;
+};
+
+export default _default;

package/Rendering/OpenGL/BufferObject.d.ts

@@ -0,0 +1,82 @@
+import { ObjectType } from './BufferObject/Constants';
+import { vtkAlgorithm, vtkObject } from './../../interfaces';
+
+/**
+ * Interface for initial values of BufferObject
+ */
+export interface IBufferObjectInitialValues {
+  objectType?: ObjectType;
+  context?: WebGLRenderingContext | WebGL2RenderingContext;
+  allocatedGPUMemoryInBytes?: number;
+}
+
+/**
+ * Interface for OpenGL Buffer Object
+ */
+export interface vtkOpenGLBufferObject extends vtkObject {
+  /**
+   * Uploads data to the buffer object.
+   * @param data The data to be uploaded.
+   * @param type The type of the data.
+   * @returns {boolean} Whether the upload was successful.
+   */
+  upload(data: any, type: any): boolean;
+
+  /**
+   * Binds the buffer object.
+   * @returns {boolean} Whether the binding was successful.
+   */
+  bind(): boolean;
+
+  /**
+   * Releases the buffer object.
+   * @returns {boolean} Whether the release was successful.
+   */
+  release(): boolean;
+
+  /**
+   * Releases graphics resources associated with the buffer object.
+   */
+  releaseGraphicsResources(): void;
+
+  /**
+   * Sets the OpenGL render window.
+   * @param renWin The render window to set.
+   */
+  setOpenGLRenderWindow(renWin: any): void;
+
+  /**
+   * Retrieves the error message, if any.
+   * @returns {string} The error message.
+   */
+  getError(): string;
+
+}
+
+/**
+ * Extends the given object with the properties and methods of vtkOpenGLBufferObject.
+ * @param publicAPI The public API to extend.
+ * @param model The model to extend.
+ * @param initialValues The initial values to apply.
+ */
+export function extend(
+  publicAPI: object,
+  model: object,
+  initialValues?: IBufferObjectInitialValues
+): void;
+
+/**
+ * Creates a new instance of vtkOpenGLBufferObject with the given initial values.
+ * @param initialValues The initial values to use.
+ * @returns {vtkOpenGLBufferObject} The new instance.
+ */
+export function newInstance(initialValues?: IBufferObjectInitialValues): vtkOpenGLBufferObject;
+
+/**
+ * Object containing the newInstance and extend functions for vtkOpenGLBufferObject.
+ */
+export declare const vtkOpenGLBufferObject: {
+  newInstance: typeof newInstance;
+  extend: typeof extend;
+};
+export default vtkOpenGLBufferObject;

package/Rendering/OpenGL/ImageMapper.js

@@ -745,6 +745,8 @@ function vtkOpenGLImageMapper(publicAPI, model) {
         });
         model.openGLTexture.setOpenGLRenderWindow(model._openGLRenderWindow);
       }
+      // Use norm16 for scalar texture if the extension is available
+      model.openGLTexture.setOglNorm16Ext(model.context.getExtension('EXT_texture_norm16'));
       if (iType === InterpolationType.NEAREST) {
         if (new Set([1, 3, 4]).has(numComp) && dataType === VtkDataTypes.UNSIGNED_CHAR && !iComps) {
           model.openGLTexture.setGenerateMipmap(true);

package/Rendering/OpenGL/RenderWindow.js

@@ -319,18 +319,22 @@ function vtkOpenGLRenderWindow(publicAPI, model) {
             default:
               return oglNorm16Ext.RGBA16_SNORM_EXT;
           }
+        case VtkDataTypes.UNSIGNED_SHORT:
+        case VtkDataTypes.SHORT:
         case VtkDataTypes.FLOAT:
         default:
+          // useHalfFloat tells us if the texture can be accurately
+          // rendered with 16 bits or not.
           switch (numComps) {
             case 1:
-              return model.context.R16F;
+              return useHalfFloat ? model.context.R16F : model.context.R32F;
             case 2:
-              return model.context.RG16F;
+              return useHalfFloat ? model.context.RG16F : model.context.RG32F;
             case 3:
-              return model.context.RGB16F;
+              return useHalfFloat ? model.context.RGB16F : model.context.RGB32F;
             case 4:
             default:
-              return model.context.RGBA16F;
+              return useHalfFloat ? model.context.RGBA16F : model.context.RGBA32F;
           }
       }
     }

package/Rendering/OpenGL/Texture/Constants.d.ts

@@ -0,0 +1,21 @@
+export declare enum Wrap {
+  CLAMP_TO_EDGE = 0,
+  REPEAT = 1,
+  MIRRORED_REPEAT = 2,
+}
+
+export declare enum Filter {
+  NEAREST = 0,
+  LINEAR = 1,
+  NEAREST_MIPMAP_NEAREST = 2,
+  NEAREST_MIPMAP_LINEAR = 3,
+  LINEAR_MIPMAP_NEAREST = 4,
+  LINEAR_MIPMAP_LINEAR = 5,
+}
+
+declare const _default: {
+  Wrap: typeof Wrap;
+  Filter: typeof Filter;
+};
+
+export default _default;

package/Rendering/OpenGL/Texture.d.ts

@@ -0,0 +1,305 @@
+import { Wrap, Filter } from './Texture/Constants';
+import vtkOpenGLRenderWindow from './RenderWindow';
+import { Nullable } from './../../types';
+import { VtkDataTypes } from './../../Common/Core/DataArray';
+import { vtkViewNode } from './../SceneGraph/ViewNode';
+import { vtkObject } from './../../interfaces' ;
+
+/**
+ * Initial values for creating a new instance of vtkOpenGLTexture.
+ */
+export interface ITextureInitialValues {
+  _openGLRenderWindow?: Nullable<vtkOpenGLRenderWindow>;
+  _forceInternalFormat?: boolean;
+  context?: WebGLRenderingContext | WebGL2RenderingContext;
+  handle?: number;
+  sendParametersTime?: vtkObject;
+  textureBuildTime?: vtkObject;
+  numberOfDimensions?: number;
+  target?: number;
+  format?: number;
+  openGLDataType?: number;
+  components?: number;
+  width?: number;
+  height?: number;
+  depth?: number;
+  autoParameters?: boolean;
+  wrapS?: Wrap;
+  wrapT?: Wrap;
+  wrapR?: Wrap;
+  minificationFilter?: Filter;
+  magnificationFilter?: Filter;
+  minLOD?: number;
+  maxLOD?: number;
+  baseLevel?: number;
+  maxLevel?: number;
+  generateMipmap?: boolean;
+  useHalfFloat?: boolean;
+  oglNorm16Ext?: any;
+  allocatedGPUMemoryInBytes?: number;
+}
+
+/**
+ * Interface for OpenGL Texture.
+ */
+export interface vtkOpenGLTexture extends vtkViewNode {
+  /**
+   * Renders the texture within the given render window.
+   * @param renWin The render window in which to render the texture.
+   */
+  render(renWin: vtkOpenGLRenderWindow): void;
+
+  /**
+   * Destroys the texture and frees up any resources it's using.
+   */
+  destroyTexture(): void;
+
+  /**
+   * Creates the texture in the OpenGL context.
+   */
+  createTexture(): void;
+
+  /**
+   * Gets the texture unit number that this texture is bound to.
+   * @returns {number} The texture unit number.
+   */
+  getTextureUnit(): number;
+
+  /**
+   * Activates the texture, making it the current texture for subsequent OpenGL operations.
+   */
+  activate(): void;
+
+  /**
+   * Deactivates the texture, making it no longer the current texture for subsequent OpenGL operations.
+   */
+  deactivate(): void;
+
+  /**
+   * Releases the graphics resources used by the texture within the given render window.
+   * @param renWin The render window whose resources should be released.
+   */
+  releaseGraphicsResources(renWin: vtkOpenGLRenderWindow): void;
+
+  /**
+   * Binds the texture to the current OpenGL context.
+   */
+  bind(): void;
+
+  /**
+   * Checks if the texture is currently bound to the OpenGL context.
+   * @returns {boolean} True if the texture is bound, false otherwise.
+   */
+  isBound(): boolean;
+
+  /**
+   * Sends the texture parameters to the OpenGL context.
+   */
+  sendParameters(): void;
+
+  /**
+   * Gets the internal format for the texture based on the VTK data type and number of components.
+   * @param vtktype The VTK data type.
+   * @param numComps The number of components in the texture.
+   * @returns The internal format.
+   */
+  getInternalFormat(vtktype: VtkDataTypes, numComps: number): any;
+
+  /**
+   * Gets the default internal format for the texture based on the VTK data type and number of components.
+   * @param vtktype The VTK data type.
+   * @param numComps The number of components in the texture.
+   * @returns The default internal format.
+   */
+  getDefaultInternalFormat(vtktype: VtkDataTypes, numComps: number): any;
+
+  /**
+   * Sets the internal format for the texture.
+   * @param iformat The internal format to set.
+   */
+  setInternalFormat(iformat: any): void;
+
+  /**
+   * Gets the format for the texture based on the VTK data type and number of components.
+   * @param vtktype The VTK data type.
+   * @param numComps The number of components in the texture.
+   * @returns The format.
+   */
+  getFormat(vtktype: VtkDataTypes, numComps: number): any;
+
+  /**
+   * Gets the default format for the texture based on the VTK data type and number of components.
+   * @param vtktype The VTK data type.
+   * @param numComps The number of components in the texture.
+   * @returns The default format.
+   */
+  getDefaultFormat(vtktype: VtkDataTypes, numComps: number): any;
+
+  /**
+   * Resets the texture format and type to their default values.
+   */
+  resetFormatAndType(): void;
+
+  /**
+   * Gets the default data type for the texture based on the VTK scalar type.
+   * @param vtkScalarType The VTK scalar type.
+   * @returns The default data type.
+   */
+  getDefaultDataType(vtkScalarType: VtkDataTypes): any;
+
+  /**
+   * Gets the OpenGL data type for the texture based on the VTK scalar type and whether to force an update.
+   * @param vtkScalarType The VTK scalar type.
+   * @param forceUpdate Whether to force the update of the data type.
+   * @returns The OpenGL data type.
+   */
+  getOpenGLDataType(vtkScalarType: VtkDataTypes, forceUpdate: boolean): any;
+
+  /**
+   * Gets the shift and scale values for the texture.
+   * @returns The shift and scale values.
+   */
+  getShiftAndScale(): any;
+
+  /**
+   * Gets the OpenGL filter mode for the texture.
+   * @param emode The filter mode.
+   * @returns The OpenGL filter mode.
+   */
+  getOpenGLFilterMode(emode: Filter): any;
+
+  /**
+   * Gets the OpenGL wrap mode for the texture.
+   * @param vtktype The wrap type.
+   * @returns The OpenGL wrap mode.
+   */
+  getOpenGLWrapMode(vtktype: Wrap): any;
+
+  /**
+   * Creates a 2D texture from raw data.
+   * @param width The width of the texture.
+   * @param height The height of the texture.
+   * @param numComps The number of components in the texture.
+   * @param dataType The data type of the texture.
+   * @param data The raw data for the texture.
+   * @param flip Whether to flip the texture vertically.
+   * @returns {boolean} True if the texture was successfully created, false otherwise.
+   */
+  create2DFromRaw(width: number, height: number, numComps: number, dataType: VtkDataTypes, data: any, flip: boolean): boolean;
+
+  /**
+   * Creates a cube texture from raw data.
+   * @param width The width of each face of the cube texture.
+   * @param height The height of each face of the cube texture.
+   * @param numComps The number of components in the texture.
+   * @param dataType The data type of the texture.
+   * @param data The raw data for the texture.
+   * @param flip Whether to flip the texture vertically.
+   * @returns {boolean} True if the cube texture was successfully created, false otherwise.
+   */
+  createCubeFromRaw(width: number, height: number, numComps: number, dataType: VtkDataTypes, data: any, flip: boolean): boolean;
+
+  /**
+   * Creates a 2D texture from an image.
+   * @param image The image to use for the texture.
+   * @returns {boolean} True if the texture was successfully created, false otherwise.
+   */
+  create2DFromImage(image: any): boolean;
+
+  /**
+   * Creates a 2D filterable texture from raw data, with a preference for size over accuracy if necessary.
+   * @param width The width of the texture.
+   * @param height The height of the texture.
+   * @param numComps The number of components in the texture.
+   * @param dataType The data type of the texture.
+   * @param data The raw data for the texture.
+   * @param preferSizeOverAccuracy Whether to prefer texture size over accuracy.
+   * @returns {boolean} True if the texture was successfully created, false otherwise.
+   */
+  create2DFilterableFromRaw(width: number, height: number, numComps: number, dataType: VtkDataTypes, data: any, preferSizeOverAccuracy: boolean): boolean;
+
+  /**
+   * Creates a 2D filterable texture from a data array, with a preference for size over accuracy if necessary.
+   * @param width The width of the texture.
+   * @param height The height of the texture.
+   * @param dataArray The data array to use for the texture.
+   * @param preferSizeOverAccuracy Whether to prefer texture size over accuracy.
+   * @returns {boolean} True if the texture was successfully created, false otherwise.
+   */
+  create2DFilterableFromDataArray(width: number, height: number, dataArray: any, preferSizeOverAccuracy: boolean): boolean;
+
+  /**
+   * Creates a 3D texture from raw data.
+   * @param width The width of the texture.
+   * @param height The height of the texture.
+   * @param depth The depth of the texture.
+   * @param numComps The number of components in the texture.
+   * @param dataType The data type of the texture.
+   * @param data The raw data for the texture.
+   * @returns {boolean} True if the texture was successfully created, false otherwise.
+   */
+  create3DFromRaw(width: number, height: number, depth: number, numComps: number, dataType: VtkDataTypes, data: any): boolean;
+
+  /**
+   * Creates a 3D filterable texture from raw data, with a preference for size over accuracy if necessary.
+   * @param width The width of the texture.
+   * @param height The height of the texture.
+   * @param depth The depth of the texture.
+   * @param numComps The number of components in the texture.
+   * @param dataType The data type of the texture.
+   * @param values The raw data for the texture.
+   * @param preferSizeOverAccuracy Whether to prefer texture size over accuracy.
+   * @returns {boolean} True if the texture was successfully created, false otherwise.
+   */
+  create3DFilterableFromRaw(width: number, height: number, depth: number, numComps: number, dataType: VtkDataTypes, values: any, preferSizeOverAccuracy: boolean): boolean;
+
+  /**
+   * Creates a 3D filterable texture from a data array, with a preference for size over accuracy if necessary.
+   * @param width The width of the texture.
+   * @param height The height of the texture.
+   * @param depth The depth of the texture.
+   * @param dataArray The data array to use for the texture.
+   * @param preferSizeOverAccuracy Whether to prefer texture size over accuracy.
+   * @returns {boolean} True if the texture was successfully created, false otherwise.
+   */
+  create3DFilterableFromDataArray(width: number, height: number, depth: number, dataArray: any, preferSizeOverAccuracy: boolean): boolean;
+
+  /**
+   * Sets the OpenGL render window in which the texture will be used.
+   * @param renWin The render window to set.
+   */
+  setOpenGLRenderWindow(renWin: any): void;
+
+  /**
+   * Gets the maximum texture size supported by the OpenGL context.
+   * @param ctx The OpenGL context.
+   * @returns {number} The maximum texture size.
+   */
+  getMaximumTextureSize(ctx: any): number;
+
+}
+
+/**
+ * Extends the publicAPI with the given model and initial values.
+ * @param publicAPI The API to extend.
+ * @param model The model to use.
+ * @param initialValues The initial values to apply.
+ */
+export function extend(publicAPI: object, model: object, initialValues?: ITextureInitialValues): void;
+
+/**
+ * Creates a new instance of vtkOpenGLTexture with the given initial values.
+ * @param initialValues The initial values to use.
+ * @returns The new instance.
+ */
+export function newInstance(initialValues?: ITextureInitialValues): vtkOpenGLTexture;
+
+/**
+ * vtkOpenGLTexture static API.
+ */
+export declare const vtkOpenGLTexture: {
+  newInstance: typeof newInstance,
+  extend: typeof extend,
+};
+
+export default vtkOpenGLTexture;

package/Rendering/OpenGL/Texture.js

@@ -275,6 +275,9 @@ function vtkOpenGLTexture(publicAPI, model) {
     if (!model.internalFormat) {
       vtkDebugMacro(`Unable to find suitable internal format for T=${vtktype} NC= ${numComps}`);
     }
+    if ([model.context.R32F, model.context.RG32F, model.context.RGB32F, model.context.RGBA32F].includes(model.internalFormat) && !model.context.getExtension('OES_texture_float_linear')) {
+      vtkWarningMacro('Failed to load OES_texture_float_linear. Texture filtering is not available for *32F internal formats.');
+    }
     return model.internalFormat;
   };
 

package/Rendering/WebGPU/CellArrayMapper.js

@@ -83,7 +83,7 @@ fn mdot(a: vec3<f32>, b: vec3<f32>) -> f32 {
 // zero and one while still maintaining a good amount of accuracy.
 fn cdot(a: vec3<f32>, b: vec3<f32>) -> f32 {
   var d: f32 = max(0.0, dot(a, b));
-  d = pow((d + 1) / 2.0, 2.6);
+  d = pow((d + 1.0) / 2.0, 2.6);
   return d;
 }
 
@@ -109,7 +109,7 @@ fn fujiiOrenNayar(p: vec3<f32>, o: f32, N: vec3<f32>, L: vec3<f32>, V: vec3<f32>
   var LdotV: f32 = mdot(L, V);
 
   var s: f32 = LdotV - NdotL*NdotV;
-  var t: f32 = mix(1, max(NdotL, NdotV), step(0, s)); // Mix with step is the equivalent of an if statement
+  var t: f32 = mix(1.0, max(NdotL, NdotV), step(0.0, s)); // Mix with step is the equivalent of an if statement
   var A: vec3<f32> = 0.5*(o2 / (o2 + 0.33)) + 0.17*p*(o2 / (o2 + 0.13));
   A = invpi*(1 - A);
   var B: f32 = 0.45*(o2 / (o2 + 0.09));
@@ -121,14 +121,14 @@ fn fujiiOrenNayar(p: vec3<f32>, o: f32, N: vec3<f32>, L: vec3<f32>, V: vec3<f32>
 // Fresnel portion of BRDF (IOR only, simplified)
 fn schlickFresnelIOR(V: vec3<f32>, N: vec3<f32>, ior: f32, k: f32) -> f32 {
   var NdotV: f32 = mdot(V, N);
-  var F0: f32 = (pow((ior - 1.0), 2) + k*k) / (pow((ior + 1.0), 2) + k*k); // This takes into account the roughness, which the other one does not
-  return F0 + (1 - F0) * pow((1-NdotV), 5); 
+  var F0: f32 = (pow((ior - 1.0), 2.0) + k*k) / (pow((ior + 1.0), 2.0) + k*k); // This takes into account the roughness, which the other one does not
+  return F0 + (1.0 - F0) * pow((1.0-NdotV), 5.0);
 }
 
 // Fresnel portion of BRDF (Color ior, better)
 fn schlickFresnelRGB(V: vec3<f32>, N: vec3<f32>, F0: vec3<f32>) -> vec3<f32> {
   var NdotV: f32 = mdot(V, N);
-  return F0 + (1 - F0) * pow((1-NdotV), 5); 
+  return F0 + (1.0 - F0) * pow((1-NdotV), 5.0);
 }
 
 // Normal portion of BRDF
@@ -158,12 +158,12 @@ fn anisotrophicTrGGX(N: vec3<f32>, H: vec3<f32>, O: vec3<f32>, s: f32, a: f32) -
 // Geometry portion of BRDF
 fn schlickGGX(N: vec3<f32>, X: vec3<f32>, k: f32) -> f32 {
   var NdotX = cdot(N, X);
-  return NdotX / max(0.000001, (NdotX*(1-k) + k));
+  return NdotX / max(0.000001, (NdotX*(1.0-k) + k));
 }
 
 fn smithSurfaceRoughness(N: vec3<f32>, V: vec3<f32>, L: vec3<f32>, k: f32) -> f32 {
-  var ggx1: f32 = min(1, schlickGGX(N, V, k));
-  var ggx2: f32 = min(1, schlickGGX(N, L, k));
+  var ggx1: f32 = min(1.0, schlickGGX(N, V, k));
+  var ggx2: f32 = min(1.0, schlickGGX(N, L, k));
   return ggx1*ggx2;
 }
 
@@ -187,7 +187,7 @@ fn calcDirectionalLight(N: vec3<f32>, V: vec3<f32>, ior: f32, roughness: f32, me
   // var F: f32 = schlickFresnelIOR(V, N, ior, k); // Fresnel
   var G: f32 = smithSurfaceRoughness(N, V, L, k); // Geometry
 
-  var brdf: f32 = cookTorrance(D, 1, G, N, V, L); // Fresnel term is replaced with 1 because it is added later
+  var brdf: f32 = cookTorrance(D, 1.0, G, N, V, L); // Fresnel term is replaced with 1 because it is added later
   var incoming: vec3<f32> = color;
   var angle: f32 = mdot(L, N);
   angle = pow(angle, 1.5);
@@ -209,14 +209,14 @@ fn calcPointLight(N: vec3<f32>, V: vec3<f32>, fragPos: vec3<f32>, ior: f32, roug
   var dist = distance(position, fragPos);
 
   var alpha = roughness*roughness;
-  var k: f32 = alpha*alpha / 2; // could also be pow(alpha + 1.0, 2) / 8
+  var k: f32 = alpha*alpha / 2.0; // could also be pow(alpha + 1.0, 2) / 8
 
   var D: f32 = trGGX(N, H, alpha); // Distribution
   // var F: f32 = schlickFresnelIOR(V, N, ior, k); // Fresnel
   var G: f32 = smithSurfaceRoughness(N, V, L, k); // Geometry
 
-  var brdf: f32 = cookTorrance(D, 1, G, N, V, L);  
-  var incoming: vec3<f32> = color * (1. / (dist*dist));
+  var brdf: f32 = cookTorrance(D, 1.0, G, N, V, L);
+  var incoming: vec3<f32> = color * (1.0 / (dist*dist));
   var angle: f32 = mdot(L, N);
   angle = pow(angle, 1.5); // Smoothing factor makes it less accurate, but reduces ugly "seams" bewteen light sources
 
@@ -237,13 +237,13 @@ fn calcSpotLight(N: vec3<f32>, V: vec3<f32>, fragPos: vec3<f32>, ior: f32, rough
   var dist = distance(position, fragPos);
 
   var alpha = roughness*roughness;
-  var k: f32 = alpha*alpha / 2; // could also be pow(alpha + 1.0, 2) / 8
+  var k: f32 = alpha*alpha / 2.0; // could also be pow(alpha + 1.0, 2) / 8
 
   var D: f32 = trGGX(N, H, alpha); // Distribution
   // var F: f32 = schlickFresnelIOR(V, N, ior, k); // Fresnel
   var G: f32 = smithSurfaceRoughness(N, V, L, k); // Geometry
 
-  var brdf: f32 = cookTorrance(D, 1, G, N, V, L);  
+  var brdf: f32 = cookTorrance(D, 1.0, G, N, V, L);
   
   // Cones.x is the inner phi and cones.y is the outer phi
   var theta: f32 = mdot(normalize(direction), L);
@@ -314,12 +314,12 @@ fn main(
   var opacity: f32 = mapperUBO.Opacity;
 
   // This should be declared somewhere else
-  var _diffuseMap: vec4<f32> = vec4<f32>(1);
-  var _roughnessMap: vec4<f32> = vec4<f32>(1);
-  var _metallicMap: vec4<f32> = vec4<f32>(1);
-  var _normalMap: vec4<f32> = vec4<f32>(0, 0, 1, 0); // normal map was setting off the normal vector detection in fragment
-  var _ambientOcclusionMap: vec4<f32> = vec4<f32>(1);
-  var _emissionMap: vec4<f32> = vec4<f32>(0);
+  var _diffuseMap: vec4<f32> = vec4<f32>(1.0);
+  var _roughnessMap: vec4<f32> = vec4<f32>(1.0);
+  var _metallicMap: vec4<f32> = vec4<f32>(1.0);
+  var _normalMap: vec4<f32> = vec4<f32>(0.0, 0.0, 1.0, 0.0); // normal map was setting off the normal vector detection in fragment
+  var _ambientOcclusionMap: vec4<f32> = vec4<f32>(1.);
+  var _emissionMap: vec4<f32> = vec4<f32>(0.);
 
   //VTK::Color::Impl
 
@@ -536,7 +536,7 @@ function vtkWebGPUCellArrayMapper(publicAPI, model) {
       // Summing diffuse and specular components of directional lights
       '  {', '    var i: i32 = 0;', '    loop {', '      if !(i < rendererUBO.LightCount) { break; }', '      switch (i32(rendererLightSSBO.values[i].LightData.x)) {', '         // Point Light', '         case 0 {', '           var color: vec3<f32> = rendererLightSSBO.values[i].LightColor.rgb * rendererLightSSBO.values[i].LightColor.w;', '           var pos: vec3<f32> = (rendererLightSSBO.values[i].LightPos).xyz;', '           var calculated: PBRData = calcPointLight(normal, V, fragPos, ior, roughness, metallic, pos, color, baseColor);', '           diffuse += max(vec3<f32>(0), calculated.diffuse);', '           specular += max(vec3<f32>(0), calculated.specular);', '          }', '         // Directional light', '         case 1 {', '           var dir: vec3<f32> = (rendererUBO.WCVCNormals * vec4<f32>(normalize(rendererLightSSBO.values[i].LightDir.xyz), 0.)).xyz;', '           dir = normalize(dir);', '           var color: vec3<f32> = rendererLightSSBO.values[i].LightColor.rgb * rendererLightSSBO.values[i].LightColor.w;', '           var calculated: PBRData = calcDirectionalLight(normal, V, ior, roughness, metallic, dir, color, baseColor); // diffuseColor.rgb needs to be fixed with a more dynamic diffuse color', '           diffuse += max(vec3<f32>(0), calculated.diffuse);', '           specular += max(vec3<f32>(0), calculated.specular);', '         }', '         // Spot Light', '         case 2 {', '           var color: vec3<f32> = rendererLightSSBO.values[i].LightColor.rgb * rendererLightSSBO.values[i].LightColor.w;', '           var pos: vec3<f32> = (rendererLightSSBO.values[i].LightPos).xyz;', '           var dir: vec3<f32> = (rendererUBO.WCVCNormals * vec4<f32>(normalize(rendererLightSSBO.values[i].LightDir.xyz), 0.)).xyz;', '           dir = normalize(dir);', '           var cones: vec2<f32> = vec2<f32>(rendererLightSSBO.values[i].LightData.y, rendererLightSSBO.values[i].LightData.z);', '           var calculated: PBRData = calcSpotLight(normal, V, fragPos, ior, roughness, metallic, pos, dir, cones, color, baseColor);', '           diffuse += max(vec3<f32>(0), calculated.diffuse);', '           specular += max(vec3<f32>(0), calculated.specular);', '         }', '         default { continue; }', '       }', '      continuing { i++; }', '    }', '  }',
       // Final variables for combining specular and diffuse
-      '  var fresnel: f32 = schlickFresnelIOR(V, normal, ior, k); // Fresnel', '  fresnel = min(1, fresnel);', '  // This could be controlled with its own variable (that isnt base color) for better artistic control', '  var fresnelMetallic: vec3<f32> = schlickFresnelRGB(V, normal, baseColor); // Fresnel for metal, takes color into account', '  var kS: vec3<f32> = mix(vec3<f32>(fresnel), fresnelMetallic, metallic);', '  kS = min(vec3<f32>(1), kS);', '  var kD: vec3<f32> = (1.0 - kS) * (1.0 - metallic);', '  var PBR: vec3<f32> = mapperUBO.DiffuseIntensity*kD*diffuse + kS*specular;', '  PBR += emission;', '  computedColor = vec4<f32>(PBR, mapperUBO.Opacity);'];
+      '  var fresnel: f32 = schlickFresnelIOR(V, normal, ior, k); // Fresnel', '  fresnel = min(1.0, fresnel);', '  // This could be controlled with its own variable (that isnt base color) for better artistic control', '  var fresnelMetallic: vec3<f32> = schlickFresnelRGB(V, normal, baseColor); // Fresnel for metal, takes color into account', '  var kS: vec3<f32> = mix(vec3<f32>(fresnel), fresnelMetallic, metallic);', '  kS = min(vec3<f32>(1.0), kS);', '  var kD: vec3<f32> = (1.0 - kS) * (1.0 - metallic);', '  var PBR: vec3<f32> = mapperUBO.DiffuseIntensity*kD*diffuse + kS*specular;', '  PBR += emission;', '  computedColor = vec4<f32>(PBR, mapperUBO.Opacity);'];
       if (renderer.getEnvironmentTexture()?.getImageLoaded()) {
         lightingCode.push('  // To get diffuse IBL, the texture is sampled with normals in worldspace', '  var diffuseIBLCoords: vec3<f32> = (transpose(rendererUBO.WCVCNormals) * vec4<f32>(normal, 1.)).xyz;', '  var diffuseCoords: vec2<f32> = vecToRectCoord(diffuseIBLCoords);', '  // To get specular IBL, the texture is sampled as the worldspace reflection between the normal and view vectors', '  // Reflections are first calculated in viewspace, then converted to worldspace to sample the environment', '  var VreflN: vec3<f32> = normalize(reflect(-V, normal));', '  var reflectionIBLCoords = (transpose(rendererUBO.WCVCNormals) * vec4<f32>(VreflN, 1.)).xyz;', '  var specularCoords: vec2<f32> = vecToRectCoord(reflectionIBLCoords);', '  var diffuseIBL = textureSampleLevel(EnvironmentTexture, EnvironmentTextureSampler, diffuseCoords, rendererUBO.MaxEnvironmentMipLevel);',
         // Level multiplier should be set by UBO

package/Rendering/WebGPU/ForwardPass.js

@@ -25,7 +25,7 @@ fn main(
 {
   var output: fragmentOutput;
 
-  var computedColor: vec4<f32> = clamp(textureSampleLevel(opaquePassColorTexture, finalPassSampler, input.tcoordVS, 0),vec4<f32>(0.0),vec4<f32>(1.0));
+  var computedColor: vec4<f32> = clamp(textureSampleLevel(opaquePassColorTexture, finalPassSampler, input.tcoordVS, 0.0),vec4<f32>(0.0),vec4<f32>(1.0));
 
   //VTK::RenderEncoder::Impl
   return output;

package/Rendering/WebGPU/Renderer.js

@@ -72,7 +72,7 @@ fn main(
   var tcoord: vec4<f32> = vec4<f32>(input.vertexVC.xy, -1, 1);
   var V: vec4<f32> = normalize(mapperUBO.FSQMatrix * tcoord); // vec2<f32>((input.tcoordVS.x - 0.5) * 2, -(input.tcoordVS.y - 0.5) * 2);
   // textureSampleLevel gets rid of some ugly artifacts
-  var background = textureSampleLevel(EnvironmentTexture, EnvironmentTextureSampler, vecToRectCoord(V.xyz), 0);
+  var background = textureSampleLevel(EnvironmentTexture, EnvironmentTextureSampler, vecToRectCoord(V.xyz), 0.0);
   var computedColor: vec4<f32> = vec4<f32>(background.rgb, 1);
 
   //VTK::RenderEncoder::Impl

package/Widgets/Core/AbstractWidgetFactory.d.ts

@@ -12,7 +12,7 @@ export interface IGetWidgetForViewParams {
   initialValues?: object;
 }
 
-export interface vtkAbstractWidgetFactory extends vtkObject {
+export interface vtkAbstractWidgetFactory<WidgetInstance extends vtkAbstractWidget> extends vtkObject {
   /**
    * Will return the widget associated with the view with Id id `locator.viewId`. 
    * If there is no widget associated with the view, a new widget will be constructed, provided
@@ -20,7 +20,7 @@ export interface vtkAbstractWidgetFactory extends vtkObject {
    * 
    * @param {IGetWidgetForViewParams} locator
    */
-  getWidgetForView(locator: IGetWidgetForViewParams): Nullable<vtkAbstractWidget>;
+  getWidgetForView(locator: IGetWidgetForViewParams): Nullable<WidgetInstance>;
 
   /**
    * Get a list of all the view ids.
@@ -72,7 +72,7 @@ export interface vtkAbstractWidgetFactory extends vtkObject {
    * 
    * @param {Bounds} bounds 
    */
-  placeWidget(bounds: Bounds);
+  placeWidget(bounds: Bounds): void;
 
   /**
    * Get the place factor.
@@ -107,6 +107,28 @@ export interface vtkAbstractWidgetFactory extends vtkObject {
   invokeWidgetChangeEvent(...args: unknown[]): void;
 }
 
+/**
+ * This hack is to "remember" the generic type T that this function turn publicAPI into
+ * This is because typescript is completely "structural" and doesn't have any way to declare "nominal" types
+ * See: https://github.com/microsoft/TypeScript/issues/202
+ * For example, in this code, widgetInstance is a vtkResliceCursorWidgetCPRInstance:
+ * 
+ * import vtkResliceCursorWidget from '@kitware/vtk.js/Widgets/Widgets3D/ResliceCursorWidget';
+ * import widgetBehavior from '@kitware/vtk.js/Widgets/Widgets3D/ResliceCursorWidget/cprBehavior';
+ *
+ * const widget = vtkResliceCursorWidget.newInstance({
+ *   planes: ['Y', 'Z'],
+ *   behavior: widgetBehavior,
+ * });
+ * const widgetInstance = widgetManager.addWidget(widget);
+ */
+declare const ExtendSymbol: unique symbol;
+export type ExtendWidgetBehavior<WidgetInstance> = ((publicAPI: object, model: object) => void) & { [ExtendSymbol]: WidgetInstance };
+
+export interface IAbstractWidgetFactoryInitialValues<WidgetInstance extends vtkAbstractWidget = vtkAbstractWidget> {
+  behavior?: ExtendWidgetBehavior<WidgetInstance>;
+}
+
 /**
  * Method used to decorate a given object (publicAPI+model) with vtkAbstractWidgetFactory characteristics.
  *
@@ -114,14 +136,14 @@ export interface vtkAbstractWidgetFactory extends vtkObject {
  * @param model object on which data structure will be bounds (protected)
  * @param initialValues (default: {})
  */
-export function extend(publicAPI: object, model: object, initialValues? : object): void;
+export function extend<WidgetInstance extends vtkAbstractWidget = vtkAbstractWidget>(publicAPI: object, model: object, initialValues?: IAbstractWidgetFactoryInitialValues<WidgetInstance>): void;
 
 /**
  * Method used to create a new instance of vtkAbstractWidgetFactory
  * 
  * @param initialValues for pre-setting some of its content
  */
-export function newInstance(initialValues?: object): vtkAbstractWidgetFactory;
+export function newInstance<WidgetInstance extends vtkAbstractWidget = vtkAbstractWidget>(initialValues?: IAbstractWidgetFactoryInitialValues<WidgetInstance>): vtkAbstractWidgetFactory<WidgetInstance>;
 
 export declare const vtkAbstractWidgetFactory: {
 	newInstance: typeof newInstance,

package/Widgets/Core/WidgetManager.d.ts

@@ -129,11 +129,11 @@ export interface vtkWidgetManager extends vtkObject {
    * @param {ViewTypes} [viewType]
    * @param {Object} [initialValues]
    */
-  addWidget(
-    widget: vtkAbstractWidgetFactory,
+  addWidget<WidgetFactory extends vtkAbstractWidgetFactory<any>>(
+    widget: WidgetFactory,
     viewType?: ViewTypes,
     initialValues?: object
-  ): Nullable<vtkAbstractWidget>;
+  ): WidgetFactory extends vtkAbstractWidgetFactory<infer WidgetInstance> ? WidgetInstance : never;
 
   /**
    * Unregister all widgets from the widget manager.
@@ -145,7 +145,7 @@ export interface vtkWidgetManager extends vtkObject {
    * 
    * @param {vtkAbstractWidget | vtkAbstractWidgetFactory} widget The widget to remove
    */
-  removeWidget(widget: vtkAbstractWidget | vtkAbstractWidgetFactory): void;
+  removeWidget(widget: vtkAbstractWidget | vtkAbstractWidgetFactory<any>): void;
 
   /**
    * Given x and y parameter, get selected data.
@@ -165,7 +165,7 @@ export interface vtkWidgetManager extends vtkObject {
    * 
    * @param {vtkAbstractWidget | vtkAbstractWidgetFactory} widget The widget instance which should get the focus.
    */
-  grabFocus(widget: vtkAbstractWidget | vtkAbstractWidgetFactory): void;
+  grabFocus(widget: vtkAbstractWidget | vtkAbstractWidgetFactory<any>): void;
 
   /**
    * Release the focus.

package/Widgets/Widgets3D/InteractiveOrientationWidget.d.ts

@@ -1,8 +1,9 @@
-import vtkAbstractWidgetFactory from './../Core/AbstractWidgetFactory';
+import { vtkAbstractWidgetFactory, IAbstractWidgetFactoryInitialValues } from './../Core/AbstractWidgetFactory';
+import vtkAbstractWidget from './../Core/AbstractWidget'
 import { Bounds } from './../../types';
 import { ViewTypes } from './../Core/WidgetManager/Constants';
 
-export interface vtkInteractiveOrientationWidget extends vtkAbstractWidgetFactory {
+export interface vtkInteractiveOrientationWidget<WidgetInstance extends vtkAbstractWidget = vtkAbstractWidget> extends vtkAbstractWidgetFactory<WidgetInstance> {
   /**
    * Set the widget bounds
    * 
@@ -16,6 +17,8 @@ export interface vtkInteractiveOrientationWidget extends vtkAbstractWidgetFactor
   getRepresentationForViewType(viewType: ViewTypes): unknown;
 }
 
+export interface IInteractiveOrientationWidgetInitialValues<WidgetInstance extends vtkAbstractWidget> extends IAbstractWidgetFactoryInitialValues<WidgetInstance> {}
+
 /**
  * Method use to decorate a given object (publicAPI+model) with vtkInteractiveOrientationWidget characteristics.
  *
@@ -23,14 +26,14 @@ export interface vtkInteractiveOrientationWidget extends vtkAbstractWidgetFactor
  * @param model object on which data structure will be bounds (protected)
  * @param {object} [initialValues] (default: {})
  */
-export function extend(publicAPI: object, model: object, initialValues? : Record<string, unknown>): void;
+export function extend<WidgetInstance extends vtkAbstractWidget>(publicAPI: object, model: object, initialValues? : IInteractiveOrientationWidgetInitialValues<WidgetInstance>): void;
 
 /**
  * Creates a new instance of vtkInteractiveOrientationWidget
  * 
  * @param {object} [initialValues] for pre-setting some of its content
  */
-export function newInstance(initialValues? : Record<string, unknown>): vtkInteractiveOrientationWidget;
+export function newInstance<WidgetInstance extends vtkAbstractWidget = vtkAbstractWidget>(initialValues? : IInteractiveOrientationWidgetInitialValues<WidgetInstance>): vtkInteractiveOrientationWidget<WidgetInstance>;
 
 export declare const vtkInteractiveOrientationWidget: {
 	newInstance: typeof newInstance,

package/Widgets/Widgets3D/ResliceCursorWidget/behavior.d.ts

@@ -0,0 +1,5 @@
+import vtkAbstractWidget from '../../Core/AbstractWidget';
+
+export default interface vtkResliceCursorWidgetDefaultInstance extends vtkAbstractWidget {
+    invokeInternalInteractionEvent: () => void;
+}

package/Widgets/Widgets3D/ResliceCursorWidget.d.ts

@@ -1,5 +1,7 @@
 import { mat4 } from 'gl-matrix';
-import vtkAbstractWidgetFactory from './../Core/AbstractWidgetFactory';
+import { vtkAbstractWidgetFactory, IAbstractWidgetFactoryInitialValues } from './../Core/AbstractWidgetFactory';
+import vtkResliceCursorWidgetDefaultInstance from './ResliceCursorWidget/behavior';
+import vtkAbstractWidget from './../Core/AbstractWidget'
 import vtkImageData from './../../Common/DataModel/ImageData';
 import vtkImageReslice from './../../Imaging/Core/ImageReslice';
 import vtkPlaneSource from './../../Filters/Sources/PlaneSource';
@@ -16,7 +18,7 @@ export interface IDisplayScaleParams {
   rendererPixelDims: Vector2
 }
 
-export interface vtkResliceCursorWidget extends vtkAbstractWidgetFactory {
+export interface vtkResliceCursorWidget<WidgetInstance extends vtkAbstractWidget = vtkResliceCursorWidgetDefaultInstance> extends vtkAbstractWidgetFactory<WidgetInstance> {
 
   /**
    * @param {ViewTypes} viewType
@@ -81,7 +83,7 @@ export interface vtkResliceCursorWidget extends vtkAbstractWidgetFactory {
 
 }
 
-export interface IResliceCursorWidgetInitialValues {}
+export interface IResliceCursorWidgetInitialValues<WidgetInstance extends vtkAbstractWidget> extends IAbstractWidgetFactoryInitialValues<WidgetInstance> {}
 
 /**
  * Method used to decorate a given object (publicAPI+model) with vtkResliceCursorWidget characteristics.
@@ -90,18 +92,18 @@ export interface IResliceCursorWidgetInitialValues {}
  * @param model object on which data structure will be bounds (protected)
  * @param initialValues (default: {})
  */
-export function extend(
+export function extend<WidgetInstance extends vtkAbstractWidget>(
   publicAPI: object,
   model: object,
-  initialValues?: IResliceCursorWidgetInitialValues
-): vtkResliceCursorWidget;
+  initialValues?: IResliceCursorWidgetInitialValues<WidgetInstance>
+): void;
 
 /**
  * Method used to create a new instance of vtkResliceCursorWidget
  * 
  * @param initialValues for pre-setting some of its content
  */
-export function newInstance(initialValues?: IResliceCursorWidgetInitialValues): vtkResliceCursorWidget;
+export function newInstance<WidgetInstance extends vtkAbstractWidget = vtkResliceCursorWidgetDefaultInstance>(initialValues?: IResliceCursorWidgetInitialValues<WidgetInstance>): vtkResliceCursorWidget<WidgetInstance>;
 
 export declare const vtkResliceCursorWidget: {
   newInstance: typeof newInstance;

package/index.d.ts

@@ -206,9 +206,13 @@
 /// <reference path="./Rendering/Misc/SynchronizableRenderWindow/ObjectManager.d.ts" />
 /// <reference path="./Rendering/Misc/SynchronizableRenderWindow.d.ts" />
 /// <reference path="./Rendering/Misc/TextureLODsDownloader.d.ts" />
+/// <reference path="./Rendering/OpenGL/BufferObject/Constants.d.ts" />
+/// <reference path="./Rendering/OpenGL/BufferObject.d.ts" />
 /// <reference path="./Rendering/OpenGL/HardwareSelector/Constants.d.ts" />
 /// <reference path="./Rendering/OpenGL/HardwareSelector.d.ts" />
 /// <reference path="./Rendering/OpenGL/RenderWindow.d.ts" />
+/// <reference path="./Rendering/OpenGL/Texture/Constants.d.ts" />
+/// <reference path="./Rendering/OpenGL/Texture.d.ts" />
 /// <reference path="./Rendering/SceneGraph/RenderPass.d.ts" />
 /// <reference path="./Rendering/SceneGraph/ViewNode.d.ts" />
 /// <reference path="./Rendering/SceneGraph/ViewNodeFactory.d.ts" />
@@ -228,6 +232,7 @@
 /// <reference path="./Widgets/Representations/WidgetRepresentation.d.ts" />
 /// <reference path="./Widgets/Widgets3D/InteractiveOrientationWidget.d.ts" />
 /// <reference path="./Widgets/Widgets3D/ResliceCursorWidget/Constants.d.ts" />
+/// <reference path="./Widgets/Widgets3D/ResliceCursorWidget/behavior.d.ts" />
 /// <reference path="./Widgets/Widgets3D/ResliceCursorWidget.d.ts" />
 /// <reference path="./Widgets/Widgets3D/SeedWidget.d.ts" />
 /// <reference path="./Widgets/Widgets3D/SphereWidget.d.ts" />

package/package.json

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