@types/three 0.143.2 → 0.146.0

three/examples/jsm/nodes/materials/Materials.d.ts

@@ -1,14 +1,16 @@
-import NodeMaterial from '../materials/NodeMaterial';
-import LineBasicNodeMaterial from '../materials/LineBasicNodeMaterial';
-import MeshBasicNodeMaterial from '../materials/MeshBasicNodeMaterial';
-import MeshStandardNodeMaterial from '../materials/MeshStandardNodeMaterial';
-import PointsNodeMaterial from '../materials/PointsNodeMaterial';
-import SpriteNodeMaterial from '../materials/SpriteNodeMaterial';
+import NodeMaterial from './NodeMaterial';
+import LineBasicNodeMaterial from './LineBasicNodeMaterial';
+import MeshBasicNodeMaterial from './MeshBasicNodeMaterial';
+import MeshStandardNodeMaterial from './MeshStandardNodeMaterial';
+import PointsNodeMaterial from './PointsNodeMaterial';
+import SpriteNodeMaterial from './SpriteNodeMaterial';
+import MeshPhysicalNodeMaterial from './MeshPhysicalNodeMaterial';
 
 export {
     NodeMaterial,
     LineBasicNodeMaterial,
     MeshBasicNodeMaterial,
+    MeshPhysicalNodeMaterial,
     MeshStandardNodeMaterial,
     PointsNodeMaterial,
     SpriteNodeMaterial,

three/examples/jsm/nodes/materials/MeshPhysicalNodeMaterial.d.ts

@@ -0,0 +1,22 @@
+import { ShaderMaterialParameters } from '../../../../src/Three';
+import { Swizzable, CheckerNode, Node } from '../Nodes';
+
+import MeshStandardNodeMaterial from './MeshStandardNodeMaterial';
+
+export default class MeshPhysicalNodeMaterial extends MeshStandardNodeMaterial {
+    iridescenceNode: null | Swizzable<CheckerNode>;
+    iridescenceIORNode: null | Swizzable;
+    iridescenceThicknessNode: null | Swizzable;
+
+    specularIntensityNode: Node | null;
+    specularColorNode: Node | null;
+
+    transmissionNode: Node | null;
+    thicknessNode: Node | null;
+    attenuationDistanceNode: Node | null;
+    attenuationColorNode: Node | null;
+
+    constructor(parameters: ShaderMaterialParameters);
+
+    copy(source: MeshPhysicalNodeMaterial): this;
+}

three/examples/jsm/nodes/materialx/MaterialXNodes.d.ts

@@ -0,0 +1,94 @@
+import { mx_hsvtorgb, mx_rgbtohsv } from './lib/mx_hsv';
+import { Swizzable } from '../shadernode/ShaderNodeElements';
+import { UVNode, MathNode } from '../Nodes';
+import { NodeRepresentation } from '../shadernode/ShaderNode';
+
+export function mx_aastep(threshold?: NodeRepresentation, value?: NodeRepresentation): Swizzable<MathNode>;
+
+export function mx_ramplr(
+    valuel?: NodeRepresentation,
+    valuer?: NodeRepresentation,
+    texcoord?: Swizzable<UVNode>,
+): Swizzable<MathNode>;
+export function mx_ramptb(
+    valuet?: NodeRepresentation,
+    valueb?: NodeRepresentation,
+    texcoord?: Swizzable<UVNode>,
+): Swizzable<MathNode>;
+
+export function mx_splitlr(
+    valuel?: NodeRepresentation,
+    valuer?: NodeRepresentation,
+    center?: NodeRepresentation,
+    texcoord?: Swizzable<UVNode>,
+): Swizzable<MathNode>;
+export function mx_splittb(
+    valuet?: NodeRepresentation,
+    valueb?: NodeRepresentation,
+    center?: NodeRepresentation,
+    texcoord?: Swizzable<UVNode>,
+): Swizzable<MathNode>;
+
+export function mx_transform_uv(
+    uv_scale?: NodeRepresentation,
+    uv_offset?: NodeRepresentation,
+    uv_geo?: Swizzable<UVNode>,
+): Swizzable;
+
+export function mx_noise_float(
+    texcoord?: Swizzable<UVNode>,
+    amplitude?: NodeRepresentation,
+    pivot?: NodeRepresentation,
+): Swizzable;
+export function mx_noise_vec2(
+    texcoord?: Swizzable<UVNode>,
+    amplitude?: NodeRepresentation,
+    pivot?: NodeRepresentation,
+): Swizzable;
+export function mx_noise_vec3(
+    texcoord?: Swizzable<UVNode>,
+    amplitude?: NodeRepresentation,
+    pivot?: NodeRepresentation,
+): Swizzable;
+export function mx_noise_vec4(
+    texcoord?: Swizzable<UVNode>,
+    amplitude?: NodeRepresentation,
+    pivot?: NodeRepresentation,
+): Swizzable;
+
+export function mx_worley_noise_float(texcoord?: Swizzable<UVNode>, jitter?: NodeRepresentation): Swizzable;
+export function mx_worley_noise_vec2(texcoord?: Swizzable<UVNode>, jitter?: NodeRepresentation): Swizzable;
+export function mx_worley_noise_vec3(texcoord?: Swizzable<UVNode>, jitter?: NodeRepresentation): Swizzable;
+
+export function mx_cell_noise_float(texcoord?: Swizzable<UVNode>): Swizzable;
+
+export function mx_fractal_noise_float(
+    position?: Swizzable<UVNode>,
+    octaves?: NodeRepresentation,
+    lacunarity?: NodeRepresentation,
+    diminish?: NodeRepresentation,
+    amplitude?: NodeRepresentation,
+): Swizzable;
+export function mx_fractal_noise_vec2(
+    position?: Swizzable<UVNode>,
+    octaves?: NodeRepresentation,
+    lacunarity?: NodeRepresentation,
+    diminish?: NodeRepresentation,
+    amplitude?: NodeRepresentation,
+): Swizzable;
+export function mx_fractal_noise_vec3(
+    position?: Swizzable<UVNode>,
+    octaves?: NodeRepresentation,
+    lacunarity?: NodeRepresentation,
+    diminish?: NodeRepresentation,
+    amplitude?: NodeRepresentation,
+): Swizzable;
+export function mx_fractal_noise_vec4(
+    position?: Swizzable<UVNode>,
+    octaves?: NodeRepresentation,
+    lacunarity?: NodeRepresentation,
+    diminish?: NodeRepresentation,
+    amplitude?: NodeRepresentation,
+): Swizzable;
+
+export { mx_hsvtorgb, mx_rgbtohsv };

three/examples/jsm/nodes/materialx/lib/mx_hsv.d.ts

@@ -0,0 +1,4 @@
+import { Fn, Node, Swizzable } from '../../Nodes';
+
+export function mx_hsvtorgb(...params: Fn<[Node]>): Swizzable;
+export function mx_rgbtohsv(...params: Fn<[Node]>): Swizzable;

three/examples/jsm/nodes/materialx/lib/mx_noise.d.ts

@@ -0,0 +1,6 @@
+import { Fn, Node, Swizzable } from '../../Nodes';
+
+export function mx_perlin_noise_float(...params: Fn<[Node]>): Swizzable;
+export function mx_cell_noise_float(...params: Fn<[Node]>): Swizzable;
+export function mx_worley_noise_float(...params: Fn<[Node]>): Swizzable;
+export function mx_fractal_noise_float(...params: Fn<[Node, Node, Node, Node]>): Swizzable;

three/examples/jsm/nodes/math/MathNode.d.ts

@@ -27,7 +27,6 @@ export type MathNodeMethod1 =
     | typeof MathNode.INVERT
     | typeof MathNode.DFDX
     | typeof MathNode.DFDY
-    | typeof MathNode.SATURATE
     | typeof MathNode.ROUND;
 
 export type MathNodeMethod2 =
@@ -80,8 +79,8 @@ export default class MathNode extends TempNode {
     static INVERT: 'invert';
     static DFDX: 'dFdx';
     static DFDY: 'dFdy';
-    static SATURATE: 'saturate';
     static ROUND: 'round';
+    static RECIPROCAL: 'reciprocal';
 
     // 2 inputs
 

three/examples/jsm/nodes/procedural/CheckerNode.d.ts

@@ -1,6 +1,6 @@
-import Node from '../core/Node';
+import TempNode from '../core/TempNode';
 
-export default class CheckerNode extends Node {
+export default class CheckerNode extends TempNode {
     uvNode: Node;
     constructor(uvNode?: Node);
 }

three/examples/jsm/nodes/shadernode/ShaderNode.d.ts

@@ -7,17 +7,19 @@ export type Swizzable<T extends Node = Node> = T &
     };
 
 /** anything that can be passed to {@link nodeObject} and returns a proxy */
-export type NodeRepresentation = number | boolean | Node | Swizzable;
+export type NodeRepresentation<T extends Node = Node> = number | boolean | Node | Swizzable<T>;
 
 /** anything that can be passed to {@link nodeObject} */
 export type NodeObjectOption = NodeRepresentation | string;
 
-// same logic as in ShaderNodeObject
+// same logic as in ShaderNodeObject: number,boolean,node->swizzable, otherwise do nothing
 export type NodeObject<T> = T extends Node ? Swizzable<T> : T extends number | boolean ? Swizzable<ConstNode> : T;
 
-type MakeObjectOption<T> = T extends Node ? NodeRepresentation : T;
+// opposite of NodeObject: node -> node|swizzable|boolean|number, otherwise do nothing
+type Proxied<T> = T extends Node ? NodeRepresentation<T> : T;
 // https://github.com/microsoft/TypeScript/issues/42435#issuecomment-765557874
-type MakeObjectOptions<T extends readonly [...unknown[]]> = [...{ [index in keyof T]: MakeObjectOption<T[index]> }];
+export type ProxiedTuple<T extends readonly [...unknown[]]> = [...{ [index in keyof T]: Proxied<T[index]> }];
+export type ProxiedObject<T> = { [index in keyof T]: Proxied<T[index]> };
 type RemoveTail<T extends readonly [...unknown[]]> = T extends [unknown, ...infer X] ? X : [];
 type RemoveHeadAndTail<T extends readonly [...unknown[]]> = T extends [unknown, ...infer X, unknown] ? X : [];
 
@@ -121,22 +123,22 @@ export function nodeArray<T extends NodeObjectOption[]>(obj: readonly [...T]): N
 
 export function nodeProxy<T>(
     nodeClass: T,
-): (...params: MakeObjectOptions<GetConstructors<T>>) => Swizzable<ConstructedNode<T>>;
+): (...params: ProxiedTuple<GetConstructors<T>>) => Swizzable<ConstructedNode<T>>;
 
 export function nodeProxy<T, S extends GetPossibleScopes<T>>(
     nodeClass: T,
     scope: S,
-): (...params: MakeObjectOptions<RemoveTail<GetConstructorsByScope<T, S>>>) => Swizzable<ConstructedNode<T>>;
+): (...params: ProxiedTuple<RemoveTail<GetConstructorsByScope<T, S>>>) => Swizzable<ConstructedNode<T>>;
 
 export function nodeProxy<T, S extends GetPossibleScopes<T>>(
     nodeClass: T,
     scope: S,
     factor: NodeObjectOption,
-): (...params: MakeObjectOptions<RemoveHeadAndTail<GetConstructorsByScope<T, S>>>) => Swizzable<ConstructedNode<T>>;
+): (...params: ProxiedTuple<RemoveHeadAndTail<GetConstructorsByScope<T, S>>>) => Swizzable<ConstructedNode<T>>;
 
 export function nodeImmutable<T>(
     nodeClass: T,
-    ...params: MakeObjectOptions<GetConstructors<T>>
+    ...params: ProxiedTuple<GetConstructors<T>>
 ): Swizzable<ConstructedNode<T>>;
 
 export class ShaderNode<T = {}, R extends Node = Node> {

three/examples/jsm/nodes/shadernode/ShaderNodeBaseElements.d.ts

@@ -13,22 +13,26 @@ import {
     Swizzable,
     NodeRepresentation,
     NodeOrType,
+    ProxiedObject,
+    ProxiedTuple,
 } from './ShaderNode';
 import { Material, Texture } from '../../../../src/Three';
 import { NodeTypeOption, NodeUserData, NodeValueOption } from '../core/constants';
 import { NodeBuilderContext } from '../core/NodeBuilder';
 import {
+    BitangentNode,
     BufferNode,
     BypassNode,
     CameraNode,
     CodeNode,
+    CodeNodeInclude,
     ComputeNode,
     ContextNode,
-    ConvertNode,
     ExpressionNode,
     FrontFacingNode,
     FunctionCallNode,
     FunctionNode,
+    FunctionNodeArguments,
     InstanceIndexNode,
     MaterialNode,
     MaterialReferenceNode,
@@ -40,6 +44,7 @@ import {
     PositionNode,
     PropertyNode,
     ReferenceNode,
+    TangentNode,
     UserDataNode,
     UVNode,
     VarNode,
@@ -83,22 +88,39 @@ export const imat4: ConvertType;
 export const umat4: ConvertType;
 export const bmat4: ConvertType;
 
-export function func(code: string): ShaderNode<FunctionNode>;
-
 export function uniform(nodeOrType: Node | Swizzable | NodeValueOption): Swizzable;
 
 export function attribute(attributeName: string, nodeType: NodeTypeOption): Swizzable;
 export function property(name: string, nodeOrType: Node | NodeTypeOption): Swizzable;
 
+export function convert(node: NodeRepresentation, types: NodeTypeOption): Swizzable;
+
 export function bypass(returnNode: NodeRepresentation, callNode: NodeRepresentation): Swizzable<BypassNode>;
 export function code(code: string, nodeType?: NodeTypeOption): Swizzable<CodeNode>;
 export function context(node: NodeRepresentation, context: NodeBuilderContext): Swizzable<ContextNode>;
 export function expression(snipped?: string, nodeType?: NodeTypeOption): Swizzable<ExpressionNode>;
 
-export function call(
-    functionNode?: NodeRepresentation,
-    parameters?: { [name: string]: Node },
-): Swizzable<FunctionCallNode>;
+// definition: const call = nodeProxy(FunctionCallNode);
+export function call<P extends FunctionNodeArguments>(
+    functionNode?: FunctionNode<P>,
+    parameters?: ProxiedObject<P>,
+): Swizzable<FunctionCallNode<P>>;
+
+export type Fn<P extends FunctionNodeArguments> = P extends readonly [...unknown[]]
+    ? ProxiedTuple<P>
+    : readonly [ProxiedObject<P>];
+
+// tslint:disable:no-unnecessary-generics
+export function func<P extends FunctionNodeArguments>(
+    code: string,
+    includes?: CodeNodeInclude[],
+): { call: (...params: Fn<P>) => Swizzable };
+
+export function fn<P extends FunctionNodeArguments>(
+    code: string,
+    includes?: CodeNodeInclude[],
+): (...params: Fn<P>) => Swizzable;
+// tslint:enable:no-unnecessary-generics
 
 export const instanceIndex: Swizzable<InstanceIndexNode>;
 export function label(node: NodeRepresentation, name?: string): Swizzable<VarNode>;
@@ -146,6 +168,20 @@ export const normalWorld: Swizzable<NormalNode>;
 export const normalView: Swizzable<NormalNode>;
 export const transformedNormalView: Swizzable<VarNode>;
 
+export const tangentGeometry: Swizzable<TangentNode>;
+export const tangentLocal: Swizzable<TangentNode>;
+export const tangentView: Swizzable<TangentNode>;
+export const tangentWorld: Swizzable<TangentNode>;
+export const transformedTangentView: Swizzable<MathNode>;
+export const transformedTangentWorld: Swizzable<MathNode>;
+
+export const bitangentGeometry: Swizzable<BitangentNode>;
+export const bitangentLocal: Swizzable<BitangentNode>;
+export const bitangentView: Swizzable<BitangentNode>;
+export const bitangentWorld: Swizzable<BitangentNode>;
+export const transformedBitangentView: Swizzable<MathNode>;
+export const transformedBitangentWorld: Swizzable<MathNode>;
+
 export const modelViewMatrix: Swizzable<ModelNode>;
 export const modelNormalMatrix: Swizzable<ModelNode>;
 export const modelWorldMatrix: Swizzable<ModelNode>;
@@ -155,6 +191,7 @@ export const modelViewPosition: Swizzable<ModelNode>;
 export const positionGeometry: Swizzable<PositionNode>;
 export const positionLocal: Swizzable<PositionNode>;
 export const positionWorld: Swizzable<PositionNode>;
+export const positionWorldDirection: Swizzable<PositionNode>;
 export const positionView: Swizzable<PositionNode>;
 export const positionViewDirection: Swizzable<PositionNode>;
 
@@ -228,8 +265,8 @@ export const negate: Unary;
 export const invert: Unary;
 export const dFdx: Unary;
 export const dFdy: Unary;
-export const saturate: Unary;
 export const round: Unary;
+export const reciprocal: Unary;
 
 export const atan2: Binary;
 export const min: Binary;
@@ -263,5 +300,8 @@ export const faceDirection: Swizzable;
 export function element(node: NodeRepresentation, indexNode: NodeRepresentation): Swizzable;
 
 // miscellaneous
+export const lumaCoeffs: Swizzable<MathNode>;
+export const luminance: Binary;
+export const difference: Binary;
 export const dotNV: Swizzable<MathNode>;
-export const transformedNormalWorld: Swizzable<MathNode>;
+export const TBNViewMatrix: Swizzable<MathNode>;

three/examples/jsm/nodes/shadernode/ShaderNodeElements.d.ts

@@ -12,10 +12,12 @@ import {
 } from '../../../../src/Three';
 import LightingContextNode, { LightingModelNode } from '../lighting/LightingContextNode';
 import {
+    BlendModeNode,
     CheckerNode,
     ColorAdjustmentNode,
     ColorSpaceNode,
     CubeTextureNode,
+    EquirectUVNode,
     FogNode,
     FogRangeNode,
     InstanceNode,
@@ -24,12 +26,15 @@ import {
     MaxMipLevelNode,
     NormalMapNode,
     OscNode,
+    PosterizeNode,
+    RemapNode,
     ReflectVectorNode,
     RotateUVNode,
     SkinningNode,
     SpriteSheetUVNode,
     TimerNode,
     ToneMappingNode,
+    TriplanarTexturesNode,
 } from '../Nodes';
 
 //
@@ -69,6 +74,11 @@ export function skinning(skinnedMesh: SkinnedMesh): Swizzable<SkinningNode>;
 
 // display
 
+export function burn(baseNode: NodeRepresentation, blendNode?: NodeRepresentation): Swizzable<BlendModeNode>;
+export function dodge(baseNode: NodeRepresentation, blendNode?: NodeRepresentation): Swizzable<BlendModeNode>;
+export function overlay(baseNode: NodeRepresentation, blendNode?: NodeRepresentation): Swizzable<BlendModeNode>;
+export function screen(baseNode: NodeRepresentation, blendNode?: NodeRepresentation): Swizzable<BlendModeNode>;
+
 export function saturation(
     colorNode: NodeRepresentation,
     adjustmentNode?: NodeRepresentation,
@@ -87,6 +97,8 @@ export function toneMapping(
     color: NodeRepresentation,
 ): Swizzable<ToneMappingNode>;
 
+export function posterize(sourceNode: NodeRepresentation, stepsNode: NodeRepresentation): Swizzable<PosterizeNode>;
+
 // lighting
 
 export function lights(lights: Light[]): Swizzable<LightsNode>;
@@ -95,6 +107,8 @@ export function lightingContext(node: Node, lightingModelNode?: LightingModelNod
 // utils
 
 export const matcapUV: Swizzable<MatcapUVNode>;
+export const equirectUV: Swizzable<EquirectUVNode>;
+
 export function maxMipLevel(texture: Texture): Swizzable<MaxMipLevelNode>;
 
 export function oscSine(timeNode?: NodeRepresentation): Swizzable<OscNode>;
@@ -102,6 +116,9 @@ export function oscSquare(timeNode?: NodeRepresentation): Swizzable<OscNode>;
 export function oscTriangle(timeNode?: NodeRepresentation): Swizzable<OscNode>;
 export function oscSawtooth(timeNode?: NodeRepresentation): Swizzable<OscNode>;
 
+export function remap(node: Node, inLowNode: Node): Swizzable<RemapNode>;
+export function remapClamp(node: Node, inLowNode: Node): Swizzable<RemapNode>;
+
 export function rotateUV(uvNode: Node, rotationNode: Node, centerNode?: Node): Swizzable<RotateUVNode>;
 
 export function spritesheetUV(
@@ -113,6 +130,19 @@ export function spritesheetUV(
 export function timerLocal(timeScale: number, value?: number): Swizzable<TimerNode>;
 export function timerGlobal(timeScale: number, value?: number): Swizzable<TimerNode>;
 export function timerDelta(timeScale: number, value?: number): Swizzable<TimerNode>;
+export const frameId: Swizzable<TimerNode>;
+export function triplanarTextures(
+    textureXNode: NodeRepresentation,
+    textureYNode?: NodeRepresentation,
+    textureZNode?: NodeRepresentation,
+    scaleNode?: NodeRepresentation,
+    positionNode?: NodeRepresentation,
+    normalNode?: NodeRepresentation,
+): Swizzable<TriplanarTexturesNode>;
+export function triplanarTexture(
+    texture: NodeRepresentation,
+    ...params: NodeRepresentation[]
+): Swizzable<TriplanarTexturesNode>;
 
 // geometry
 

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

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

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

@@ -0,0 +1,13 @@
+import Node from '../core/Node';
+
+export default class RemapNode extends Node {
+    node: Node;
+    inLowNode: Node;
+    inHighNode: Node;
+    outLowNode: Node;
+    outHighNode: Node;
+
+    doClamp: boolean;
+
+    constructor(node: Node, inLowNode: Node, inHighNode: Node, outLowNode: Node, outHighNode: Node);
+}

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

@@ -1,11 +1,16 @@
 import UniformNode from '../core/UniformNode';
 
-export type TimerNodeScope = typeof TimerNode.LOCAL | typeof TimerNode.GLOBAL | typeof TimerNode.DELTA;
+export type TimerNodeScope =
+    | typeof TimerNode.LOCAL
+    | typeof TimerNode.GLOBAL
+    | typeof TimerNode.DELTA
+    | typeof TimerNode.FRAME;
 
 export default class TimerNode extends UniformNode {
     static LOCAL: 'local';
     static GLOBAL: 'global';
     static DELTA: 'delta';
+    static FRAME: 'frame';
 
     scope: TimerNodeScope;
     scale: number;

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

@@ -0,0 +1,22 @@
+import Node from '../core/Node';
+import { PositionNode, Swizzable, TextureNode } from '../Nodes';
+
+export default class TriplanarTexturesNode extends Node {
+    textureXNode: TextureNode;
+    textureYNode: TextureNode | null;
+    textureZNode: TextureNode | null;
+
+    scaleNode: Swizzable;
+
+    positionNode: Swizzable<PositionNode>;
+    normalNode: Swizzable<PositionNode>;
+
+    constructor(
+        textureXNode: Node,
+        textureYNode?: TextureNode | null,
+        textureZNode?: TextureNode | null,
+        scaleNode?: Swizzable,
+        positionNode?: Swizzable<PositionNode>,
+        normalNode?: Swizzable<PositionNode>,
+    );
+}

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

@@ -21,7 +21,7 @@ export interface ReflectorShader {
     fragmentShader: string;
 }
 
-export interface ReflectorOptions {
+export interface ReflectorForSSRPassOptions {
     clipBias?: number | undefined;
     textureWidth?: number | undefined;
     textureHeight?: number | undefined;
@@ -30,9 +30,9 @@ export interface ReflectorOptions {
     shader?: ReflectorShader | undefined;
 }
 
-export class Reflector<TGeometry extends BufferGeometry = BufferGeometry> extends Mesh<TGeometry> {
+export class ReflectorForSSRPass<TGeometry extends BufferGeometry = BufferGeometry> extends Mesh<TGeometry> {
     type: 'ReflectorForSSRPass';
-    options: ReflectorOptions;
+    options: ReflectorForSSRPassOptions;
 
     static ReflectorShader: ReflectorShader;
 
@@ -49,7 +49,7 @@ export class Reflector<TGeometry extends BufferGeometry = BufferGeometry> extend
 
     renderTarget: WebGLRenderTarget;
 
-    constructor(geometry: TGeometry, options: ReflectorOptions);
+    constructor(geometry: TGeometry, options: ReflectorForSSRPassOptions);
 
     doRender: (renderer: WebGLRenderer, scene: Scene, camera: Camera) => void;
 

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

@@ -3,7 +3,7 @@ import { WebGLRenderTarget, ShaderMaterial } from '../../../src/Three';
 import { Pass } from './Pass';
 
 export class BloomPass extends Pass {
-    constructor(strength?: number, kernelSize?: number, sigma?: number, resolution?: number);
+    constructor(strength?: number, kernelSize?: number, sigma?: number);
     renderTargetX: WebGLRenderTarget;
     renderTargetY: WebGLRenderTarget;
     copyUniforms: object;

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

@@ -7,8 +7,6 @@ export interface BokehPassParamters {
     aspect?: number;
     aperture?: number;
     maxblur?: number;
-    width?: number;
-    height?: number;
 }
 
 export class BokehPass extends Pass {

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

@@ -27,4 +27,5 @@ export class EffectComposer {
     reset(renderTarget?: WebGLRenderTarget): void;
     setSize(width: number, height: number): void;
     setPixelRatio(pixelRatio: number): void;
+    dispose(): void;
 }

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

@@ -15,6 +15,8 @@ export class Pass {
         deltaTime: number,
         maskActive: boolean,
     ): void;
+
+    dispose(): void;
 }
 
 export class FullScreenQuad {

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

@@ -12,7 +12,7 @@ import {
     ColorRepresentation,
 } from '../../../src/Three';
 import { Pass, FullScreenQuad } from '../postprocessing/Pass';
-import { Reflector } from '../objects/ReflectorForSSRPass';
+import { ReflectorForSSRPass } from '../objects/ReflectorForSSRPass';
 
 export interface SSRPassParams {
     renderer: WebGLRenderer;
@@ -23,7 +23,7 @@ export interface SSRPassParams {
     selects: Mesh[] | null;
     isPerspectiveCamera?: boolean | undefined;
     isBouncing?: boolean | undefined;
-    groundReflector: Reflector | null;
+    groundReflector: ReflectorForSSRPass | null;
 }
 
 export class SSRPass extends Pass {
@@ -33,7 +33,7 @@ export class SSRPass extends Pass {
     renderer: WebGLRenderer;
     scene: Scene;
     camera: Camera;
-    groundReflector: Reflector | null;
+    groundReflector: ReflectorForSSRPass | null;
     opacity: number;
     output: number;
     maxDistance: number;

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

@@ -1,5 +1,17 @@
-import Node from '../../../nodes/core/Node.js';
+import Node from '../../../nodes/core/Node';
 
-export default class SlotNode extends Node {
-    constructor(node: Node, name: string, NodeTypeOption: string);
+export interface SlotNodeParameters<TNode extends Node = Node> {
+    node?: TNode;
+    nodeType?: string;
+    source?: string | null;
+    target?: string | null;
+}
+
+export default class SlotNode<TNode extends Node = Node> extends Node {
+    inclusionType: 'replace';
+    node: TNode | null;
+    source: null;
+    target: null;
+
+    constructor(params: SlotNodeParameters<TNode>);
 }

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

@@ -1,8 +1,8 @@
-import NodeBuilder from '../../../nodes/core/NodeBuilder.js';
+import NodeBuilder from '../../../nodes/core/NodeBuilder';
 import { Texture, TextureEncoding, Renderer, Object3D } from '../../../../../src/Three';
-import Node from '../../../nodes/core/Node.js';
-import SlotNode from './SlotNode.js';
-import { NodeShaderStageOption } from '../../../nodes/core/constants.js';
+import Node from '../../../nodes/core/Node';
+import SlotNode from './SlotNode';
+import { NodeShaderStageOption } from '../../../nodes/core/constants';
 
 export class WebGLNodeBuilder extends NodeBuilder {
     constructor(
@@ -39,10 +39,10 @@ export class WebGLNodeBuilder extends NodeBuilder {
 
     getVarys(shaderStage: string): string;
 
-    addCodeAfterSnippet(shaderStage: string, snippet: string, code: string): string;
+    addCode(shaderStage: string, source: string, code: string, scope?: this): string;
     addCodeAfterInclude(shaderStage: string, snippet: string, code: string): string;
 
-    replaceCode(shaderStage: string, source: string, target: string): void;
+    replaceCode(shaderStage: string, source: string, target: string, scope?: this): void;
     parseInclude(shaderStage: string, ...includes: string[]): void;
     getTextureEncodingFromMap(map: Texture): TextureEncoding;
 

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';
 
 export const nodeFrame: NodeFrame;