@types/three 0.180.0 → 0.182.0

three/src/renderers/common/Renderer.d.ts

@@ -23,10 +23,13 @@ import Attributes from "./Attributes.js";
 import Backend from "./Backend.js";
 import Background from "./Background.js";
 import Bindings from "./Bindings.js";
+import CanvasTarget from "./CanvasTarget.js";
 import ClippingContext from "./ClippingContext.js";
 import Color4 from "./Color4.js";
 import Geometries from "./Geometries.js";
+import IndirectStorageBufferAttribute from "./IndirectStorageBufferAttribute.js";
 import Info from "./Info.js";
+import InspectorBase from "./InspectorBase.js";
 import Lighting from "./Lighting.js";
 import NodeLibrary from "./nodes/NodeLibrary.js";
 import Nodes from "./nodes/Nodes.js";
@@ -61,7 +64,7 @@ export interface RendererParameters {
     antialias?: boolean | undefined;
     samples?: number | undefined;
     getFallback?: ((error: unknown) => Backend) | null | undefined;
-    colorBufferType?: TextureDataType | undefined;
+    outputBufferType?: TextureDataType | undefined;
     multiview?: boolean | undefined;
 }
 /**
@@ -69,9 +72,7 @@ export interface RendererParameters {
  */
 declare class Renderer {
     readonly isRenderer: true;
-    domElement: HTMLCanvasElement;
     backend: Backend;
-    samples: number;
     autoClear: boolean;
     autoClearColor: boolean;
     autoClearDepth: boolean;
@@ -87,13 +88,10 @@ declare class Renderer {
     info: Info;
     library: NodeLibrary;
     lighting: Lighting;
+    _samples: number;
+    _canvasTarget: CanvasTarget;
+    _inspector: InspectorBase;
     _getFallback: ((error: unknown) => Backend) | null;
-    _pixelRatio: number;
-    _width: number;
-    _height: number;
-    _viewport: Vector4;
-    _scissor: Vector4;
-    _scissorTest: boolean;
     _attributes: Attributes | null;
     _geometries: Geometries | null;
     _nodes: Nodes | null;
@@ -158,7 +156,7 @@ declare class Renderer {
     ) => void;
     _isDeviceLost: boolean;
     onDeviceLost: (info: DeviceLostInfo) => void;
-    _colorBufferType: TextureDataType;
+    _outputBufferType: TextureDataType;
     _initialized: boolean;
     _initPromise: Promise<this> | null;
     _compilationPromises: Promise<void>[] | null;
@@ -197,7 +195,7 @@ declare class Renderer {
      * @property {number} [samples=0] - When `antialias` is `true`, `4` samples are used by default. This parameter can set to any other integer value than 0
      * to overwrite the default.
      * @property {?Function} [getFallback=null] - This callback function can be used to provide a fallback backend, if the primary backend can't be targeted.
-     * @property {number} [colorBufferType=HalfFloatType] - Defines the type of color buffers. The default `HalfFloatType` is recommend for best
+     * @property {number} [outputBufferType=HalfFloatType] - Defines the type of output buffers. The default `HalfFloatType` is recommend for best
      * quality. To save memory and bandwidth, `UnsignedByteType` might be used. This will reduce rendering quality though.
      * @property {boolean} [multiview=false] - If set to `true`, the renderer will use multiview during WebXR rendering if supported.
      */
@@ -215,6 +213,14 @@ declare class Renderer {
      * @return {Promise<this>} A Promise that resolves when the renderer has been initialized.
      */
     init(): Promise<this>;
+    /**
+     * A reference to the canvas element the renderer is drawing to.
+     * This value of this property will automatically be created by
+     * the renderer.
+     *
+     * @type {HTMLCanvasElement|OffscreenCanvas}
+     */
+    get domElement(): HTMLCanvasElement;
     /**
      * The coordinate system of the renderer. The value of this property
      * depends on the selected backend. Either `THREE.WebGLCoordinateSystem` or
@@ -237,13 +243,14 @@ declare class Renderer {
      * @param {Object3D} scene - The scene or 3D object to precompile.
      * @param {Camera} camera - The camera that is used to render the scene.
      * @param {?Scene} targetScene - If the first argument is a 3D object, this parameter must represent the scene the 3D object is going to be added.
-     * @return {Promise<Array|undefined>} A Promise that resolves when the compile has been finished.
+     * @return {Promise} A Promise that resolves when the compile has been finished.
      */
     compileAsync(scene: Object3D, camera: Camera, targetScene?: Scene | null): Promise<void>;
     /**
      * Renders the scene in an async fashion.
      *
      * @async
+     * @deprecated
      * @param {Object3D} scene - The scene or 3D object to render.
      * @param {Camera} camera - The camera.
      * @return {Promise} A Promise that resolves when the render has been finished.
@@ -254,9 +261,17 @@ declare class Renderer {
      * the CPU waits for the GPU to complete its operation (e.g. a compute task).
      *
      * @async
+     * @deprecated
      * @return {Promise} A Promise that resolves when synchronization has been finished.
      */
     waitForGPU(): Promise<void>;
+    set inspector(value: InspectorBase);
+    /**
+     * The inspector instance. The inspector can be any class that extends from `InspectorBase`.
+     *
+     * @type {InspectorBase}
+     */
+    get inspector(): InspectorBase;
     /**
      * Enables or disables high precision for model-view and normal-view matrices.
      * When enabled, will use CPU 64-bit precision for higher precision instead of GPU 32-bit for higher performance.
@@ -288,9 +303,16 @@ declare class Renderer {
      */
     getMRT(): MRTNode | null;
     /**
-     * Returns the color buffer type.
+     * Returns the output buffer type.
+     *
+     * @return {number} The output buffer type.
+     */
+    getOutputBufferType(): TextureDataType;
+    /**
+     * Returns the output buffer type.
      *
-     * @return {number} The color buffer type.
+     * @deprecated since r182. Use `.getOutputBufferType()` instead.
+     * @return {number} The output buffer type.
      */
     getColorBufferType(): TextureDataType;
     /**
@@ -311,17 +333,27 @@ declare class Renderer {
     _renderBundle(bundle: Bundle, sceneRef: Scene, lightsNode: LightsNode): void;
     /**
      * Renders the scene or 3D object with the given camera. This method can only be called
-     * if the renderer has been initialized.
+     * if the renderer has been initialized. When using `render()` inside an animation loop,
+     * it's guaranteed the renderer will be initialized. The animation loop must be defined
+     * with {@link Renderer#setAnimationLoop} though.
+     *
+     * For all other use cases (like when using on-demand rendering), you must call
+     * {@link Renderer#init} before rendering.
      *
      * The target of the method is the default framebuffer (meaning the canvas)
      * or alternatively a render target when specified via `setRenderTarget()`.
      *
      * @param {Object3D} scene - The scene or 3D object to render.
      * @param {Camera} camera - The camera to render the scene with.
-     * @return {?Promise} A Promise that resolve when the scene has been rendered.
-     * Only returned when the renderer has not been initialized.
      */
-    render(scene: Object3D, camera: Camera): Promise<void> | undefined;
+    render(scene: Object3D, camera: Camera): void;
+    /**
+     * Returns whether the renderer has been initialized or not.
+     *
+     * @readonly
+     * @return {boolean} Whether the renderer has been initialized or not.
+     */
+    get initialized(): boolean;
     /**
      * Returns an internal render target which is used when computing the output tone mapping
      * and color space conversion. Unlike in `WebGLRenderer`, this is done in a separate render
@@ -330,7 +362,7 @@ declare class Renderer {
      * @private
      * @return {?RenderTarget} The render target. The method returns `null` if no output conversion should be applied.
      */
-    _getFrameBufferTarget(): RenderTarget<Texture> | null;
+    _getFrameBufferTarget(): RenderTarget<Texture<unknown>> | null;
     /**
      * Renders the scene or 3D object with the given camera.
      *
@@ -373,10 +405,16 @@ declare class Renderer {
      * for best compatibility.
      *
      * @async
-     * @param {?Function} callback - The application's animation loop.
+     * @param {?onAnimationCallback} callback - The application's animation loop.
      * @return {Promise} A Promise that resolves when the set has been executed.
      */
     setAnimationLoop(callback: ((time: DOMHighResTimeStamp, frame?: XRFrame) => void) | null): Promise<void>;
+    /**
+     * Returns the current animation loop callback.
+     *
+     * @return {?Function} The current animation loop callback.
+     */
+    getAnimationLoop(): ((time: DOMHighResTimeStamp, xrFrame?: XRFrame) => void) | null;
     /**
      * Can be used to transfer buffer data from a storage buffer attribute
      * from the GPU to the CPU in context of compute shaders.
@@ -464,9 +502,9 @@ declare class Renderer {
     /**
      * Defines the scissor rectangle.
      *
-     * @param {number | Vector4} x - The horizontal coordinate for the lower left corner of the box in logical pixel unit.
+     * @param {number | Vector4} x - The horizontal coordinate for the upper left corner of the box in logical pixel unit.
      * Instead of passing four arguments, the method also works with a single four-dimensional vector.
-     * @param {number} y - The vertical coordinate for the lower left corner of the box in logical pixel unit.
+     * @param {number} y - The vertical coordinate for the upper left corner of the box in logical pixel unit.
      * @param {number} width - The width of the scissor box in logical pixel unit.
      * @param {number} height - The height of the scissor box in logical pixel unit.
      */
@@ -494,8 +532,8 @@ declare class Renderer {
     /**
      * Defines the viewport.
      *
-     * @param {number | Vector4} x - The horizontal coordinate for the lower left corner of the viewport origin in logical pixel unit.
-     * @param {number} y - The vertical coordinate for the lower left corner of the viewport origin  in logical pixel unit.
+     * @param {number | Vector4} x - The horizontal coordinate for the upper left corner of the viewport origin in logical pixel unit.
+     * @param {number} y - The vertical coordinate for the upper left corner of the viewport origin  in logical pixel unit.
      * @param {number} width - The width of the viewport in logical pixel unit.
      * @param {number} height - The height of the viewport in logical pixel unit.
      * @param {number} minDepth - The minimum depth value of the viewport. WebGPU only.
@@ -568,35 +606,25 @@ declare class Renderer {
      * @param {boolean} [color=true] - Whether the color buffer should be cleared or not.
      * @param {boolean} [depth=true] - Whether the depth buffer should be cleared or not.
      * @param {boolean} [stencil=true] - Whether the stencil buffer should be cleared or not.
-     * @return {Promise} A Promise that resolves when the clear operation has been executed.
-     * Only returned when the renderer has not been initialized.
      */
-    clear(color?: boolean, depth?: boolean, stencil?: boolean): Promise<void> | undefined;
+    clear(color?: boolean, depth?: boolean, stencil?: boolean): void;
     /**
      * Performs a manual clear operation of the color buffer. This method ignores `autoClear` properties.
-     *
-     * @return {Promise} A Promise that resolves when the clear operation has been executed.
-     * Only returned when the renderer has not been initialized.
      */
-    clearColor(): Promise<void> | undefined;
+    clearColor(): void;
     /**
      * Performs a manual clear operation of the depth buffer. This method ignores `autoClear` properties.
-     *
-     * @return {Promise} A Promise that resolves when the clear operation has been executed.
-     * Only returned when the renderer has not been initialized.
      */
-    clearDepth(): Promise<void> | undefined;
+    clearDepth(): void;
     /**
      * Performs a manual clear operation of the stencil buffer. This method ignores `autoClear` properties.
-     *
-     * @return {Promise} A Promise that resolves when the clear operation has been executed.
-     * Only returned when the renderer has not been initialized.
      */
-    clearStencil(): Promise<void> | undefined;
+    clearStencil(): void;
     /**
      * Async version of {@link Renderer#clear}.
      *
      * @async
+     * @deprecated
      * @param {boolean} [color=true] - Whether the color buffer should be cleared or not.
      * @param {boolean} [depth=true] - Whether the depth buffer should be cleared or not.
      * @param {boolean} [stencil=true] - Whether the stencil buffer should be cleared or not.
@@ -607,6 +635,7 @@ declare class Renderer {
      * Async version of {@link Renderer#clearColor}.
      *
      * @async
+     * @deprecated
      * @return {Promise} A Promise that resolves when the clear operation has been executed.
      */
     clearColorAsync(): Promise<void>;
@@ -614,6 +643,7 @@ declare class Renderer {
      * Async version of {@link Renderer#clearDepth}.
      *
      * @async
+     * @deprecated
      * @return {Promise} A Promise that resolves when the clear operation has been executed.
      */
     clearDepthAsync(): Promise<void>;
@@ -621,9 +651,32 @@ declare class Renderer {
      * Async version of {@link Renderer#clearStencil}.
      *
      * @async
+     * @deprecated
      * @return {Promise} A Promise that resolves when the clear operation has been executed.
      */
     clearStencilAsync(): Promise<void>;
+    /**
+     * Returns `true` if a framebuffer target is needed to perform tone mapping or color space conversion.
+     * If this is the case, the renderer allocates an internal render target for that purpose.
+     */
+    get needsFrameBufferTarget(): boolean;
+    /**
+     * The number of samples used for multi-sample anti-aliasing (MSAA).
+     *
+     * @type {number}
+     * @default 0
+     */
+    get samples(): number;
+    /**
+     * The current number of samples used for multi-sample anti-aliasing (MSAA).
+     *
+     * When rendering to a custom render target, the number of samples of that render target is used.
+     * If the renderer needs an internal framebuffer target for tone mapping or color space conversion,
+     * the number of samples is set to 0.
+     *
+     * @type {number}
+     */
+    get currentSamples(): number;
     /**
      * The current tone mapping of the renderer. When not producing screen output,
      * the tone mapping is always `NoToneMapping`.
@@ -664,7 +717,7 @@ declare class Renderer {
      *
      * @return {?RenderTarget} The render target. Returns `null` if no render target is set.
      */
-    getRenderTarget(): RenderTarget<Texture> | null;
+    getRenderTarget(): RenderTarget<Texture<unknown>> | null;
     /**
      * Sets the output render target for the renderer.
      *
@@ -676,9 +729,24 @@ declare class Renderer {
      *
      * @return {?RenderTarget} The current output render target. Returns `null` if no output target is set.
      */
-    getOutputRenderTarget(): RenderTarget<Texture> | null;
+    getOutputRenderTarget(): RenderTarget<Texture<unknown>> | null;
+    /**
+     * Sets the canvas target. The canvas target manages the HTML canvas
+     * or the offscreen canvas the renderer draws into.
+     *
+     * @param {CanvasTarget} canvasTarget - The canvas target.
+     */
+    setCanvasTarget(canvasTarget: CanvasTarget): void;
+    /**
+     * Returns the current canvas target.
+     *
+     * @return {CanvasTarget} The current canvas target.
+     */
+    getCanvasTarget(): CanvasTarget;
     /**
      * Resets the renderer to the initial state before WebXR started.
+     *
+     * @private
      */
     _resetXRState(): void;
     /**
@@ -742,29 +810,36 @@ declare class Renderer {
      * if the renderer has been initialized.
      *
      * @param {Node|Array<Node>} computeNodes - The compute node(s).
-     * @param {?(Array<number>|number)} [dispatchSizeOrCount=null] - Array with [ x, y, z ] values for dispatch or a single number for the count.
+     * @param {number|Array<number>|IndirectStorageBufferAttribute} [dispatchSize=null]
+     * - A single number representing count, or
+     * - An array [x, y, z] representing dispatch size, or
+     * - A IndirectStorageBufferAttribute for indirect dispatch size.
      * @return {Promise|undefined} A Promise that resolve when the compute has finished. Only returned when the renderer has not been initialized.
      */
     compute(
         computeNodes: ComputeNode | ComputeNode[],
-        dispatchSizeOrCount?: number[] | number | null,
+        dispatchSize?: number[] | number | IndirectStorageBufferAttribute | null,
     ): Promise<void> | undefined;
     /**
      * Execute a single or an array of compute nodes.
      *
      * @async
      * @param {Node|Array<Node>} computeNodes - The compute node(s).
-     * @param {?(Array<number>|number)} [dispatchSizeOrCount=null] - Array with [ x, y, z ] values for dispatch or a single number for the count.
+     * @param {number|Array<number>|IndirectStorageBufferAttribute} [dispatchSize=null]
+     * - A single number representing count, or
+     * - An array [x, y, z] representing dispatch size, or
+     * - A IndirectStorageBufferAttribute for indirect dispatch size.
      * @return {Promise} A Promise that resolve when the compute has finished.
      */
     computeAsync(
         computeNodes: ComputeNode | ComputeNode[],
-        dispatchSizeOrCount?: number[] | number | null,
+        dispatchSize?: number[] | number | IndirectStorageBufferAttribute | null,
     ): Promise<void>;
     /**
      * Checks if the given feature is supported by the selected backend.
      *
      * @async
+     * @deprecated
      * @param {string} name - The feature's name.
      * @return {Promise<boolean>} A Promise that resolves with a bool that indicates whether the feature is supported or not.
      */
@@ -777,7 +852,7 @@ declare class Renderer {
      * @param {string} name - The feature's name.
      * @return {boolean} Whether the feature is supported or not.
      */
-    hasFeature(name: string): false | void;
+    hasFeature(name: string): void;
     /**
      * Returns `true` when the renderer has been initialized.
      *
@@ -789,6 +864,7 @@ declare class Renderer {
      * (which can cause noticeable lags due to decode and GPU upload overhead).
      *
      * @async
+     * @deprecated
      * @param {Texture} texture - The texture.
      * @return {Promise} A Promise that resolves when the texture has been initialized.
      */
@@ -853,6 +929,7 @@ declare class Renderer {
      * Analyzes the given 3D object's hierarchy and builds render lists from the
      * processed hierarchy.
      *
+     * @private
      * @param {Object3D} object - The 3D object to process (usually a scene).
      * @param {Camera} camera - The camera the object is rendered with.
      * @param {number} groupOrder - The group order is derived from the `renderOrder` of groups and is used to group 3D objects within groups.
@@ -909,6 +986,15 @@ declare class Renderer {
         lightsNode: LightsNode,
         passId?: string | null,
     ): void;
+    /**
+     * Retrieves shadow nodes for the given material. This is used to setup shadow passes.
+     * The result is cached per material and updated when the material's version changes.
+     *
+     * @private
+     * @param {Material} material
+     * @returns {Object} - The shadow nodes for the material.
+     */
+    _getShadowNodes(material: Material): any;
     /**
      * This method represents the default render object function that manages the render lifecycle
      * of the object.
@@ -982,6 +1068,12 @@ declare class Renderer {
         clippingContext: ClippingContext | null,
         passId?: string,
     ): void;
+    /**
+     * Callback when the canvas has been resized.
+     *
+     * @private
+     */
+    _onCanvasTargetResize(): void;
     /**
      * Alias for `compileAsync()`.
      *
@@ -993,4 +1085,11 @@ declare class Renderer {
      */
     get compile(): (scene: Object3D, camera: Camera, targetScene?: Scene | null) => Promise<void>;
 }
+/**
+ * Animation loop parameter of `renderer.setAnimationLoop()`.
+ *
+ * @callback onAnimationCallback
+ * @param {DOMHighResTimeStamp} time - A timestamp indicating the end time of the previous frame's rendering.
+ * @param {XRFrame} [frame] - A reference to the current XR frame. Only relevant when using XR rendering.
+ */
 export default Renderer;

three/src/renderers/common/SampledTexture.d.ts

@@ -6,6 +6,8 @@ declare class SampledTexture extends Sampler {
 
     store: boolean;
 
+    mipLevel: number;
+
     readonly isSampledTexture: true;
 
     constructor(name: string, texture: Texture | null);

three/src/renderers/common/Sampler.d.ts

@@ -6,6 +6,8 @@ declare class Sampler extends Binding {
 
     generation: number | null;
 
+    samplerKey: string;
+
     readonly isSampler: true;
 
     constructor(name: string, texture: Texture | null);

three/src/renderers/common/Textures.d.ts

@@ -87,6 +87,19 @@ declare class Textures extends DataMap<{
      * @param {Object} [options={}] - The options.
      */
     updateTexture(texture: Texture, options?: TextureOptions): void;
+    /**
+     * Updates the sampler for the given texture. This method has no effect
+     * for the WebGL backend since it has no concept of samplers. Texture
+     * parameters are configured with the `texParameter()` command for each
+     * texture.
+     *
+     * In WebGPU, samplers are objects like textures and it's possible to share
+     * them when the texture parameters match.
+     *
+     * @param {Texture} texture - The texture to update the sampler for.
+     * @return {string} The current sampler key.
+     */
+    updateSampler(texture: Texture): void;
     /**
      * Computes the size of the given texture and writes the result
      * into the target vector. This vector is also returned by the
@@ -116,6 +129,13 @@ declare class Textures extends DataMap<{
      * @return {boolean} Whether mipmaps are required or not.
      */
     needsMipmaps(texture: Texture): boolean;
+    /**
+     * Frees internal resources when the given render target isn't
+     * required anymore.
+     *
+     * @param {RenderTarget} renderTarget - The render target to destroy.
+     */
+    _destroyRenderTarget(renderTarget: RenderTarget): void;
     /**
      * Frees internal resource when the given texture isn't
      * required anymore.

three/src/renderers/common/TimestampQueryPool.d.ts

@@ -10,21 +10,44 @@ declare abstract class TimestampQueryPool {
     queryOffsets: Map<number, number>;
     isDisposed: boolean;
     lastValue: number;
+    frames: number[];
     pendingResolve: boolean;
+    timestamps: Map<string, number>;
     /**
      * Creates a new timestamp query pool.
      *
      * @param {number} [maxQueries=256] - Maximum number of queries this pool can hold.
      */
     constructor(maxQueries?: number);
+    /**
+     * Returns all timestamp frames.
+     *
+     * @return {Array<number>} The timestamp frames.
+     */
+    getTimestampFrames(): number[];
+    /**
+     * Returns the timestamp for a given render context.
+     *
+     * @param {string} uid - A unique identifier for the render context.
+     * @return {?number} The timestamp, or undefined if not available.
+     */
+    getTimestamp(uid: string): number;
+    /**
+     * Returns whether a timestamp is available for a given render context.
+     *
+     * @param {string} uid - A unique identifier for the render context.
+     * @return {boolean} True if a timestamp is available, false otherwise.
+     */
+    hasTimestamp(uid: string): boolean;
     /**
      * Allocate queries for a specific uid.
      *
      * @abstract
      * @param {string} uid - A unique identifier for the render context.
+     * @param {number} frameId - The current frame identifier.
      * @returns {?number}
      */
-    abstract allocateQueriesForContext(uid: string): number | null;
+    abstract allocateQueriesForContext(uid: string, frameId: number): number | null;
     /**
      * Resolve all timestamps and return data (or process them).
      *

three/src/renderers/common/UniformsGroup.d.ts

@@ -128,6 +128,7 @@ declare class UniformsGroup extends UniformBuffer {
     /**
      * Returns a typed array that matches the given data type.
      *
+     * @private
      * @param {string} type - The data type.
      * @return {TypedArray} The typed array.
      */

three/src/renderers/common/extras/PMREMGenerator.d.ts

@@ -1,6 +1,7 @@
 import { RenderTarget } from "../../../core/RenderTarget.js";
 import { Vector3 } from "../../../math/Vector3.js";
 import { Scene } from "../../../scenes/Scene.js";
+import { Texture } from "../../../textures/Texture.js";
 import Renderer from "../Renderer.js";
 
 export interface PMREMGeneratorOptions {
@@ -19,7 +20,9 @@ declare class PMREMGenerator {
         far?: number,
         options?: PMREMGeneratorOptions,
     ): RenderTarget;
-
+    /**
+     * @deprecated ".fromSceneAsync()" is deprecated. Use "await renderer.init()" instead.
+     */
     fromSceneAsync(
         scene: Scene,
         sigma?: number,
@@ -28,6 +31,21 @@ declare class PMREMGenerator {
         options?: PMREMGeneratorOptions,
     ): Promise<RenderTarget>;
 
+    fromEquirectangular(equirectangular: Texture, renderTarget?: RenderTarget | null): RenderTarget;
+    /**
+     * @deprecated ".fromEquirectangularAsync()" is deprecated. Use "await renderer.init()" instead.
+     */
+    fromEquirectangularAsync(equirectangular: Texture, renderTarget?: RenderTarget | null): Promise<RenderTarget>;
+
+    fromCubemap(cubemap: Texture, renderTarget?: RenderTarget | null): RenderTarget;
+    /**
+     * @deprecated ".fromCubemapAsync()" is deprecated. Use "await renderer.init()" instead.
+     */
+    fromCubemapAsync(cubemap: Texture, renderTarget?: RenderTarget | null): Promise<RenderTarget>;
+
+    compileCubemapShader(): Promise<void>;
+    compileEquirectangularShader(): Promise<void>;
+
     dispose(): void;
 }
 

three/src/renderers/common/nodes/NodeLibrary.d.ts

@@ -4,7 +4,6 @@ import { Material } from "../../../materials/Material.js";
 import NodeMaterial from "../../../materials/nodes/NodeMaterial.js";
 import Node from "../../../nodes/core/Node.js";
 import AnalyticLightNode from "../../../nodes/lighting/AnalyticLightNode.js";
-import { ShaderNodeObject } from "../../../nodes/tsl/TSLCore.js";
 /**
  * The purpose of a node library is to assign node implementations
  * to existing library features. In `WebGPURenderer` lights, materials
@@ -22,7 +21,7 @@ declare class NodeLibrary {
     materialNodes: Map<string, {
         new(): NodeMaterial;
     }>;
-    toneMappingNodes: Map<ToneMapping, (color: Node, exposure: Node) => ShaderNodeObject<Node>>;
+    toneMappingNodes: Map<ToneMapping, (color: Node, exposure: Node) => Node>;
     /**
      * Constructs a new node library.
      */
@@ -44,17 +43,14 @@ declare class NodeLibrary {
      * @param {Function} toneMappingNode - The tone mapping node function.
      * @param {number} toneMapping - The tone mapping.
      */
-    addToneMapping(
-        toneMappingNode: (color: Node, exposure: Node) => ShaderNodeObject<Node>,
-        toneMapping: ToneMapping,
-    ): void;
+    addToneMapping(toneMappingNode: (color: Node, exposure: Node) => Node, toneMapping: ToneMapping): void;
     /**
      * Returns a tone mapping node function for a tone mapping technique (constant).
      *
      * @param {number} toneMapping - The tone mapping.
      * @return {?Function} The tone mapping node function. Returns `null` if no node function is found.
      */
-    getToneMappingFunction(toneMapping: ToneMapping): ((color: Node, exposure: Node) => ShaderNodeObject<Node>) | null;
+    getToneMappingFunction(toneMapping: ToneMapping): ((color: Node, exposure: Node) => Node) | null;
     /**
      * Returns a node material class definition for a material type.
      *