@types/three 0.144.0 → 0.147.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, 02 Sep 2022 10:02:40 GMT
+ * Last updated: Thu, 29 Dec 2022 19:32:53 GMT
  * Dependencies: [@types/webxr](https://npmjs.com/package/@types/webxr)
  * Global values: `THREE`
 

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

@@ -1,13 +1,17 @@
-import { Object3D, SkinnedMesh } from '../../../src/Three';
+import { Object3D, SkinnedMesh, Vector3 } from '../../../src/Three';
 
 // tslint:disable-next-line:interface-name
 export interface IKS {
     effector: number;
     iteration: number;
-    links: {
+    links: Array<{
         enabled: boolean;
         index: number;
-    };
+        limitation?: Vector3;
+        rotationMin?: Vector3;
+        rotationMax?: Vector3;
+    }>;
+    minAngle: number;
     maxAngle: number;
     target: number;
 }
@@ -21,5 +25,6 @@ export class CCDIKSolver {
 }
 
 export class CCDIKHelper extends Object3D {
-    constructor(mesh: SkinnedMesh, iks: IKS[]);
+    constructor(mesh: SkinnedMesh, iks?: IKS[], sphereSize?: number);
+    dispose(): void;
 }

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

@@ -115,5 +115,10 @@ export class Constraint {
 }
 
 export class MMDPhysicsHelper extends Object3D {
-    constructor();
+    mesh: THREE.SkinnedMesh;
+    physics: MMDPhysics;
+    materials: [THREE.MeshBasicMaterial, THREE.MeshBasicMaterial, THREE.MeshBasicMaterial];
+
+    constructor(mesh: THREE.SkinnedMesh, physics: MMDPhysics);
+    dispose(): void;
 }

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

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

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

@@ -23,4 +23,5 @@ export class CSMHelper<TCSM extends CSM = CSM> extends Group {
     shadowLines: Box3Helper[];
     updateVisibility(): void;
     update(): void;
+    dispose(): void;
 }

three/examples/jsm/helpers/OctreeHelper.d.ts

@@ -11,4 +11,7 @@ export class OctreeHelper extends LineSegments {
      * @default 'OctreeHelper'
      */
     type: 'OctreeHelper' | string;
+
+    update(): void;
+    dispose(): void;
 }

three/examples/jsm/helpers/VertexNormalsHelper.d.ts

@@ -7,4 +7,6 @@ export class VertexNormalsHelper extends LineSegments {
     size: number;
 
     update(): void;
+
+    dispose(): void;
 }

three/examples/jsm/helpers/VertexTangentsHelper.d.ts

@@ -7,4 +7,6 @@ export class VertexTangentsHelper extends LineSegments {
     size: number;
 
     update(): void;
+
+    dispose(): void;
 }

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

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

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

@@ -11,5 +11,5 @@ export class PCDLoader extends Loader {
         onError?: (event: ErrorEvent) => void,
     ): void;
     loadAsync(url: string, onProgress?: (event: ProgressEvent) => void): Promise<Points>;
-    parse(data: ArrayBuffer | string, url: string): Points;
+    parse(data: ArrayBuffer | string): Points;
 }

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

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

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

@@ -7,7 +7,6 @@ export interface RGBE {
     header: string;
     gamma: number;
     exposure: number;
-    format: PixelFormat;
     type: TextureDataType;
 }
 

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

@@ -0,0 +1,18 @@
+import { Loader, LoadingManager, Mesh } from '../../../src/Three';
+
+export class USDAParser {
+    parse(text: string): object;
+}
+
+export class USDZLoader extends Loader {
+    constructor(manager?: LoadingManager);
+
+    load(
+        url: string,
+        onLoad: (usdz: Mesh) => void,
+        onProgress?: (event: ProgressEvent) => void,
+        onError?: (event: ErrorEvent) => void,
+    ): void;
+
+    parse(buffer: ArrayBuffer | string): THREE.Group;
+}

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

@@ -18,7 +18,7 @@ import NodeFunctionInput from './core/NodeFunctionInput';
 import NodeKeywords from './core/NodeKeywords';
 import NodeUniform from './core/NodeUniform';
 import NodeVar from './core/NodeVar';
-import NodeVary from './core/NodeVary';
+import NodeVarying from './core/NodeVarying';
 import PropertyNode from './core/PropertyNode';
 import TempNode from './core/TempNode';
 import UniformNode from './core/UniformNode';
@@ -26,6 +26,7 @@ import VarNode from './core/VarNode';
 import VaryNode from './core/VaryNode';
 
 // accessors
+import BitangentNode, { BitangentNodeScope } from './accessors/BitangentNode';
 import BufferNode from './accessors/BufferNode';
 import CameraNode, { CameraNodeScope } from './accessors/CameraNode';
 import CubeTextureNode from './accessors/CubeTextureNode';
@@ -41,6 +42,7 @@ import PositionNode, { PositionNodeScope } from './accessors/PositionNode';
 import ReferenceNode from './accessors/ReferenceNode';
 import ReflectVectorNode from './accessors/ReflectVectorNode';
 import SkinningNode from './accessors/SkinningNode';
+import TangentNode, { TangentNodeScope } from './accessors/TangentNode';
 import TextureNode from './accessors/TextureNode';
 import UVNode from './accessors/UVNode';
 import UserDataNode from './accessors/UserDataNode';
@@ -52,11 +54,14 @@ import RangeNode, { RangeModeBound } from './geometry/RangeNode';
 import ComputeNode from './gpgpu/ComputeNode';
 
 // display
+import BlendModeNode, { BlendMode } from './display/BlendModeNode';
 import ColorAdjustmentNode, { ColorAdjustmentMethod } from './display/ColorAdjustmentNode';
 import ColorSpaceNode, { ColorSpaceNodeMethod } from './display/ColorSpaceNode';
 import FrontFacingNode from './display/FrontFacingNode';
 import NormalMapNode from './display/NormalMapNode';
+import PosterizeNode from './display/PosterizeNode';
 import ToneMappingNode from './display/ToneMappingNode';
+import ViewportNode from './display/ViewportNode';
 
 // math
 import MathNode, { MathNodeMethod1, MathNodeMethod2, MathNodeMethod3, MathNodeMethod } from './math/MathNode';
@@ -77,14 +82,17 @@ import AnalyticLightNode from './lighting/AnalyticLightNode';
 
 import ArrayElementNode from './utils/ArrayElementNode';
 import ConvertNode from './utils/ConvertNode';
+import EquirectUVNode from './utils/EquirectUVNode';
 import JoinNode from './utils/JoinNode';
 import MatcapUVNode from './utils/MatcapUVNode';
 import MaxMipLevelNode from './utils/MaxMipLevelNode';
 import OscNode, { OscNodeMethod } from './utils/OscNode';
+import RemapNode from './utils/RemapNode';
 import RotateUVNode from './utils/RotateUVNode';
 import SplitNode from './utils/SplitNode';
 import SpriteSheetUVNode from './utils/SpriteSheetUVNode';
 import TimerNode, { TimerNodeScope } from './utils/TimerNode';
+import TriplanarTexturesNode from './utils/TriplanarTexturesNode';
 
 // loaders
 import NodeLoader from './loaders/NodeLoader';
@@ -129,7 +137,7 @@ export {
     NodeKeywords,
     NodeUniform,
     NodeVar,
-    NodeVary,
+    NodeVarying,
     PropertyNode,
     TempNode,
     UniformNode,
@@ -141,6 +149,8 @@ export {
     // gpgpu
     ComputeNode,
     // accessors
+    BitangentNode,
+    BitangentNodeScope,
     BufferNode,
     CameraNode,
     CameraNodeScope,
@@ -161,17 +171,23 @@ export {
     ReferenceNode,
     ReflectVectorNode,
     SkinningNode,
+    TangentNode,
+    TangentNodeScope,
     TextureNode,
     UVNode,
     UserDataNode,
     // display
+    BlendModeNode,
+    BlendMode,
     ColorAdjustmentNode,
     ColorAdjustmentMethod,
     ColorSpaceNode,
     ColorSpaceNodeMethod,
     FrontFacingNode,
     NormalMapNode,
+    PosterizeNode,
     ToneMappingNode,
+    ViewportNode,
     // math
     MathNode,
     MathNodeMethod1,
@@ -194,16 +210,19 @@ export {
     // utils
     ArrayElementNode,
     ConvertNode,
+    EquirectUVNode,
     JoinNode,
     MatcapUVNode,
     MaxMipLevelNode,
     OscNode,
     OscNodeMethod,
+    RemapNode,
     RotateUVNode,
     SplitNode,
     SpriteSheetUVNode,
     TimerNode,
     TimerNodeScope,
+    TriplanarTexturesNode,
     // procedural
     CheckerNode,
     // fog

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

@@ -0,0 +1,18 @@
+import Node from '../core/Node';
+
+export type BitangentNodeScope =
+    | typeof BitangentNode.LOCAL
+    | typeof BitangentNode.VIEW
+    | typeof BitangentNode.WORLD
+    | typeof BitangentNode.GEOMETRY;
+
+export default class BitangentNode extends Node {
+    static GEOMETRY: 'geometry';
+    static LOCAL: 'local';
+    static VIEW: 'view';
+    static WORLD: 'world';
+
+    scope: BitangentNodeScope;
+
+    constructor(scope?: BitangentNodeScope);
+}

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

@@ -1,15 +1,10 @@
 import Node from '../core/Node';
 
-export type NormalNodeScope =
-    | typeof NormalNode.GEOMETRY
-    | typeof NormalNode.LOCAL
-    | typeof NormalNode.WORLD
-    | typeof NormalNode.VIEW;
+export type NormalNodeScope = typeof NormalNode.GEOMETRY | typeof NormalNode.LOCAL | typeof NormalNode.VIEW;
 
 export default class NormalNode extends Node {
     static GEOMETRY: 'geometry';
     static LOCAL: 'local';
-    static WORLD: 'world';
     static VIEW: 'view';
     scope: NormalNodeScope;
 

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

@@ -4,6 +4,7 @@ export type PositionNodeScope =
     | typeof PositionNode.GEOMETRY
     | typeof PositionNode.LOCAL
     | typeof PositionNode.WORLD
+    | typeof PositionNode.WORLD_DIRECTION
     | typeof PositionNode.VIEW
     | typeof PositionNode.VIEW_DIRECTION;
 
@@ -11,6 +12,7 @@ export default class PositionNode extends Node {
     static GEOMETRY: 'geometry';
     static LOCAL: 'local';
     static WORLD: 'world';
+    static WORLD_DIRECTION: 'worldDirection';
     static VIEW: 'view';
     static VIEW_DIRECTION: 'viewDirection';
     scope: PositionNodeScope;

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

@@ -0,0 +1,18 @@
+import Node from '../core/Node.js';
+
+export type TangentNodeScope =
+    | typeof TangentNode.LOCAL
+    | typeof TangentNode.VIEW
+    | typeof TangentNode.WORLD
+    | typeof TangentNode.GEOMETRY;
+
+export default class TangentNode extends Node {
+    static GEOMETRY: 'geometry';
+    static LOCAL: 'local';
+    static VIEW: 'view';
+    static WORLD: 'world';
+
+    scope: TangentNodeScope;
+
+    constructor(scope?: TangentNodeScope);
+}

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

@@ -17,7 +17,7 @@ import NodeAttribute from './NodeAttribute';
 import NodeParser from './NodeParser';
 import NodeUniform from './NodeUniform';
 import NodeVar from './NodeVar';
-import NodeVary from './NodeVary';
+import NodeVarying from './NodeVarying';
 
 export type BuildStageOption = 'construct' | 'analyze' | 'generate';
 
@@ -74,6 +74,10 @@ export default abstract class NodeBuilder {
 
     abstract getFrontFacing(): string;
 
+    abstract getFragCoord(): string;
+
+    isFlipY(): boolean;
+
     abstract getTexture(textureProperty: string, uvSnippet: string): string;
 
     abstract getTextureLevel(textureProperty: string, uvSnippet: string, levelSnippet: string): string;
@@ -82,7 +86,7 @@ export default abstract class NodeBuilder {
     abstract getCubeTextureLevel(textureProperty: string, uvSnippet: string, levelSnippet: string): string;
 
     // @TODO: rename to .generateConst()
-    getConst(type: NodeTypeOption, value: unknown): Node;
+    getConst(type: NodeTypeOption, value?: unknown): Node;
     getType(type: NodeTypeOption): NodeTypeOption;
 
     generateMethod(method: string): string;
@@ -105,7 +109,7 @@ export default abstract class NodeBuilder {
     getNodeProperties(node: Node, shaderStage?: NodeShaderStageOption): AnyObject;
     getUniformFromNode(node: Node, shaderStage: NodeShaderStageOption, type: NodeTypeOption): NodeUniform;
     getVarFromNode(node: Node, type: NodeTypeOption, shaderStage?: NodeShaderStageOption): NodeVar;
-    getVaryFromNode(node: Node, type: NodeTypeOption): NodeVary;
+    getVaryFromNode(node: Node, type: NodeTypeOption): NodeVarying;
     getCodeFromNode(node: Node, type: NodeTypeOption, shaderStage?: NodeShaderStageOption): string;
     addFlowCode(code: string): void;
     getFlowData(node: Node, shaderStage: NodeShaderStageOption): FlowData;
@@ -117,6 +121,7 @@ export default abstract class NodeBuilder {
         output?: string | null,
         propertyName?: string,
     ): FlowData;
+    hasGeometryAttribute(name: string): boolean;
     abstract getAttributes(shaderStage: NodeShaderStageOption): string;
     abstract getVarys(shaderStage: NodeShaderStageOption): string;
     getVars(shaderStage: NodeShaderStageOption): string;

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

@@ -0,0 +1,8 @@
+import NodeVar from './NodeVar';
+
+export default class NodeVarying extends NodeVar {
+    needsInterpolation: false;
+    isNodeVarying: true;
+
+    constructor(name: string, type: string);
+}