@types/three 0.132.1 → 0.134.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: Sat, 25 Sep 2021 01:01:27 GMT
+ * Last updated: Mon, 08 Nov 2021 18:01:35 GMT
  * Dependencies: none
  * Global values: `THREE`
 

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

@@ -0,0 +1,160 @@
+import { EventDispatcher, Camera, Scene, Vector3, Raycaster } from '../../../src/Three';
+
+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;
+
+    /**
+     * @default 500
+     */
+    focusAnimationTime: number;
+
+    /**
+     * @default true
+     */
+    enabled: boolean;
+
+    /**
+     * @default true
+     */
+    enablePan: boolean;
+
+    /**
+     * @default true
+     */
+    enableRotate: boolean;
+
+    /**
+     * @default true
+     */
+    enableZoom: boolean;
+
+    /**
+     * @default true
+     */
+    enableGizmos: boolean;
+
+    /**
+     * @default true
+     */
+    adjustNearFar: boolean;
+
+    /**
+     * @default 1.1
+     */
+    scaleFactor: number;
+
+    /**
+     * @default 25
+     */
+    dampingFactor: number;
+
+    /**
+     * @default 20
+     */
+    wMax: number; // maximum angular velocity allowed
+
+    /**
+     * @default true
+     */
+    enableAnimations: boolean; // if animations should be performed
+
+    /**
+     * @default false
+     */
+    enableGrid: boolean; // if grid should be showed during pan operation
+
+    /**
+     * @default false
+     */
+    cursorZoom: boolean; // if wheel zoom should be cursor centered
+
+    /**
+     * @default 5
+     */
+    minFov: number;
+
+    /**
+     * @default 90
+     */
+    maxFov: number;
+
+    /**
+     * @default 0
+     */
+    minDistance: number;
+
+    /**
+     * @default Infinity
+     */
+    maxDistance: number;
+
+    /**
+     * @default 0
+     */
+    minZoom: number;
+
+    /**
+     * @default Infinity
+     */
+    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;
+
+    setTarget(x: number, y: number, z: number): void;
+
+    update(): void;
+
+    dispose(): void;
+}

three/examples/jsm/geometries/ParametricGeometries.d.ts

@@ -1,8 +1,10 @@
-import { Curve, ParametricGeometry, Vector3 } from '../../../src/Three';
+import { Curve, Vector3 } from '../../../src/Three';
+
+import { ParametricGeometry } from './ParametricGeometry';
 
 export namespace ParametricGeometries {
     function klein(v: number, u: number, target: Vector3): Vector3;
-    function plane(width: number, height: number, target: Vector3): Vector3;
+    function plane(width: number, height: number): (u: number, v: number, target: Vector3) => Vector3;
     function mobius(u: number, t: number, target: Vector3): Vector3;
     function mobius3d(u: number, t: number, target: Vector3): Vector3;
 

three/{src → examples/jsm}/geometries/ParametricGeometry.d.ts

@@ -1,8 +1,7 @@
-import { Vector3 } from './../math/Vector3';
-import { BufferGeometry } from './../core/BufferGeometry';
+import { Vector3, BufferGeometry } from '../../../src/Three';
 
 export class ParametricGeometry extends BufferGeometry {
-    constructor(func: (u: number, v: number, dest: Vector3) => void, slices: number, stacks: number);
+    constructor(func?: (u: number, v: number, target: Vector3) => void, slices?: number, stacks?: number);
 
     /**
      * @default 'ParametricGeometry'

three/{src → examples/jsm}/geometries/TextGeometry.d.ts

@@ -1,5 +1,6 @@
-import { Font } from './../extras/core/Font';
-import { ExtrudeGeometry } from './ExtrudeGeometry';
+import { ExtrudeGeometry } from '../../../src/Three';
+
+import { Font } from '../loaders/FontLoader';
 
 export interface TextGeometryParameters {
     font: Font;

three/examples/jsm/lines/LineSegmentsGeometry.d.ts

@@ -14,10 +14,10 @@ export class LineSegmentsGeometry extends InstancedBufferGeometry {
     applyMatrix4(matrix: Matrix4): this;
     computeBoundingBox(): void;
     computeBoundingSphere(): void;
-    fromEdgesGeometry(geometry: WireframeGeometry): this;
+    fromEdgesGeometry(geometry: EdgesGeometry): this;
     fromLineSegments(lineSegments: LineSegments): this;
     fromMesh(mesh: Mesh): this;
-    fromWireframeGeometry(geometry: EdgesGeometry): this;
+    fromWireframeGeometry(geometry: WireframeGeometry): this;
     setColors(array: number[] | Float32Array): this;
     setPositions(array: number[] | Float32Array): this;
 }

three/{src → examples/jsm}/loaders/FontLoader.d.ts

@@ -1,6 +1,4 @@
-import { Loader } from './Loader';
-import { LoadingManager } from './LoadingManager';
-import { Font } from './../extras/core/Font';
+import { Shape, Loader, LoadingManager } from '../../../src/Three';
 
 export class FontLoader extends Loader {
     constructor(manager?: LoadingManager);
@@ -14,3 +12,16 @@ export class FontLoader extends Loader {
     loadAsync(url: string, onProgress?: (event: ProgressEvent) => void): Promise<Font>;
     parse(json: any): Font;
 }
+
+export class Font {
+    constructor(jsondata: any);
+
+    /**
+     * @default 'Font'
+     */
+    type: string;
+
+    data: string;
+
+    generateShapes(text: string, size: number): Shape[];
+}

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';
@@ -63,18 +66,31 @@ export class GLTFLoader extends Loader {
     ): void;
 }
 
-export type GLTFReferenceType = 'materials'|'nodes'|'textures'|'meshes';
+export type GLTFReferenceType = 'materials' | 'nodes' | 'textures' | 'meshes';
 
 export interface GLTFReference {
-  materials?: number;
-  nodes?: number;
-  textures?: number;
-  meshes?: number;
+    materials?: number;
+    nodes?: number;
+    textures?: number;
+    meshes?: number;
 }
 
 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 +151,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/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/modifiers/TessellateModifier.d.ts

@@ -5,5 +5,5 @@ export class TessellateModifier {
     maxEdgeLength: number;
     maxIterations: number;
 
-    modify(geometry: BufferGeometry): BufferGeometry;
+    modify<TGeometry extends BufferGeometry>(geometry: TGeometry): TGeometry;
 }

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/postprocessing/SSRPass.d.ts

@@ -7,7 +7,6 @@ import {
     Scene,
     WebGLRenderer,
     Camera,
-    TextureEncoding,
     Mesh,
     Material,
     ColorRepresentation,
@@ -22,7 +21,6 @@ export interface SSRPassParams {
     width?: number | undefined;
     height?: number | undefined;
     selects: Mesh[] | null;
-    encoding: TextureEncoding;
     isPerspectiveCamera?: boolean | undefined;
     isBouncing?: boolean | undefined;
     groundReflector: Reflector | null;
@@ -40,7 +38,6 @@ export class SSRPass extends Pass {
     output: number;
     maxDistance: number;
     thickness: number;
-    encoding: TextureEncoding;
     tempColor: Color;
 
     get selects(): Mesh[] | null;

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

@@ -1,32 +1,18 @@
 import {
-    AddEquation,
     Color,
-    NormalBlending,
-    DepthTexture,
-    SrcAlphaFactor,
-    OneMinusSrcAlphaFactor,
     MeshNormalMaterial,
     MeshBasicMaterial,
-    NearestFilter,
-    NoBlending,
-    RGBAFormat,
     ShaderMaterial,
-    UniformsUtils,
-    UnsignedShortType,
     WebGLRenderTarget,
-    HalfFloatType,
     MeshStandardMaterial,
     WebGLRenderer,
     Scene,
     Camera,
     Mesh,
-    TextureEncoding,
     Material,
     ColorRepresentation,
 } from '../../../src/Three';
 import { Pass, FullScreenQuad } from './Pass';
-import { SSRrShader, SSRrDepthShader } from '../shaders/SSRrShader';
-import { CopyShader } from '../shaders/CopyShader';
 
 export interface SSRrPassParams {
     renderer: WebGLRenderer;
@@ -35,7 +21,6 @@ export interface SSRrPassParams {
     width?: number | undefined;
     height?: number | undefined;
     selects: Mesh[] | null;
-    encoding: TextureEncoding;
 }
 
 export class SSRrPass extends Pass {
@@ -53,8 +38,6 @@ export class SSRrPass extends Pass {
     maxDistance: number;
     surfDist: number;
 
-    encoding: TextureEncoding;
-
     color: Color;
 
     seleects: Mesh[] | null;

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

@@ -1,4 +1,4 @@
-// Type definitions for three 0.132
+// Type definitions for three 0.134
 // 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.132.1",
+    "version": "0.134.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": "3bc2c085ec825e9046e6e08328e766b595e0d10694adebcd6bcc872a22385730",
+    "typesPublisherContentHash": "081e8a2aa20cac9bb8a5fc1c65f63e7f502175cd0654faf460174999473bd0ac",
     "typeScriptVersion": "3.7"
 }

three/src/Three.d.ts

@@ -58,12 +58,10 @@ 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';
 export * from './extras/core/ShapePath';
-export * from './extras/core/Font';
 export * from './extras/core/CurvePath';
 export * from './extras/core/Curve';
 export * from './extras/DataUtils';
@@ -121,7 +119,6 @@ export * from './loaders/BufferGeometryLoader';
 export * from './loaders/LoadingManager';
 export * from './loaders/ImageLoader';
 export * from './loaders/ImageBitmapLoader';
-export * from './loaders/FontLoader';
 export * from './loaders/FileLoader';
 export * from './loaders/Loader';
 export * from './loaders/LoaderUtils';

three/src/core/Raycaster.d.ts

@@ -13,14 +13,14 @@ export interface Face {
     materialIndex: number;
 }
 
-export interface Intersection {
+export interface Intersection<TIntersected extends Object3D = Object3D> {
     distance: number;
     distanceToRay?: number | undefined;
     point: Vector3;
     index?: number | undefined;
     face?: Face | null | undefined;
     faceIndex?: number | undefined;
-    object: Object3D;
+    object: TIntersected;
     uv?: Vector2 | undefined;
     instanceId?: number | undefined;
 }
@@ -97,7 +97,11 @@ export class Raycaster {
      * @param recursive If true, it also checks all descendants. Otherwise it only checks intersecton with the object. Default is false.
      * @param optionalTarget (optional) target to set the result. Otherwise a new Array is instantiated. If set, you must clear this array prior to each call (i.e., array.length = 0;).
      */
-    intersectObject(object: Object3D, recursive?: boolean, optionalTarget?: Intersection[]): Intersection[];
+    intersectObject<TIntersected extends Object3D>(
+        object: Object3D,
+        recursive?: boolean,
+        optionalTarget?: Array<Intersection<TIntersected>>,
+    ): Array<Intersection<TIntersected>>;
 
     /**
      * Checks all intersection between the ray and the objects with or without the descendants.
@@ -107,5 +111,9 @@ export class Raycaster {
      * @param recursive If true, it also checks all descendants of the objects. Otherwise it only checks intersecton with the objects. Default is false.
      * @param optionalTarget (optional) target to set the result. Otherwise a new Array is instantiated. If set, you must clear this array prior to each call (i.e., array.length = 0;).
      */
-    intersectObjects(objects: Object3D[], recursive?: boolean, optionalTarget?: Intersection[]): Intersection[];
+    intersectObjects<TIntersected extends Object3D>(
+        objects: Object3D[],
+        recursive?: boolean,
+        optionalTarget?: Array<Intersection<TIntersected>>,
+    ): Array<Intersection<TIntersected>>;
 }

three/src/extras/core/CurvePath.d.ts

@@ -21,6 +21,6 @@ export class CurvePath<T extends Vector> extends Curve<T> {
 
     add(curve: Curve<T>): void;
     closePath(): void;
-    getPoint(t: number): T;
+    getPoint(t: number, optionalTarget?: T): T;
     getCurveLengths(): number[];
 }

three/src/geometries/EdgesGeometry.d.ts

@@ -1,11 +1,11 @@
 import { BufferGeometry } from '../core/BufferGeometry';
 
-export class EdgesGeometry extends BufferGeometry {
+export class EdgesGeometry<TBufferGeometry extends BufferGeometry = BufferGeometry> extends BufferGeometry {
     /**
      * @param geometry
      * @param [thresholdAngle=1]
      */
-    constructor(geometry: BufferGeometry, thresholdAngle?: number);
+    constructor(geometry?: TBufferGeometry, thresholdAngle?: number);
 
     /**
      * @default 'EdgesGeometry'
@@ -13,6 +13,7 @@ export class EdgesGeometry extends BufferGeometry {
     type: string;
 
     parameters: {
+        geometry: TBufferGeometry;
         thresholdAngle: number;
     };
 }

three/src/geometries/ExtrudeGeometry.d.ts

@@ -57,7 +57,7 @@ export interface UVGenerator {
 }
 
 export class ExtrudeGeometry extends BufferGeometry {
-    constructor(shapes: Shape | Shape[], options?: ExtrudeGeometryOptions);
+    constructor(shapes?: Shape | Shape[], options?: ExtrudeGeometryOptions);
 
     /**
      * @default 'ExtrudeGeometry'

three/src/geometries/Geometries.d.ts

@@ -8,14 +8,12 @@ export * from './ExtrudeGeometry';
 export * from './IcosahedronGeometry';
 export * from './LatheGeometry';
 export * from './OctahedronGeometry';
-export * from './ParametricGeometry';
 export * from './PlaneGeometry';
 export * from './PolyhedronGeometry';
 export * from './RingGeometry';
 export * from './ShapeGeometry';
 export * from './SphereGeometry';
 export * from './TetrahedronGeometry';
-export * from './TextGeometry';
 export * from './TorusGeometry';
 export * from './TorusKnotGeometry';
 export * from './TubeGeometry';

three/src/geometries/LatheGeometry.d.ts

@@ -8,7 +8,7 @@ export class LatheGeometry extends BufferGeometry {
      * @param [phiStart=0]
      * @param [phiLength=Math.PI * 2]
      */
-    constructor(points: Vector2[], segments?: number, phiStart?: number, phiLength?: number);
+    constructor(points?: Vector2[], segments?: number, phiStart?: number, phiLength?: number);
 
     /**
      * @default 'LatheGeometry'

three/src/geometries/PolyhedronGeometry.d.ts

@@ -7,7 +7,7 @@ export class PolyhedronGeometry extends BufferGeometry {
      * @param [radius=1]
      * @param [detail=0]
      */
-    constructor(vertices: number[], indices: number[], radius?: number, detail?: number);
+    constructor(vertices?: number[], indices?: number[], radius?: number, detail?: number);
 
     /**
      * @default 'PolyhedronGeometry'

three/src/geometries/ShapeGeometry.d.ts

@@ -7,7 +7,7 @@ export class ShapeGeometry extends BufferGeometry {
      */
     type: string;
 
-    constructor(shapes: Shape | Shape[], curveSegments?: number);
+    constructor(shapes?: Shape | Shape[], curveSegments?: number);
 
     static fromJSON(data: any): ShapeGeometry;
 }

three/src/geometries/TubeGeometry.d.ts

@@ -11,7 +11,7 @@ export class TubeGeometry extends BufferGeometry {
      * @param [closed=false]
      */
     constructor(
-        path: Curve<Vector3>,
+        path?: Curve<Vector3>,
         tubularSegments?: number,
         radius?: number,
         radiusSegments?: number,

three/src/geometries/WireframeGeometry.d.ts

@@ -1,10 +1,14 @@
 import { BufferGeometry } from './../core/BufferGeometry';
 
-export class WireframeGeometry extends BufferGeometry {
-    constructor(geometry: BufferGeometry);
+export class WireframeGeometry<TBufferGeometry extends BufferGeometry = BufferGeometry> extends BufferGeometry {
+    constructor(geometry?: TBufferGeometry);
 
     /**
      * @default 'WireframeGeometry'
      */
     type: string;
+
+    parameters: {
+        geometry: TBufferGeometry;
+    };
 }

three/src/lights/DirectionalLight.d.ts

@@ -24,7 +24,7 @@ export class DirectionalLight extends Light {
     /**
      * @default THREE.Object3D.DefaultUp
      */
-    position: Vector3;
+    readonly position: Vector3;
 
     /**
      * Target used for shadow camera orientation.

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

@@ -317,7 +317,7 @@ export class Material extends EventDispatcher {
      * If *null*, the value is opposite that of side, above.
      * @default null
      */
-    shadowSide: Side;
+    shadowSide: Side | null;
 
     /**
      * Defines whether this material is tone mapped according to the renderer's toneMapping setting.

three/src/materials/MeshPhysicalMaterial.d.ts

@@ -14,17 +14,19 @@ export interface MeshPhysicalMaterialParameters extends MeshStandardMaterialPara
     reflectivity?: number | undefined;
     ior?: number | undefined;
 
-    sheenTint?: Color | undefined;
+    sheen?: number | 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 {
@@ -80,10 +82,30 @@ export class MeshPhysicalMaterial extends MeshStandardMaterial {
      */
     ior: number;
 
+    /**
+     * @default 0.0
+     */
+    sheen: number;
+
+    /**
+     * @default Color( 0x000000 )
+     */
+    sheenColor: Color;
+
+    /**
+     * @default null
+     */
+    sheenColorMap: Texture | null;
+
+    /**
+     * @default 1.0
+     */
+    sheenRoughness: number;
+
     /**
      * @default null
      */
-    sheenTint: Color | null;
+    sheenRoughnessMap: Texture | null;
 
     /**
      * @default 0
@@ -123,7 +145,7 @@ export class MeshPhysicalMaterial extends MeshStandardMaterial {
     /**
      * @default Color(1, 1, 1)
      */
-    specularTint: Color;
+    specularColor: Color;
 
     /**
      * @default null
@@ -133,5 +155,5 @@ export class MeshPhysicalMaterial extends MeshStandardMaterial {
     /**
      * @default null
      */
-    specularTintMap: Texture | null;
+    specularColorMap: Texture | null;
 }

three/src/math/Quaternion.d.ts

@@ -172,4 +172,6 @@ export class Quaternion {
      * @deprecated Use {@link Quaternion#invert .invert()} instead.
      */
     inverse(): Quaternion;
+
+    random(): Quaternion;
 }

three/src/math/Triangle.d.ts

@@ -3,6 +3,9 @@ import { Vector3 } from './Vector3';
 import { Plane } from './Plane';
 import { Box3 } from './Box3';
 
+import { InterleavedBufferAttribute } from '../core/InterleavedBufferAttribute';
+import { BufferAttribute } from '../core/BufferAttribute';
+
 export class Triangle {
     constructor(a?: Vector3, b?: Vector3, c?: Vector3);
 
@@ -22,7 +25,13 @@ export class Triangle {
     c: Vector3;
 
     set(a: Vector3, b: Vector3, c: Vector3): Triangle;
-    setFromPointsAndIndices(points: Vector3[], i0: number, i1: number, i2: number): Triangle;
+    setFromPointsAndIndices(points: Vector3[], i0: number, i1: number, i2: number): this;
+    setFromAttributeAndIndices(
+        attribute: BufferAttribute | InterleavedBufferAttribute,
+        i0: number,
+        i1: number,
+        i2: number,
+    ): this;
     clone(): this;
     copy(triangle: Triangle): this;
     getArea(): number;

three/src/math/Vector3.d.ts

@@ -287,4 +287,6 @@ export class Vector3 implements Vector {
      * Sets this vector's x, y and z from Math.random
      */
     random(): this;
+
+    randomDirection(): 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,

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/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/src/extras/core/Font.d.ts

@@ -1,14 +0,0 @@
-import { Shape } from './Shape';
-
-export class Font {
-    constructor(jsondata: any);
-
-    /**
-     * @default 'Font'
-     */
-    type: string;
-
-    data: string;
-
-    generateShapes(text: string, size: number): Shape[];
-}

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