@types/three 0.159.0 → 0.161.0

three/examples/jsm/nodes/utils/DiscardNode.d.ts

@@ -0,0 +1,16 @@
+import CondNode from '../math/CondNode.js';
+import Node from '../core/Node.js';
+import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
+
+export default class DiscardNode extends CondNode {
+    constructor(condNode: Node);
+}
+
+export const inlineDiscard: (condNode: NodeRepresentation) => ShaderNodeObject<DiscardNode>;
+export const discard: (condNode: NodeRepresentation) => ShaderNodeObject<Node>;
+
+declare module '../shadernode/ShaderNode.js' {
+    interface NodeElements {
+        discard: typeof discard;
+    }
+}

three/examples/jsm/nodes/utils/EquirectUVNode.d.ts

@@ -1,6 +1,8 @@
 import { PositionNode, TempNode } from '../Nodes.js';
-import { Swizzable } from '../shadernode/ShaderNodeElements.js';
+import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 export default class EquirectUVNode extends TempNode {
-    constructor(dirNode?: Swizzable<PositionNode>);
+    constructor(dirNode?: ShaderNodeObject<PositionNode>);
 }
+
+export const equirectUV: ShaderNodeObject<EquirectUVNode>;

three/examples/jsm/nodes/utils/MatcapUVNode.d.ts

@@ -1,5 +1,8 @@
 import TempNode from '../core/TempNode.js';
+import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 export default class MatcapUVNode extends TempNode {
     constructor();
 }
+
+export const matcapUV: ShaderNodeObject<MatcapUVNode>;

three/examples/jsm/nodes/utils/MaxMipLevelNode.d.ts

@@ -1,11 +1,14 @@
-import UniformNode from '../core/UniformNode.js';
 import { Texture } from '../../../../src/Three.js';
-import { TextureNode } from '../Nodes.js';
+import UniformNode from '../core/UniformNode.js';
+import TextureNode from '../accessors/TextureNode.js';
+import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
-export default class MaxMipLevelNode extends UniformNode {
+export default class MaxMipLevelNode extends UniformNode<0> {
     textureNode: TextureNode;
 
     constructor(textureNode: TextureNode);
 
     get texture(): Texture;
 }
+
+export const maxMipLevel: (texture: Texture) => ShaderNodeObject<MaxMipLevelNode>;

three/examples/jsm/nodes/utils/OscNode.d.ts

@@ -1,4 +1,5 @@
 import Node from '../core/Node.js';
+import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 export type OscNodeMethod =
     | typeof OscNode.SINE
@@ -17,3 +18,8 @@ export default class OscNode extends Node {
 
     constructor(method: OscNodeMethod, timeNode?: Node);
 }
+
+export const oscSine: (timeNode?: NodeRepresentation) => ShaderNodeObject<OscNode>;
+export const oscSquare: (timeNode?: NodeRepresentation) => ShaderNodeObject<OscNode>;
+export const oscTriangle: (timeNode?: NodeRepresentation) => ShaderNodeObject<OscNode>;
+export const oscSawtooth: (timeNode?: NodeRepresentation) => ShaderNodeObject<OscNode>;

three/examples/jsm/nodes/utils/ReflectorNode.d.ts

@@ -0,0 +1,30 @@
+import { Camera, Object3D, RenderTarget } from '../../../../src/Three.js';
+import TextureNode from '../accessors/TextureNode.js';
+import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
+
+export interface ReflectorNodeParameters {
+    target?: Object3D | undefined;
+    resolution?: number | undefined;
+    generateMipmaps?: boolean | undefined;
+    bounces?: boolean | undefined;
+}
+
+export default class ReflectorNode extends TextureNode {
+    target: Object3D;
+    resolution: number;
+    generateMipmaps: boolean;
+    bounces: boolean;
+
+    virtualCameras: WeakMap<Camera, Camera>;
+    renderTargets: WeakMap<Camera, RenderTarget>;
+
+    constructor(parameters?: ReflectorNodeParameters);
+
+    getTextureNode(): TextureNode;
+
+    getVirtualCamera(camera: Camera): Camera;
+
+    getRenderTarget(camera: Camera): RenderTarget;
+}
+
+export const reflector: (parameters?: ReflectorNodeParameters) => ShaderNodeObject<ReflectorNode>;

three/examples/jsm/nodes/utils/RemapNode.d.ts

@@ -1,4 +1,5 @@
 import Node from '../core/Node.js';
+import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 export default class RemapNode extends Node {
     node: Node;
@@ -9,5 +10,27 @@ export default class RemapNode extends Node {
 
     doClamp: boolean;
 
-    constructor(node: Node, inLowNode: Node, inHighNode: Node, outLowNode: Node, outHighNode: Node);
+    constructor(node: Node, inLowNode: Node, inHighNode: Node, outLowNode?: Node, outHighNode?: Node);
+}
+
+export const remap: (
+    node: Node,
+    inLowNode: NodeRepresentation,
+    inHighNode: NodeRepresentation,
+    outLowNode?: NodeRepresentation,
+    outHighNode?: NodeRepresentation,
+) => ShaderNodeObject<RemapNode>;
+export const remapClamp: (
+    node: Node,
+    inLowNode: NodeRepresentation,
+    inHighNode: NodeRepresentation,
+    outLowNode?: NodeRepresentation,
+    outHighNode?: NodeRepresentation,
+) => ShaderNodeObject<RemapNode>;
+
+declare module '../shadernode/ShaderNode.js' {
+    interface NodeElements {
+        remap: typeof remap;
+        remapClamp: typeof remapClamp;
+    }
 }

three/examples/jsm/nodes/utils/RotateNode.d.ts

@@ -0,0 +1,21 @@
+import TempNode from '../core/TempNode.js';
+import Node from '../core/Node.js';
+import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
+
+export default class RotateNode extends TempNode {
+    positionNode: Node;
+    rotationNode: Node;
+
+    constructor(positionNode: Node, rotationNode: Node);
+}
+
+export const rotate: (
+    positionNode: NodeRepresentation,
+    rotationNode: NodeRepresentation,
+) => ShaderNodeObject<RotateNode>;
+
+declare module '../shadernode/ShaderNode.js' {
+    interface NodeElements {
+        rotate: typeof rotate;
+    }
+}

three/examples/jsm/nodes/utils/RotateUVNode.d.ts

@@ -1,5 +1,6 @@
 import TempNode from '../core/TempNode.js';
 import Node from '../core/Node.js';
+import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 export default class RotateUVNode extends TempNode {
     uvNode: Node;
@@ -8,3 +9,11 @@ export default class RotateUVNode extends TempNode {
 
     constructor(uvNode: Node, rotationNode: Node, centerNode?: Node);
 }
+
+export const rotateUV: (uvNode: Node, rotationNode: Node, centerNode?: Node) => ShaderNodeObject<RotateUVNode>;
+
+declare module '../shadernode/ShaderNode.js' {
+    interface NodeElements {
+        rotateUV: typeof rotateUV;
+    }
+}

three/examples/jsm/nodes/utils/SpecularMIPLevelNode.d.ts

@@ -1,4 +1,6 @@
-import { Node, TextureNode } from '../Nodes.js';
+import Node from '../core/Node.js';
+import TextureNode from '../accessors/TextureNode.js';
+import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 export default class SpecularMIPLevelNode extends Node {
     textureNode: TextureNode;
@@ -6,3 +8,5 @@ export default class SpecularMIPLevelNode extends Node {
 
     constructor(textureNode: TextureNode, roughnessNode?: Node | null);
 }
+
+export const specularMIPLevel: () => ShaderNodeObject<SpecularMIPLevelNode>;

three/examples/jsm/nodes/utils/SpriteSheetUVNode.d.ts

@@ -1,4 +1,5 @@
 import Node from '../core/Node.js';
+import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 export default class SpriteSheetUVNode extends Node {
     countNode: Node;
@@ -7,3 +8,9 @@ export default class SpriteSheetUVNode extends Node {
 
     constructor(countNode: Node, uvNode?: Node, frameNode?: Node);
 }
+
+export const spritesheetUV: (
+    countNode: NodeRepresentation,
+    uvNode?: NodeRepresentation,
+    frameNode?: NodeRepresentation,
+) => ShaderNodeObject<SpriteSheetUVNode>;

three/examples/jsm/nodes/utils/TimerNode.d.ts

@@ -1,4 +1,5 @@
 import UniformNode from '../core/UniformNode.js';
+import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 export type TimerNodeScope =
     | typeof TimerNode.LOCAL
@@ -6,7 +7,7 @@ export type TimerNodeScope =
     | typeof TimerNode.DELTA
     | typeof TimerNode.FRAME;
 
-export default class TimerNode extends UniformNode {
+export default class TimerNode extends UniformNode<number> {
     static LOCAL: 'local';
     static GLOBAL: 'global';
     static DELTA: 'delta';
@@ -17,3 +18,8 @@ export default class TimerNode extends UniformNode {
 
     constructor(scope?: TimerNodeScope, scale?: number, value?: number);
 }
+
+export const timerLocal: (timeScale?: number, value?: number) => ShaderNodeObject<TimerNode>;
+export const timerGlobal: (timeScale?: number, value?: number) => ShaderNodeObject<TimerNode>;
+export const timerDelta: (timeScale?: number, value?: number) => ShaderNodeObject<TimerNode>;
+export const frameId: ShaderNodeObject<TimerNode>;

three/examples/jsm/nodes/utils/TriplanarTexturesNode.d.ts

@@ -1,22 +1,43 @@
 import Node from '../core/Node.js';
-import { PositionNode, Swizzable, TextureNode } from '../Nodes.js';
+import PositionNode from '../accessors/PositionNode.js';
+import TextureNode from '../accessors/TextureNode.js';
+import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 export default class TriplanarTexturesNode extends Node {
     textureXNode: TextureNode;
     textureYNode: TextureNode | null;
     textureZNode: TextureNode | null;
 
-    scaleNode: Swizzable;
+    scaleNode: ShaderNodeObject<Node>;
 
-    positionNode: Swizzable<PositionNode>;
-    normalNode: Swizzable<PositionNode>;
+    positionNode: ShaderNodeObject<PositionNode>;
+    normalNode: ShaderNodeObject<PositionNode>;
 
     constructor(
         textureXNode: Node,
         textureYNode?: TextureNode | null,
         textureZNode?: TextureNode | null,
-        scaleNode?: Swizzable,
-        positionNode?: Swizzable<PositionNode>,
-        normalNode?: Swizzable<PositionNode>,
+        scaleNode?: ShaderNodeObject<Node>,
+        positionNode?: ShaderNodeObject<PositionNode>,
+        normalNode?: ShaderNodeObject<PositionNode>,
     );
 }
+
+export const triplanarTextures: (
+    textureXNode: NodeRepresentation,
+    textureYNode?: NodeRepresentation,
+    textureZNode?: NodeRepresentation,
+    scaleNode?: NodeRepresentation,
+    positionNode?: NodeRepresentation,
+    normalNode?: NodeRepresentation,
+) => ShaderNodeObject<TriplanarTexturesNode>;
+export const triplanarTexture: (
+    texture: NodeRepresentation,
+    ...params: NodeRepresentation[]
+) => ShaderNodeObject<TriplanarTexturesNode>;
+
+declare module '../shadernode/ShaderNode.js' {
+    interface NodeElements {
+        triplanarTexture: typeof triplanarTexture;
+    }
+}

three/examples/jsm/objects/GroundedSkybox.d.ts

@@ -0,0 +1,5 @@
+import { Mesh, MeshBasicMaterial, SphereGeometry, Texture } from '../../../src/Three.js';
+
+export class GroundedSkybox extends Mesh<SphereGeometry, MeshBasicMaterial> {
+    constructor(map: Texture, height: number, radius: number, resolution?: number);
+}

three/examples/jsm/objects/QuadMesh.d.ts

@@ -0,0 +1,15 @@
+import { Material } from '../../../src/Three.js';
+import Renderer from '../renderers/common/Renderer.js';
+
+export default class QuadMesh {
+    constructor(material?: Material | null);
+
+    dispose(): void;
+
+    renderAsync(renderer: Renderer): Promise<void>;
+
+    get material(): Material;
+    set material(value: Material);
+
+    get render(): (renderer: Renderer) => Promise<void>;
+}

three/examples/jsm/postprocessing/{HBAOPass.d.ts → GTAOPass.d.ts}

@@ -1,4 +1,5 @@
 import {
+    Box3,
     Camera,
     Color,
     ColorRepresentation,
@@ -14,23 +15,26 @@ import {
 
 import { FullScreenQuad, Pass } from './Pass.js';
 
-export class HBAOPass extends Pass {
+export class GTAOPass extends Pass {
     width: number;
     height: number;
     clear: boolean;
     camera: Camera;
     scene: Scene;
     output: number;
+    blendIntensity: number;
 
-    rings: number;
-    samples: number;
+    pdRings: number;
+    pdRadiusExponent: number;
+    pdSamples: number;
 
-    noiseTexture: DataTexture;
+    gtaoNoiseTexture: DataTexture;
+    pdNoiseTexture: DataTexture;
 
-    hbaoRenderTarget: WebGLRenderTarget;
+    gtaoRenderTarget: WebGLRenderTarget;
     pdRenderTarget: WebGLRenderTarget;
 
-    hbaoMaterial: ShaderMaterial;
+    gtaoMaterial: ShaderMaterial;
 
     normalMaterial: MeshNormalMaterial;
 
@@ -40,6 +44,8 @@ export class HBAOPass extends Pass {
 
     copyMaterial: ShaderMaterial;
 
+    blendMaterial: ShaderMaterial;
+
     fsQuad: FullScreenQuad;
 
     originalClearColor: Color;
@@ -55,13 +61,20 @@ export class HBAOPass extends Pass {
         parameters?: { depthTexture?: DepthTexture | undefined; normalTexture?: Texture | undefined } | undefined,
     );
 
-    setTextures(depthTexture?: DepthTexture | undefined, normalTexture?: Texture | undefined): void;
+    get gtaoMap(): Texture;
+
+    setGBuffer(depthTexture?: DepthTexture | undefined, normalTexture?: Texture | undefined): void;
+
+    setSceneClipBox(box: Box3): void;
 
-    updateHbaoMaterial(parameters: {
+    updateGtaoMaterial(parameters: {
         radius?: number | undefined;
         distanceExponent?: number | undefined;
-        bias?: number | undefined;
+        thickness?: number | undefined;
+        distanceFallOff?: number | undefined;
+        scale?: number | undefined;
         samples?: number | undefined;
+        screenSpaceRadius?: boolean | undefined;
     }): void;
 
     updatePdMaterial(parameters: {
@@ -69,6 +82,7 @@ export class HBAOPass extends Pass {
         depthPhi?: number | undefined;
         normalPhi?: number | undefined;
         radius?: number | undefined;
+        radiusExponent?: number | undefined;
         rings?: number | undefined;
         samples?: number | undefined;
     }): void;
@@ -96,11 +110,12 @@ export class HBAOPass extends Pass {
     generateNoise(size?: number): DataTexture;
 
     static OUTPUT: {
+        Off: -1;
         Default: 0;
         Diffuse: 1;
         Depth: 2;
         Normal: 3;
-        HBAO: 4;
+        AO: 4;
         Denoise: 5;
     };
 }

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

@@ -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/renderers/common/Backend.d.ts

@@ -1,13 +1,17 @@
 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

@@ -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 Renderer from './Renderer.js';
+import { Node } from '../../nodes/Nodes.js';
+
+export default class PostProcessing {
+    renderer: Renderer;
+    outputNode: Node;
+
+    constructor(renderer: Renderer, outputNode?: Node);
+
+    render(): Promise<void>;
+}