@types/three 0.160.0 → 0.161.1

three/examples/jsm/postprocessing/SSAARenderPass.d.ts

@@ -1,6 +1,6 @@
-import { Scene, Camera, ColorRepresentation, ShaderMaterial, WebGLRenderTarget } from '../../../src/Three.js';
+import { Camera, ColorRepresentation, Scene, ShaderMaterial, WebGLRenderTarget } from "../../../src/Three.js";
 
-import { Pass, FullScreenQuad } from './Pass.js';
+import { FullScreenQuad, Pass } from "./Pass.js";
 
 export class SSAARenderPass extends Pass {
     constructor(scene: Scene, camera: Camera, clearColor?: ColorRepresentation, clearAlpha?: number);

three/examples/jsm/postprocessing/SSAOPass.d.ts

@@ -1,6 +1,7 @@
 import {
     Camera,
     Color,
+    ColorRepresentation,
     DataTexture,
     Material,
     MeshNormalMaterial,
@@ -9,10 +10,9 @@ import {
     Vector3,
     WebGLRenderer,
     WebGLRenderTarget,
-    ColorRepresentation,
-} from '../../../src/Three.js';
+} from "../../../src/Three.js";
 
-import { Pass, FullScreenQuad } from './Pass.js';
+import { FullScreenQuad, Pass } from "./Pass.js";
 
 export enum SSAOPassOUTPUT {
     Default,
@@ -27,7 +27,7 @@ export class SSAOPass extends Pass {
     scene: Scene;
     camera: Camera;
     width: number;
-    height: boolean;
+    height: number;
     clear: boolean;
     kernelRadius: number;
     kernel: Vector3[];

three/examples/jsm/postprocessing/SSRPass.d.ts

@@ -1,18 +1,18 @@
 import {
+    Camera,
     Color,
-    MeshNormalMaterial,
+    ColorRepresentation,
+    Material,
+    Mesh,
     MeshBasicMaterial,
-    ShaderMaterial,
-    WebGLRenderTarget,
+    MeshNormalMaterial,
     Scene,
+    ShaderMaterial,
     WebGLRenderer,
-    Camera,
-    Mesh,
-    Material,
-    ColorRepresentation,
-} from '../../../src/Three.js';
-import { Pass, FullScreenQuad } from '../postprocessing/Pass.js';
-import { ReflectorForSSRPass } from '../objects/ReflectorForSSRPass.js';
+    WebGLRenderTarget,
+} from "../../../src/Three.js";
+import { ReflectorForSSRPass } from "../objects/ReflectorForSSRPass.js";
+import { FullScreenQuad, Pass } from "../postprocessing/Pass.js";
 
 export interface SSRPassParams {
     renderer: WebGLRenderer;

three/examples/jsm/postprocessing/SavePass.d.ts

@@ -1,6 +1,6 @@
-import { ShaderMaterial, WebGLRenderTarget } from '../../../src/Three.js';
+import { ShaderMaterial, WebGLRenderTarget } from "../../../src/Three.js";
 
-import { Pass, FullScreenQuad } from './Pass.js';
+import { FullScreenQuad, Pass } from "./Pass.js";
 
 export class SavePass extends Pass {
     constructor(renderTarget?: WebGLRenderTarget);

three/examples/jsm/postprocessing/ShaderPass.d.ts

@@ -1,6 +1,6 @@
-import { ShaderMaterial } from '../../../src/Three.js';
+import { ShaderMaterial } from "../../../src/Three.js";
 
-import { Pass, FullScreenQuad } from './Pass.js';
+import { FullScreenQuad, Pass } from "./Pass.js";
 
 export class ShaderPass extends Pass {
     constructor(shader: object, textureID?: string);

three/examples/jsm/postprocessing/TAARenderPass.d.ts

@@ -1,6 +1,6 @@
-import { Scene, Camera, ColorRepresentation } from '../../../src/Three.js';
+import { Camera, ColorRepresentation, Scene } from "../../../src/Three.js";
 
-import { SSAARenderPass } from './SSAARenderPass.js';
+import { SSAARenderPass } from "./SSAARenderPass.js";
 
 export class TAARenderPass extends SSAARenderPass {
     constructor(scene: Scene, camera: Camera, clearColor?: ColorRepresentation, clearAlpha?: number);

three/examples/jsm/postprocessing/TexturePass.d.ts

@@ -1,6 +1,6 @@
-import { Texture, ShaderMaterial, IUniform } from '../../../src/Three.js';
+import { IUniform, ShaderMaterial, Texture } from "../../../src/Three.js";
 
-import { Pass, FullScreenQuad } from './Pass.js';
+import { FullScreenQuad, Pass } from "./Pass.js";
 
 export class TexturePass extends Pass {
     constructor(map?: Texture, opacity?: number);

three/examples/jsm/postprocessing/UnrealBloomPass.d.ts

@@ -1,6 +1,6 @@
-import { Color, MeshBasicMaterial, ShaderMaterial, Vector2, Vector3, WebGLRenderTarget } from '../../../src/Three.js';
+import { Color, MeshBasicMaterial, ShaderMaterial, Vector2, Vector3, WebGLRenderTarget } from "../../../src/Three.js";
 
-import { Pass, FullScreenQuad } from './Pass.js';
+import { FullScreenQuad, Pass } from "./Pass.js";
 
 export class UnrealBloomPass extends Pass {
     constructor(resolution: Vector2, strength: number, radius: number, threshold: number);

three/examples/jsm/renderers/CSS2DRenderer.d.ts

@@ -1,4 +1,4 @@
-import { Object3D, Scene, Camera, Vector2 } from '../../../src/Three.js';
+import { Camera, Object3D, Scene, Vector2 } from "../../../src/Three.js";
 
 export class CSS2DObject extends Object3D {
     constructor(element: HTMLElement);

three/examples/jsm/renderers/CSS3DRenderer.d.ts

@@ -1,4 +1,4 @@
-import { Object3D, Scene, Camera } from '../../../src/Three.js';
+import { Camera, Object3D, Scene } from "../../../src/Three.js";
 
 export class CSS3DObject extends Object3D {
     constructor(element: HTMLElement);

three/examples/jsm/renderers/Projector.d.ts

@@ -1,4 +1,4 @@
-import { Object3D, Scene, Camera, Vector2, Vector3, Vector4, Color, Material } from '../../../src/Three.js';
+import { Camera, Color, Material, Object3D, Scene, Vector2, Vector3, Vector4 } from "../../../src/Three.js";
 
 export class RenderableObject {
     id: number;

three/examples/jsm/renderers/SVGRenderer.d.ts

@@ -1,4 +1,4 @@
-import { Object3D, Color, Scene, Camera, ColorSpace } from '../../../src/Three.js';
+import { Camera, Color, ColorSpace, Object3D, Scene } from "../../../src/Three.js";
 
 export class SVGObject extends Object3D {
     constructor(node: SVGElement);

three/examples/jsm/renderers/common/Backend.d.ts

@@ -1,13 +1,17 @@
-import { CoordinateSystem } from '../../../../src/Three.js';
-import Renderer from './Renderer.js';
+import { CoordinateSystem } from "../../../../src/Three.js";
+import Renderer from "./Renderer.js";
+
+export interface BackendParameters {
+    canvas?: HTMLCanvasElement | undefined;
+}
 
 export default abstract class Backend {
     renderer: Renderer | null;
     domElement: HTMLCanvasElement | null;
 
-    constructor(parameters?: { canvas?: HTMLCanvasElement | undefined });
+    constructor(parameters?: BackendParameters);
 
-    init(renderer: Renderer): Promise<void>;
+    init(renderer: Renderer): void;
 
     abstract get coordinateSystem(): CoordinateSystem;
 

three/examples/jsm/renderers/common/Color4.d.ts

@@ -0,0 +1,9 @@
+import { Color, ColorRepresentation } from "../../../../src/math/Color.ts";
+
+export default class Color4 extends Color {
+    constructor(r: number, g: number, b: number, a?: number);
+
+    set(...args: [color: ColorRepresentation] | [r: number, g: number, b: number, a?: number]): this;
+
+    clone(): this;
+}

three/examples/jsm/renderers/common/Info.d.ts

@@ -1,4 +1,4 @@
-import { Object3D } from '../../../../src/Three.js';
+import { Object3D } from "../../../../src/Three.js";
 
 export default class Info {
     autoReset: boolean;
@@ -8,12 +8,18 @@ export default class Info {
 
     render: { calls: number; drawCalls: number; triangles: number; points: number; lines: number };
 
-    compute: { calls: number };
+    compute: { calls: number; computeCalls: number };
 
     memory: { geometries: number; textures: number };
 
+    timestamp: { compute: number; render: number };
+
     update(object: Object3D, count: number, instanceCount: number): void;
 
+    updateTimestamp(type: keyof typeof this.timestamp, time: number): void;
+
+    resetCompute(): void;
+
     reset(): void;
 
     dispose(): void;

three/examples/jsm/renderers/common/PostProcessing.d.ts

@@ -0,0 +1,11 @@
+import { Node } from "../../nodes/Nodes.js";
+import Renderer from "./Renderer.js";
+
+export default class PostProcessing {
+    renderer: Renderer;
+    outputNode: Node;
+
+    constructor(renderer: Renderer, outputNode?: Node);
+
+    render(): Promise<void>;
+}

three/examples/jsm/renderers/common/Renderer.d.ts

@@ -1,42 +1,281 @@
-import { Camera, ColorSpace, CoordinateSystem, Scene, ToneMapping } from '../../../../src/Three.js';
-import Backend from './Backend.js';
-import Info from './Info.js';
+import {
+    BufferGeometry,
+    Camera,
+    Color,
+    ColorSpace,
+    CoordinateSystem,
+    FramebufferTexture,
+    Group,
+    Material,
+    Object3D,
+    RenderTarget,
+    Scene,
+    ToneMapping,
+    Vector2,
+    Vector4,
+} from "../../../../src/Three.js";
+import ComputeNode from "../../nodes/gpgpu/ComputeNode.js";
+import LightsNode from "../../nodes/lighting/LightsNode.js";
+import Color4 from "./../common/Color4.js";
+import Backend from "./Backend.js";
+import Info from "./Info.js";
 
+export interface RendererParameters {
+    logarithmicDepthBuffer?: boolean | undefined;
+    alpha?: boolean | undefined;
+}
+
+/**
+ * Generic Renderer interface containing either a WebGL or WebGPU backend.
+ */
 export default class Renderer {
-    isRenderer: true;
+    /**
+     * @default true
+     */
+    readonly isRenderer: true;
 
     domElement: HTMLCanvasElement;
 
+    /**
+     * The renderer backend; could be WebGLBackend or WebGPUBackend
+     */
     backend: Backend;
 
+    /**
+     * @default true
+     */
     autoClear: boolean;
+
+    /**
+     * @default true
+     */
     autoClearColor: boolean;
+
+    /**
+     * @default true
+     */
     autoClearDepth: boolean;
+
+    /**
+     * @default true
+     */
     autoClearStencil: boolean;
 
+    /**
+     * @default SRGBColorSpace
+     */
     outputColorSpace: ColorSpace;
 
+    /**
+     * @default NoToneMapping
+     */
     toneMapping: ToneMapping;
+
+    /**
+     * @default 1.0
+     */
     toneMappingExposure: number;
 
+    /**
+     * @default true
+     */
     sortObjects: boolean;
 
+    /**
+     * @default true
+     */
     depth: boolean;
+
+    /**
+     * @default true
+     */
     stencil: boolean;
 
     info: Info;
 
-    constructor(backend: Backend, parameters?: { logarithmicDepthBuffer?: boolean | undefined });
+    constructor(backend: Backend, parameters?: RendererParameters);
 
     init(): Promise<void>;
 
     get coordinateSystem(): CoordinateSystem;
 
-    render(scene: Scene, camera: Camera): Promise<void>;
+    compileAsync(scene: Scene, camera: Camera, targetScene?: Scene | null): Promise<void>;
+
+    renderAsync(scene: Scene, camera: Camera): Promise<void>;
+
+    getMaxAnisotropy(): number;
+
+    getActiveCubeFace(): number;
+
+    getActiveMipmapLevel(): number;
 
     setAnimationLoop(callback: ((time: DOMHighResTimeStamp) => void) | null): Promise<void>;
 
+    /**
+     * Sets the pixel ratio of the Renderer.
+     */
     setPixelRatio(value?: number): void;
 
+    /**
+     * Sets the width and height of the output canvas and optionally updates the CSS style on the DOM element.
+     */
     setSize(width: number, height: number, updateStyle?: boolean): void;
+
+    /**
+     * Gets the Rendering Context of the renderer.
+     */
+    getContext(): RenderingContext;
+
+    /**
+     * Gets the current pixel ratio of the renderer.
+     */
+    getPixelRatio(): number;
+
+    getDrawingBufferSize(target: Vector2): Vector2;
+
+    getSize(target: Vector2): Vector2;
+
+    setDrawingBufferSize(width: number, height: number, pixelRatio: number): void;
+
+    /**
+     * Sets the custom opaque sort function for the RenderLists. Pass null to use the default painterSortStable function.
+     */
+    setOpaqueSort(method: (a: unknown, b: unknown) => number): void;
+
+    /**
+     * Sets the custom transparent sort function for the RenderLists. Pass null to use the default reversePainterSortStable function.
+     */
+    setTransparentSort(method: (a: unknown, b: unknown) => number): void;
+
+    /**
+     * Copies the scissor area into target.
+     */
+    getScissor(target: Vector4): Vector4;
+
+    /**
+     * Sets the scissor area from (x, y) to (x + width, y + height).
+     */
+    setScissor(x: number, y: number, width: number, height: number): void;
+
+    /**
+     * Returns true if scissor test is enabled; returns false otherwise.
+     */
+    getScissorTest(): boolean;
+
+    /**
+     * Enable the scissor test. When this is enabled, only the pixels within the defined scissor area will be affected by further renderer actions.
+     */
+    setScissorTest(boolean: boolean): void;
+
+    /**
+     * Copies the viewport into target.
+     */
+    getViewport(target: Vector4): Vector4;
+
+    /**
+     * Sets the viewport to render from (x, y) to (x + width, y + height).
+     * (x, y) is the lower-left corner of the region.
+     */
+    setViewport(x: number, y: number, width: number, height: number, minDepth?: number, maxDepth?: number): void;
+
+    /**
+     * Returns a Color4 instance with the current clear color.
+     */
+    getClearColor(target: Color4): Color4;
+
+    /**
+     * Sets the clear color, using color for the color and alpha for the opacity.
+     */
+    setClearColor(color: Color, alpha?: number): void;
+
+    /**
+     * Returns a float with the current clear alpha. Ranges from 0 to 1.
+     */
+    getClearAlpha(): number;
+
+    setClearAlpha(alpha: number): void;
+
+    getClearDepth(): number;
+
+    setClearDepth(depth: number): void;
+
+    getClearStencil(): number;
+
+    setClearStencil(stencil: number): void;
+
+    isOccluded(object: Object3D): boolean;
+
+    /**
+     * Tells the renderer to clear its color, depth or stencil drawing buffer(s).
+     * Arguments default to true
+     */
+    clearAsync(color?: boolean, depth?: boolean, stencil?: boolean): Promise<void>;
+
+    /**
+     * Clear the color buffer. Equivalent to calling .clear( true, false, false ).
+     */
+    clearColorAsync(): Promise<void>;
+
+    /**
+     * Clear the depth buffer. Equivalent to calling .clear( false, true, false ).
+     */
+    clearDepthAsync(): Promise<void>;
+
+    /**
+     * Clear the stencil buffer. Equivalent to calling .clear( false, false, true ).
+     */
+    clearStencilAsync(): Promise<void>;
+
+    get currentColorSpace(): ColorSpace;
+
+    dispose(): void;
+
+    setRenderTarget(renderTarget: RenderTarget, activeCubeFace?: number, activeMipmapLevel?: number): void;
+
+    getRenderTarget(): RenderTarget;
+
+    setRenderObjectFunction(renderObjectFunction: () => {}): void;
+
+    getRenderObjectFunction(): () => {};
+
+    /**
+     * Runs a compute pipeline
+     */
+    computeAsync(computeNodes: ComputeNode | ComputeNode[]): Promise<void>;
+
+    hasFeature(name: string): boolean;
+
+    copyFramebufferToTexture(framebufferTexture: FramebufferTexture): void;
+
+    readRenderTargetPixelsAsync(
+        renderTarget: RenderTarget,
+        x: number,
+        y: number,
+        width: number,
+        height: number,
+    ): Promise<Float32Array | Uint16Array | Uint8Array | Int8Array | Int16Array | Uint32Array | Int32Array>;
+
+    renderObject(
+        object: Object3D,
+        scene: Scene,
+        camera: Camera,
+        geometry: BufferGeometry,
+        material: Material,
+        group: Group,
+        lightsNode: LightsNode,
+    ): void;
+
+    get compute(): (computeNodes: ComputeNode | ComputeNode[]) => Promise<void>;
+
+    get compile(): (scene: Scene, camera: Camera, targetScene?: Scene | null) => Promise<void>;
+
+    get render(): (scene: Scene, camera: Camera) => Promise<void>;
+
+    get clear(): (color?: boolean, depth?: boolean, stencil?: boolean) => Promise<void>;
+
+    get clearColor(): () => Promise<void>;
+
+    get clearDepth(): () => Promise<void>;
+
+    get clearStencil(): () => Promise<void>;
 }

three/examples/jsm/renderers/common/StorageTexture.d.ts

@@ -0,0 +1,5 @@
+import { Texture } from "../../../../src/Three.js";
+
+export default class StorageTexture extends Texture {
+    constructor(width?: number, height?: number);
+}

three/examples/jsm/renderers/webgl/WebGLBackend.d.ts

@@ -1,8 +1,10 @@
-import { CoordinateSystem } from '../../../../src/Three.js';
-import Backend from '../common/Backend.js';
+import { CoordinateSystem } from "../../../../src/Three.js";
+import Backend, { BackendParameters } from "../common/Backend.js";
 
 export default class WebGLBackend extends Backend {
-    constructor(parameters?: { canvas?: HTMLCanvasElement | undefined });
+    constructor(parameters?: BackendParameters);
 
     get coordinateSystem(): CoordinateSystem;
+
+    getMaxAnisotropy(): number;
 }

three/examples/jsm/renderers/webgl/nodes/SlotNode.d.ts

@@ -1,4 +1,4 @@
-import Node from '../../../nodes/core/Node.js';
+import Node from "../../../nodes/core/Node.js";
 
 export interface SlotNodeParameters<TNode extends Node = Node> {
     node?: TNode;
@@ -8,7 +8,7 @@ export interface SlotNodeParameters<TNode extends Node = Node> {
 }
 
 export default class SlotNode<TNode extends Node = Node> extends Node {
-    inclusionType: 'replace';
+    inclusionType: "replace";
     node: TNode | null;
     source: null;
     target: null;

three/examples/jsm/renderers/webgl/nodes/WebGLNodeBuilder.d.ts

@@ -1,8 +1,8 @@
-import NodeBuilder from '../../../nodes/core/NodeBuilder.js';
-import { Renderer, Object3D } from '../../../../../src/Three.js';
-import Node from '../../../nodes/core/Node.js';
-import SlotNode from './SlotNode.js';
-import { NodeShaderStageOption } from '../../../nodes/core/constants.js';
+import { Object3D, Renderer } from "../../../../../src/Three.js";
+import { NodeShaderStage } from "../../../nodes/core/constants.js";
+import Node from "../../../nodes/core/Node.js";
+import NodeBuilder from "../../../nodes/core/NodeBuilder.js";
+import SlotNode from "./SlotNode.js";
 
 export class WebGLNodeBuilder extends NodeBuilder {
     constructor(
@@ -11,7 +11,7 @@ export class WebGLNodeBuilder extends NodeBuilder {
         shader: { uniforms: any; vertexShader: any; fragmentShader: any },
     );
 
-    addSlot(shaderStage: NodeShaderStageOption, slotNode: SlotNode): Node;
+    addSlot(shaderStage: NodeShaderStage, slotNode: SlotNode): Node;
 
     getUniforms(shaderStage: string): string;
 
@@ -27,7 +27,7 @@ export class WebGLNodeBuilder extends NodeBuilder {
 
     getInstanceIndex(): string;
     getFrontFacing(): string;
-    getFragCoord(): 'gl_FragCoord';
+    getFragCoord(): "gl_FragCoord";
     isFlipY(): true;
 
     buildCode(): void;

three/examples/jsm/renderers/webgl/nodes/WebGLNodes.d.ts

@@ -1,3 +1,3 @@
-import NodeFrame from '../../../nodes/core/NodeFrame.js';
+import NodeFrame from "../../../nodes/core/NodeFrame.js";
 
 export const nodeFrame: NodeFrame;

three/examples/jsm/renderers/webgl-legacy/nodes/WebGLNodes.d.ts

@@ -1,3 +1,3 @@
-import { NodeFrame } from '../../../nodes/Nodes.js';
+import { NodeFrame } from "../../../nodes/Nodes.js";
 
 export const nodeFrame: NodeFrame;

three/examples/jsm/renderers/webgpu/WebGPUBackend.d.ts

@@ -1,12 +1,21 @@
-import { CoordinateSystem } from '../../../../src/Three.js';
-import Backend from '../common/Backend.js';
+import { CoordinateSystem } from "../../../../src/Three.js";
+import Backend, { BackendParameters } from "../common/Backend.js";
+
+export interface WebGPUBackendParameters extends BackendParameters {
+    alpha?: boolean | undefined;
+    antialias?: boolean | undefined;
+    sampleCount?: number | undefined;
+    trackTimestamp?: boolean | undefined;
+}
 
 export default class WebGPUBackend extends Backend {
-    constructor(parameters?: {
-        canvas?: HTMLCanvasElement | undefined;
-        antialias?: boolean | undefined;
-        sampleCount?: number | undefined;
-    });
+    readonly isWebGPUBackend: true;
+
+    constructor(parameters?: WebGPUBackendParameters);
 
     get coordinateSystem(): CoordinateSystem;
+
+    // utils public
+
+    getMaxAnisotropy(): number;
 }

three/examples/jsm/renderers/webgpu/WebGPURenderer.d.ts

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

three/examples/jsm/shaders/ACESFilmicToneMappingShader.d.ts

@@ -1,4 +1,4 @@
-import { IUniform, Texture } from '../../../src/Three.js';
+import { IUniform, Texture } from "../../../src/Three.js";
 
 export const ACESFilmicToneMappingShader: {
     name: string;

three/examples/jsm/shaders/AfterimageShader.d.ts

@@ -1,4 +1,4 @@
-import { IUniform } from '../../../src/Three.js';
+import { IUniform } from "../../../src/Three.js";
 
 export const AfterimageShader: {
     name: string;

three/examples/jsm/shaders/BleachBypassShader.d.ts

@@ -1,4 +1,4 @@
-import { IUniform } from '../../../src/Three.js';
+import { IUniform } from "../../../src/Three.js";
 
 export const BleachBypassShader: {
     uniforms: {