@types/three 0.144.0 → 0.147.0

three/examples/jsm/nodes/core/constants.d.ts

@@ -2,14 +2,14 @@ import { Color, Matrix3, Matrix4, Vector2, Vector3, Vector4 } from '../../../../
 
 // disable automatic export, we have some private declarations
 export const NodeShaderStage: {
-    Vertex: 'vertex';
-    Fragment: 'fragment';
+    VERTEX: 'vertex';
+    FRAGMENT: 'fragment';
 };
 
 export const NodeUpdateType: {
-    None: 'none';
-    Frame: 'frame';
-    Object: 'object';
+    NONE: 'none';
+    FRAME: 'frame';
+    OBJECT: 'object';
 };
 
 export type NodeValueOption = Color | Vector2 | Vector3 | Vector4 | Matrix3 | Matrix4 | boolean | number;
@@ -66,12 +66,12 @@ export interface AnyObject {
 export type AnyJson = any;
 
 export const NodeType: {
-    Boolean: 'bool';
-    Integer: 'int';
-    Float: 'float';
-    Vector2: 'vec2';
-    Vector3: 'vec3';
-    Vector4: 'vec4';
-    Matrix3: 'mat3';
-    Matrix4: 'mat4';
+    BOOLEAN: 'bool';
+    INTEGER: 'int';
+    FLOAT: 'float';
+    VECTOR2: 'vec2';
+    VECTOR3: 'vec3';
+    VECTOR4: 'vec4';
+    MATRIX3: 'mat3';
+    MATRIX4: 'mat4';
 };

three/examples/jsm/nodes/display/BlendModeNode.d.ts

@@ -0,0 +1,32 @@
+import TempNode from '../core/TempNode';
+import { ShaderNode } from '../shadernode/ShaderNodeBaseElements';
+import { Node } from '../Nodes';
+
+export const BurnNode: ShaderNode<{ base: Node; blendNode: Node }>;
+
+export const DodgeNode: ShaderNode<{ base: Node; blendNode: Node }>;
+
+export const ScreenNode: ShaderNode<{ base: Node; blendNode: Node }>;
+
+export const OverlayNode: ShaderNode<{ base: Node; blendNode: Node }>;
+
+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);
+
+    construct(): Node;
+}

three/examples/jsm/nodes/display/PosterizeNode.d.ts

@@ -0,0 +1,8 @@
+import Node from '../core/Node';
+
+export default class PosterizeNode extends Node {
+    sourceNode: Node;
+    stepsNode: Node;
+
+    constructor(sourceNode: Node, stepsNode: Node);
+}

three/examples/jsm/nodes/display/ViewportNode.d.ts

@@ -0,0 +1,23 @@
+import Node from '../core/Node';
+
+export type ViewportNodeScope =
+    | typeof ViewportNode.COORDINATE
+    | typeof ViewportNode.RESOLUTION
+    | typeof ViewportNode.TOP_LEFT
+    | typeof ViewportNode.BOTTOM_LEFT
+    | typeof ViewportNode.TOP_RIGHT
+    | typeof ViewportNode.BOTTOM_RIGHT;
+
+export default class ViewportNode extends Node {
+    static COORDINATE: 'coordinate';
+    static RESOLUTION: 'resolution';
+    static TOP_LEFT: 'topLeft';
+    static BOTTOM_LEFT: 'bottomLeft';
+    static TOP_RIGHT: 'topRight';
+    static BOTTOM_RIGHT: 'bottomRight';
+
+    scope: ViewportNodeScope;
+    isViewportNode: true;
+
+    constructor(scope: ViewportNodeScope);
+}

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/{functions/lib → lib}/mx_hsv.d.ts

@@ -1,4 +1,4 @@
-import { Fn, Node, Swizzable } from '../../../Nodes';
+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/{functions/lib → lib}/mx_noise.d.ts

@@ -1,4 +1,4 @@
-import { Fn, Node, Swizzable } from '../../../Nodes';
+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;

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/shadernode/ShaderNodeBaseElements.d.ts

@@ -20,6 +20,7 @@ import { Material, Texture } from '../../../../src/Three';
 import { NodeTypeOption, NodeUserData, NodeValueOption } from '../core/constants';
 import { NodeBuilderContext } from '../core/NodeBuilder';
 import {
+    BitangentNode,
     BufferNode,
     BypassNode,
     CameraNode,
@@ -43,6 +44,7 @@ import {
     PositionNode,
     PropertyNode,
     ReferenceNode,
+    TangentNode,
     UserDataNode,
     UVNode,
     VarNode,
@@ -91,6 +93,8 @@ export function uniform(nodeOrType: Node | Swizzable | NodeValueOption): Swizzab
 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>;
@@ -164,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>;
@@ -173,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>;
 
@@ -246,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;
@@ -281,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,16 @@ import {
     MaxMipLevelNode,
     NormalMapNode,
     OscNode,
+    PosterizeNode,
+    RemapNode,
     ReflectVectorNode,
     RotateUVNode,
     SkinningNode,
     SpriteSheetUVNode,
     TimerNode,
     ToneMappingNode,
+    TriplanarTexturesNode,
+    ViewportNode,
 } from '../Nodes';
 
 //
@@ -69,6 +75,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 +98,15 @@ export function toneMapping(
     color: NodeRepresentation,
 ): Swizzable<ToneMappingNode>;
 
+export function posterize(sourceNode: NodeRepresentation, stepsNode: NodeRepresentation): Swizzable<PosterizeNode>;
+
+export const viewportCoordinate: Swizzable<ViewportNode>;
+export const viewportResolution: Swizzable<ViewportNode>;
+export const viewportTopLeft: Swizzable<ViewportNode>;
+export const viewportBottomLeft: Swizzable<ViewportNode>;
+export const viewportTopRight: Swizzable<ViewportNode>;
+export const viewportBottomRight: Swizzable<ViewportNode>;
+
 // lighting
 
 export function lights(lights: Light[]): Swizzable<LightsNode>;
@@ -95,6 +115,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 +124,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 +138,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/ShadowMesh.d.ts

@@ -1,7 +1,10 @@
-import { Mesh, Plane, Vector4 } from '../../../src/Three';
+import { Mesh, Plane, Vector4, Matrix4, MeshBasicMaterial, BufferGeometry } from '../../../src/Three';
 
-export class ShadowMesh extends Mesh {
-    constructor();
+export class ShadowMesh extends Mesh<BufferGeometry, MeshBasicMaterial> {
+    readonly isShadowMesh: true;
+    meshMatrix: Matrix4;
+
+    constructor(mesh: Mesh);
 
     update(plane: Plane, lightPosition4D: Vector4): void;
 }

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

@@ -1,6 +1,6 @@
 import { WebGLRenderTarget, ShaderMaterial } from '../../../src/Three';
 
-import { Pass } from './Pass';
+import { Pass, FullScreenQuad } from './Pass';
 
 export class AdaptiveToneMappingPass extends Pass {
     constructor(adaptive?: boolean, resolution?: number);
@@ -16,7 +16,7 @@ export class AdaptiveToneMappingPass extends Pass {
     adaptLuminanceShader: object;
     materialAdaptiveLum: ShaderMaterial;
     materialToneMap: ShaderMaterial;
-    fsQuad: object;
+    fsQuad: FullScreenQuad;
 
     reset(): void;
     setAdaptive(adaptive: boolean): void;

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

@@ -1,6 +1,6 @@
 import { WebGLRenderTarget, ShaderMaterial } from '../../../src/Three';
 
-import { Pass } from './Pass';
+import { Pass, FullScreenQuad } from './Pass';
 
 export class AfterimagePass extends Pass {
     constructor(damp?: number);
@@ -9,6 +9,6 @@ export class AfterimagePass extends Pass {
     textureComp: WebGLRenderTarget;
     textureOld: WebGLRenderTarget;
     shaderMaterial: ShaderMaterial;
-    compFsQuad: object;
-    copyFsQuad: object;
+    compFsQuad: FullScreenQuad;
+    copyFsQuad: FullScreenQuad;
 }

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

@@ -1,14 +1,14 @@
 import { WebGLRenderTarget, ShaderMaterial } from '../../../src/Three';
 
-import { Pass } from './Pass';
+import { Pass, FullScreenQuad } 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;
     materialCopy: ShaderMaterial;
     convolutionUniforms: object;
     materialConvolution: ShaderMaterial;
-    fsQuad: object;
+    fsQuad: FullScreenQuad;
 }

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

@@ -1,14 +1,12 @@
 import { Scene, Camera, ShaderMaterial, WebGLRenderTarget, MeshDepthMaterial, Color } from '../../../src/Three';
 
-import { Pass } from './Pass';
+import { Pass, FullScreenQuad } from './Pass';
 
 export interface BokehPassParamters {
     focus?: number;
     aspect?: number;
     aperture?: number;
     maxblur?: number;
-    width?: number;
-    height?: number;
 }
 
 export class BokehPass extends Pass {
@@ -20,6 +18,6 @@ export class BokehPass extends Pass {
     materialDepth: MeshDepthMaterial;
     materialBokeh: ShaderMaterial;
     uniforms: object;
-    fsQuad: object;
+    fsQuad: FullScreenQuad;
     oldClearColor: Color;
 }

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

@@ -1,6 +1,6 @@
 import { ColorRepresentation } from '../../../src/Three';
 
-import { Pass } from './Pass';
+import { Pass, FullScreenQuad } from './Pass';
 
 export class ClearPass extends Pass {
     constructor(clearColor?: ColorRepresentation, clearAlpha?: number);

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

@@ -1,6 +1,6 @@
 import { PerspectiveCamera, CubeTexture, Mesh, Scene } from '../../../src/Three';
 
-import { Pass } from './Pass';
+import { Pass, FullScreenQuad } from './Pass';
 
 export class CubeTexturePass extends Pass {
     constructor(camera: PerspectiveCamera, envMap?: CubeTexture, opacity?: number);

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

@@ -1,10 +1,10 @@
 import { Vector2, ShaderMaterial } from '../../../src/Three';
 
-import { Pass } from './Pass';
+import { Pass, FullScreenQuad } from './Pass';
 
 export class DotScreenPass extends Pass {
     constructor(center?: Vector2, angle?: number, scale?: number);
     uniforms: object;
     material: ShaderMaterial;
-    fsQuad: object;
+    fsQuad: FullScreenQuad;
 }

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

@@ -1,6 +1,6 @@
 import { Clock, WebGLRenderer, WebGLRenderTarget } from '../../../src/Three';
 
-import { Pass } from './Pass';
+import { Pass, FullScreenQuad } from './Pass';
 import { ShaderPass } from './ShaderPass';
 
 export { FullScreenQuad } from './Pass';
@@ -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/FilmPass.d.ts

@@ -1,10 +1,10 @@
 import { ShaderMaterial } from '../../../src/Three';
 
-import { Pass } from './Pass';
+import { Pass, FullScreenQuad } from './Pass';
 
 export class FilmPass extends Pass {
     constructor(noiseIntensity?: number, scanlinesIntensity?: number, scanlinesCount?: number, grayscale?: number);
     uniforms: object;
     material: ShaderMaterial;
-    fsQuad: object;
+    fsQuad: FullScreenQuad;
 }

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

@@ -1,12 +1,12 @@
 import { ShaderMaterial, DataTexture } from '../../../src/Three';
 
-import { Pass } from './Pass';
+import { Pass, FullScreenQuad } from './Pass';
 
 export class GlitchPass extends Pass {
     constructor(dt_size?: number);
     uniforms: object;
     material: ShaderMaterial;
-    fsQuad: object;
+    fsQuad: FullScreenQuad;
     goWild: boolean;
     curF: number;
     randX: number;

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

@@ -1,6 +1,6 @@
 import { ShaderMaterial } from '../../../src/Three';
 
-import { Pass } from './Pass';
+import { Pass, FullScreenQuad } from './Pass';
 
 export interface HalftonePassParameters {
     shape?: number;
@@ -19,5 +19,5 @@ export class HalftonePass extends Pass {
     constructor(width: number, height: number, params: HalftonePassParameters);
     uniforms: object;
     material: ShaderMaterial;
-    fsQuad: object;
+    fsQuad: FullScreenQuad;
 }

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

@@ -1,6 +1,6 @@
 import { Scene, Camera } from '../../../src/Three';
 
-import { Pass } from './Pass';
+import { Pass, FullScreenQuad } from './Pass';
 
 export class MaskPass extends Pass {
     constructor(scene: Scene, camera: Camera);