@types/three 0.167.2 → 0.169.0

three/src/nodes/utils/{StoargeArrayElementNode.d.ts → StorageArrayElementNode.d.ts}

@@ -1,5 +1,5 @@
 import StorageBufferNode from "../accessors/StorageBufferNode.js";
-import { NodeRepresentation, ShaderNodeObject } from "../shadernode/ShaderNode.js";
+import { NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
 import ArrayElementNode from "./ArrayElementNode.js";
 
 export default class StorageArrayElementNode extends ArrayElementNode {
@@ -17,9 +17,3 @@ export const storageElement: (
     storageBufferNode: NodeRepresentation,
     indexNode: NodeRepresentation,
 ) => ShaderNodeObject<StorageArrayElementNode>;
-
-declare module "../shadernode/ShaderNode.js" {
-    interface NodeElements {
-        storageElement: typeof storageElement;
-    }
-}

three/src/nodes/utils/TimerNode.d.ts

@@ -1,5 +1,5 @@
 import UniformNode from "../core/UniformNode.js";
-import { ShaderNodeObject } from "../shadernode/ShaderNode.js";
+import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
 export type TimerNodeScope =
     | typeof TimerNode.LOCAL

three/src/nodes/utils/TriplanarTexturesNode.d.ts

@@ -1,6 +1,6 @@
 import TextureNode from "../accessors/TextureNode.js";
 import Node from "../core/Node.js";
-import { NodeRepresentation, ShaderNodeObject } from "../shadernode/ShaderNode.js";
+import { NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
 
 export default class TriplanarTexturesNode extends Node {
     textureXNode: TextureNode;
@@ -34,9 +34,3 @@ export const triplanarTexture: (
     texture: NodeRepresentation,
     ...params: NodeRepresentation[]
 ) => ShaderNodeObject<TriplanarTexturesNode>;
-
-declare module "../shadernode/ShaderNode.js" {
-    interface NodeElements {
-        triplanarTexture: typeof triplanarTexture;
-    }
-}

three/src/nodes/utils/UVUtils.d.ts

@@ -0,0 +1,14 @@
+import OperatorNode from "../math/OperatorNode.js";
+import { NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
+
+export const rotateUV: (
+    uv: NodeRepresentation,
+    rotation: NodeRepresentation,
+    center?: NodeRepresentation,
+) => ShaderNodeObject<OperatorNode>;
+
+export const spherizeUV: (
+    uv: NodeRepresentation,
+    strength: NodeRepresentation,
+    center?: NodeRepresentation,
+) => ShaderNodeObject<OperatorNode>;

three/src/nodes/utils/ViewportUtils.d.ts

@@ -0,0 +1,4 @@
+import Node from "../core/Node.js";
+import { NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
+
+export const viewportSafeUV: (uv?: NodeRepresentation | null) => ShaderNodeObject<Node>;

three/src/objects/BatchedMesh.d.ts

@@ -141,6 +141,25 @@ declare class BatchedMesh extends Mesh<BufferGeometry, Material> {
      */
     getVisibleAt(instanceId: number): boolean;
 
+    /**
+     * Get the range representing the subset of triangles related to the attached geometry, indicating the starting
+     * offset and count, or `null` if invalid.
+     *
+     * Return an object of the form: { start: Integer, count: Integer }
+     * @param geometryId The id of the geometry to get the range of.
+     * @param target Optional target object to copy the range in to.
+     */
+    getGeometryRangeAt(
+        geometryId: number,
+        target?: { start: number; count: number },
+    ): { start: number; count: number } | null;
+
+    /**
+     * Get the geometryIndex of the defined instance.
+     * @param instanceId The id of an instance to get the geometryIndex of.
+     */
+    getGeometryIdAt(instanceId: number): number;
+
     /**
      * Sets the given color to the defined geometry instance.
      * @param instanceId The id of the instance to set the color of.
@@ -162,6 +181,13 @@ declare class BatchedMesh extends Mesh<BufferGeometry, Material> {
      */
     setVisibleAt(instanceId: number, visible: boolean): this;
 
+    /**
+     * Sets the geometryIndex of the instance at the given index.
+     * @param instanceId The id of the instance to set the geometryIndex of.
+     * @param geometryId The geometryIndex to be use by the instance.
+     */
+    setGeometryIdAt(instanceId: number, geometryId: number): this;
+
     /**
      * Adds the given geometry to the {@link BatchedMesh} and returns the associated index referring to it.
      * @param geometry The geometry to add into the {@link BatchedMesh}.
@@ -182,6 +208,13 @@ declare class BatchedMesh extends Mesh<BufferGeometry, Material> {
      */
     addInstance(geometryId: number): number;
 
+    /**
+     * Removes an existing instance from the BatchedMesh using the given instanceId.
+     * @param instanceId The id of an instance to remove from the BatchedMesh that was previously added via
+     * "addInstance".
+     */
+    deleteInstance(instanceId: number): this;
+
     /**
      * Replaces the geometry at `geometryId` with the provided geometry. Throws an error if there is not enough space
      * reserved for geometry. Calling this will change all instances that are rendering that geometry.

three/src/objects/Group.d.ts

@@ -34,10 +34,4 @@ export class Group<TEventMap extends Object3DEventMap = Object3DEventMap> extend
      * @defaultValue `true`
      */
     readonly isGroup: true;
-
-    /**
-     * @override
-     * @defaultValue `Group`
-     */
-    override readonly type: string | "Group";
 }

three/src/objects/LOD.d.ts

@@ -81,6 +81,13 @@ export class LOD<TEventMap extends Object3DEventMap = Object3DEventMap> extends
      */
     addLevel(object: Object3D, distance?: number, hysteresis?: number): this;
 
+    /**
+     * Removes an existing level, based on the distance from the camera. Returns `true` when the level has been removed.
+     * Otherwise `false`.
+     * @param distance Distance of the level to delete.
+     */
+    removeLabel(distance: number): boolean;
+
     /**
      * Get the currently active {@link LOD} level
      * @remarks

three/src/renderers/WebGLRenderer.d.ts

@@ -15,7 +15,7 @@ import { Scene } from "../scenes/Scene.js";
 import { Data3DTexture } from "../textures/Data3DTexture.js";
 import { DataArrayTexture } from "../textures/DataArrayTexture.js";
 import { OffscreenCanvas, Texture } from "../textures/Texture.js";
-import { WebGLCapabilities } from "./webgl/WebGLCapabilities.js";
+import { WebGLCapabilities, WebGLCapabilitiesParameters } from "./webgl/WebGLCapabilities.js";
 import { WebGLExtensions } from "./webgl/WebGLExtensions.js";
 import { WebGLInfo } from "./webgl/WebGLInfo.js";
 import { WebGLProgram } from "./webgl/WebGLProgram.js";
@@ -33,7 +33,7 @@ export interface Renderer {
     setSize(width: number, height: number, updateStyle?: boolean): void;
 }
 
-export interface WebGLRendererParameters {
+export interface WebGLRendererParameters extends WebGLCapabilitiesParameters {
     /**
      * A Canvas where the renderer draws its output.
      */
@@ -46,11 +46,6 @@ export interface WebGLRendererParameters {
      */
     context?: WebGLRenderingContext | undefined;
 
-    /**
-     * shader precision. Can be "highp", "mediump" or "lowp".
-     */
-    precision?: string | undefined;
-
     /**
      * default is false.
      */
@@ -86,11 +81,6 @@ export interface WebGLRendererParameters {
      */
     depth?: boolean | undefined;
 
-    /**
-     * default is false.
-     */
-    logarithmicDepthBuffer?: boolean | undefined;
-
     /**
      * default is false.
      */

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

@@ -3,7 +3,14 @@ import NodeUniformsGroup from "./nodes/NodeUniformsGroup.js";
 declare class BindGroup {
     name: string;
     bindings: NodeUniformsGroup[] | Binding[];
+    index: number;
+    bindingsReference: NodeUniformsGroup[] | BindGroup;
     id: number;
-    constructor(name?: string, bindings?: NodeUniformsGroup[]);
+    constructor(
+        name?: string,
+        bindings?: NodeUniformsGroup[],
+        index?: number,
+        bindingsReference?: NodeUniformsGroup[] | BindGroup,
+    );
 }
 export default BindGroup;

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

@@ -35,8 +35,8 @@ declare class Bindings extends DataMap<{
     getForCompute(computeNode: ComputeNode): BindGroup[];
     updateForCompute(computeNode: ComputeNode): void;
     updateForRender(renderObject: RenderObject): void;
-    _updateBindings(object: ComputeNode | RenderObject, bindings: BindGroup[]): void;
+    _updateBindings(bindings: BindGroup[]): void;
     _init(bindGroup: BindGroup): void;
-    _update(object: ComputeNode | RenderObject, bindGroup: BindGroup, bindings: BindGroup[]): void;
+    _update(bindGroup: BindGroup, bindings: BindGroup[]): void;
 }
 export default Bindings;

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

@@ -0,0 +1,10 @@
+import { Group } from "../../objects/Group.js";
+declare class BundleGroup extends Group {
+    readonly isBundleGroup: true;
+    readonly type: string;
+    static: boolean;
+    version: number;
+    constructor();
+    set needsUpdate(value: boolean);
+}
+export default BundleGroup;

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

@@ -14,6 +14,7 @@ declare class ClippingContext {
     planes: Vector4[];
     parentVersion: number;
     viewNormalMatrix: Matrix3;
+    cacheKey: number;
     viewMatrix?: Matrix4 | undefined;
     constructor();
     projectPlanes(source: readonly Plane[], offset: number): void;

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

@@ -6,6 +6,8 @@ import Renderer from "./Renderer.js";
 export default class QuadMesh extends Mesh {
     camera: OrthographicCamera;
 
+    readonly isQuadMesh: true;
+
     constructor(material?: Material | null);
 
     renderAsync(renderer: Renderer): Promise<void>;

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

@@ -1,11 +1,11 @@
 import { Camera } from "../../cameras/Camera.js";
-import { Object3D } from "../../core/Object3D.js";
+import BundleGroup from "./BundleGroup.js";
 import ChainMap from "./ChainMap.js";
 import RenderBundle from "./RenderBundle.js";
 declare class RenderBundles {
-    lists: ChainMap<readonly [Object3D, Camera], RenderBundle>;
+    lists: ChainMap<readonly [BundleGroup, Camera], RenderBundle>;
     constructor();
-    get(scene: Object3D, camera: Camera): RenderBundle;
+    get(scene: BundleGroup, camera: Camera): RenderBundle;
     dispose(): void;
 }
 export default RenderBundles;

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

@@ -37,5 +37,7 @@ declare class RenderContext {
     activeMipmapLevel?: number | undefined;
     occlusionQueryCount?: number | undefined;
     constructor();
+    getCacheKey(): number;
 }
+export declare function getCacheKey(renderContext: RenderContext): number;
 export default RenderContext;

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

@@ -1,15 +1,17 @@
 import { Camera } from "../../cameras/Camera.js";
+import { Object3D } from "../../core/Object3D.js";
 import { RenderTarget } from "../../core/RenderTarget.js";
-import { Scene } from "../../scenes/Scene.js";
 import ChainMap from "./ChainMap.js";
 import RenderContext from "./RenderContext.js";
 declare class RenderContexts {
     chainMaps: {
-        [attachmentState: string]: ChainMap<readonly [Scene, Camera], RenderContext> | undefined;
+        [attachmentState: string]: ChainMap<readonly [Object3D, Camera], RenderContext> | undefined;
     };
     constructor();
-    get(scene: Scene, camera: Camera, renderTarget?: RenderTarget | null): RenderContext;
-    getChainMap(attachmentState: string): ChainMap<readonly [Scene, Camera], RenderContext>;
+    get(scene: Object3D, camera: Camera, renderTarget?: RenderTarget | null): RenderContext;
+    getChainMap(
+        attachmentState: string,
+    ): ChainMap<readonly [Object3D<import("../../core/Object3D.js").Object3DEventMap>, Camera], RenderContext>;
     dispose(): void;
 }
 export default RenderContexts;

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

@@ -4,8 +4,9 @@ import { Object3D } from "../../core/Object3D.js";
 import { Light } from "../../lights/Light.js";
 import { Material } from "../../materials/Material.js";
 import { LightsNode } from "../../nodes/Nodes.js";
+import BundleGroup from "./BundleGroup.js";
 export interface Bundle {
-    object: Object3D;
+    bundleGroup: BundleGroup;
     camera: Camera;
     renderList: RenderList;
 }

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

@@ -5,9 +5,11 @@ import { InterleavedBuffer } from "../../core/InterleavedBuffer.js";
 import { InterleavedBufferAttribute } from "../../core/InterleavedBufferAttribute.js";
 import { Object3D } from "../../core/Object3D.js";
 import { Material } from "../../materials/Material.js";
+import NodeMaterialObserver from "../../materials/nodes/manager/NodeMaterialObserver.js";
 import { LightsNode } from "../../nodes/Nodes.js";
 import { Scene } from "../../scenes/Scene.js";
 import BindGroup from "./BindGroup.js";
+import BundleGroup from "./BundleGroup.js";
 import ClippingContext from "./ClippingContext.js";
 import Geometries from "./Geometries.js";
 import NodeBuilderState from "./nodes/NodeBuilderState.js";
@@ -35,12 +37,20 @@ export default class RenderObject {
     attributes: Array<BufferAttribute | InterleavedBufferAttribute> | null;
     pipeline: RenderPipeline | null;
     vertexBuffers: Array<BufferAttribute | InterleavedBuffer> | null;
+    drawParams: {
+        vertexCount: number;
+        firstVertex: number;
+        instanceCount: number;
+        firstInstance: number;
+    } | null;
+    bundle: BundleGroup | null;
     clippingContext: ClippingContext;
     clippingContextVersion: number;
     initialNodesCacheKey: string;
     initialCacheKey: string;
     _nodeBuilderState: NodeBuilderState | null;
     _bindings: BindGroup[] | null;
+    _monitor: NodeMaterialObserver | null;
     onDispose: (() => void) | null;
     readonly isRenderObject: true;
     onMaterialDispose: () => void;
@@ -58,6 +68,7 @@ export default class RenderObject {
     updateClipping(parent: ClippingContext): void;
     get clippingNeedsUpdate(): boolean;
     getNodeBuilderState(): NodeBuilderState;
+    getMonitor(): NodeMaterialObserver;
     getBindings(): BindGroup[];
     getIndex(): BufferAttribute | null;
     getChainArray(): readonly [
@@ -68,7 +79,14 @@ export default class RenderObject {
     ];
     getAttributes(): (InterleavedBufferAttribute | BufferAttribute)[];
     getVertexBuffers(): (InterleavedBuffer | BufferAttribute)[] | null;
-    getMaterialCacheKey(): string;
+    getDrawParameters(): {
+        vertexCount: number;
+        firstVertex: number;
+        instanceCount: number;
+        firstInstance: number;
+    } | null;
+    getGeometryCacheKey(): string;
+    getMaterialCacheKey(): number;
     get needsUpdate(): boolean;
     getDynamicCacheKey(): string;
     getCacheKey(): string;

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

@@ -37,7 +37,7 @@ declare class RenderObjects {
         camera: Camera,
         lightsNode: LightsNode,
         renderContext: RenderContext,
-        passId: string | undefined,
+        passId?: string | undefined,
     ): RenderObject;
     getChainMap(
         passId?: string,

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

@@ -10,7 +10,9 @@ import { Color } from "../../math/Color.js";
 import { Plane } from "../../math/Plane.js";
 import { Vector2 } from "../../math/Vector2.js";
 import { Vector4 } from "../../math/Vector4.js";
-import { ComputeNode, LightsNode, MRTNode } from "../../nodes/Nodes.js";
+import MRTNode from "../../nodes/core/MRTNode.js";
+import ComputeNode from "../../nodes/gpgpu/ComputeNode.js";
+import LightsNode from "../../nodes/lighting/LightsNode.js";
 import { Scene } from "../../scenes/Scene.js";
 import { FramebufferTexture } from "../../textures/FramebufferTexture.js";
 import { Texture } from "../../textures/Texture.js";
@@ -22,6 +24,7 @@ import Bindings from "./Bindings.js";
 import Color4 from "./Color4.js";
 import Geometries from "./Geometries.js";
 import Info from "./Info.js";
+import NodeLibrary from "./nodes/NodeLibrary.js";
 import Nodes from "./nodes/Nodes.js";
 import Pipelines from "./Pipelines.js";
 import QuadMesh from "./QuadMesh.js";
@@ -33,11 +36,18 @@ import RenderList, { Bundle, RenderItem } from "./RenderList.js";
 import RenderLists from "./RenderLists.js";
 import RenderObjects from "./RenderObjects.js";
 import Textures from "./Textures.js";
+interface Rectangle {
+    x: number;
+    y: number;
+    z: number;
+    w: number;
+}
 export interface RendererParameters {
     logarithmicDepthBuffer?: boolean | undefined;
     alpha?: boolean | undefined;
     antialias?: boolean | undefined;
     samples?: number | undefined;
+    getFallback?: ((error: unknown) => Backend) | null | undefined;
 }
 declare class Renderer {
     readonly isRenderer: true;
@@ -58,6 +68,10 @@ declare class Renderer {
     stencil: boolean;
     clippingPlanes: readonly Plane[];
     info: Info;
+    nodes: {
+        library: NodeLibrary;
+    };
+    _getFallback: ((error: unknown) => Backend) | null;
     _pixelRatio: number;
     _width: number;
     _height: number;
@@ -142,12 +156,16 @@ declare class Renderer {
                 glFragmentShader: WebGLShader,
             ) => void)
             | null;
+        getShaderAsync: (scene: Scene, camera: Camera, object: Object3D) => Promise<{
+            fragmentShader: string | null;
+            vertexShader: string | null;
+        }>;
     };
     localClippingEnabled?: boolean | undefined;
     constructor(backend: Backend, parameters?: RendererParameters);
     init(): Promise<void>;
     get coordinateSystem(): import("../../constants.js").CoordinateSystem;
-    compileAsync(scene: Scene, camera: Camera, targetScene?: Scene | null): Promise<void>;
+    compileAsync(scene: Object3D, camera: Camera, targetScene?: Object3D | null): Promise<void>;
     renderAsync(scene: Scene, camera: Camera): Promise<void>;
     setMRT(mrt: MRTNode | null): this;
     getMRT(): MRTNode | null;
@@ -194,6 +212,7 @@ declare class Renderer {
     clearColorAsync(): Promise<void>;
     clearDepthAsync(): Promise<void>;
     clearStencilAsync(): Promise<void>;
+    get currentToneMapping(): ToneMapping;
     get currentColorSpace(): ColorSpace;
     dispose(): void;
     setRenderTarget(renderTarget: RenderTarget | null, activeCubeFace?: number, activeMipmapLevel?: number): void;
@@ -225,7 +244,7 @@ declare class Renderer {
     computeAsync(computeNodes: ComputeNode | ComputeNode[]): Promise<void>;
     hasFeatureAsync(name: string): Promise<void>;
     hasFeature(name: string): false | void;
-    copyFramebufferToTexture(framebufferTexture: FramebufferTexture): void;
+    copyFramebufferToTexture(framebufferTexture: FramebufferTexture, rectangle?: Rectangle | null): void;
     copyTextureToTexture(
         srcTexture: Texture,
         dstTexture: Texture,
@@ -240,6 +259,7 @@ declare class Renderer {
         width: number,
         height: number,
         index?: number,
+        faceIndex?: number,
     ): Promise<import("../../core/BufferAttribute.js").TypedArray>;
     _projectObject(object: Object3D, camera: Camera, groupOrder: number, renderList: RenderList): void;
     _renderBundles(bundles: Bundle[], sceneRef: Scene, lightsNode: LightsNode): void;
@@ -268,10 +288,9 @@ declare class Renderer {
         scene: Scene,
         camera: Camera,
         lightsNode: LightsNode,
-        group: GeometryGroup,
         passId?: string,
     ): void;
     get compute(): (computeNodes: ComputeNode | ComputeNode[]) => Promise<void>;
-    get compile(): (scene: Scene, camera: Camera, targetScene?: Scene | null) => Promise<void>;
+    get compile(): (scene: Object3D, camera: Camera, targetScene?: Object3D | null) => Promise<void>;
 }
 export default Renderer;

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

@@ -3,12 +3,18 @@ import Binding from "./Binding.js";
 
 declare class SampledTexture extends Binding {
     id: number;
+
     texture: Texture | null;
     version: number;
     store: boolean;
+    generation: number | null;
+
     readonly isSampledTexture: true;
+
     constructor(name: string, texture: Texture | null);
-    get needsBindingsUpdate(): boolean;
+
+    needsBindingsUpdate(generation: number): boolean;
+
     update(): boolean;
 }
 

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

@@ -34,6 +34,7 @@ interface TextureData {
     initialized?: boolean;
     version?: number;
     isDefaultTexture?: boolean;
+    generation?: number;
 }
 interface TextureOptions {
     width?: number;

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

@@ -1,3 +1,4 @@
+import NodeMaterialObserver from "../../../materials/nodes/manager/NodeMaterialObserver.js";
 import Node from "../../../nodes/core/Node.js";
 import NodeAttribute from "../../../nodes/core/NodeAttribute.js";
 import BindGroup from "../BindGroup.js";
@@ -11,7 +12,7 @@ declare class NodeBuilderState {
     updateNodes: Node[];
     updateBeforeNodes: Node[];
     updateAfterNodes: Node[];
-    instanceBindGroups: boolean;
+    monitor: NodeMaterialObserver;
     usedTimes: number;
     constructor(
         vertexShader: string | null,
@@ -22,7 +23,7 @@ declare class NodeBuilderState {
         updateNodes: Node[],
         updateBeforeNodes: Node[],
         updateAfterNodes: Node[],
-        instanceBindGroups?: boolean,
+        monitor: NodeMaterialObserver,
         transforms?: never[],
     );
     createBindings(): BindGroup[];

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

@@ -0,0 +1,56 @@
+import { ToneMapping } from "../../../constants.js";
+import { Light } from "../../../lights/Light.js";
+import { Material } from "../../../materials/Material.js";
+import NodeMaterial from "../../../materials/nodes/NodeMaterial.js";
+import Node from "../../../nodes/core/Node.js";
+import { ColorSpaceMethod } from "../../../nodes/display/ColorSpaceNode.js";
+import AnalyticLightNode from "../../../nodes/lighting/AnalyticLightNode.js";
+import { NodeRepresentation, ShaderNodeObject } from "../../../nodes/tsl/TSLCore.js";
+declare class NodeLibrary {
+    lightNodes: WeakMap<{
+        new(): Light;
+    }, {
+        new(light: Light): AnalyticLightNode<Light>;
+    }>;
+    materialNodes: Map<string, {
+        new(): NodeMaterial;
+    }>;
+    toneMappingNodes: Map<
+        ToneMapping,
+        (color: NodeRepresentation, exposure: NodeRepresentation) => ShaderNodeObject<Node>
+    >;
+    colorSpaceNodes: Map<ColorSpaceMethod, (color: NodeRepresentation) => ShaderNodeObject<Node>>;
+    constructor();
+    fromMaterial(material: Material): Material | null;
+    addColorSpace(
+        colorSpaceNode: (color: NodeRepresentation) => ShaderNodeObject<Node>,
+        colorSpace: ColorSpaceMethod,
+    ): void;
+    getColorSpaceFunction(colorSpace: ColorSpaceMethod): ((color: NodeRepresentation) => ShaderNodeObject<Node>) | null;
+    addToneMapping(
+        toneMappingNode: (color: NodeRepresentation, exposure: NodeRepresentation) => ShaderNodeObject<Node>,
+        toneMapping: ToneMapping,
+    ): void;
+    getToneMappingFunction(
+        toneMapping: ToneMapping,
+    ): ((color: NodeRepresentation, exposure: NodeRepresentation) => ShaderNodeObject<Node>) | null;
+    getMaterialNodeClass(materialType: string): (new() => NodeMaterial) | null;
+    addMaterial(materialNodeClass: {
+        new(): NodeMaterial;
+    }, materialClass: {
+        new(): Material;
+    }): void;
+    getLightNodeClass(light: Light): (new(light: Light) => AnalyticLightNode<Light>) | null;
+    addLight<TLight extends Light>(lightNodeClass: {
+        new(light: TLight): AnalyticLightNode<TLight>;
+    }, lightClass: {
+        new(): TLight;
+    }): void;
+    addType<TNodeClass, TType>(nodeClass: TNodeClass, type: TType, library: Map<TType, TNodeClass>): void;
+    addClass<TNodeClass, TBaseClass extends object>(
+        nodeClass: TNodeClass,
+        baseClass: TBaseClass,
+        library: WeakMap<TBaseClass, TNodeClass>,
+    ): void;
+}
+export default NodeLibrary;

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

@@ -7,15 +7,15 @@ type GPUStorageTextureAccess = "read-only" | "read-write" | "write-only";
 declare class NodeSampledTexture extends SampledTexture {
     textureNode: TextureNode | undefined;
     groupNode: UniformGroupNode;
+
     access: "read-write" | "read-only" | "write-only";
+
     constructor(
         name: string,
         textureNode: TextureNode | undefined,
         groupNode: UniformGroupNode,
-        access: GPUStorageTextureAccess | null,
+        access?: GPUStorageTextureAccess | null,
     );
-    get needsBindingsUpdate(): boolean;
-    update(): boolean;
 }
 
 declare class NodeSampledCubeTexture extends NodeSampledTexture {

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

@@ -2,15 +2,13 @@ import { Camera } from "../../../cameras/Camera.js";
 import { Object3D } from "../../../core/Object3D.js";
 import { Material } from "../../../materials/Material.js";
 import { Color } from "../../../math/Color.js";
-import {
-    ComputeNode,
-    LightsNode,
-    Node,
-    NodeBuilder,
-    NodeFrame,
-    ShaderNodeObject,
-    UniformGroupNode,
-} from "../../../nodes/Nodes.js";
+import Node from "../../../nodes/core/Node.js";
+import NodeBuilder from "../../../nodes/core/NodeBuilder.js";
+import UniformGroupNode from "../../../nodes/core/UniformGroupNode.js";
+import ComputeNode from "../../../nodes/gpgpu/ComputeNode.js";
+import LightsNode from "../../../nodes/lighting/LightsNode.js";
+import { NodeFrame } from "../../../nodes/Nodes.js";
+import { ShaderNodeObject } from "../../../nodes/TSL.js";
 import { Fog } from "../../../scenes/Fog.js";
 import { FogExp2 } from "../../../scenes/FogExp2.js";
 import { Scene } from "../../../scenes/Scene.js";
@@ -41,6 +39,13 @@ interface SceneData {
     environment?: Texture | undefined;
     environmentNode?: Node | undefined;
 }
+declare module "../../../scenes/Scene.js" {
+    interface Scene {
+        environmentNode?: Node | null | undefined;
+        backgroundNode?: Node | null | undefined;
+        fogNode?: Node | null | undefined;
+    }
+}
 declare class Nodes extends DataMap<{
     nodeUniformsGroup: {
         key: NodeUniformsGroup;
@@ -103,6 +108,7 @@ declare class Nodes extends DataMap<{
     updateAfter(renderObject: RenderObject): void;
     updateForCompute(computeNode: ComputeNode): void;
     updateForRender(renderObject: RenderObject): void;
+    needsRefresh(renderObject: RenderObject): boolean;
     dispose(): void;
 }
 export default Nodes;

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

@@ -0,0 +1,5 @@
+import NodeLibrary from "./NodeLibrary.js";
+declare class StandardNodeLibrary extends NodeLibrary {
+    constructor();
+}
+export default StandardNodeLibrary;