@types/three 0.147.1 → 0.148.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: Fri, 30 Dec 2022 23:03:50 GMT
+ * Last updated: Tue, 03 Jan 2023 22:32:45 GMT
  * Dependencies: [@types/webxr](https://npmjs.com/package/@types/webxr)
  * Global values: `THREE`
 

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

@@ -143,6 +143,7 @@ export class GLTFParser {
 export interface GLTFLoaderPlugin {
     beforeRoot?: (() => Promise<void> | null) | undefined;
     afterRoot?: ((result: GLTF) => Promise<void> | null) | undefined;
+    loadNode?: ((nodeIndex: number) => Promise<Object3D> | null) | undefined;
     loadMesh?: ((meshIndex: number) => Promise<Group | Mesh | SkinnedMesh> | null) | undefined;
     loadBufferView?: ((bufferViewIndex: number) => Promise<ArrayBuffer> | null) | undefined;
     loadMaterial?: ((materialIndex: number) => Promise<Material> | null) | undefined;

three/examples/jsm/math/Capsule.d.ts

@@ -9,7 +9,7 @@ export class Capsule {
     set(start: Vector3, end: Vector3, radius: number): this;
     clone(): Capsule;
     copy(capsule: Capsule): this;
-    getCenter(target: number): Vector3;
+    getCenter(target: Vector3): Vector3;
     translate(v: Vector3): this;
     checkAABBAxis(
         p1x: number,

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

@@ -2,6 +2,7 @@
 import ArrayUniformNode from './core/ArrayUniformNode';
 import AttributeNode from './core/AttributeNode';
 import BypassNode from './core/BypassNode';
+import CacheNode from './core/CacheNode';
 import CodeNode, { CodeNodeInclude } from './core/CodeNode';
 import ConstNode from './core/ConstNode';
 import ContextNode from './core/ContextNode';
@@ -12,6 +13,7 @@ import InstanceIndexNode from './core/InstanceIndexNode';
 import Node from './core/Node';
 import NodeAttribute from './core/NodeAttribute';
 import NodeBuilder from './core/NodeBuilder';
+import NodeCache from './core/NodeCache';
 import NodeCode from './core/NodeCode';
 import NodeFrame from './core/NodeFrame';
 import NodeFunctionInput from './core/NodeFunctionInput';
@@ -20,6 +22,7 @@ import NodeUniform from './core/NodeUniform';
 import NodeVar from './core/NodeVar';
 import NodeVarying from './core/NodeVarying';
 import PropertyNode from './core/PropertyNode';
+import StackNode from './core/StackNode';
 import TempNode from './core/TempNode';
 import UniformNode from './core/UniformNode';
 import VarNode from './core/VarNode';
@@ -89,6 +92,7 @@ import MaxMipLevelNode from './utils/MaxMipLevelNode';
 import OscNode, { OscNodeMethod } from './utils/OscNode';
 import RemapNode from './utils/RemapNode';
 import RotateUVNode from './utils/RotateUVNode';
+import SpecularMIPLevelNode from './utils/SpecularMIPLevelNode';
 import SplitNode from './utils/SplitNode';
 import SpriteSheetUVNode from './utils/SpriteSheetUVNode';
 import TimerNode, { TimerNodeScope } from './utils/TimerNode';
@@ -104,6 +108,7 @@ import CheckerNode from './procedural/CheckerNode';
 // fog
 import FogNode from './fog/FogNode';
 import FogRangeNode from './fog/FogRangeNode';
+import FogExp2Node from './fog/FogExp2Node';
 
 // core
 export * from './core/constants';
@@ -119,6 +124,7 @@ export {
     ArrayUniformNode,
     AttributeNode,
     BypassNode,
+    CacheNode,
     CodeNode,
     CodeNodeInclude,
     ContextNode,
@@ -131,6 +137,7 @@ export {
     Node,
     NodeAttribute,
     NodeBuilder,
+    NodeCache,
     NodeCode,
     NodeFrame,
     NodeFunctionInput,
@@ -139,6 +146,7 @@ export {
     NodeVar,
     NodeVarying,
     PropertyNode,
+    StackNode,
     TempNode,
     UniformNode,
     VarNode,
@@ -218,6 +226,7 @@ export {
     OscNodeMethod,
     RemapNode,
     RotateUVNode,
+    SpecularMIPLevelNode,
     SplitNode,
     SpriteSheetUVNode,
     TimerNode,
@@ -228,6 +237,7 @@ export {
     // fog
     FogNode,
     FogRangeNode,
+    FogExp2Node,
     // loaders
     NodeLoader,
     NodeObjectLoader,

three/examples/jsm/nodes/accessors/CubeTextureNode.d.ts

@@ -8,4 +8,6 @@ export default class CubeTextureNode extends TextureNode {
     levelNode: Node | null;
 
     constructor(value: CubeTexture, uvNode?: Node | null, levelNode?: Node | null);
+
+    getDefaultUV(): Node;
 }

three/examples/jsm/nodes/accessors/TextureNode.d.ts

@@ -9,4 +9,6 @@ export default class TextureNode extends UniformNode {
     levelNode: Node | null;
 
     constructor(value: Texture, uvNode?: Node, levelNode?: Node | null);
+
+    getDefaultUV(): Node;
 }

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

@@ -0,0 +1,10 @@
+import Node from './Node';
+import NodeCache from './NodeCache';
+
+export default class CacheNode extends Node {
+    isCacheNode: true;
+    node: Node;
+    cache: NodeCache;
+
+    constructor(node: Node, cache?: NodeCache);
+}

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

@@ -12,11 +12,11 @@ export default abstract class Node {
 
     constructor(nodeType?: NodeTypeOption | null);
 
+    isGlobal(builder: NodeBuilder): boolean;
     getChildren(): Node[];
     getHash(builder: NodeBuilder): string;
     getUpdateType(builder: NodeBuilder): NodeUpdateTypeOption;
     getNodeType(builder: NodeBuilder, output?: string | null): NodeTypeOption | null;
-    getConstructHash(builder: NodeBuilder): string;
     getReference(builder: NodeBuilder): Node;
     construct(builder: NodeBuilder): Node | null;
     analyze(builder: NodeBuilder): void;

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

@@ -14,6 +14,7 @@ import { nodeObject } from '../Nodes';
 import { AnyObject, NodeShaderStageOption, NodeTypeOption } from './constants';
 import Node from './Node';
 import NodeAttribute from './NodeAttribute';
+import NodeCache from './NodeCache';
 import NodeParser from './NodeParser';
 import NodeUniform from './NodeUniform';
 import NodeVar from './NodeVar';
@@ -52,6 +53,14 @@ export default abstract class NodeBuilder {
     fragmentShader: string;
     computeShader: string;
 
+    cache: NodeCache;
+    globalCache: NodeCache;
+
+    /**
+     * @TODO used to be missing. check the actual type later
+     */
+    flowsData: any;
+
     shaderStage: NodeShaderStageOption | null;
     buildStage: BuildStageOption | null;
     stack: Node[];

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

@@ -0,0 +1,9 @@
+import Node from './Node';
+import { NodeData } from './NodeBuilder';
+
+export default class NodeCache {
+    id: number;
+    nodesData: WeakMap<Node, NodeData>;
+
+    constructor();
+}

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

@@ -0,0 +1,11 @@
+import Node from './Node';
+
+export default class StackNode extends Node {
+    isStackNode: true;
+    nodes: Node[];
+    outputNode: Node | null;
+
+    constructor();
+
+    assign(targetNode: Node, sourceValue: Node): this;
+}

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

@@ -1,8 +1,11 @@
 import { NodeTypeOption } from './constants';
 import Node from './Node';
+import NodeBuilder from './NodeBuilder';
 
 export default class TempNode extends Node {
     isTempNode: true;
 
     constructor(type: NodeTypeOption | null);
+
+    hasDependencies(builder: NodeBuilder): void;
 }

three/examples/jsm/nodes/fog/FogExp2Node.d.ts

@@ -0,0 +1,9 @@
+import Node from '../core/Node';
+import FogNode from './FogNode';
+
+export default class FogExp2Node extends FogNode {
+    isFogExp2Node: true;
+    densityNode: Node;
+
+    constructor(colorNode: Node, densityNode: Node);
+}

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

@@ -23,6 +23,7 @@ import {
     BitangentNode,
     BufferNode,
     BypassNode,
+    CacheNode,
     CameraNode,
     CodeNode,
     CodeNodeInclude,
@@ -37,6 +38,7 @@ import {
     MaterialNode,
     MaterialReferenceNode,
     MathNode,
+    MaxMipLevelNode,
     ModelNode,
     ModelViewProjectionNode,
     NormalNode,
@@ -51,6 +53,7 @@ import {
     VaryNode,
 } from '../Nodes';
 import StorageBufferNode from '../accessors/StorageBufferNode';
+import NodeCache from '../core/NodeCache';
 
 // shader node base
 
@@ -94,8 +97,10 @@ export function attribute(attributeName: string, nodeType: NodeTypeOption): Swiz
 export function property(name: string, nodeOrType: Node | NodeTypeOption): Swizzable;
 
 export function convert(node: NodeRepresentation, types: NodeTypeOption): Swizzable;
+export function maxMipLevel(texture: Texture): Swizzable<MaxMipLevelNode>;
 
 export function bypass(returnNode: NodeRepresentation, callNode: NodeRepresentation): Swizzable<BypassNode>;
+export function cache(node: Node, cache?: NodeCache): Swizzable<CacheNode>;
 export function code(code: string, nodeType?: NodeTypeOption): Swizzable<CodeNode>;
 export function context(node: NodeRepresentation, context: NodeBuilderContext): Swizzable<ContextNode>;
 export function expression(snipped?: string, nodeType?: NodeTypeOption): Swizzable<ExpressionNode>;
@@ -110,17 +115,17 @@ export type Fn<P extends FunctionNodeArguments> = P extends readonly [...unknown
     ? ProxiedTuple<P>
     : readonly [ProxiedObject<P>];
 
-/* eslint-disable no-unnecessary-generics */
 export function func<P extends FunctionNodeArguments>(
     code: string,
     includes?: CodeNodeInclude[],
+    // eslint-disable-next-line no-unnecessary-generics
 ): { call: (...params: Fn<P>) => Swizzable };
 
 export function fn<P extends FunctionNodeArguments>(
     code: string,
     includes?: CodeNodeInclude[],
+    // eslint-disable-next-line no-unnecessary-generics
 ): (...params: Fn<P>) => Swizzable;
-/* 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

@@ -20,10 +20,10 @@ import {
     EquirectUVNode,
     FogNode,
     FogRangeNode,
+    FogExp2Node,
     InstanceNode,
     LightsNode,
     MatcapUVNode,
-    MaxMipLevelNode,
     NormalMapNode,
     OscNode,
     PosterizeNode,
@@ -35,6 +35,7 @@ import {
     TimerNode,
     ToneMappingNode,
     TriplanarTexturesNode,
+    SpecularMIPLevelNode,
     ViewportNode,
 } from '../Nodes';
 
@@ -117,7 +118,7 @@ export function lightingContext(node: Node, lightingModelNode?: LightingModelNod
 export const matcapUV: Swizzable<MatcapUVNode>;
 export const equirectUV: Swizzable<EquirectUVNode>;
 
-export function maxMipLevel(texture: Texture): Swizzable<MaxMipLevelNode>;
+export function specularMIPLevel(): Swizzable<SpecularMIPLevelNode>;
 
 export function oscSine(timeNode?: NodeRepresentation): Swizzable<OscNode>;
 export function oscSquare(timeNode?: NodeRepresentation): Swizzable<OscNode>;
@@ -164,3 +165,4 @@ export function checker(uvNode?: NodeRepresentation): Swizzable<CheckerNode>;
 
 export function fog(colorNode: NodeRepresentation, factorNode: NodeRepresentation): Swizzable<FogNode>;
 export function rangeFog(colorNode: Node, nearNode: Node, farNode: Node): Swizzable<FogRangeNode>;
+export function exp2Fog(colorNode: Node, densityNode: Node): Swizzable<FogExp2Node>;

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

@@ -1,7 +1,11 @@
 import UniformNode from '../core/UniformNode';
 import { Texture } from '../../../../src/Three';
+import { TextureNode } from '../Nodes';
 
 export default class MaxMipLevelNode extends UniformNode {
-    texture: Texture;
-    constructor(texture: Texture);
+    textureNode: TextureNode;
+
+    constructor(textureNode: TextureNode);
+
+    get texture(): Texture;
 }

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

@@ -0,0 +1,8 @@
+import { Node, TextureNode } from '../Nodes';
+
+export default class SpecularMIPLevelNode extends Node {
+    textureNode: TextureNode;
+    roughnessNode: Node | null;
+
+    constructor(textureNode: TextureNode, roughnessNode?: Node | null);
+}

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

@@ -15,6 +15,17 @@ export function createMeshesFromMultiMaterialMesh(mesh: Mesh): Group;
 
 export function sortInstancedMesh(mesh: InstancedMesh, compareFn: (a: number, b: number) => number): void;
 
+/**
+ * Akin to Array.prototype.reduce(), but operating on the vertices of all the visible descendant objects, in world space.
+ * Additionally, it can operate as a transform-reduce, returning a different type T than the Vector3 input.
+ * This can be useful for e.g. fitting a viewing frustum to the scene.
+ *
+ * @param object - The object to traverse (uses traverseVisible internally).
+ * @param func - The binary function applied for the reduction.
+ * Must have the signature: (value: T, vertex: Vector3): T.
+ * @param initialValue - The value to initialize the reduction with.
+ * This is required as it also sets the reduction type, which is not required to be Vector3.
+ */
 export function reduceVertices<TValue>(
     object: Object3D,
     func: (value: TValue, vertex: Vector3) => TValue,

three/index.d.ts

@@ -1,4 +1,4 @@
-// Type definitions for three 0.147
+// Type definitions for three 0.148
 // 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.147.1",
+    "version": "0.148.0",
     "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": "817382c65c940c6161d82bd35bba71b745760fd0e4d06c8cc05eb3b2953c438c",
+    "typesPublisherContentHash": "04304766d975fb3b4535f738695662f357aebd92f1bfaf6d66a40f3d6919b08e",
     "typeScriptVersion": "4.2"
 }

three/src/animation/KeyframeTrack.d.ts

@@ -1,6 +1,7 @@
 import { DiscreteInterpolant } from './../math/interpolants/DiscreteInterpolant';
 import { LinearInterpolant } from './../math/interpolants/LinearInterpolant';
 import { CubicInterpolant } from './../math/interpolants/CubicInterpolant';
+import { Interpolant } from '../math/Interpolant';
 import { InterpolationModes } from '../constants';
 
 export class KeyframeTrack {
@@ -10,7 +11,7 @@ export class KeyframeTrack {
      * @param values
      * @param [interpolation=THREE.InterpolateLinear]
      */
-    constructor(name: string, times: ArrayLike<any>, values: ArrayLike<any>, interpolation?: InterpolationModes);
+    constructor(name: string, times: ArrayLike<number>, values: ArrayLike<any>, interpolation?: InterpolationModes);
 
     name: string;
     times: Float32Array;
@@ -31,6 +32,7 @@ export class KeyframeTrack {
 
     setInterpolation(interpolation: InterpolationModes): KeyframeTrack;
     getInterpolation(): InterpolationModes;
+    createInterpolant(): Interpolant;
 
     getValueSize(): number;
 

three/src/animation/tracks/BooleanKeyframeTrack.d.ts

@@ -1,7 +1,7 @@
 import { KeyframeTrack } from './../KeyframeTrack';
 
 export class BooleanKeyframeTrack extends KeyframeTrack {
-    constructor(name: string, times: any[], values: any[]);
+    constructor(name: string, times: ArrayLike<number>, values: ArrayLike<any>);
 
     /**
      * @default 'bool'

three/src/animation/tracks/ColorKeyframeTrack.d.ts

@@ -2,7 +2,7 @@ import { KeyframeTrack } from './../KeyframeTrack';
 import { InterpolationModes } from '../../constants';
 
 export class ColorKeyframeTrack extends KeyframeTrack {
-    constructor(name: string, times: any[], values: any[], interpolation?: InterpolationModes);
+    constructor(name: string, times: ArrayLike<number>, values: ArrayLike<number>, interpolation?: InterpolationModes);
 
     /**
      * @default 'color'

three/src/animation/tracks/NumberKeyframeTrack.d.ts

@@ -2,7 +2,7 @@ import { KeyframeTrack } from './../KeyframeTrack';
 import { InterpolationModes } from '../../constants';
 
 export class NumberKeyframeTrack extends KeyframeTrack {
-    constructor(name: string, times: any[], values: any[], interpolation?: InterpolationModes);
+    constructor(name: string, times: ArrayLike<number>, values: ArrayLike<number>, interpolation?: InterpolationModes);
 
     /**
      * @default 'number'

three/src/animation/tracks/QuaternionKeyframeTrack.d.ts

@@ -2,7 +2,7 @@ import { KeyframeTrack } from './../KeyframeTrack';
 import { InterpolationModes } from '../../constants';
 
 export class QuaternionKeyframeTrack extends KeyframeTrack {
-    constructor(name: string, times: any[], values: any[], interpolation?: InterpolationModes);
+    constructor(name: string, times: ArrayLike<number>, values: ArrayLike<number>, interpolation?: InterpolationModes);
 
     /**
      * @default 'quaternion'

three/src/animation/tracks/StringKeyframeTrack.d.ts

@@ -2,7 +2,7 @@ import { KeyframeTrack } from './../KeyframeTrack';
 import { InterpolationModes } from '../../constants';
 
 export class StringKeyframeTrack extends KeyframeTrack {
-    constructor(name: string, times: any[], values: any[], interpolation?: InterpolationModes);
+    constructor(name: string, times: ArrayLike<number>, values: ArrayLike<any>, interpolation?: InterpolationModes);
 
     /**
      * @default 'string'

three/src/animation/tracks/VectorKeyframeTrack.d.ts

@@ -2,7 +2,7 @@ import { KeyframeTrack } from './../KeyframeTrack';
 import { InterpolationModes } from '../../constants';
 
 export class VectorKeyframeTrack extends KeyframeTrack {
-    constructor(name: string, times: any[], values: any[], interpolation?: InterpolationModes);
+    constructor(name: string, times: ArrayLike<number>, values: ArrayLike<number>, interpolation?: InterpolationModes);
 
     /**
      * @default 'vector'

three/src/constants.d.ts

@@ -34,10 +34,17 @@ export const VSMShadowMap: ShadowMapType;
 // MATERIAL CONSTANTS
 
 // side
+/**
+ * Defines which side of faces will be rendered - front, back or both.
+ * Default is FrontSide.
+ *
+ * TwoPassDoubleSide will renderer double-sided transparent materials in two passes in back-front order to mitigate transparency artifacts.
+ */
 export enum Side {}
 export const FrontSide: Side;
 export const BackSide: Side;
 export const DoubleSide: Side;
+export const TwoPassDoubleSide: Side;
 
 // blending modes
 export enum Blending {}

three/src/core/BufferAttribute.d.ts

@@ -6,6 +6,24 @@ import { Matrix4 } from './../math/Matrix4';
  * see {@link https://github.com/mrdoob/three.js/blob/master/src/core/BufferAttribute.js|src/core/BufferAttribute.js}
  */
 export class BufferAttribute {
+    /**
+     * @param array - Must be a TypedArray. Used to instantiate the buffer.
+     * This array should have
+     * ```
+     * itemSize * numVertices
+     * ```
+     * elements, where numVertices is the number of vertices in the associated BufferGeometry.
+     * @param itemSize - the number of values of the array that should be associated with a particular vertex.
+     * For instance, if this attribute is storing a 3-component vector (such as a position, normal, or color),
+     * then itemSize should be 3.
+     * @param normalized - (optional) Applies to integer data only.
+     * Indicates how the underlying data in the buffer maps to the values in the GLSL code.
+     * For instance, if array is an instance of UInt16Array, and normalized is true,
+     * the values 0 - +65535 in the array data will be mapped to 0.0f - +1.0f in the GLSL attribute.
+     * An Int16Array (signed) would map from -32768 - +32767 to -1.0f - +1.0f.
+     * If normalized is false, the values will be converted to floats unmodified,
+     * i.e. 32767 becomes 32767.0f.
+     */
     constructor(array: ArrayLike<number>, itemSize: number, normalized?: boolean); // array parameter should be TypedArray.
 
     /**

three/src/core/Object3D.d.ts

@@ -372,8 +372,24 @@ export class Object3D<E extends BaseEvent = Event> extends EventDispatcher<E> {
      */
     getObjectByName(name: string): Object3D | undefined;
 
+    /**
+     * Searches through an object and its children, starting with the object itself,
+     * and returns the first with a property that matches the value given.
+     *
+     * @param name - the property name to search for.
+     * @param value - value of the given property.
+     */
     getObjectByProperty(name: string, value: any): Object3D | undefined;
 
+    /**
+     * Searches through an object and its children, starting with the object itself,
+     * and returns all the objects with a property that matches the value given.
+     *
+     * @param name - the property name to search for.
+     * @param value - value of the given property.
+     */
+    getObjectsByProperty(name: string, value: any): Object3D[];
+
     getWorldPosition(target: Vector3): Vector3;
     getWorldQuaternion(target: Quaternion): Quaternion;
     getWorldScale(target: Vector3): Vector3;

three/src/geometries/CircleGeometry.d.ts

@@ -2,10 +2,10 @@ import { BufferGeometry } from '../core/BufferGeometry';
 
 export class CircleGeometry extends BufferGeometry {
     /**
-     * @param [radius=1]
-     * @param [segments=8]
-     * @param [thetaStart=0]
-     * @param [thetaLength=Math.PI * 2]
+     * @param radius - Radius of the circle, default = 1.
+     * @param segments - Number of segments (triangles), minimum = 3, default = 32.
+     * @param thetaStart - Start angle for first segment, default = 0 (three o'clock position).
+     * @param thetaLength - The central angle, often called theta, of the circular sector. The default is 2*Pi, which makes for a complete circle.
      */
     constructor(radius?: number, segments?: number, thetaStart?: number, thetaLength?: number);
 

three/src/geometries/ConeGeometry.d.ts

@@ -2,13 +2,13 @@ import { CylinderGeometry } from './CylinderGeometry';
 
 export class ConeGeometry extends CylinderGeometry {
     /**
-     * @param [radius=1] — Radius of the cone base.
-     * @param [height=1] — Height of the cone.
-     * @param [radialSegments=8] — Number of segmented faces around the circumference of the cone.
-     * @param [heightSegments=1] — Number of rows of faces along the height of the cone.
-     * @param [openEnded=false] — A Boolean indicating whether the base of the cone is open or capped.
-     * @param [thetaStart=0]
-     * @param [thetaLength=Math.PI * 2]
+     * @param radius - Radius of the cone base. Default is 1.
+     * @param height - Height of the cone. Default is 1.
+     * @param radialSegments - Number of segmented faces around the circumference of the cone. Default is 32
+     * @param heightSegments - Number of rows of faces along the height of the cone. Default is 1.
+     * @param openEnded - A Boolean indicating whether the base of the cone is open or capped. Default is false, meaning capped.
+     * @param thetaStart - Start angle for first segment, default = 0 (three o'clock position).
+     * @param thetaLength - The central angle, often called theta, of the circular sector. The default is 2*Pi, which makes for a complete cone.
      */
     constructor(
         radius?: number,

three/src/geometries/CylinderGeometry.d.ts

@@ -2,14 +2,14 @@ import { BufferGeometry } from '../core/BufferGeometry';
 
 export class CylinderGeometry extends BufferGeometry {
     /**
-     * @param [radiusTop=1] — Radius of the cylinder at the top.
-     * @param [radiusBottom=1] — Radius of the cylinder at the bottom.
-     * @param [height=1] — Height of the cylinder.
-     * @param [radialSegments=8] — Number of segmented faces around the circumference of the cylinder.
-     * @param [heightSegments=1] — Number of rows of faces along the height of the cylinder.
-     * @param [openEnded=false] - A Boolean indicating whether or not to cap the ends of the cylinder.
-     * @param [thetaStart=0]
-     * @param [thetaLength=Math.PI * 2]
+     * @param radiusTop - Radius of the cylinder at the top. Default is 1.
+     * @param radiusBottom - Radius of the cylinder at the bottom. Default is 1.
+     * @param height - Height of the cylinder. Default is 1.
+     * @param radialSegments - Number of segmented faces around the circumference of the cylinder. Default is 32
+     * @param heightSegments - Number of rows of faces along the height of the cylinder. Default is 1.
+     * @param openEnded - A Boolean indicating whether the ends of the cylinder are open or capped. Default is false, meaning capped.
+     * @param thetaStart - Start angle for first segment, default = 0 (three o'clock position).
+     * @param thetaLength - The central angle, often called theta, of the circular sector. The default is 2*Pi, which makes for a complete cylinder.
      */
     constructor(
         radiusTop?: number,

three/src/geometries/RingGeometry.d.ts

@@ -2,12 +2,12 @@ import { BufferGeometry } from './../core/BufferGeometry';
 
 export class RingGeometry extends BufferGeometry {
     /**
-     * @param [innerRadius=0.5]
-     * @param [outerRadius=1]
-     * @param [thetaSegments=8]
-     * @param [phiSegments=1]
-     * @param [thetaStart=0]
-     * @param [thetaLength=Math.PI * 2]
+     * @param innerRadius - Default is 0.5.
+     * @param outerRadius - Default is 1.
+     * @param thetaSegments - Number of segments. A higher number means the ring will be more round. Minimum is 3. Default is 32.
+     * @param phiSegments - Minimum is 1. Default is 1.
+     * @param thetaStart - Starting angle. Default is 0.
+     * @param thetaLength - Central angle. Default is Math.PI * 2.
      */
     constructor(
         innerRadius?: number,

three/src/geometries/SphereGeometry.d.ts

@@ -2,13 +2,19 @@ import { BufferGeometry } from './../core/BufferGeometry';
 
 export class SphereGeometry extends BufferGeometry {
     /**
-     * @param [radius=50] — sphere radius. Default is 50.
-     * @param [widthSegments=8] — number of horizontal segments. Minimum value is 3, and the default is 8.
-     * @param [heightSegments=6] — number of vertical segments. Minimum value is 2, and the default is 6.
-     * @param [phiStart=0] — specify horizontal starting angle. Default is 0.
-     * @param [phiLength=Math.PI * 2] — specify horizontal sweep angle size. Default is Math.PI * 2.
-     * @param [thetaStart=0] — specify vertical starting angle. Default is 0.
-     * @param [thetaLength=Math.PI * 2] — specify vertical sweep angle size. Default is Math.PI.
+     * The geometry is created by sweeping and calculating vertexes
+     * around the Y axis (horizontal sweep) and the Z axis (vertical sweep).
+     * Thus, incomplete spheres (akin to `'sphere slices'`) can be created
+     * through the use of different values of phiStart, phiLength, thetaStart and thetaLength,
+     * in order to define the points in which we start (or end) calculating those vertices.
+     *
+     * @param [radius=50] - sphere radius. Default is 50.
+     * @param [widthSegments=8] - number of horizontal segments. Minimum value is 3, and the default is 32.
+     * @param [heightSegments=6] - number of vertical segments. Minimum value is 2, and the default is 16.
+     * @param [phiStart=0] - specify horizontal starting angle. Default is 0.
+     * @param [phiLength=Math.PI * 2] - specify horizontal sweep angle size. Default is Math.PI * 2.
+     * @param [thetaStart=0] - specify vertical starting angle. Default is 0.
+     * @param [thetaLength=Math.PI * 2] - specify vertical sweep angle size. Default is Math.PI.
      */
     constructor(
         radius?: number,

three/src/geometries/TorusGeometry.d.ts

@@ -2,11 +2,11 @@ import { BufferGeometry } from './../core/BufferGeometry';
 
 export class TorusGeometry extends BufferGeometry {
     /**
-     * @param [radius=1]
-     * @param [tube=0.4]
-     * @param [radialSegments=8]
-     * @param [tubularSegments=6]
-     * @param [arc=Math.PI * 2]
+     * @param radius - Radius of the torus, from the center of the torus to the center of the tube. Default is 1.
+     * @param tube - Radius of the tube. Default is 0.4.
+     * @param radialSegments - Default is 12
+     * @param tubularSegments - Default is 48.
+     * @param arc - Central angle. Default is Math.PI * 2.
      */
     constructor(radius?: number, tube?: number, radialSegments?: number, tubularSegments?: number, arc?: number);
 

three/src/lights/PointLight.d.ts

@@ -28,6 +28,14 @@ export class PointLight extends Light {
      */
     distance: number;
 
+    /**
+     * If set to `true` light will cast dynamic shadows.
+     * **Warning**: This is expensive and requires tweaking to get shadows looking right.
+     * See the {@link PointLightShadow} for details.
+     * The default is `false`.
+     */
+    castShadow: boolean;
+
     /**
      * @default 1
      */

three/src/loaders/ObjectLoader.d.ts

@@ -6,37 +6,37 @@ import { Material } from './../materials/Material';
 import { AnimationClip } from './../animation/AnimationClip';
 import { InstancedBufferGeometry } from '../core/InstancedBufferGeometry';
 import { BufferGeometry } from '../core/BufferGeometry';
+import { Source } from '../textures/Source';
 
 export class ObjectLoader extends Loader {
     constructor(manager?: LoadingManager);
 
     load(
         url: string,
-        // eslint-disable-next-line no-unnecessary-generics
-        onLoad?: <ObjectType extends Object3D>(object: ObjectType) => void,
+        onLoad?: (object: Object3D) => void,
         onProgress?: (event: ProgressEvent) => void,
         onError?: (event: Error | ErrorEvent) => void,
     ): void;
     loadAsync<ObjectType extends Object3D>(
         url: string,
         onProgress?: (event: ProgressEvent) => void,
-    ): // eslint-disable-next-line no-unnecessary-generics
+    ): // tslint:disable-next-line:no-unnecessary-generics
     Promise<ObjectType>;
-    // eslint-disable-next-line no-unnecessary-generics
+    // tslint:disable-next-line:no-unnecessary-generics
     parse<T extends Object3D>(json: any, onLoad?: (object: Object3D) => void): T;
-    // eslint-disable-next-line no-unnecessary-generics
+    // tslint: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.
+    parseMaterials(json: any, textures: { [key: string]: Texture }): Material[]; // Array of Classes that inherits from Matrial.
     parseAnimations(json: any): AnimationClip[];
-    parseImages(json: any, onLoad: () => void): { [key: string]: HTMLImageElement };
-    parseImagesAsync(json: any): Promise<{ [key: string]: HTMLImageElement }>;
+    parseImages(json: any, onLoad?: () => void): { [key: string]: Source };
+    parseImagesAsync(json: any): Promise<{ [key: string]: Source }>;
     parseTextures(json: any, images: any): Texture[];
     parseObject<T extends Object3D>(
         data: any,
         geometries: any[],
         materials: Material[],
         animations: AnimationClip[],
-    ): // eslint-disable-next-line no-unnecessary-generics
+    ): // tslint:disable-next-line:no-unnecessary-generics
     T;
 }

three/src/objects/Mesh.d.ts

@@ -3,6 +3,7 @@ import { Raycaster } from './../core/Raycaster';
 import { Object3D } from './../core/Object3D';
 import { BufferGeometry } from '../core/BufferGeometry';
 import { Intersection } from '../core/Raycaster';
+import { Vector3 } from '../math/Vector3';
 
 export class Mesh<
     TGeometry extends BufferGeometry = BufferGeometry,
@@ -18,5 +19,12 @@ export class Mesh<
     type: string;
 
     updateMorphTargets(): void;
+
+    /**
+     * Get the current position of the indicated vertex in local space,
+     * taking into account the current animation state of both morph targets and skinning.
+     */
+    getVertexPosition(vert: number, target: Vector3): Vector3;
+
     raycast(raycaster: Raycaster, intersects: Intersection[]): void;
 }