@types/three 0.180.0 → 0.181.0

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

@@ -0,0 +1,105 @@
+import { Camera } from "../../cameras/Camera.js";
+import { RenderTarget } from "../../core/RenderTarget.js";
+import ComputeNode from "../../nodes/gpgpu/ComputeNode.js";
+import { Scene } from "../../scenes/Scene.js";
+import { Texture } from "../../textures/Texture.js";
+import Renderer from "./Renderer.js";
+/**
+ * InspectorBase is the base class for all inspectors.
+ *
+ * @class InspectorBase
+ */
+declare class InspectorBase {
+    _renderer: Renderer | null;
+    /**
+     * Creates a new InspectorBase.
+     */
+    constructor();
+    /**
+     * Returns the node frame for the current renderer.
+     *
+     * @return {Object} The node frame.
+     */
+    get nodeFrame(): import("../../Three.WebGPU.Nodes.js").NodeFrame;
+    /**
+     * Sets the renderer for this inspector.
+     *
+     * @param {WebGLRenderer} renderer - The renderer to associate with this inspector.
+     * @return {InspectorBase} This inspector instance.
+     */
+    setRenderer(renderer: Renderer | null): this;
+    /**
+     * Returns the renderer associated with this inspector.
+     *
+     * @return {WebGLRenderer} The associated renderer.
+     */
+    getRenderer(): Renderer | null;
+    /**
+     * Initializes the inspector.
+     */
+    init(): void;
+    /**
+     * Called when a frame begins.
+     */
+    begin(): void;
+    /**
+     * Called when a frame ends.
+     */
+    finish(): void;
+    /**
+     * Inspects a node.
+     *
+     * @param {Node} node - The node to inspect.
+     */
+    inspect(): void;
+    /**
+     * When a compute operation is performed.
+     *
+     * @param {ComputeNode} computeNode - The compute node being executed.
+     * @param {number|Array<number>} dispatchSizeOrCount - The dispatch size or count.
+     */
+    computeAsync(computeNode: ComputeNode, dispatchSizeOrCount: number | number[]): void;
+    /**
+     * Called when a compute operation begins.
+     *
+     * @param {string} uid - A unique identifier for the render context.
+     * @param {ComputeNode} computeNode - The compute node being executed.
+     */
+    beginCompute(uid: string, computeNode: ComputeNode): void;
+    /**
+     * Called when a compute operation ends.
+     *
+     * @param {string} uid - A unique identifier for the render context.
+     * @param {ComputeNode} computeNode - The compute node being executed.
+     */
+    finishCompute(uid: string): void;
+    /**
+     * Called when a render operation begins.
+     *
+     * @param {string} uid - A unique identifier for the render context.
+     * @param {Scene} scene - The scene being rendered.
+     * @param {Camera} camera - The camera being used for rendering.
+     * @param {?WebGLRenderTarget} renderTarget - The render target, if any.
+     */
+    beginRender(uid: string, scene: Scene, camera: Camera, renderTarget: RenderTarget): void;
+    /**
+     * Called when an animation loop ends.
+     *
+     * @param {string} uid - A unique identifier for the render context.
+     */
+    finishRender(uid: string): void;
+    /**
+     * Called when a texture copy operation is performed.
+     *
+     * @param {Texture} srcTexture - The source texture.
+     * @param {Texture} dstTexture - The destination texture.
+     */
+    copyTextureToTexture(srcTexture: Texture, dstTexture: Texture): void;
+    /**
+     * Called when a framebuffer copy operation is performed.
+     *
+     * @param {Texture} framebufferTexture - The texture associated with the framebuffer.
+     */
+    copyFramebufferToTexture(framebufferTexture: Texture): void;
+}
+export default InspectorBase;

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

@@ -15,6 +15,9 @@ declare class PostProcessing {
 
     dispose(): void;
 
+    /**
+     * @deprecated "renderAsync()" has been deprecated. Use "render()" and "await renderer.init();" when creating the renderer.
+     */
     renderAsync(): Promise<void>;
 }
 

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

@@ -10,6 +10,9 @@ export default class QuadMesh extends Mesh {
 
     constructor(material?: Material | null);
 
+    /**
+     * @deprecated "renderAsync()" has been deprecated. Use "render()" and "await renderer.init();" when creating the renderer.
+     */
     renderAsync(renderer: Renderer): Promise<void>;
 
     render(renderer: Renderer): void;

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

@@ -39,7 +39,9 @@ declare class RenderContexts {
      * @param {string} attachmentState - The attachment state.
      * @return {ChainMap} The chain map.
      */
-    _getChainMap(attachmentState: string): ChainMap<readonly [Scene, Camera], RenderContext>;
+    _getChainMap(
+        attachmentState: string,
+    ): ChainMap<readonly [Scene<import("../../Three.Core.js").Object3DEventMap>, Camera], RenderContext>;
     /**
      * Frees internal resources.
      */

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";
@@ -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;
@@ -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
@@ -244,6 +250,7 @@ declare class Renderer {
      * 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>;
+    /**
+     * Sets the inspector instance. The inspector can be any class that extends from `InspectorBase`.
+     *
+     * @param {InspectorBase} value - The new inspector.
+     */
+    set inspector(value: 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.
@@ -311,17 +326,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 +355,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 +398,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.
@@ -568,35 +599,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 +628,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 +636,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 +644,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 +710,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,7 +722,20 @@ 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.
      */
@@ -742,29 +801,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 +843,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 +855,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.
      */
@@ -909,6 +976,14 @@ 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.
+     *
+     * @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 +1057,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 +1074,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/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.
      *