@types/three 0.168.0 → 0.170.0

three/src/renderers/WebGLRenderer.d.ts

@@ -1,5 +1,5 @@
 import { Camera } from "../cameras/Camera.js";
-import { ColorSpace, CullFace, ShadowMapType, ToneMapping, WebGLCoordinateSystem } from "../constants.js";
+import { CullFace, ShadowMapType, ToneMapping, WebGLCoordinateSystem } from "../constants.js";
 import { TypedArray } from "../core/BufferAttribute.js";
 import { BufferGeometry } from "../core/BufferGeometry.js";
 import { Object3D } from "../core/Object3D.js";
@@ -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.
      */
@@ -79,18 +74,13 @@ export interface WebGLRendererParameters {
     /**
      * Can be "high-performance", "low-power" or "default"
      */
-    powerPreference?: string | undefined;
+    powerPreference?: WebGLPowerPreference | undefined;
 
     /**
      * default is true.
      */
     depth?: boolean | undefined;
 
-    /**
-     * default is false.
-     */
-    logarithmicDepthBuffer?: boolean | undefined;
-
     /**
      * default is false.
      */
@@ -193,8 +183,8 @@ export class WebGLRenderer implements Renderer {
      * {@link SRGBColorSpace} and {@link LinearSRGBColorSpace}.
      * @default THREE.SRGBColorSpace.
      */
-    get outputColorSpace(): ColorSpace;
-    set outputColorSpace(colorSpace: ColorSpace);
+    get outputColorSpace(): string;
+    set outputColorSpace(colorSpace: string);
 
     get coordinateSystem(): typeof WebGLCoordinateSystem;
 
@@ -441,26 +431,37 @@ export class WebGLRenderer implements Renderer {
     copyFramebufferToTexture(texture: Texture, position?: Vector2 | null, level?: number): void;
 
     /**
-     * Copies the pixels of a texture in the bounds `srcRegion` in the destination texture starting from the given
-     * position.
+     * Copies the pixels of a texture in the bounds [srcRegion]{@link Box3} in the destination texture starting from the
+     * given position. 2D Texture, 3D Textures, or a mix of the two can be used as source and destination texture
+     * arguments for copying between layers of 3d textures
+     *
+     * The `depthTexture` and `texture` property of render targets are supported as well.
+     *
+     * When using render target textures as `srcTexture` and `dstTexture`, you must make sure both render targets are
+     * initialized e.g. via {@link .initRenderTarget}().
      *
      * @param srcTexture Specifies the source texture.
      * @param dstTexture Specifies the destination texture.
      * @param srcRegion Specifies the bounds
      * @param dstPosition Specifies the pixel offset into the dstTexture where the copy will occur.
-     * @param level Specifies the destination mipmap level of the texture.
+     * @param dstLevel Specifies the destination mipmap level of the texture.
      */
     copyTextureToTexture(
         srcTexture: Texture,
         dstTexture: Texture,
-        srcRegion?: Box2 | null,
-        dstPosition?: Vector2 | null,
-        level?: number,
+        srcRegion?: Box2 | Box3 | null,
+        dstPosition?: Vector2 | Vector3 | null,
+        dstLevel?: number,
     ): void;
 
     /**
+     * @deprecated Use "copyTextureToTexture" instead.
+     *
      * Copies the pixels of a texture in the bounds `srcRegion` in the destination texture starting from the given
-     * position.
+     * position. The `depthTexture` and `texture` property of 3D render targets are supported as well.
+     *
+     * When using render target textures as `srcTexture` and `dstTexture`, you must make sure both render targets are
+     * intitialized e.g. via {@link .initRenderTarget}().
      *
      * @param srcTexture Specifies the source texture.
      * @param dstTexture Specifies the destination texture.

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

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

@@ -1,7 +1,8 @@
 export declare const AttributeType: {
     readonly VERTEX: 1;
     readonly INDEX: 2;
-    readonly STORAGE: 4;
+    readonly STORAGE: 3;
+    readonly INDIRECT: 4;
 };
 export type AttributeType = (typeof AttributeType)[keyof typeof AttributeType];
 export declare const GPU_CHUNK_BYTES = 16;

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

@@ -26,6 +26,7 @@ declare class Geometries extends DataMap<{
     initGeometry(renderObject: RenderObject): void;
     updateAttributes(renderObject: RenderObject): void;
     updateAttribute(attribute: BufferAttribute | InterleavedBufferAttribute, type: AttributeType): void;
+    getIndirect(renderObject: RenderObject): import("./IndirectStorageBufferAttribute.js").default | null;
     getIndex(renderObject: RenderObject): BufferAttribute | null;
 }
 export default Geometries;

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

@@ -0,0 +1,10 @@
+import { TypedArray } from "../../core/BufferAttribute.js";
+import StorageBufferAttribute from "./StorageBufferAttribute.js";
+
+declare class IndirectStorageBufferAttribute extends StorageBufferAttribute {
+    readonly isIndirectStorageBufferAttribute: true;
+
+    constructor(array: TypedArray, itemSize: number);
+}
+
+export default IndirectStorageBufferAttribute;

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

@@ -0,0 +1,15 @@
+import { Camera } from "../../cameras/Camera.js";
+import { Object3D } from "../../core/Object3D.js";
+import { Light } from "../../lights/Light.js";
+import LightsNode from "../../nodes/lighting/LightsNode.js";
+import ChainMap from "./ChainMap.js";
+
+declare class Lighting extends ChainMap<[Object3D, Camera], LightsNode> {
+    constructor();
+
+    createNode(lights?: Light[]): LightsNode;
+
+    getNode(scene: Object3D, camera: Camera): LightsNode;
+}
+
+export default Lighting;

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

@@ -0,0 +1,66 @@
+import { Camera } from "../../cameras/Camera.js";
+import { ToneMapping } from "../../constants.js";
+import { BufferGeometry, GeometryGroup } from "../../core/BufferGeometry.js";
+import { Object3D } from "../../core/Object3D.js";
+import { RenderTarget } from "../../core/RenderTarget.js";
+import { Material } from "../../materials/Material.js";
+import { Color } from "../../math/Color.js";
+import MRTNode from "../../nodes/core/MRTNode.js";
+import LightsNode from "../../nodes/lighting/LightsNode.js";
+import { Scene } from "../../scenes/Scene.js";
+import { CubeTexture } from "../../textures/CubeTexture.js";
+import { Texture } from "../../textures/Texture.js";
+import Color4 from "./Color4.js";
+import Renderer from "./Renderer.js";
+
+// renderer state
+
+export interface RendererState {
+    toneMapping: ToneMapping;
+    toneMappingExposure: number;
+    outputColorSpace: string;
+    renderTarget: RenderTarget | null;
+    activeCubeFace: number;
+    activeMipmapLevel: number;
+    renderObjectFunction:
+        | ((
+            object: Object3D,
+            scene: Scene,
+            camera: Camera,
+            geometry: BufferGeometry,
+            material: Material,
+            group: GeometryGroup,
+            lightsNode: LightsNode,
+        ) => void)
+        | null;
+    pixelRatio: number;
+    mrt: MRTNode | null;
+    clearColor: Color4;
+    clearAlpha: number;
+    autoClear: boolean;
+    scissorTest: boolean;
+}
+
+export function saveRendererState(renderer: Renderer, state?: RendererState): RendererState;
+
+export function resetRendererState(renderer: Renderer, state?: RendererState): RendererState;
+
+export function restoreRendererState(renderer: Renderer, state: RendererState): void;
+
+// renderer and scene state
+
+export interface RendererAndSceneState extends RendererState {
+    background: Color | Texture | CubeTexture | null;
+    backgroundNode: Node | null | undefined;
+    overrideMaterial: Material | null;
+}
+
+export function saveRendererAndSceneState(
+    renderer: RendererState,
+    scene: Scene,
+    state?: RendererAndSceneState,
+): RendererAndSceneState;
+
+export function resetRendererAndSceneState(renderer: Renderer, state?: RendererAndSceneState): RendererAndSceneState;
+
+export function restoreRendererAndSceneState(renderer: Renderer, state: RendererAndSceneState): 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,7 +37,7 @@ declare class RenderContext {
     activeMipmapLevel?: number | undefined;
     occlusionQueryCount?: number | undefined;
     constructor();
-    getCacheKey(): string;
+    getCacheKey(): number;
 }
-export declare function getCacheKey(renderContext: RenderContext): string;
+export declare function getCacheKey(renderContext: RenderContext): number;
 export default RenderContext;

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

@@ -4,8 +4,10 @@ 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";
+import Lighting from "./Lighting.js";
 export interface Bundle {
-    object: Object3D;
+    bundleGroup: BundleGroup;
     camera: Camera;
     renderList: RenderList;
 }
@@ -23,12 +25,15 @@ declare class RenderList {
     renderItems: RenderItem[];
     renderItemsIndex: number;
     opaque: RenderItem[];
+    transparentDoublePass: RenderItem[];
     transparent: RenderItem[];
     bundles: Bundle[];
     lightsNode: LightsNode;
     lightsArray: Light[];
+    scene: Object3D;
+    camera: Camera;
     occlusionQueryCount: number;
-    constructor();
+    constructor(lighting: Lighting, scene: Object3D, camera: Camera);
     begin(): this;
     getNextRenderItem(
         object: Object3D,
@@ -56,7 +61,6 @@ declare class RenderList {
     ): void;
     pushBundle(group: Bundle): void;
     pushLight(light: Light): void;
-    getLightsNode(): LightsNode;
     sort(
         customOpaqueSort: ((a: RenderItem, b: RenderItem) => number) | null,
         customTransparentSort: ((a: RenderItem, b: RenderItem) => number) | null,

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

@@ -1,10 +1,12 @@
 import { Camera } from "../../cameras/Camera.js";
 import { Object3D } from "../../core/Object3D.js";
 import ChainMap from "./ChainMap.js";
+import Lighting from "./Lighting.js";
 import RenderList from "./RenderList.js";
 declare class RenderLists {
+    lighting: Lighting;
     lists: ChainMap<readonly [Object3D, Camera], RenderList>;
-    constructor();
+    constructor(lighting: Lighting);
     get(scene: Object3D, camera: Camera): RenderList;
     dispose(): void;
 }

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,8 +68,10 @@ export default class RenderObject {
     updateClipping(parent: ClippingContext): void;
     get clippingNeedsUpdate(): boolean;
     getNodeBuilderState(): NodeBuilderState;
+    getMonitor(): NodeMaterialObserver;
     getBindings(): BindGroup[];
     getIndex(): BufferAttribute | null;
+    getIndirect(): import("./IndirectStorageBufferAttribute.js").default | null;
     getChainArray(): readonly [
         Object3D<import("../../core/Object3D.js").Object3DEventMap>,
         Material,
@@ -68,7 +80,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/Renderer.d.ts

@@ -1,5 +1,5 @@
 import { Camera } from "../../cameras/Camera.js";
-import { ColorSpace, ShadowMapType, ToneMapping } from "../../constants.js";
+import { ShadowMapType, ToneMapping } from "../../constants.js";
 import { BufferAttribute } from "../../core/BufferAttribute.js";
 import { BufferGeometry, GeometryGroup } from "../../core/BufferGeometry.js";
 import { Object3D } from "../../core/Object3D.js";
@@ -24,6 +24,7 @@ import Bindings from "./Bindings.js";
 import Color4 from "./Color4.js";
 import Geometries from "./Geometries.js";
 import Info from "./Info.js";
+import Lighting from "./Lighting.js";
 import NodeLibrary from "./nodes/NodeLibrary.js";
 import Nodes from "./nodes/Nodes.js";
 import Pipelines from "./Pipelines.js";
@@ -36,9 +37,23 @@ 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;
+}
+interface DeviceLostInfo {
+    api: "WebGL" | "WebGPU";
+    message: string;
+    reason: string | null;
+    originalEvent: unknown;
+}
 export interface RendererParameters {
     logarithmicDepthBuffer?: boolean | undefined;
     alpha?: boolean | undefined;
+    depth?: boolean | undefined;
+    stencil?: boolean | undefined;
     antialias?: boolean | undefined;
     samples?: number | undefined;
     getFallback?: ((error: unknown) => Backend) | null | undefined;
@@ -54,7 +69,7 @@ declare class Renderer {
     autoClearStencil: boolean;
     alpha: boolean;
     logarithmicDepthBuffer: boolean;
-    outputColorSpace: ColorSpace;
+    outputColorSpace: string;
     toneMapping: ToneMapping;
     toneMappingExposure: number;
     sortObjects: boolean;
@@ -62,9 +77,8 @@ declare class Renderer {
     stencil: boolean;
     clippingPlanes: readonly Plane[];
     info: Info;
-    nodes: {
-        library: NodeLibrary;
-    };
+    library: NodeLibrary;
+    lighting: Lighting;
     _getFallback: ((error: unknown) => Backend) | null;
     _pixelRatio: number;
     _width: number;
@@ -128,6 +142,8 @@ declare class Renderer {
         group: GeometryGroup,
         passId?: string,
     ) => void;
+    _isDeviceLost: boolean;
+    onDeviceLost: (info: DeviceLostInfo) => void;
     _initialized: boolean;
     _initPromise: Promise<void> | null;
     _compilationPromises: Promise<void>[] | null;
@@ -161,12 +177,14 @@ declare class Renderer {
     get coordinateSystem(): import("../../constants.js").CoordinateSystem;
     compileAsync(scene: Object3D, camera: Camera, targetScene?: Object3D | null): Promise<void>;
     renderAsync(scene: Scene, camera: Camera): Promise<void>;
+    waitForGPU(): Promise<void>;
     setMRT(mrt: MRTNode | null): this;
     getMRT(): MRTNode | null;
+    _onDeviceLost(info: DeviceLostInfo): void;
     _renderBundle(bundle: Bundle, sceneRef: Scene, lightsNode: LightsNode): void;
     render(scene: Scene, camera: Camera): Promise<void> | undefined;
     _getFrameBufferTarget(): RenderTarget<Texture> | null;
-    _renderScene(scene: Scene, camera: Camera, useFrameBufferTarget?: boolean): RenderContext;
+    _renderScene(scene: Scene, camera: Camera, useFrameBufferTarget?: boolean): RenderContext | undefined;
     getMaxAnisotropy(): number;
     getActiveCubeFace(): number;
     getActiveMipmapLevel(): number;
@@ -207,7 +225,7 @@ declare class Renderer {
     clearDepthAsync(): Promise<void>;
     clearStencilAsync(): Promise<void>;
     get currentToneMapping(): ToneMapping;
-    get currentColorSpace(): ColorSpace;
+    get currentColorSpace(): string;
     dispose(): void;
     setRenderTarget(renderTarget: RenderTarget | null, activeCubeFace?: number, activeMipmapLevel?: number): void;
     getRenderTarget(): RenderTarget<Texture> | null;
@@ -235,10 +253,11 @@ declare class Renderer {
             lightsNode: LightsNode,
         ) => void)
         | null;
+    compute(computeNodes: ComputeNode | ComputeNode[]): Promise<void> | undefined;
     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,
@@ -253,10 +272,24 @@ 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;
-    _renderObjects(renderList: RenderItem[], camera: Camera, scene: Scene, lightsNode: LightsNode): void;
+    _renderTransparents(
+        renderList: RenderItem[],
+        doublePassList: RenderItem[],
+        camera: Camera,
+        scene: Scene,
+        lightsNode: LightsNode,
+    ): void;
+    _renderObjects(
+        renderList: RenderItem[],
+        camera: Camera,
+        scene: Scene,
+        lightsNode: LightsNode,
+        passId?: string | null,
+    ): void;
     renderObject(
         object: Object3D,
         scene: Scene,
@@ -265,6 +298,7 @@ declare class Renderer {
         material: Material,
         group: GeometryGroup,
         lightsNode: LightsNode,
+        passId?: string | null,
     ): void;
     _renderObjectDirect(
         object: Object3D,
@@ -283,7 +317,6 @@ declare class Renderer {
         lightsNode: LightsNode,
         passId?: string,
     ): void;
-    get compute(): (computeNodes: ComputeNode | ComputeNode[]) => Promise<void>;
     get compile(): (scene: Object3D, camera: Camera, targetScene?: Object3D | null) => Promise<void>;
 }
 export default Renderer;

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

@@ -2,8 +2,12 @@ import { RenderTarget } from "../../../core/RenderTarget.js";
 import { Scene } from "../../../scenes/Scene.js";
 import Renderer from "../Renderer.js";
 
-export default class PMREMGenerator {
+declare class PMREMGenerator {
     constructor(renderer: Renderer);
 
     fromScene(scene: Scene, sigma?: number, near?: number, far?: number): RenderTarget;
+
+    dispose(): void;
 }
+
+export default PMREMGenerator;

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

@@ -3,7 +3,6 @@ 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 {
@@ -19,14 +18,8 @@ declare class NodeLibrary {
         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,

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

@@ -39,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;
@@ -101,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/webgl/WebGLCapabilities.d.ts

@@ -1,8 +1,20 @@
 import { PixelFormat, TextureDataType } from "../../constants.js";
 
 export interface WebGLCapabilitiesParameters {
+    /**
+     * shader precision. Can be "highp", "mediump" or "lowp".
+     */
     precision?: string | undefined;
+
+    /**
+     * default is false.
+     */
     logarithmicDepthBuffer?: boolean | undefined;
+
+    /**
+     * default is false.
+     */
+    reverseDepthBuffer?: boolean | undefined;
 }
 
 export class WebGLCapabilities {
@@ -18,6 +30,7 @@ export class WebGLCapabilities {
 
     precision: string;
     logarithmicDepthBuffer: boolean;
+    reverseDepthBuffer: boolean;
 
     maxTextures: number;
     maxVertexTextures: number;