@types/three 0.167.2 → 0.168.0

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

@@ -14,6 +14,7 @@ declare class ClippingContext {
     planes: Vector4[];
     parentVersion: number;
     viewNormalMatrix: Matrix3;
+    cacheKey: string;
     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/RenderContext.d.ts

@@ -37,5 +37,7 @@ declare class RenderContext {
     activeMipmapLevel?: number | undefined;
     occlusionQueryCount?: number | undefined;
     constructor();
+    getCacheKey(): string;
 }
+export declare function getCacheKey(renderContext: RenderContext): string;
 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/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";
@@ -38,6 +41,7 @@ export interface RendererParameters {
     alpha?: boolean | undefined;
     antialias?: boolean | undefined;
     samples?: number | undefined;
+    getFallback?: ((error: unknown) => Backend) | null | undefined;
 }
 declare class Renderer {
     readonly isRenderer: true;
@@ -58,6 +62,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 +150,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 +206,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;
@@ -268,10 +281,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/StandardRenderer.d.ts

@@ -0,0 +1,12 @@
+import Backend from "./Backend.js";
+import Renderer, { RendererParameters } from "./Renderer.js";
+
+export interface StandardRendererParameters extends RendererParameters {}
+
+declare class StandardRenderer extends Renderer {
+    readonly isStandardRenderer: true;
+
+    constructor(backend: Backend, parameters?: StandardRendererParameters);
+}
+
+export default StandardRenderer;

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/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";

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;

three/src/renderers/webgl/WebGLProperties.d.ts

@@ -1,8 +1,9 @@
 export class WebGLProperties {
     constructor();
 
-    get(object: any): any;
-    remove(object: any): void;
-    update(object: any, key: any, value: any): any;
-    dispose(): void;
+    has: (object: unknown) => boolean;
+    get: (object: unknown) => unknown;
+    remove: (object: unknown) => void;
+    update: (object: unknown, key: unknown, value: unknown) => unknown;
+    dispose: () => void;
 }

three/src/renderers/webgpu/WebGPUBackend.d.ts

@@ -1,11 +1,15 @@
+/// <reference types="@webgpu/types" />
+
 import { CoordinateSystem } from "../../constants.js";
 import Backend, { BackendParameters } from "../common/Backend.js";
 
 export interface WebGPUBackendParameters extends BackendParameters {
     alpha?: boolean | undefined;
-    antialias?: boolean | undefined;
-    sampleCount?: number | undefined;
+    requiredLimits?: Record<string, GPUSize64> | undefined;
     trackTimestamp?: boolean | undefined;
+    device?: GPUDevice | undefined;
+    powerPreference?: GPUPowerPreference | undefined;
+    context?: GPUCanvasContext | undefined;
 }
 
 export default class WebGPUBackend extends Backend {

three/src/renderers/webgpu/WebGPURenderer.d.ts

@@ -1,10 +1,10 @@
-import Renderer, { RendererParameters } from "../common/Renderer.js";
+import StandardRenderer, { StandardRendererParameters } from "../common/StandardRenderer.js";
 import { WebGPUBackendParameters } from "./WebGPUBackend.js";
 
-export interface WebGPURendererParameters extends RendererParameters, WebGPUBackendParameters {
+export interface WebGPURendererParameters extends StandardRendererParameters, WebGPUBackendParameters {
     forceWebGL?: boolean | undefined;
 }
 
-export default class WebGPURenderer extends Renderer {
+export default class WebGPURenderer extends StandardRenderer {
     constructor(parameters?: WebGPURendererParameters);
 }

three/src/renderers/webgpu/nodes/WGSLNodeBuilder.d.ts

@@ -4,7 +4,7 @@ import NodeBuilder from "../../../nodes/core/NodeBuilder.js";
 import NodeUniform from "../../../nodes/core/NodeUniform.js";
 import NodeVar from "../../../nodes/core/NodeVar.js";
 import StructTypeNode from "../../../nodes/core/StructTypeNode.js";
-import { ShaderNode } from "../../../nodes/shadernode/ShaderNode.js";
+import { ShaderNode } from "../../../nodes/tsl/TSLCore.js";
 import { Texture } from "../../../textures/Texture.js";
 import NodeUniformsGroup from "../../common/nodes/NodeUniformsGroup.js";
 
@@ -19,7 +19,7 @@ export default class WGSLNodeBuilder extends NodeBuilder {
     builtins: { [key in BuiltinStage]: Map<string, BuiltinType> };
     uniformGroups: { [key in NodeShaderStage]: NodeUniformsGroup };
 
-    needsColorSpaceToLinear(texture: Texture): boolean;
+    needsToWorkingColorSpace(texture: Texture): boolean;
     _generateTextureSample(
         texture: Texture,
         textureProperty: string,

three/src/renderers/webxr/WebXRManager.d.ts

@@ -1,5 +1,3 @@
-// https://threejs.org/docs/#api/en/renderers/webxr/WebXRManager
-
 /// <reference types="webxr" />
 
 import { ArrayCamera } from "../../cameras/ArrayCamera.js";

three/examples/jsm/loaders/LogLuvLoader.d.ts

@@ -1,19 +0,0 @@
-import { DataTextureLoader, LoadingManager, PixelFormat, TextureDataType } from "three";
-
-export interface LogLuv {
-    width: number;
-    height: number;
-    data: Uint16Array | Float32Array;
-    format: PixelFormat;
-    type: TextureDataType;
-    flipY: boolean;
-}
-
-export class LogLuvLoader extends DataTextureLoader {
-    type: TextureDataType;
-    constructor(manager?: LoadingManager);
-
-    parse(buffer: Iterable<number>): LogLuv;
-
-    setDataType(value: TextureDataType): this;
-}

three/src/nodes/accessors/TextureBicubicNode.d.ts

@@ -1,18 +0,0 @@
-import Node from "../core/Node.js";
-import TempNode from "../core/TempNode.js";
-import { NodeRepresentation, ShaderNodeObject } from "../shadernode/ShaderNode.js";
-
-export default class TextureBicubicNode extends TempNode {
-    textureNode: Node;
-    blurNode: Node;
-
-    constructor(textureNode: Node, blurNode?: Node);
-}
-
-export const textureBicubic: (textureNode: Node, blurNode?: NodeRepresentation) => ShaderNodeObject<TextureBicubicNode>;
-
-declare module "../shadernode/ShaderNode.js" {
-    interface NodeElements {
-        bicubic: typeof textureBicubic;
-    }
-}

three/src/nodes/accessors/UniformsNode.d.ts

@@ -1,23 +0,0 @@
-import Node from "../core/Node.js";
-import { ShaderNodeObject } from "../shadernode/ShaderNode.js";
-import ArrayElementNode from "../utils/ArrayElementNode.js";
-import BufferNode from "./BufferNode.js";
-
-declare class UniformsElementNode extends ArrayElementNode {
-    constructor(arrayBuffer: Node, indexNode: Node);
-}
-
-export default class UniformsNode extends BufferNode {
-    array: unknown[];
-    elementType: string | null;
-
-    readonly isArrayBufferNode: true;
-
-    constructor(value: unknown[], elementType?: string | null);
-
-    getElementLength(): number;
-
-    element(indexNode: number): ShaderNodeObject<UniformsElementNode>;
-}
-
-export const uniforms: (values: unknown[], nodeType?: string | null) => ShaderNodeObject<UniformsNode>;

three/src/nodes/core/NodeKeywords.d.ts

@@ -1,17 +0,0 @@
-import Node from "./Node.js";
-import NodeBuilder from "./NodeBuilder.js";
-declare class NodeKeywords {
-    keywords: string[];
-    nodes: {
-        [name: string]: Node;
-    };
-    keywordsCallback: {
-        [name: string]: (name: string) => Node;
-    };
-    constructor();
-    getNode(name: string): Node;
-    addKeyword(name: string, callback: (name: string) => Node): this;
-    parse(code: string): Node[];
-    include(builder: NodeBuilder, code: string): void;
-}
-export default NodeKeywords;

three/src/nodes/display/BlendModeNode.d.ts

@@ -1,47 +0,0 @@
-import Node from "../core/Node.js";
-import TempNode from "../core/TempNode.js";
-import { JoinNode } from "../Nodes.js";
-import { NodeRepresentation, ShaderNode, ShaderNodeObject } from "../shadernode/ShaderNode.js";
-
-export const BurnNode: (args: { base: Node; blend: Node }) => ShaderNodeObject<JoinNode>;
-
-export const DodgeNode: (args: { base: Node; blend: Node }) => ShaderNodeObject<JoinNode>;
-
-export const ScreenNode: (args: { base: Node; blend: Node }) => ShaderNodeObject<JoinNode>;
-
-export const OverlayNode: (args: { base: Node; blend: Node }) => ShaderNodeObject<JoinNode>;
-
-export type BlendMode =
-    | typeof BlendModeNode.BURN
-    | typeof BlendModeNode.DODGE
-    | typeof BlendModeNode.SCREEN
-    | typeof BlendModeNode.OVERLAY;
-
-export default class BlendModeNode extends TempNode {
-    static BURN: "burn";
-    static DODGE: "dodge";
-    static SCREEN: "screen";
-    static OVERLAY: "overlay";
-
-    baseNode: Node;
-    blendMode: BlendMode;
-    blendNode: Node;
-
-    constructor(blendMode: BlendMode, baseNode: Node, blendNode: Node);
-
-    setup(): Node;
-}
-
-export const burn: (baseNode: NodeRepresentation, blendNode?: NodeRepresentation) => ShaderNodeObject<BlendModeNode>;
-export const dodge: (baseNode: NodeRepresentation, blendNode?: NodeRepresentation) => ShaderNodeObject<BlendModeNode>;
-export const overlay: (baseNode: NodeRepresentation, blendNode?: NodeRepresentation) => ShaderNodeObject<BlendModeNode>;
-export const screen: (baseNode: NodeRepresentation, blendNode?: NodeRepresentation) => ShaderNodeObject<BlendModeNode>;
-
-declare module "../shadernode/ShaderNode.js" {
-    interface NodeElements {
-        burn: typeof burn;
-        dodge: typeof dodge;
-        overlay: typeof overlay;
-        screen: typeof screen;
-    }
-}

three/src/nodes/display/ColorAdjustmentNode.d.ts

@@ -1,47 +0,0 @@
-import TempNode from "../core/TempNode.js";
-import MathNode from "../math/MathNode.js";
-import { NodeRepresentation, ShaderNodeObject } from "../shadernode/ShaderNode.js";
-
-export type ColorAdjustmentMethod =
-    | typeof ColorAdjustmentNode.SATURATION
-    | typeof ColorAdjustmentNode.VIBRANCE
-    | typeof ColorAdjustmentNode.HUE;
-
-export default class ColorAdjustmentNode extends TempNode {
-    static SATURATION: "saturation";
-    static VIBRANCE: "vibrance";
-    static HUE: "hue";
-
-    method: ColorAdjustmentMethod;
-
-    colorNode: Node;
-    adjustmentNode: Node;
-
-    constructor(method: ColorAdjustmentMethod, colorNode: Node, adjustmentNode?: Node);
-}
-
-export const saturation: (
-    colorNode: NodeRepresentation,
-    adjustmentNode?: NodeRepresentation,
-) => ShaderNodeObject<ColorAdjustmentNode>;
-export const vibrance: (
-    colorNode: NodeRepresentation,
-    adjustmentNode?: NodeRepresentation,
-) => ShaderNodeObject<ColorAdjustmentNode>;
-export const hue: (
-    colorNode: NodeRepresentation,
-    adjustmentNode?: NodeRepresentation,
-) => ShaderNodeObject<ColorAdjustmentNode>;
-
-export const luminance: (a: NodeRepresentation, b: NodeRepresentation) => ShaderNodeObject<MathNode>;
-
-export const threshold: (color: NodeRepresentation, thershold: NodeRepresentation) => ShaderNodeObject<MathNode>;
-
-declare module "../shadernode/ShaderNode.js" {
-    interface NodeElements {
-        saturation: typeof saturation;
-        vibrance: typeof vibrance;
-        hue: typeof hue;
-        threshold: typeof threshold;
-    }
-}