@types/three 0.133.0 → 0.136.0

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: Wed, 06 Oct 2021 16:31:20 GMT
+ * Last updated: Mon, 03 Jan 2022 15:01:28 GMT
  * Dependencies: none
  * Global values: `THREE`
 

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

@@ -1,6 +1,20 @@
-import { Object3D, Camera, Scene } from '../../../src/Three';
+import { EventDispatcher, Camera, Scene, Vector3, Raycaster } from '../../../src/Three';
 
-export class ArcballControls extends Object3D {
+export enum ArcballControlsMouseActionOperations {
+    PAN = 'PAN',
+    ROTATE = 'ROTATE',
+    ZOOM = 'ZOOM',
+    FOV = 'FOV',
+}
+
+export type ArcballControlsMouseActionMouse = 0 | 1 | 2 | 'WHEEL';
+
+export enum ArcballControlsMouseActionKeys {
+    SHIFT = 'SHIFT',
+    CTRL = 'CTRL',
+}
+
+export class ArcballControls extends EventDispatcher {
     camera: Camera | null;
     domElement: HTMLElement;
     scene?: Scene | null | undefined;
@@ -100,7 +114,45 @@ export class ArcballControls extends Object3D {
      */
     maxZoom: number;
 
+    /**
+     * @default Vector3(0,0,0)
+     */
+    target: Vector3;
+
+    /**
+     * @default 0.67
+     */
+    radiusFactor: number;
+
     constructor(camera: Camera, domElement: HTMLElement, scene?: Scene | null);
 
+    getRaycaster(): Raycaster;
+
+    activateGizmos(isActive: boolean): void;
+
+    copyState(): void;
+
+    pasteState(): void;
+
+    saveState(): void;
+
+    reset(): void;
+
+    setCamera(camera: Camera): void;
+
+    setGizmosVisible(value: boolean): void;
+
+    setTbRadius(value: number): void;
+
+    setMouseAction(
+        operation: ArcballControlsMouseActionOperations,
+        mouse: ArcballControlsMouseActionMouse,
+        key?: ArcballControlsMouseActionKeys,
+    ): boolean;
+
+    unsetMouseAction(mouse: ArcballControlsMouseActionMouse, key?: ArcballControlsMouseActionKeys): boolean;
+
+    update(): void;
+
     dispose(): void;
 }

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

@@ -1,4 +1,4 @@
-import { Camera, EventDispatcher, Object3D } from '../../../src/Three';
+import { Camera, EventDispatcher, Object3D, Raycaster } from '../../../src/Three';
 
 export class DragControls extends EventDispatcher {
     constructor(objects: Object3D[], camera: Camera, domElement?: HTMLElement);
@@ -14,4 +14,5 @@ export class DragControls extends EventDispatcher {
     deactivate(): void;
     dispose(): void;
     getObjects(): Object3D[];
+    getRaycaster(): Raycaster;
 }

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

@@ -37,5 +37,6 @@ export class TransformControls extends Object3D {
     setScaleSnap(scaleSnap: number | null): void;
     setSize(size: number): void;
     setSpace(space: 'world' | 'local'): void;
+    reset(): void;
     dispose(): void;
 }

three/examples/jsm/csm/CSM.d.ts

@@ -1,36 +1,61 @@
+import { Camera, Vector3, DirectionalLight, Material, Vector2, Object3D } from '../../../src/Three';
+
+export enum CMSMode {
+    practical = 'practical',
+    uniform = 'uniform',
+    logarithmic = 'logarithmic',
+    custom = 'custom',
+}
+
+export interface CMSParameters {
+    camera?: Camera;
+    parent?: Object3D;
+    cascades?: number;
+    maxFar?: number;
+    mode?: CMSMode;
+    shadowMapSize?: number;
+    shadowBias?: number;
+    lightDirection?: Vector3;
+    lightIntensity?: number;
+    lightNear?: number;
+    lightFar?: number;
+    lightMargin?: number;
+    customSplitsCallback?: (cascades: number, cameraNear: number, cameraFar: number, breaks: number[]) => void;
+}
+
 export class CSM {
-    constructor(data: any);
-    camera: any;
-    parent: any;
-    cascades: any;
-    maxFar: any;
-    mode: any;
-    shadowMapSize: any;
-    shadowBias: any;
-    lightDirection: any;
-    lightIntensity: any;
-    lightNear: any;
-    lightFar: any;
-    lightMargin: any;
-    customSplitsCallback: any;
+    constructor(data?: CMSParameters);
+    camera: Camera;
+    parent: Object3D;
+    cascades: number;
+    maxFar: number;
+    mode: CMSMode;
+    shadowMapSize: number;
+    shadowBias: number;
+    lightDirection: Vector3;
+    lightIntensity: number;
+    lightNear: number;
+    lightFar: number;
+    lightMargin: number;
+    customSplitsCallback: (cascades: number, cameraNear: number, cameraFar: number, breaks: number[]) => void;
     fade: boolean;
-    mainFrustum: Frustum;
-    frustums: any[];
-    breaks: any[];
-    lights: any[];
-    shaders: Map<any, any>;
+    mainFrustum: CSMFrustrum;
+    frustums: CSMFrustrum[];
+    breaks: number[];
+    lights: DirectionalLight[];
+    shaders: Map<unknown, string>;
     createLights(): void;
     initCascades(): void;
     updateShadowBounds(): void;
     getBreaks(): void;
     update(): void;
     injectInclude(): void;
-    setupMaterial(material: any): void;
+    setupMaterial(material: Material): void;
     updateUniforms(): void;
-    getExtendedBreaks(target: any): void;
+    getExtendedBreaks(target: Vector2[]): void;
     updateFrustums(): void;
     remove(): void;
     dispose(): void;
 }
 
-import Frustum from './Frustum.js';
+import CSMFrustrum from './CSMFrustum.js';

three/examples/jsm/csm/CSMFrustum.d.ts

@@ -0,0 +1,19 @@
+import { Matrix4, Vector3 } from '../../../src/Three';
+
+export interface CSMFrustumVerticies {
+    near: Vector3[];
+    far: Vector3[];
+}
+
+export interface CSMFrustumParameters {
+    projectionMatrix?: Matrix4;
+    maxFar?: number;
+}
+
+export default class CSMFrustum {
+    constructor(data?: CSMFrustumParameters);
+    vertices: CSMFrustumVerticies;
+    setFromProjectionMatrix(projectionMatrix: Matrix4, maxFar: number): CSMFrustumVerticies;
+    split(breaks: number[], target: CSMFrustum[]): void;
+    toSpace(cameraMatrix: Matrix4, target: CSMFrustum): void;
+}

three/examples/jsm/csm/CSMHelper.d.ts

@@ -1,13 +1,26 @@
-export class CSMHelper {
-    constructor(csm: any);
-    csm: any;
+import {
+    Box3Helper,
+    BufferGeometry,
+    Group,
+    LineBasicMaterial,
+    LineSegments,
+    Mesh,
+    MeshBasicMaterial,
+    PlaneGeometry,
+} from '../../../src/Three';
+
+import { CSM } from './CSM';
+
+export class CSMHelper<TCSM extends CSM = CSM> extends Group {
+    constructor(csm: TCSM);
+    csm: TCSM;
     displayFrustum: boolean;
     displayPlanes: boolean;
     displayShadowBounds: boolean;
-    frustumLines: any;
-    cascadeLines: any[];
-    cascadePlanes: any[];
-    shadowLines: any[];
+    frustumLines: LineSegments<BufferGeometry, LineBasicMaterial>;
+    cascadeLines: Box3Helper[];
+    cascadePlanes: Array<Mesh<PlaneGeometry, MeshBasicMaterial>>;
+    shadowLines: Box3Helper[];
     updateVisibility(): void;
     update(): void;
 }

three/examples/jsm/csm/CSMShader.d.ts

@@ -0,0 +1,4 @@
+export interface CSMShader {
+    lights_fragment_begin: string;
+    lights_pars_begin: string;
+}

three/examples/jsm/exporters/GLTFExporter.d.ts

@@ -16,4 +16,5 @@ export class GLTFExporter {
     constructor();
 
     parse(input: Object3D, onCompleted: (gltf: object) => void, options: GLTFExporterOptions): void;
+    parseAsync(input: Object3D, options: GLTFExporterOptions): Promise<void>;
 }

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

@@ -13,6 +13,9 @@ import {
     Material,
     SkinnedMesh,
     Texture,
+    TextureLoader,
+    FileLoader,
+    ImageBitmapLoader,
 } from '../../../src/Three';
 
 import { DRACOLoader } from './DRACOLoader';
@@ -61,6 +64,8 @@ export class GLTFLoader extends Loader {
         onLoad: (gltf: GLTF) => void,
         onError?: (event: ErrorEvent) => void,
     ): void;
+
+    parseAsync(data: ArrayBuffer | string, path: string): Promise<void>;
 }
 
 export type GLTFReferenceType = 'materials' | 'nodes' | 'textures' | 'meshes';
@@ -75,6 +80,19 @@ export interface GLTFReference {
 export class GLTFParser {
     json: any;
 
+    options: {
+        path: string;
+        manager: LoadingManager;
+        ktx2Loader: KTX2Loader;
+        meshoptDecoder: /* MeshoptDecoder */ any;
+        crossOrigin: string;
+        requestHeader: { [header: string]: string };
+    };
+
+    fileLoader: FileLoader;
+    textureLoader: TextureLoader | ImageBitmapLoader;
+    plugins: GLTFLoaderPlugin;
+    extensions: { [name: string]: any };
     associations: Map<Object3D | Material | Texture, GLTFReference>;
 
     getDependency: (type: string, index: number) => Promise<any>;
@@ -135,5 +153,6 @@ export interface GLTFLoaderPlugin {
     extendMaterialParams?:
         | ((materialIndex: number, materialParams: { [key: string]: any }) => Promise<any> | null)
         | undefined;
+    createNodeMesh?: ((nodeIndex: number) => Promise<Group | Mesh | SkinnedMesh> | null) | undefined;
     createNodeAttachment?: ((nodeIndex: number) => Promise<Object3D> | null) | undefined;
 }

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

@@ -0,0 +1,19 @@
+import { DataTextureLoader, TextureDataType, LoadingManager, PixelFormat } from '../../../src/Three';
+
+export interface LogLuv {
+    width: number;
+    height: number;
+    data: Uint16Array | Float32Array;
+    format: PixelFormat;
+    type: TextureDataType;
+    flipY: boolean;
+}
+
+export class LogLuvLoader extends DataTextureLoader {
+    type: TextureDataType;
+    constructor(manager: LoadingManager);
+
+    parse(buffer: Iterable<number>): LogLuv;
+
+    setDataType(value: TextureDataType): this;
+}

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

@@ -1,24 +1,20 @@
-import {
-    CubeTexture,
-    LoadingManager,
-    DataTextureLoader,
-    PixelFormat,
-    TextureDataType,
-    TextureEncoding,
-} from '../../../src/Three';
+import { CubeTexture, LoadingManager, DataTextureLoader, PixelFormat, TextureDataType } from '../../../src/Three';
 
 export interface RGBM {
     width: number;
     height: number;
-    data: Uint8Array;
+    data: Uint16Array | Float32Array;
     header: string;
     format: PixelFormat;
     type: TextureDataType;
     flipY: boolean;
-    encoding: TextureEncoding;
 }
 
 export class RGBMLoader extends DataTextureLoader {
+    type: TextureDataType;
+
+    maxRange: number;
+
     constructor(manager?: LoadingManager);
 
     loadCubemap(
@@ -29,4 +25,8 @@ export class RGBMLoader extends DataTextureLoader {
     ): CubeTexture;
 
     parse(buffer: ArrayBuffer): RGBM;
+
+    setDataType(dataType: TextureDataType): this;
+
+    setMaxRange(value: number): this;
 }

three/examples/jsm/misc/GPUComputationRenderer.d.ts

@@ -1,6 +1,6 @@
 import {
     WebGLRenderer,
-    RenderTarget,
+    WebGLRenderTarget,
     Texture,
     DataTexture,
     Material,
@@ -8,6 +8,7 @@ import {
     Wrapping,
     TextureFilter,
     TextureDataType,
+    IUniform,
 } from '../../../src/Three';
 
 export interface Variable {
@@ -15,7 +16,7 @@ export interface Variable {
     initialValueTexture: Texture;
     material: ShaderMaterial;
     dependencies: Variable[];
-    renderTargets: RenderTarget[];
+    renderTargets: WebGLRenderTarget[];
     wrapS: number;
     wrapT: number;
     minFilter: number;
@@ -33,9 +34,10 @@ export class GPUComputationRenderer {
     init(): string | null;
     compute(): void;
 
-    getCurrentRenderTarget(variable: Variable): RenderTarget;
-    getAlternateRenderTarget(variable: Variable): RenderTarget;
+    getCurrentRenderTarget(variable: Variable): WebGLRenderTarget;
+    getAlternateRenderTarget(variable: Variable): WebGLRenderTarget;
     addResolutionDefine(materialShader: ShaderMaterial): void;
+    createShaderMaterial(computeFragmentShader: string, uniforms?: { [uniform: string]: IUniform }): ShaderMaterial;
     createRenderTarget(
         sizeXTexture: number,
         sizeYTexture: number,
@@ -43,8 +45,8 @@ export class GPUComputationRenderer {
         wrapT: number,
         minFilter: TextureFilter,
         magFilter: TextureFilter,
-    ): RenderTarget;
+    ): WebGLRenderTarget;
     createTexture(): DataTexture;
     renderTexture(input: Texture, output: Texture): void;
-    doRenderTarget(material: Material, output: RenderTarget): void;
+    doRenderTarget(material: Material, output: WebGLRenderTarget): void;
 }

three/examples/jsm/nodes/inputs/ColorNode.d.ts

@@ -1,4 +1,4 @@
-import { Color } from '../../../../src/Three';
+import { Color, ColorRepresentation } from '../../../../src/Three';
 
 import { InputNode } from '../core/InputNode';
 import { NodeBuilder } from '../core/NodeBuilder';

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

@@ -21,5 +21,5 @@ export class StandardNodeMaterial extends NodeMaterial {
     environment: Node;
     mask: Node;
     position: Node;
-    sheenTint: Node;
+    sheenColor: Node;
 }

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

@@ -8,7 +8,7 @@ export class StandardNode extends Node {
     roughness: Node;
     metalness: Node;
     nodeType: string;
-    sheenTint: Node;
+    sheenColor: Node;
 
     build(builder: NodeBuilder): string;
     copy(source: StandardNode): this;

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

@@ -1,7 +1,13 @@
-import { BufferGeometry, Material, ImmediateRenderObject } from '../../../src/Three';
+import { BufferGeometry, Material, Mesh, Color } from '../../../src/Three';
 
-export class MarchingCubes extends ImmediateRenderObject {
-    constructor(resolution: number, material: Material, enableUvs?: boolean, enableColors?: boolean);
+export class MarchingCubes extends Mesh {
+    constructor(
+        resolution: number,
+        material: Material,
+        enableUvs?: boolean,
+        enableColors?: boolean,
+        maxPolyCount?: number,
+    );
 
     enableUvs: boolean;
     enableColors: boolean;
@@ -46,9 +52,9 @@ export class MarchingCubes extends ImmediateRenderObject {
     begin(): void;
     end(): void;
 
-    init(resolution: string): void;
+    init(resolution: number): void;
 
-    addBall(ballx: number, bally: number, ballz: number, strength: number, subtract: number, colors: any): void;
+    addBall(ballx: number, bally: number, ballz: number, strength: number, subtract: number, colors?: Color): void;
 
     addPlaneX(strength: number, subtract: number): void;
     addPlaneY(strength: number, subtract: number): void;

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

@@ -13,4 +13,6 @@ export class Reflector extends Mesh {
     constructor(geometry?: BufferGeometry, options?: ReflectorOptions);
 
     getRenderTarget(): WebGLRenderTarget;
+
+    dispose(): void;
 }

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

@@ -13,4 +13,6 @@ export class Refractor extends Mesh {
     constructor(geometry?: BufferGeometry, options?: RefractorOptions);
 
     getRenderTarget(): WebGLRenderTarget;
+
+    dispose(): void;
 }

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

@@ -8,8 +8,12 @@ export class CSS2DObject extends Object3D {
     onAfterRender: (renderer: unknown, scene: Scene, camera: Camera) => void;
 }
 
+export type CSS2DParameters = {
+    element?: HTMLElement;
+};
+
 export class CSS2DRenderer {
-    constructor();
+    constructor(parameters?: CSS2DParameters);
     domElement: HTMLElement;
 
     getSize(): { width: number; height: number };

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

@@ -12,8 +12,12 @@ export class CSS3DSprite extends CSS3DObject {
     constructor(element: HTMLElement);
 }
 
+export type CSS3DParameters = {
+    element?: HTMLElement;
+};
+
 export class CSS3DRenderer {
-    constructor();
+    constructor(parameters?: CSS3DParameters);
     domElement: HTMLElement;
 
     getSize(): { width: number; height: number };

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

@@ -53,11 +53,11 @@ export class OculusHandPointerModel extends Object3D {
 
     public isAttached(): boolean;
 
-    public intersectObject(object: Object3D): Array<Intersection<Object3D>> | void;
+    public intersectObject(object: Object3D, recursive?: boolean): Intersection[] | void;
 
-    public intersectObjects(objects: Object3D[]): Array<Intersection<Object3D>> | void;
+    public intersectObjects(objects: Object3D[], recursive?: boolean): Intersection[] | void;
 
-    public checkIntersections(objects: Object3D[]): void;
+    public checkIntersections(objects: Object3D[], recursive?: boolean): void;
 
     public setCursor(distance: number): void;
 }

three/index.d.ts

@@ -1,4 +1,4 @@
-// Type definitions for three 0.133
+// Type definitions for three 0.136
 // 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.133.0",
+    "version": "0.136.0",
     "description": "TypeScript definitions for three",
     "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/three",
     "license": "MIT",
@@ -25,6 +25,6 @@
     },
     "scripts": {},
     "dependencies": {},
-    "typesPublisherContentHash": "f09be7a6ce6adc84150c13415d9f9bd2c13348dfa73897133542715bc05ab9f3",
-    "typeScriptVersion": "3.7"
+    "typesPublisherContentHash": "fc646ca261a81275f767c4d73525a7edd6d769ac837d7a54015dad64f2d216e1",
+    "typeScriptVersion": "3.8"
 }

three/src/Three.d.ts

@@ -58,7 +58,6 @@ export * from './core/Clock';
 /**
  * Extras
  */
-export * from './extras/objects/ImmediateRenderObject';
 export * from './extras/curves/Curves';
 export * from './extras/core/Shape';
 export * from './extras/core/Path';
@@ -225,4 +224,5 @@ export * from './textures/CompressedTexture';
 export * from './textures/CubeTexture';
 export * from './textures/CanvasTexture';
 export * from './textures/DepthTexture';
+export * from './textures/FramebufferTexture';
 export * from './textures/Texture';

three/src/cameras/OrthographicCamera.d.ts

@@ -18,7 +18,7 @@ export class OrthographicCamera extends Camera {
      * @param [near=0.1] Camera frustum near plane.
      * @param [far=2000] Camera frustum far plane.
      */
-    constructor(left: number, right: number, top: number, bottom: number, near?: number, far?: number);
+    constructor(left?: number, right?: number, top?: number, bottom?: number, near?: number, far?: number);
 
     type: 'OrthographicCamera';
 

three/src/constants.d.ts

@@ -157,7 +157,6 @@ export const RGBFormat: PixelFormat;
 export const RGBAFormat: PixelFormat;
 export const LuminanceFormat: PixelFormat;
 export const LuminanceAlphaFormat: PixelFormat;
-export const RGBEFormat: PixelFormat;
 export const DepthFormat: PixelFormat;
 export const DepthStencilFormat: PixelFormat;
 export const RedFormat: PixelFormat;
@@ -315,12 +314,9 @@ export const TriangleFanDrawMode: TrianglesDrawModes;
 export enum TextureEncoding {}
 export const LinearEncoding: TextureEncoding;
 export const sRGBEncoding: TextureEncoding;
-export const GammaEncoding: TextureEncoding;
-export const RGBEEncoding: TextureEncoding;
 export const LogLuvEncoding: TextureEncoding;
 export const RGBM7Encoding: TextureEncoding;
 export const RGBM16Encoding: TextureEncoding;
-export const RGBDEncoding: TextureEncoding;
 
 // Depth packing strategies
 export enum DepthPackingStrategies {}

three/src/core/Layers.d.ts

@@ -13,4 +13,5 @@ export class Layers {
     disable(channel: number): void;
     disableAll(): void;
     test(layers: Layers): boolean;
+    isEnabled(channel: number): boolean;
 }

three/src/core/Object3D.d.ts

@@ -119,6 +119,7 @@ export class Object3D<E extends BaseEvent = Event> extends EventDispatcher<E> {
      * @default new THREE.Layers()
      */
     layers: Layers;
+
     /**
      * Object gets rendered if true.
      * @default true
@@ -211,18 +212,41 @@ export class Object3D<E extends BaseEvent = Event> extends EventDispatcher<E> {
     static DefaultMatrixAutoUpdate: boolean;
 
     /**
-     * This updates the position, rotation and scale with the matrix.
+     * Applies the matrix transform to the object and updates the object's position, rotation and scale.
      */
     applyMatrix4(matrix: Matrix4): void;
 
+    /**
+     * Applies the rotation represented by the quaternion to the object.
+     */
     applyQuaternion(quaternion: Quaternion): this;
 
+    /**
+     * axis -- A normalized vector in object space.
+     * angle -- angle in radians
+     * @param axis A normalized vector in object space.
+     * @param angle angle in radians
+     */
     setRotationFromAxisAngle(axis: Vector3, angle: number): void;
 
+    /**
+     * Calls setRotationFromEuler(euler) on the .quaternion.
+     * @param euler Euler angle specifying rotation amount.
+     */
     setRotationFromEuler(euler: Euler): void;
 
+    /**
+     * Calls setFromRotationMatrix(m) on the .quaternion.
+     *
+     * Note that this assumes that the upper 3x3 of m is a pure rotation matrix (i.e, unscaled).
+     * @param m rotate the quaternion by the rotation component of the matrix.
+     */
     setRotationFromMatrix(m: Matrix4): void;
 
+    /**
+     * Copy the given quaternion into .quaternion.
+     * @param q normalized Quaternion
+     */
     setRotationFromQuaternion(q: Quaternion): void;
 
     /**
@@ -240,24 +264,25 @@ export class Object3D<E extends BaseEvent = Event> extends EventDispatcher<E> {
     rotateOnWorldAxis(axis: Vector3, angle: number): this;
 
     /**
-     *
-     * @param angle
+     * Rotates the object around x axis in local space.
+     * @param angle the angle to rotate in radians.
      */
     rotateX(angle: number): this;
 
     /**
-     *
-     * @param angle
+     * Rotates the object around y axis in local space.
+     * @param angle the angle to rotate in radians.
      */
     rotateY(angle: number): this;
 
     /**
-     *
-     * @param angle
+     * Rotates the object around z axis in local space.
+     * @param angle the angle to rotate in radians.
      */
     rotateZ(angle: number): this;
 
     /**
+     * Translate an object by distance along an axis in object space. The axis is assumed to be normalized.
      * @param axis	A normalized vector in object space.
      * @param distance	The distance to translate.
      */
@@ -294,7 +319,9 @@ export class Object3D<E extends BaseEvent = Event> extends EventDispatcher<E> {
     worldToLocal(vector: Vector3): Vector3;
 
     /**
-     * Rotates object to face point in space.
+     * Optionally, the x, y and z components of the world space position.
+     * Rotates the object to face a point in world space.
+     * This method does not support objects having non-uniformly-scaled parent(s).
      * @param vector A world vector to look at.
      */
     lookAt(vector: Vector3 | number, y?: number, z?: number): void;
@@ -343,7 +370,7 @@ export class Object3D<E extends BaseEvent = Event> extends EventDispatcher<E> {
     getWorldScale(target: Vector3): Vector3;
     getWorldDirection(target: Vector3): Vector3;
 
-    raycast(raycaster: Raycaster, intersects: Array<Intersection<Object3D>>): void;
+    raycast(raycaster: Raycaster, intersects: Intersection[]): void;
 
     traverse(callback: (object: Object3D) => any): void;
 
@@ -361,6 +388,11 @@ export class Object3D<E extends BaseEvent = Event> extends EventDispatcher<E> {
      */
     updateMatrixWorld(force?: boolean): void;
 
+    /**
+     * Updates the global transform of the object.
+     * @param updateParents recursively updates global transform of ancestors.
+     * @param updateChildren recursively updates global transform of descendants.
+     */
     updateWorldMatrix(updateParents: boolean, updateChildren: boolean): void;
 
     toJSON(meta?: { geometries: any; materials: any; textures: any; images: any }): any;

three/src/core/Raycaster.d.ts

@@ -13,7 +13,7 @@ export interface Face {
     materialIndex: number;
 }
 
-export interface Intersection<TIntersected extends Object3D> {
+export interface Intersection<TIntersected extends Object3D = Object3D> {
     distance: number;
     distanceToRay?: number | undefined;
     point: Vector3;

three/src/lights/LightShadow.d.ts

@@ -3,7 +3,7 @@ import { Light } from './../lights/Light';
 import { Vector2 } from './../math/Vector2';
 import { Vector4 } from './../math/Vector4';
 import { Matrix4 } from './../math/Matrix4';
-import { RenderTarget } from '../renderers/webgl/WebGLRenderLists';
+import { WebGLRenderTarget } from '../renderers/WebGLRenderTarget';
 
 export class LightShadow {
     constructor(camera: Camera);
@@ -38,12 +38,12 @@ export class LightShadow {
     /**
      * @default null
      */
-    map: RenderTarget;
+    map: WebGLRenderTarget;
 
     /**
      * @default null
      */
-    mapPass: RenderTarget;
+    mapPass: WebGLRenderTarget;
 
     /**
      * @default new THREE.Matrix4()

three/src/loaders/LoaderUtils.d.ts

@@ -1,6 +1,7 @@
 export interface LoaderUtils {
     decodeText(array: BufferSource): string;
     extractUrlBase(url: string): string;
+    resolveURL(url: string, path: string): string;
 }
 
 export const LoaderUtils: LoaderUtils;

three/src/materials/MeshPhysicalMaterial.d.ts

@@ -15,18 +15,18 @@ export interface MeshPhysicalMaterialParameters extends MeshStandardMaterialPara
     ior?: number | undefined;
 
     sheen?: number | undefined;
-    sheenTint?: Color | undefined;
+    sheenColor?: Color | undefined;
     sheenRoughness?: number | undefined;
 
     transmission?: number | undefined;
     transmissionMap?: Texture | null | undefined;
     attenuationDistance?: number | undefined;
-    attenuationTint?: Color | undefined;
+    attenuationColor?: Color | undefined;
 
     specularIntensity?: number | undefined;
-    specularTint?: Color | undefined;
+    specularColor?: Color | undefined;
     specularIntensityMap?: Texture | null | undefined;
-    specularTintMap?: Texture | null | undefined;
+    specularColorMap?: Texture | null | undefined;
 }
 
 export class MeshPhysicalMaterial extends MeshStandardMaterial {
@@ -90,13 +90,23 @@ export class MeshPhysicalMaterial extends MeshStandardMaterial {
     /**
      * @default Color( 0x000000 )
      */
-    sheenTint: Color;
+    sheenColor: Color;
+
+    /**
+     * @default null
+     */
+    sheenColorMap: Texture | null;
 
     /**
      * @default 1.0
      */
     sheenRoughness: number;
 
+    /**
+     * @default null
+     */
+    sheenRoughnessMap: Texture | null;
+
     /**
      * @default 0
      */
@@ -125,7 +135,7 @@ export class MeshPhysicalMaterial extends MeshStandardMaterial {
     /**
      * @default Color( 1, 1, 1 )
      */
-    attenuationTint: Color;
+    attenuationColor: Color;
 
     /**
      * @default 1.0
@@ -135,7 +145,7 @@ export class MeshPhysicalMaterial extends MeshStandardMaterial {
     /**
      * @default Color(1, 1, 1)
      */
-    specularTint: Color;
+    specularColor: Color;
 
     /**
      * @default null
@@ -145,5 +155,5 @@ export class MeshPhysicalMaterial extends MeshStandardMaterial {
     /**
      * @default null
      */
-    specularTintMap: Texture | null;
+    specularColorMap: Texture | null;
 }

three/src/math/Color.d.ts

@@ -85,28 +85,6 @@ export class Color {
      */
     copy(color: Color): this;
 
-    /**
-     * Copies given color making conversion from gamma to linear space.
-     * @param color Color to copy.
-     */
-    copyGammaToLinear(color: Color, gammaFactor?: number): Color;
-
-    /**
-     * Copies given color making conversion from linear to gamma space.
-     * @param color Color to copy.
-     */
-    copyLinearToGamma(color: Color, gammaFactor?: number): Color;
-
-    /**
-     * Converts this color from gamma to linear space.
-     */
-    convertGammaToLinear(gammaFactor?: number): Color;
-
-    /**
-     * Converts this color from linear to gamma space.
-     */
-    convertLinearToGamma(gammaFactor?: number): Color;
-
     /**
      * Copies given color making conversion from sRGB to linear space.
      * @param color Color to copy.

three/src/objects/LOD.d.ts

@@ -15,7 +15,7 @@ export class LOD extends Object3D {
     addLevel(object: Object3D, distance?: number): this;
     getCurrentLevel(): number;
     getObjectForDistance(distance: number): Object3D | null;
-    raycast(raycaster: Raycaster, intersects: Array<Intersection<Object3D>>): void;
+    raycast(raycaster: Raycaster, intersects: Intersection[]): void;
     update(camera: Camera): void;
     toJSON(meta: any): any;
 

three/src/objects/Line.d.ts

@@ -20,6 +20,6 @@ export class Line<
     morphTargetDictionary?: { [key: string]: number } | undefined;
 
     computeLineDistances(): this;
-    raycast(raycaster: Raycaster, intersects: Array<Intersection<Object3D>>): void;
+    raycast(raycaster: Raycaster, intersects: Intersection[]): void;
     updateMorphTargets(): void;
 }

three/src/objects/Mesh.d.ts

@@ -18,5 +18,5 @@ export class Mesh<
     type: string;
 
     updateMorphTargets(): void;
-    raycast(raycaster: Raycaster, intersects: Array<Intersection<Object3D>>): void;
+    raycast(raycaster: Raycaster, intersects: Intersection[]): void;
 }

three/src/objects/Points.d.ts

@@ -32,6 +32,6 @@ export class Points<
      */
     material: TMaterial;
 
-    raycast(raycaster: Raycaster, intersects: Array<Intersection<Object3D>>): void;
+    raycast(raycaster: Raycaster, intersects: Intersection[]): void;
     updateMorphTargets(): void;
 }

three/src/objects/Sprite.d.ts

@@ -15,6 +15,6 @@ export class Sprite extends Object3D {
     material: SpriteMaterial;
     center: Vector2;
 
-    raycast(raycaster: Raycaster, intersects: Array<Intersection<Object3D>>): void;
+    raycast(raycaster: Raycaster, intersects: Intersection[]): void;
     copy(source: this): this;
 }

three/src/renderers/WebGLRenderer.d.ts

@@ -6,12 +6,13 @@ import { WebGLShadowMap } from './webgl/WebGLShadowMap';
 import { WebGLCapabilities } from './webgl/WebGLCapabilities';
 import { WebGLProperties } from './webgl/WebGLProperties';
 import { WebGLProgram } from './webgl/WebGLProgram';
-import { RenderTarget, WebGLRenderLists } from './webgl/WebGLRenderLists';
+import { WebGLRenderLists } from './webgl/WebGLRenderLists';
 import { WebGLState } from './webgl/WebGLState';
 import { Vector2 } from './../math/Vector2';
 import { Vector4 } from './../math/Vector4';
 import { Color } from './../math/Color';
 import { WebGLRenderTarget } from './WebGLRenderTarget';
+import { WebGLMultipleRenderTargets } from './WebGLMultipleRenderTargets';
 import { Object3D } from './../core/Object3D';
 import { Material } from './../materials/Material';
 import { ToneMapping, ShadowMapType, CullFace, TextureEncoding } from '../constants';
@@ -221,6 +222,7 @@ export class WebGLRenderer implements Renderer {
     getContext(): WebGLRenderingContext;
     getContextAttributes(): any;
     forceContextLoss(): void;
+    forceContextRestore(): void;
 
     /**
      * @deprecated Use {@link WebGLCapabilities#getMaxAnisotropy .capabilities.getMaxAnisotropy()} instead.
@@ -322,8 +324,6 @@ export class WebGLRenderer implements Renderer {
     resetGLState(): void;
     dispose(): void;
 
-    renderBufferImmediate(object: Object3D, program: WebGLProgram): void;
-
     renderBufferDirect(
         camera: Camera,
         scene: Scene,
@@ -375,12 +375,12 @@ export class WebGLRenderer implements Renderer {
     /**
      * Returns the current render target. If no render target is set, null is returned.
      */
-    getRenderTarget(): RenderTarget | null;
+    getRenderTarget(): WebGLRenderTarget | null;
 
     /**
      * @deprecated Use {@link WebGLRenderer#getRenderTarget .getRenderTarget()} instead.
      */
-    getCurrentRenderTarget(): RenderTarget | null;
+    getCurrentRenderTarget(): WebGLRenderTarget | null;
 
     /**
      * Sets the active render target.
@@ -389,10 +389,14 @@ export class WebGLRenderer implements Renderer {
      * @param activeCubeFace Specifies the active cube side (PX 0, NX 1, PY 2, NY 3, PZ 4, NZ 5) of {@link WebGLCubeRenderTarget}.
      * @param activeMipmapLevel Specifies the active mipmap level.
      */
-    setRenderTarget(renderTarget: RenderTarget | null, activeCubeFace?: number, activeMipmapLevel?: number): void;
+    setRenderTarget(
+        renderTarget: WebGLRenderTarget | WebGLMultipleRenderTargets | null,
+        activeCubeFace?: number,
+        activeMipmapLevel?: number,
+    ): void;
 
     readRenderTargetPixels(
-        renderTarget: RenderTarget,
+        renderTarget: WebGLRenderTarget | WebGLMultipleRenderTargets,
         x: number,
         y: number,
         width: number,
@@ -449,11 +453,6 @@ export class WebGLRenderer implements Renderer {
      */
     resetState(): void;
 
-    /**
-     * @deprecated
-     */
-    gammaFactor: number;
-
     /**
      * @deprecated Use {@link WebGLRenderer#xr .xr} instead.
      */

three/src/renderers/webgl/WebGLRenderLists.d.ts

@@ -7,9 +7,6 @@ import { Camera } from './../../cameras/Camera';
 import { BufferGeometry } from '../../core/BufferGeometry';
 import { WebGLProperties } from './WebGLProperties';
 
-// tslint:disable-next-line:no-empty-interface
-export interface RenderTarget {} // not defined in the code, used in LightShadow and WebGRenderer classes
-
 export interface RenderItem {
     id: number;
     object: Object3D;

three/src/textures/FramebufferTexture.d.ts

@@ -0,0 +1,8 @@
+import { Texture } from './Texture';
+import { PixelFormat } from '../constants';
+
+export class FramebufferTexture extends Texture {
+    readonly isFramebufferTexture: true;
+
+    constructor(width: number, height: number, format: PixelFormat);
+}

three/src/textures/Texture.d.ts

@@ -158,6 +158,12 @@ export class Texture extends EventDispatcher {
      */
     isRenderTargetTexture: boolean;
 
+    /**
+     * An object that can be used to store custom data about the Material. It should not hold references to functions as these will not be cloned.
+     * @default {}
+     */
+    userData: any;
+
     /**
      * @default 0
      */

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

@@ -1,19 +0,0 @@
-import { Camera, EventDispatcher } from '../../../src/Three';
-
-export class DeviceOrientationControls extends EventDispatcher {
-    constructor(object: Camera);
-
-    object: Camera;
-
-    // API
-
-    alphaOffset: number;
-    deviceOrientation: any;
-    enabled: boolean;
-    screenOrientation: number;
-
-    connect(): void;
-    disconnect(): void;
-    dispose(): void;
-    update(): void;
-}

three/examples/jsm/csm/Frustum.d.ts

@@ -1,16 +0,0 @@
-export default class Frustum {
-    constructor(data: any);
-    vertices: {
-        near: any[];
-        far: any[];
-    };
-    setFromProjectionMatrix(
-        projectionMatrix: any,
-        maxFar: any,
-    ): {
-        near: any[];
-        far: any[];
-    };
-    split(breaks: any, target: any): void;
-    toSpace(cameraMatrix: any, target: any): void;
-}

three/examples/jsm/csm/Shader.d.ts

@@ -1,6 +0,0 @@
-declare namespace _default {
-    const lights_fragment_begin: string;
-    const lights_pars_begin: string;
-}
-
-export default _default;

three/src/extras/objects/ImmediateRenderObject.d.ts

@@ -1,59 +0,0 @@
-import { Object3D } from './../../core/Object3D';
-import { Material } from './../../materials/Material';
-
-// Extras / Objects /////////////////////////////////////////////////////////////////////
-
-export class ImmediateRenderObject extends Object3D {
-    constructor(material: Material);
-
-    readonly isImmediateRenderObject: true;
-
-    material: Material;
-
-    /**
-     * @default false
-     */
-    hasPositions: boolean;
-
-    /**
-     * @default false
-     */
-    hasNormals: boolean;
-
-    /**
-     * @default false
-     */
-    hasColors: boolean;
-
-    /**
-     * @default false
-     */
-    hasUvs: boolean;
-
-    /**
-     * @default null
-     */
-    positionArray: null | Float32Array;
-
-    /**
-     * @default null
-     */
-    normalArray: null | Float32Array;
-
-    /**
-     * @default null
-     */
-    colorArray: null | Float32Array;
-
-    /**
-     * @default null
-     */
-    uvArray: null | Float32Array;
-
-    /**
-     * @default 0
-     */
-    count: number;
-
-    render(renderCallback: () => void): void;
-}