@types/three 0.146.0 → 0.147.1

three/README.md

@@ -8,7 +8,7 @@ This package contains type definitions for three (https://threejs.org/).
 Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/three.
 
 ### Additional Details
- * Last updated: Mon, 07 Nov 2022 20:26:35 GMT
+ * Last updated: Fri, 30 Dec 2022 23:03:50 GMT
  * Dependencies: [@types/webxr](https://npmjs.com/package/@types/webxr)
  * Global values: `THREE`
 

three/examples/jsm/animation/CCDIKSolver.d.ts

@@ -1,13 +1,17 @@
-import { Object3D, SkinnedMesh } from '../../../src/Three';
+import { Object3D, SkinnedMesh, Vector3 } from '../../../src/Three';
 
 // tslint:disable-next-line:interface-name
 export interface IKS {
     effector: number;
     iteration: number;
-    links: {
+    links: Array<{
         enabled: boolean;
         index: number;
-    };
+        limitation?: Vector3;
+        rotationMin?: Vector3;
+        rotationMax?: Vector3;
+    }>;
+    minAngle: number;
     maxAngle: number;
     target: number;
 }

three/examples/jsm/controls/OrbitControls.d.ts

@@ -1,69 +1,265 @@
 import { Camera, MOUSE, TOUCH, Vector3 } from '../../../src/Three';
 
+/**
+ * Orbit controls allow the camera to orbit around a target.
+ * @param object - The camera to be controlled. The camera must not
+ * be a child of another object, unless that object is the scene itself.
+ * @param domElement - The HTML element used for
+ * event listeners.
+ */
 export class OrbitControls {
     constructor(object: Camera, domElement?: HTMLElement);
 
+    /**
+     * The camera being controlled.
+     */
     object: Camera;
+
+    /**
+     * The HTMLElement used to listen for mouse / touch events.
+     * This must be passed in the constructor;
+     * changing it here will not set up new event listeners.
+     */
     domElement: HTMLElement | Document;
 
-    // API
+    /**
+     * When set to `false`, the controls will not respond to user input.
+     * @default true
+     */
     enabled: boolean;
+
+    /**
+     * The focus point of the controls, the .object orbits around this.
+     * It can be updated manually at any point to change the focus
+     * of the controls.
+     */
     target: Vector3;
 
-    // deprecated
+    /** @deprecated */
     center: Vector3;
 
+    /**
+     * How far you can dolly in ( PerspectiveCamera only ).
+     * @default 0
+     */
     minDistance: number;
+
+    /**
+     * How far you can dolly out ( PerspectiveCamera only ).
+     * @default Infinity
+     */
     maxDistance: number;
 
+    /**
+     * How far you can zoom in ( OrthographicCamera only ).
+     * @default 0
+     */
     minZoom: number;
+
+    /**
+     * How far you can zoom out ( OrthographicCamera only ).
+     * @default Infinity
+     */
     maxZoom: number;
 
+    /**
+     * How far you can orbit vertically, lower limit.
+     * Range is 0 to Math.PI radians.
+     * @default 0
+     */
     minPolarAngle: number;
+
+    /**
+     * How far you can orbit vertically, upper limit.
+     * Range is 0 to Math.PI radians.
+     * @default Math.PI.
+     */
     maxPolarAngle: number;
 
+    /**
+     * How far you can orbit horizontally, lower limit.
+     * If set, the interval [ min, max ]
+     * must be a sub-interval of [ - 2 PI, 2 PI ],
+     * with ( max - min < 2 PI ).
+     * @default Infinity
+     */
     minAzimuthAngle: number;
+
+    /**
+     * How far you can orbit horizontally, upper limit.
+     * If set, the interval [ min, max ] must be a sub-interval
+     * of [ - 2 PI, 2 PI ], with ( max - min < 2 PI ).
+     * @default Infinity
+     */
     maxAzimuthAngle: number;
 
+    /**
+     * Set to true to enable damping (inertia), which can
+     * be used to give a sense of weight to the controls.
+     * Note that if this is enabled, you must call
+     * .update () in your animation loop.
+     * @default false
+     */
     enableDamping: boolean;
+
+    /**
+     * The damping inertia used if .enableDamping is set to true.
+     * Note that for this to work,
+     * you must call .update () in your animation loop.
+     * @default 0.05
+     */
     dampingFactor: number;
 
+    /**
+     * Enable or disable zooming (dollying) of the camera.
+     * @default true
+     */
     enableZoom: boolean;
+
+    /**
+     * Speed of zooming / dollying.
+     * @default 1
+     */
     zoomSpeed: number;
 
+    /**
+     * Enable or disable horizontal and
+     * vertical rotation of the camera.
+     * Note that it is possible to disable a single axis
+     * by setting the min and max of the polar angle or
+     * azimuth angle to the same value, which will cause
+     * the vertical or horizontal rotation to be fixed at that value.
+     * @default true
+     */
     enableRotate: boolean;
+
+    /**
+     * Speed of rotation.
+     * @default 1
+     */
     rotateSpeed: number;
 
+    /**
+     * Enable or disable camera panning.
+     * @default true
+     */
     enablePan: boolean;
+
+    /**
+     * Speed of panning.
+     * @default 1
+     */
     panSpeed: number;
+
+    /**
+     * Defines how the camera's position is translated when panning.
+     * If true, the camera pans in screen space. Otherwise,
+     * the camera pans in the plane orthogonal to the camera's
+     * up direction. Default is true for OrbitControls; false for MapControls.
+     * @default true
+     */
     screenSpacePanning: boolean;
+
+    /**
+     * How fast to pan the camera when the keyboard is used.
+     * Default is 7.0 pixels per keypress.
+     * @default 7
+     */
     keyPanSpeed: number;
 
+    /**
+     * Set to true to automatically rotate around the target.
+     * Note that if this is enabled, you must call
+     * .update () in your animation loop.
+     */
     autoRotate: boolean;
+
+    /**
+     * How fast to rotate around the target if .autoRotate is true.
+     * Default is 2.0, which equates to 30 seconds per orbit at 60fps.
+     * Note that if .autoRotate is enabled, you must call
+     * .update () in your animation loop.
+     * @default 2
+     */
     autoRotateSpeed: number;
 
+    /**
+     * This object contains references to the keycodes for controlling
+     * camera panning. Default is the 4 arrow keys.
+     */
     keys: { LEFT: string; UP: string; RIGHT: string; BOTTOM: string };
+
+    /**
+     * This object contains references to the mouse actions used
+     * by the controls.
+     */
     mouseButtons: Partial<{ LEFT: MOUSE; MIDDLE: MOUSE; RIGHT: MOUSE }>;
+
+    /**
+     * This object contains references to the touch actions used by
+     * the controls.
+     */
     touches: Partial<{ ONE: TOUCH; TWO: TOUCH }>;
 
+    /**
+     * Used internally by the .saveState and .reset methods.
+     */
     target0: Vector3;
+
+    /**
+     * Used internally by the .saveState and .reset methods.
+     */
     position0: Vector3;
+
+    /**
+     * Used internally by the .saveState and .reset methods.
+     */
     zoomO: number;
 
+    /**
+     * Update the controls. Must be called after any manual changes
+     * to the camera's transform, or in the update loop if .autoRotate
+     * or .enableDamping are set.
+     */
     update(): boolean;
 
+    /**
+     * Adds key event listeners to the given DOM element. `window`
+     * is a recommended argument for using this method.
+     * @param domElement
+     */
     listenToKeyEvents(domElement: HTMLElement | Window): void;
 
+    /**
+     * Save the current state of the controls. This can later be
+     * recovered with .reset.
+     */
     saveState(): void;
 
+    /**
+     * Reset the controls to their state from either the last time
+     * the .saveState was called, or the initial state.
+     */
     reset(): void;
 
+    /**
+     * Remove all the event listeners.
+     */
     dispose(): void;
 
+    /**
+     * Get the current vertical rotation, in radians.
+     */
     getPolarAngle(): number;
 
+    /**
+     * Get the current horizontal rotation, in radians.
+     */
     getAzimuthalAngle(): number;
 
+    /**
+     * Returns the distance from the camera to the target.
+     */
     getDistance(): number;
 
     // EventDispatcher mixins

three/examples/jsm/interactive/SelectionHelper.d.ts

@@ -12,4 +12,5 @@ export class SelectionHelper {
     onSelectStart(event: Event): void;
     onSelectMove(event: Event): void;
     onSelectOver(event: Event): void;
+    dispose(): void;
 }

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

@@ -3,6 +3,7 @@ import { BufferGeometry, Loader, LoadingManager } from '../../../src/Three';
 export class PLYLoader extends Loader {
     constructor(manager?: LoadingManager);
     propertyNameMapping: object;
+    customPropertyMapping: Record<string, any>;
 
     load(
         url: string,
@@ -12,5 +13,6 @@ export class PLYLoader extends Loader {
     ): void;
     loadAsync(url: string, onProgress?: (event: ProgressEvent) => void): Promise<BufferGeometry>;
     setPropertyNameMapping(mapping: object): void;
+    setCustomPropertyNameMapping(mapping: Record<string, any>): void;
     parse(data: ArrayBuffer | string): BufferGeometry;
 }

three/examples/jsm/nodes/Nodes.d.ts

@@ -61,6 +61,7 @@ import FrontFacingNode from './display/FrontFacingNode';
 import NormalMapNode from './display/NormalMapNode';
 import PosterizeNode from './display/PosterizeNode';
 import ToneMappingNode from './display/ToneMappingNode';
+import ViewportNode from './display/ViewportNode';
 
 // math
 import MathNode, { MathNodeMethod1, MathNodeMethod2, MathNodeMethod3, MathNodeMethod } from './math/MathNode';
@@ -186,6 +187,7 @@ export {
     NormalMapNode,
     PosterizeNode,
     ToneMappingNode,
+    ViewportNode,
     // math
     MathNode,
     MathNodeMethod1,

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

@@ -74,6 +74,10 @@ export default abstract class NodeBuilder {
 
     abstract getFrontFacing(): string;
 
+    abstract getFragCoord(): string;
+
+    isFlipY(): boolean;
+
     abstract getTexture(textureProperty: string, uvSnippet: string): string;
 
     abstract getTextureLevel(textureProperty: string, uvSnippet: string, levelSnippet: string): string;

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

@@ -110,7 +110,7 @@ export type Fn<P extends FunctionNodeArguments> = P extends readonly [...unknown
     ? ProxiedTuple<P>
     : readonly [ProxiedObject<P>];
 
-// tslint:disable:no-unnecessary-generics
+/* eslint-disable no-unnecessary-generics */
 export function func<P extends FunctionNodeArguments>(
     code: string,
     includes?: CodeNodeInclude[],
@@ -120,7 +120,7 @@ export function fn<P extends FunctionNodeArguments>(
     code: string,
     includes?: CodeNodeInclude[],
 ): (...params: Fn<P>) => Swizzable;
-// tslint:enable:no-unnecessary-generics
+/* eslint-enable no-unnecessary-generics */
 
 export const instanceIndex: Swizzable<InstanceIndexNode>;
 export function label(node: NodeRepresentation, name?: string): Swizzable<VarNode>;

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

@@ -35,6 +35,7 @@ import {
     TimerNode,
     ToneMappingNode,
     TriplanarTexturesNode,
+    ViewportNode,
 } from '../Nodes';
 
 //
@@ -99,6 +100,13 @@ export function toneMapping(
 
 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>;

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,6 +1,6 @@
 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);
@@ -10,5 +10,5 @@ export class BloomPass extends Pass {
     materialCopy: ShaderMaterial;
     convolutionUniforms: object;
     materialConvolution: ShaderMaterial;
-    fsQuad: object;
+    fsQuad: FullScreenQuad;
 }

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

@@ -1,6 +1,6 @@
 import { Scene, Camera, ShaderMaterial, WebGLRenderTarget, MeshDepthMaterial, Color } from '../../../src/Three';
 
-import { Pass } from './Pass';
+import { Pass, FullScreenQuad } from './Pass';
 
 export interface BokehPassParamters {
     focus?: number;
@@ -18,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';

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);

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

@@ -12,7 +12,7 @@ import {
     Texture,
 } from '../../../src/Three';
 
-import { Pass } from './Pass';
+import { Pass, FullScreenQuad } from './Pass';
 
 export class OutlinePass extends Pass {
     constructor(resolution: Vector2, scene: Scene, camera: Camera, selectedObjects?: Object3D[]);
@@ -48,7 +48,7 @@ export class OutlinePass extends Pass {
     materialCopy: ShaderMaterial;
     oldClearColor: Color;
     oldClearAlpha: number;
-    fsQuad: object;
+    fsQuad: FullScreenQuad;
     tempPulseColor1: Color;
     tempPulseColor2: Color;
     textureMatrix: Matrix4;

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

@@ -1,6 +1,6 @@
 import { Scene, Camera, Material, Color } from '../../../src/Three';
 
-import { Pass } from './Pass';
+import { Pass, FullScreenQuad } from './Pass';
 
 export class RenderPass extends Pass {
     constructor(scene: Scene, camera: Camera, overrideMaterial?: Material, clearColor?: Color, clearAlpha?: number);

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

@@ -0,0 +1,28 @@
+import { Scene, Camera, ShaderMaterial, Vector2, MeshNormalMaterial, WebGLRenderTarget } from '../../../src/Three';
+
+import { Pass, FullScreenQuad } from './Pass';
+
+export interface RenderPixelatedPassParameters {
+    normalEdgeStrength?: number;
+    depthEdgeStrength?: number;
+}
+
+export class RenderPixelatedPass extends Pass {
+    constructor(pixelSize: number, scene: Scene, camera: Camera, options?: RenderPixelatedPassParameters);
+    pixelSize: number;
+    resolution: Vector2;
+    renderResolution: Vector2;
+
+    pixelatedMaterial: ShaderMaterial;
+    normalMaterial: MeshNormalMaterial;
+
+    fsQuad: FullScreenQuad;
+    scene: Scene;
+    camera: Camera;
+
+    normalEdgeStrength: RenderPixelatedPassParameters['normalEdgeStrength'];
+    depthEdgeStrength: RenderPixelatedPassParameters['depthEdgeStrength'];
+
+    beautyRenderTarget: WebGLRenderTarget;
+    normalRenderTarget: WebGLRenderTarget;
+}

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

@@ -12,7 +12,7 @@ import {
     ColorRepresentation,
 } from '../../../src/Three';
 
-import { Pass } from './Pass';
+import { Pass, FullScreenQuad } from './Pass';
 
 export enum OUTPUT {
     Beauty,
@@ -57,7 +57,7 @@ export class SAOPass extends Pass {
     hBlurMaterial: ShaderMaterial;
     materialCopy: ShaderMaterial;
     depthCopy: ShaderMaterial;
-    fsQuad: object;
+    fsQuad: FullScreenQuad;
     params: SAOPassParams;
 
     static OUTPUT: typeof OUTPUT;

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

@@ -1,6 +1,6 @@
 import { ShaderMaterial, Texture, WebGLRenderTarget } from '../../../src/Three';
 
-import { Pass } from './Pass';
+import { Pass, FullScreenQuad } from './Pass';
 
 export class SMAAPass extends Pass {
     constructor(width: number, height: number);
@@ -14,7 +14,7 @@ export class SMAAPass extends Pass {
     materialWeights: ShaderMaterial;
     uniformsBlend: object;
     materialBlend: ShaderMaterial;
-    fsQuad: object;
+    fsQuad: FullScreenQuad;
 
     getAreaTexture(): string;
     getSearchTexture(): string;

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

@@ -1,6 +1,6 @@
 import { Scene, Camera, ColorRepresentation, ShaderMaterial, WebGLRenderTarget } from '../../../src/Three';
 
-import { Pass } from './Pass';
+import { Pass, FullScreenQuad } from './Pass';
 
 export class SSAARenderPass extends Pass {
     constructor(scene: Scene, camera: Camera, clearColor?: ColorRepresentation, clearAlpha?: number);
@@ -12,6 +12,6 @@ export class SSAARenderPass extends Pass {
     clearAlpha: number;
     copyUniforms: object;
     copyMaterial: ShaderMaterial;
-    fsQuad: object;
+    fsQuad: FullScreenQuad;
     sampleRenderTarget: undefined | WebGLRenderTarget;
 }

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

@@ -12,7 +12,7 @@ import {
     ColorRepresentation,
 } from '../../../src/Three';
 
-import { Pass } from './Pass';
+import { Pass, FullScreenQuad } from './Pass';
 
 export enum SSAOPassOUTPUT {
     Default,
@@ -46,7 +46,7 @@ export class SSAOPass extends Pass {
     blurMaterial: ShaderMaterial;
     depthRenderMaterial: ShaderMaterial;
     copyMaterial: ShaderMaterial;
-    fsQuad: object;
+    fsQuad: FullScreenQuad;
     originalClearColor: Color;
 
     static OUTPUT: SSAOPassOUTPUT;

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

@@ -1,6 +1,6 @@
 import { ShaderMaterial, WebGLRenderTarget } from '../../../src/Three';
 
-import { Pass } from './Pass';
+import { Pass, FullScreenQuad } from './Pass';
 
 export class SavePass extends Pass {
     constructor(renderTarget?: WebGLRenderTarget);
@@ -8,5 +8,5 @@ export class SavePass extends Pass {
     renderTarget: WebGLRenderTarget;
     uniforms: object;
     material: ShaderMaterial;
-    fsQuad: object;
+    fsQuad: FullScreenQuad;
 }

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

@@ -1,11 +1,11 @@
 import { ShaderMaterial } from '../../../src/Three';
 
-import { Pass } from './Pass';
+import { Pass, FullScreenQuad } from './Pass';
 
 export class ShaderPass extends Pass {
     constructor(shader: object, textureID?: string);
     textureID: string;
     uniforms: { [name: string]: { value: any } };
     material: ShaderMaterial;
-    fsQuad: object;
+    fsQuad: FullScreenQuad;
 }

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

@@ -1,6 +1,6 @@
 import { Texture, ShaderMaterial } from '../../../src/Three';
 
-import { Pass } from './Pass';
+import { Pass, FullScreenQuad } from './Pass';
 
 export class TexturePass extends Pass {
     constructor(map: Texture, opacity?: number);
@@ -8,5 +8,5 @@ export class TexturePass extends Pass {
     opacity: number;
     uniforms: object;
     material: ShaderMaterial;
-    fsQuad: object;
+    fsQuad: FullScreenQuad;
 }

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

@@ -1,6 +1,6 @@
 import { Color, MeshBasicMaterial, ShaderMaterial, Vector2, Vector3, WebGLRenderTarget } from '../../../src/Three';
 
-import { Pass } from './Pass';
+import { Pass, FullScreenQuad } from './Pass';
 
 export class UnrealBloomPass extends Pass {
     constructor(resolution: Vector2, strength: number, radius: number, threshold: number);
@@ -23,7 +23,7 @@ export class UnrealBloomPass extends Pass {
     oldClearColor: Color;
     oldClearAlpha: number;
     basic: MeshBasicMaterial;
-    fsQuad: object;
+    fsQuad: FullScreenQuad;
 
     dispose(): void;
     getSeperableBlurMaterial(): ShaderMaterial;

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

@@ -1,5 +1,5 @@
 import NodeBuilder from '../../../nodes/core/NodeBuilder';
-import { Texture, TextureEncoding, Renderer, Object3D } from '../../../../../src/Three';
+import { Renderer, Object3D } from '../../../../../src/Three';
 import Node from '../../../nodes/core/Node';
 import SlotNode from './SlotNode';
 import { NodeShaderStageOption } from '../../../nodes/core/constants';
@@ -44,10 +44,11 @@ export class WebGLNodeBuilder extends NodeBuilder {
 
     replaceCode(shaderStage: string, source: string, target: string, scope?: this): void;
     parseInclude(shaderStage: string, ...includes: string[]): void;
-    getTextureEncodingFromMap(map: Texture): TextureEncoding;
 
     getInstanceIndex(): string;
     getFrontFacing(): string;
+    getFragCoord(): 'gl_FragCoord';
+    isFlipY(): true;
 
     buildCode(): void;
     build(): this;

three/examples/jsm/utils/BufferGeometryUtils.d.ts

@@ -1,3 +1,5 @@
+// https://threejs.org/docs/?q=buffergeome#examples/en/utils/BufferGeometryUtils
+
 import {
     BufferAttribute,
     BufferGeometry,
@@ -24,3 +26,11 @@ export function computeMikkTSpaceTangents(
 export function mergeGroups(geometry: BufferGeometry): BufferGeometry;
 export function deinterleaveAttribute(geometry: BufferGeometry): void;
 export function deinterleaveGeometry(geometry: BufferGeometry): void;
+
+/**
+ * Creates a new, non-indexed geometry with smooth normals everywhere except faces that meet at an angle greater than the crease angle.
+ *
+ * @param geometry The input geometry.
+ * @param creaseAngle The crease angle.
+ */
+export function toCreasedNormals(geometry: BufferGeometry, creaseAngle?: number): BufferGeometry;

three/examples/jsm/webxr/OculusHandPointerModel.d.ts

@@ -7,7 +7,7 @@ import {
     MeshBasicMaterial,
     Object3D,
     Raycaster,
-    SphereBufferGeometry,
+    SphereGeometry,
     Texture,
     Vector3,
 } from '../../../src/Three';
@@ -30,7 +30,7 @@ export class OculusHandPointerModel extends Object3D {
     pinched: boolean;
     attached: boolean;
 
-    cursorObject: Mesh<SphereBufferGeometry, MeshBasicMaterial> | null;
+    cursorObject: Mesh<SphereGeometry, MeshBasicMaterial> | null;
 
     raycaster: Raycaster;
 

three/index.d.ts

@@ -1,4 +1,4 @@
-// Type definitions for three 0.146
+// Type definitions for three 0.147
 // Project: https://threejs.org/
 // Definitions by: Josh Ellis <https://github.com/joshuaellis>
 //                 Nathan Bierema <https://github.com/Methuselah96>

three/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@types/three",
-    "version": "0.146.0",
+    "version": "0.147.1",
     "description": "TypeScript definitions for three",
     "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/three",
     "license": "MIT",
@@ -27,6 +27,6 @@
     "dependencies": {
         "@types/webxr": "*"
     },
-    "typesPublisherContentHash": "8811cec6dcb6daed91e5163eee03aeed7a0b56ad67126ce3b6ade0354b3d8614",
-    "typeScriptVersion": "4.1"
+    "typesPublisherContentHash": "817382c65c940c6161d82bd35bba71b745760fd0e4d06c8cc05eb3b2953c438c",
+    "typeScriptVersion": "4.2"
 }

three/src/lights/PointLight.d.ts

@@ -18,7 +18,7 @@ export class PointLight extends Light {
 
     /**
      * Light's intensity.
-     * @default 1
+     * @default 2
      */
     intensity: number;
 

three/src/lights/SpotLight.d.ts

@@ -4,6 +4,7 @@ import { Object3D } from './../core/Object3D';
 import { SpotLightShadow } from './SpotLightShadow';
 import { Light } from './Light';
 import { ColorRepresentation } from '../utils';
+import { Texture } from '../textures/Texture';
 
 /**
  * A point light that can cast shadow in one direction.
@@ -36,7 +37,7 @@ export class SpotLight extends Light {
 
     /**
      * Light's intensity.
-     * @default 1
+     * @default 2
      */
     intensity: number;
 
@@ -68,5 +69,10 @@ export class SpotLight extends Light {
      */
     penumbra: number;
 
+    /**
+     * @default null
+     */
+    map: Texture | null;
+
     readonly isSpotLight: true;
 }

three/src/loaders/ObjectLoader.d.ts

@@ -12,7 +12,7 @@ export class ObjectLoader extends Loader {
 
     load(
         url: string,
-        // tslint:disable-next-line:no-unnecessary-generics
+        // eslint-disable-next-line no-unnecessary-generics
         onLoad?: <ObjectType extends Object3D>(object: ObjectType) => void,
         onProgress?: (event: ProgressEvent) => void,
         onError?: (event: Error | ErrorEvent) => void,
@@ -20,11 +20,11 @@ export class ObjectLoader extends Loader {
     loadAsync<ObjectType extends Object3D>(
         url: string,
         onProgress?: (event: ProgressEvent) => void,
-    ): // tslint:disable-next-line:no-unnecessary-generics
+    ): // eslint-disable-next-line no-unnecessary-generics
     Promise<ObjectType>;
-    // tslint:disable-next-line:no-unnecessary-generics
+    // eslint-disable-next-line no-unnecessary-generics
     parse<T extends Object3D>(json: any, onLoad?: (object: Object3D) => void): T;
-    // tslint:disable-next-line:no-unnecessary-generics
+    // eslint-disable-next-line no-unnecessary-generics
     parseAsync<T extends Object3D>(json: any): Promise<T>;
     parseGeometries(json: any): { [key: string]: InstancedBufferGeometry | BufferGeometry }; // Array of BufferGeometry or Geometry or Geometry2.
     parseMaterials(json: any, textures: Texture[]): Material[]; // Array of Classes that inherits from Matrial.
@@ -37,6 +37,6 @@ export class ObjectLoader extends Loader {
         geometries: any[],
         materials: Material[],
         animations: AnimationClip[],
-    ): // tslint:disable-next-line:no-unnecessary-generics
+    ): // eslint-disable-next-line no-unnecessary-generics
     T;
 }

three/src/math/Matrix3.d.ts

@@ -1,3 +1,5 @@
+// https://threejs.org/docs/#api/en/math/Matrix3
+
 import { Matrix4 } from './Matrix4';
 import { Vector3 } from './Vector3';
 
@@ -99,6 +101,50 @@ export class Matrix3 implements Matrix {
 
     scale(sx: number, sy: number): Matrix3;
 
+    /**
+     * Sets this matrix as a 2D translation transform:
+     *
+     * ```
+     * 1, 0, x,
+     * 0, 1, y,
+     * 0, 0, 1
+     * ```
+     *
+     * @param x the amount to translate in the X axis.
+     * @param y the amount to translate in the Y axis.
+     */
+    makeTranslation(x: number, y: number): this;
+    makeTranslation(x: number, y: number): Matrix3;
+
+    /**
+     * Sets this matrix as a 2D rotational transformation by theta radians. The resulting matrix will be:
+     *
+     * ```
+     * cos(θ) -sin(θ) 0
+     * sin(θ) cos(θ)  0
+     * 0      0       1
+     * ```
+     *
+     * @param theta Rotation angle in radians. Positive values rotate counterclockwise.
+     */
+    makeRotation(theta: number): this;
+    makeRotation(theta: number): Matrix3;
+
+    /**
+     * Sets this matrix as a 2D scale transform:
+     *
+     * ```
+     * x, 0, 0,
+     * 0, y, 0,
+     * 0, 0, 1
+     * ```
+     *
+     * @param x the amount to scale in the X axis.
+     * @param y the amount to scale in the Y axis.
+     */
+    makeScale(x: number, y: number): this;
+    makeScale(x: number, y: number): Matrix3;
+
     rotate(theta: number): Matrix3;
 
     translate(tx: number, ty: number): Matrix3;

three/src/objects/LOD.d.ts

@@ -8,17 +8,37 @@ export class LOD extends Object3D {
 
     type: 'LOD';
 
-    levels: Array<{ distance: number; object: Object3D }>;
+    /**
+     *
+     * An array of level objects
+     *
+     * Each level is an object with the following properties:
+     *
+     * - object - The Object3D to display at this level.
+     * - distance - The distance at which to display this level of detail.
+     * - hysteresis - Threshold used to avoid flickering at LOD boundaries, as a fraction of distance.
+     */
+    levels: Array<{ distance: number; hysteresis: number; object: Object3D }>;
+
     autoUpdate: boolean;
     readonly isLOD: true;
 
-    addLevel(object: Object3D, distance?: number): this;
+    /**
+     * Adds a mesh that will display at a certain distance and greater. Typically the further away the distance, the lower the detail on the mesh.
+     *
+     * @param object The Object3D to display at this level.
+     * @param distance The distance at which to display this level of detail. Default 0.0.
+     * @param hysteresis Threshold used to avoid flickering at LOD boundaries, as a fraction of distance. Default 0.0.
+     */
+    addLevel(object: Object3D, distance?: number, hysteresis?: number): this;
+
     getCurrentLevel(): number;
     getObjectForDistance(distance: number): Object3D | null;
     raycast(raycaster: Raycaster, intersects: Intersection[]): void;
     update(camera: Camera): void;
     toJSON(meta: any): any;
 
+    // TODO: Remove this
     /**
      * @deprecated Use {@link LOD#levels .levels} instead.
      */

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

@@ -3,7 +3,11 @@ import { Vector3 } from '../../math/Vector3';
 
 export type XRControllerEventType = XRSessionEventType | XRInputSourceEventType | 'disconnected' | 'connected';
 
-export type XRHandJoints = Record<XRHandJoint, number>;
+export class XRJointSpace extends Group {
+    readonly jointRadius: number | undefined;
+}
+
+export type XRHandJoints = Record<XRHandJoint, XRJointSpace>;
 
 export interface XRHandInputState {
     pinching: boolean;
@@ -35,6 +39,7 @@ export class WebXRController {
     getTargetRaySpace(): XRTargetRaySpace;
     getGripSpace(): XRGripSpace;
     dispatchEvent(event: { type: XRControllerEventType; data?: XRInputSource }): this;
+    connect(inputSource: XRInputSource): this;
     disconnect(inputSource: XRInputSource): this;
     update(inputSource: XRInputSource, frame: XRFrame, referenceSpace: XRReferenceSpace): this;
 }

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

@@ -1,3 +1,5 @@
+// https://threejs.org/docs/#api/en/renderers/webxr/WebXRManager
+
 /// <reference types="webxr" />
 
 import { Vector4 } from '../../math/Vector4';
@@ -44,5 +46,11 @@ export class WebXRManager extends EventDispatcher {
     setAnimationLoop(callback: XRFrameRequestCallback | null): void;
     getFoveation(): number | undefined;
     setFoveation(foveation: number): void;
+
+    /**
+     * Returns the set of planes detected by WebXR's plane detection API.
+     */
+    getPlanes(): Set<XRPlane>;
+
     dispose(): void;
 }

three/src/scenes/Scene.d.ts

@@ -1,3 +1,5 @@
+// https://threejs.org/docs/?q=scene#api/en/scenes/Scene
+
 import { FogBase } from './Fog';
 import { Material } from './../materials/Material';
 import { Object3D } from './../core/Object3D';
@@ -22,8 +24,20 @@ export class Scene extends Object3D {
      */
     fog: FogBase | null;
 
+    /**
+     * Sets the blurriness of the background. Only influences environment maps assigned to Scene.background. Valid input is a float between 0 and 1.
+     *
+     * @default 0
+     */
     backgroundBlurriness: number;
 
+    /**
+     * Attenuates the color of the background. Only applies to background textures.
+     *
+     * @default 1
+     */
+    backgroundIntensity: number;
+
     /**
      * If not null, it will force everything in the scene to be rendered with that material. Default is null.
      * @default null

three/src/textures/Texture.d.ts

@@ -1,3 +1,5 @@
+// https://threejs.org/docs/?q=texture#api/en/textures/Texture
+
 import { Vector2 } from './../math/Vector2';
 import { Matrix3 } from './../math/Matrix3';
 import { Source } from './Source';
@@ -26,7 +28,7 @@ export class Texture extends EventDispatcher {
      * @param [minFilter=THREE.LinearMipmapLinearFilter]
      * @param [format=THREE.RGBAFormat]
      * @param [type=THREE.UnsignedByteType]
-     * @param [anisotropy=1]
+     * @param [anisotropy=THREE.Texture.DEFAULT_ANISOTROPY]
      * @param [encoding=THREE.LinearEncoding]
      */
     constructor(
@@ -203,6 +205,8 @@ export class Texture extends EventDispatcher {
     readonly isTexture: true;
 
     onUpdate: () => void;
+
+    static DEFAULT_ANISOTROPY: number;
     static DEFAULT_IMAGE: any;
     static DEFAULT_MAPPING: any;
 

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

@@ -1,11 +0,0 @@
-import { IUniform } from '../../../src/Three';
-
-export const PixelShader: {
-    uniforms: {
-        tDiffuse: IUniform;
-        resolution: IUniform;
-        pixelSize: IUniform;
-    };
-    vertexShader: string;
-    fragmentShader: string;
-};