@types/three 0.141.0 → 0.143.1

three/README.md

@@ -8,7 +8,7 @@ This package contains type definitions for three (https://threejs.org/).
 Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/three.
 
 ### Additional Details
- * Last updated: Tue, 31 May 2022 18:31:37 GMT
+ * Last updated: Wed, 17 Aug 2022 12:32:25 GMT
  * Dependencies: [@types/webxr](https://npmjs.com/package/@types/webxr)
  * Global values: `THREE`
 

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

@@ -4,7 +4,7 @@ export class FirstPersonControls {
     constructor(object: Camera, domElement?: HTMLElement);
 
     object: Camera;
-    domElement: HTMLElement | HTMLDocument;
+    domElement: HTMLElement | Document;
 
     enabled: boolean;
     movementSpeed: number;

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

@@ -4,7 +4,7 @@ export class FlyControls extends EventDispatcher {
     constructor(object: Camera, domElement?: HTMLElement);
 
     object: Camera;
-    domElement: HTMLElement | HTMLDocument;
+    domElement: HTMLElement | Document;
 
     movementSpeed: number;
     rollSpeed: number;

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

@@ -4,7 +4,7 @@ export class OrbitControls {
     constructor(object: Camera, domElement?: HTMLElement);
 
     object: Camera;
-    domElement: HTMLElement | HTMLDocument;
+    domElement: HTMLElement | Document;
 
     // API
     enabled: boolean;
@@ -43,8 +43,8 @@ export class OrbitControls {
     autoRotateSpeed: number;
 
     keys: { LEFT: string; UP: string; RIGHT: string; BOTTOM: string };
-    mouseButtons: { LEFT: MOUSE; MIDDLE: MOUSE; RIGHT: MOUSE };
-    touches: { ONE: TOUCH; TWO: TOUCH };
+    mouseButtons: Partial<{ LEFT: MOUSE; MIDDLE: MOUSE; RIGHT: MOUSE }>;
+    touches: Partial<{ ONE: TOUCH; TWO: TOUCH }>;
 
     target0: Vector3;
     position0: Vector3;

three/examples/jsm/curves/NURBSUtils.d.ts

@@ -1,22 +1,20 @@
 import { Vector3, Vector4 } from '../../../src/Three';
 
-export namespace NURBSUtils {
-    function findSpan(p: number, u: number, U: number[]): number;
-    function calcBasisFunctions(span: number, u: number, p: number, U: number[]): number[];
-    function calcBSplinePoint(p: number, U: number[], P: Vector4[], u: number): Vector4;
-    function calcBasisFunctionDerivatives(span: number, u: number, p: number, n: number, U: number[]): number[][];
-    function calcBSplineDerivatives(p: number, U: number[], P: Vector4[], u: number, nd: number): Vector4[];
-    function calcKoverI(k: number, i: number): number;
-    function calcRationalCurveDerivatives(Pders: Vector4[]): Vector3[];
-    function calcNURBSDerivatives(p: number, U: number[], P: Vector4[], u: number, nd: number): Vector3[];
-    function calcSurfacePoint(
-        p: number,
-        q: number,
-        U: number[],
-        V: number[],
-        P: Vector4[],
-        u: number,
-        v: number,
-        target: Vector3,
-    ): Vector3;
-}
+export function findSpan(p: number, u: number, U: number[]): number;
+export function calcBasisFunctions(span: number, u: number, p: number, U: number[]): number[];
+export function calcBSplinePoint(p: number, U: number[], P: Vector4[], u: number): Vector4;
+export function calcBasisFunctionDerivatives(span: number, u: number, p: number, n: number, U: number[]): number[][];
+export function calcBSplineDerivatives(p: number, U: number[], P: Vector4[], u: number, nd: number): Vector4[];
+export function calcKoverI(k: number, i: number): number;
+export function calcRationalCurveDerivatives(Pders: Vector4[]): Vector3[];
+export function calcNURBSDerivatives(p: number, U: number[], P: Vector4[], u: number, nd: number): Vector3[];
+export function calcSurfacePoint(
+    p: number,
+    q: number,
+    U: number[],
+    V: number[],
+    P: Vector4[],
+    u: number,
+    v: number,
+    target: Vector3,
+): Vector3;

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

@@ -65,7 +65,7 @@ export class GLTFLoader extends Loader {
         onError?: (event: ErrorEvent) => void,
     ): void;
 
-    parseAsync(data: ArrayBuffer | string, path: string): Promise<void>;
+    parseAsync(data: ArrayBuffer | string, path: string): Promise<GLTF>;
 }
 
 export type GLTFReferenceType = 'materials' | 'nodes' | 'textures' | 'meshes';

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

@@ -0,0 +1,215 @@
+// core
+import ArrayUniformNode from './core/ArrayUniformNode';
+import AttributeNode from './core/AttributeNode';
+import BypassNode from './core/BypassNode';
+import CodeNode, { CodeNodeInclude } from './core/CodeNode';
+import ConstNode from './core/ConstNode';
+import ContextNode from './core/ContextNode';
+import ExpressionNode from './core/ExpressionNode';
+import FunctionCallNode from './core/FunctionCallNode';
+import FunctionNode from './core/FunctionNode';
+import InstanceIndexNode from './core/InstanceIndexNode';
+import Node from './core/Node';
+import NodeAttribute from './core/NodeAttribute';
+import NodeBuilder from './core/NodeBuilder';
+import NodeCode from './core/NodeCode';
+import NodeFrame from './core/NodeFrame';
+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 PropertyNode from './core/PropertyNode';
+import TempNode from './core/TempNode';
+import UniformNode from './core/UniformNode';
+import VarNode from './core/VarNode';
+import VaryNode from './core/VaryNode';
+
+// accessors
+import BufferNode from './accessors/BufferNode';
+import CameraNode, { CameraNodeScope } from './accessors/CameraNode';
+import CubeTextureNode from './accessors/CubeTextureNode';
+import InstanceNode from './accessors/InstanceNode';
+import MaterialNode, { MaterialNodeScope } from './accessors/MaterialNode';
+import MaterialReferenceNode from './accessors/MaterialReferenceNode';
+import ModelNode from './accessors/ModelNode';
+import ModelViewProjectionNode from './accessors/ModelViewProjectionNode';
+import NormalNode, { NormalNodeScope } from './accessors/NormalNode';
+import Object3DNode, { Object3DNodeScope } from './accessors/Object3DNode';
+import PointUVNode from './accessors/PointUVNode';
+import PositionNode, { PositionNodeScope } from './accessors/PositionNode';
+import ReferenceNode from './accessors/ReferenceNode';
+import ReflectVectorNode from './accessors/ReflectVectorNode';
+import SkinningNode from './accessors/SkinningNode';
+import TextureNode from './accessors/TextureNode';
+import UVNode from './accessors/UVNode';
+import UserDataNode from './accessors/UserDataNode';
+
+// geometry
+import RangeNode, { RangeModeBound } from './geometry/RangeNode';
+
+// gpgpu
+import ComputeNode from './gpgpu/ComputeNode';
+
+// display
+import ColorAdjustmentNode, { ColorAdjustmentMethod } from './display/ColorAdjustmentNode';
+import ColorSpaceNode, { ColorSpaceNodeMethod } from './display/ColorSpaceNode';
+import FrontFacingNode from './display/FrontFacingNode';
+import NormalMapNode from './display/NormalMapNode';
+import ToneMappingNode from './display/ToneMappingNode';
+
+// math
+import MathNode, { MathNodeMethod1, MathNodeMethod2, MathNodeMethod3, MathNodeMethod } from './math/MathNode';
+import OperatorNode, { OperatorNodeOp } from './math/OperatorNode';
+import CondNode from './math/CondNode';
+
+// lighting
+import PunctualLightNode from './lighting/PunctualLightNode';
+import LightsNode from './lighting/LightsNode';
+import LightingNode from './lighting/LightingNode';
+import LightingContextNode, { LightingModelNode } from './lighting/LightingContextNode';
+import HemisphereLightNode from './lighting/HemisphereLightNode';
+import EnvironmentNode from './lighting/EnvironmentNode';
+import AONode from './lighting/AONode';
+import AnalyticLightNode from './lighting/AnalyticLightNode';
+
+// utils
+
+import ArrayElementNode from './utils/ArrayElementNode';
+import ConvertNode from './utils/ConvertNode';
+import JoinNode from './utils/JoinNode';
+import MatcapUVNode from './utils/MatcapUVNode';
+import MaxMipLevelNode from './utils/MaxMipLevelNode';
+import OscNode, { OscNodeMethod } from './utils/OscNode';
+import RotateUVNode from './utils/RotateUVNode';
+import SplitNode from './utils/SplitNode';
+import SpriteSheetUVNode from './utils/SpriteSheetUVNode';
+import TimerNode, { TimerNodeScope } from './utils/TimerNode';
+
+// loaders
+import NodeLoader from './loaders/NodeLoader';
+import NodeObjectLoader from './loaders/NodeObjectLoader';
+import NodeMaterialLoader from './loaders/NodeMaterialLoader';
+
+// procedural
+import CheckerNode from './procedural/CheckerNode';
+// fog
+import FogNode from './fog/FogNode';
+import FogRangeNode from './fog/FogRangeNode';
+
+// core
+export * from './core/constants';
+
+// materials
+export * from './materials/Materials';
+
+// shader node
+export * from './shadernode/ShaderNodeElements';
+
+export {
+    // core
+    ArrayUniformNode,
+    AttributeNode,
+    BypassNode,
+    CodeNode,
+    CodeNodeInclude,
+    ContextNode,
+    ConstNode,
+    ExpressionNode,
+    FunctionCallNode,
+    FunctionNode,
+    InstanceIndexNode,
+    Node,
+    NodeAttribute,
+    NodeBuilder,
+    NodeCode,
+    NodeFrame,
+    NodeFunctionInput,
+    NodeKeywords,
+    NodeUniform,
+    NodeVar,
+    NodeVary,
+    PropertyNode,
+    TempNode,
+    UniformNode,
+    VarNode,
+    VaryNode,
+    // geometry
+    RangeNode,
+    RangeModeBound,
+    // gpgpu
+    ComputeNode,
+    // accessors
+    BufferNode,
+    CameraNode,
+    CameraNodeScope,
+    CubeTextureNode,
+    InstanceNode,
+    MaterialNode,
+    MaterialNodeScope,
+    MaterialReferenceNode,
+    ModelNode,
+    ModelViewProjectionNode,
+    NormalNode,
+    NormalNodeScope,
+    Object3DNode,
+    Object3DNodeScope as OObject3DNodeScope,
+    PointUVNode,
+    PositionNode,
+    PositionNodeScope,
+    ReferenceNode,
+    ReflectVectorNode,
+    SkinningNode,
+    TextureNode,
+    UVNode,
+    UserDataNode,
+    // display
+    ColorAdjustmentNode,
+    ColorAdjustmentMethod,
+    ColorSpaceNode,
+    ColorSpaceNodeMethod,
+    FrontFacingNode,
+    NormalMapNode,
+    ToneMappingNode,
+    // math
+    MathNode,
+    MathNodeMethod1,
+    MathNodeMethod2,
+    MathNodeMethod3,
+    MathNodeMethod,
+    OperatorNode,
+    OperatorNodeOp,
+    CondNode,
+    // lighting
+    PunctualLightNode,
+    LightsNode,
+    LightingNode,
+    LightingContextNode,
+    LightingModelNode,
+    HemisphereLightNode,
+    EnvironmentNode,
+    AONode,
+    AnalyticLightNode,
+    // utils
+    ArrayElementNode,
+    ConvertNode,
+    JoinNode,
+    MatcapUVNode,
+    MaxMipLevelNode,
+    OscNode,
+    OscNodeMethod,
+    RotateUVNode,
+    SplitNode,
+    SpriteSheetUVNode,
+    TimerNode,
+    TimerNodeScope,
+    // procedural
+    CheckerNode,
+    // fog
+    FogNode,
+    FogRangeNode,
+    // loaders
+    NodeLoader,
+    NodeObjectLoader,
+    NodeMaterialLoader,
+};

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

@@ -0,0 +1,11 @@
+import { NodeTypeOption } from '../core/constants';
+import UniformNode from '../core/UniformNode';
+
+export default class BufferNode extends UniformNode {
+    isBufferNode: true;
+
+    bufferType: string;
+    bufferCount: number;
+
+    constructor(value: ArrayLike<number>, bufferType: NodeTypeOption, bufferCount?: number);
+}

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

@@ -0,0 +1,12 @@
+import Object3DNode, { Object3DNodeScope } from './Object3DNode';
+
+export type CameraNodeScope = Object3DNodeScope | typeof CameraNode.PROJECTION_MATRIX;
+
+export default class CameraNode extends Object3DNode {
+    static PROJECTION_MATRIX: 'projectionMatrix';
+
+    // @ts-expect-error
+    scope: CameraNodeScope;
+
+    constructor(scope?: CameraNodeScope);
+}

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

@@ -0,0 +1,11 @@
+import TextureNode from './TextureNode';
+import { Node } from '../Nodes';
+import { CubeTexture } from '../../../../src/Three';
+
+export default class CubeTextureNode extends TextureNode {
+    isCubeTextureNode: boolean;
+    uvNode: Node | null;
+    levelNode: Node | null;
+
+    constructor(value: CubeTexture, uvNode?: Node | null, levelNode?: Node | null);
+}

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

@@ -0,0 +1,9 @@
+import { InstancedMesh } from '../../../../src/Three';
+import Node from '../core/Node';
+
+export default class InstanceNode extends Node {
+    instanceMesh: InstancedMesh;
+    instanceMatrixNode: Node;
+
+    constructor(instanceMesh: InstancedMesh);
+}

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

@@ -0,0 +1,23 @@
+import Node from '../core/Node';
+
+export type MaterialNodeScope =
+    | typeof MaterialNode.ALPHA_TEST
+    | typeof MaterialNode.COLOR
+    | typeof MaterialNode.OPACITY
+    | typeof MaterialNode.ROUGHNESS
+    | typeof MaterialNode.METALNESS
+    | typeof MaterialNode.EMISSIVE
+    | typeof MaterialNode.ROTATION;
+
+export default class MaterialNode extends Node {
+    static ALPHA_TEST: 'alphaTest';
+    static COLOR: 'color';
+    static OPACITY: 'opacity';
+    static ROUGHNESS: 'roughness';
+    static METALNESS: 'metalness';
+    static EMISSIVE: 'emissive';
+    static ROTATION: 'rotation';
+
+    scope: MaterialNodeScope;
+    constructor(scope?: MaterialNodeScope);
+}

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

@@ -0,0 +1,6 @@
+import { Material } from '../../../../src/Three';
+import ReferenceNode from './ReferenceNode';
+
+export default class MaterialReferenceNode extends ReferenceNode<Material | null> {
+    constructor(property: string, inputType: string, material?: Material | null);
+}

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

@@ -0,0 +1,9 @@
+import { NodeFrame } from '../Nodes';
+import Object3DNode, { Object3DNodeScope } from './Object3DNode';
+
+/**
+ * Similar to {@link Object3DNode} but the object comes from {@link NodeFrame}
+ */
+export default class ModelNode extends Object3DNode {
+    constructor(scope?: Object3DNodeScope);
+}

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

@@ -0,0 +1,6 @@
+import Node from '../core/Node';
+import PositionNode from './PositionNode';
+
+export default class ModelViewProjectionNode extends Node {
+    constructor(position?: PositionNode);
+}

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

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

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

@@ -0,0 +1,22 @@
+import { Object3D } from '../../../../src/Three';
+import Node from '../core/Node';
+
+export type Object3DNodeScope =
+    | typeof Object3DNode.VIEW_MATRIX
+    | typeof Object3DNode.NORMAL_MATRIX
+    | typeof Object3DNode.WORLD_MATRIX
+    | typeof Object3DNode.POSITION
+    | typeof Object3DNode.VIEW_POSITION;
+
+export default class Object3DNode extends Node {
+    static VIEW_MATRIX: 'viewMatrix';
+    static NORMAL_MATRIX: 'normalMatrix';
+    static WORLD_MATRIX: 'worldMatrix';
+    static POSITION: 'position';
+    static VIEW_POSITION: 'viewPosition';
+
+    scope: Object3DNodeScope;
+    object3d: Object3D | null;
+
+    constructor(scope?: Object3DNodeScope, object3d?: Object3D | null);
+}

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

@@ -0,0 +1,7 @@
+import Node from '../core/Node';
+
+export default class PointUVNode extends Node {
+    isPointUVNode: true;
+
+    constructor();
+}

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

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

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

@@ -0,0 +1,13 @@
+import Node from '../core/Node';
+import { NodeTypeOption } from '../Nodes';
+
+export default class ReferenceNode<T> extends Node {
+    object: T;
+    property: string;
+    uniformType: string;
+    node: Node | null;
+
+    constructor(property: string, uniformType: NodeTypeOption, object?: T | null);
+
+    setNodeType(uniformType: NodeTypeOption): void;
+}

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

@@ -0,0 +1,8 @@
+import Node from '../core/Node';
+
+export default class ReflectVectorNode extends Node {
+    constructor();
+
+    getHash(): 'reflectVector';
+    construct(): Node;
+}

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

@@ -0,0 +1,13 @@
+import { SkinnedMesh } from '../../../../src/Three';
+import Node from '../core/Node';
+
+export default class SkinningNode extends Node {
+    skinIndexNode: Node;
+    skinWeightNode: Node;
+
+    bindMatrixNode: Node;
+    bindMatrixInverseNode: Node;
+    boneMatricesNode: Node;
+
+    constructor(skinnedMesh: SkinnedMesh);
+}

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

@@ -0,0 +1,6 @@
+import { NodeTypeOption } from '../Nodes';
+import BufferNode from './BufferNode';
+
+export default class StorageBufferNode extends BufferNode {
+    constructor(value: ArrayLike<number>, bufferType: NodeTypeOption, bufferCount?: number);
+}

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

@@ -0,0 +1,12 @@
+import { Texture } from '../../../../src/Three';
+import UniformNode from '../core/UniformNode';
+import { Node } from '../Nodes';
+
+export default class TextureNode extends UniformNode {
+    isTextureNode: true;
+
+    uvNode: Node | null;
+    levelNode: Node | null;
+
+    constructor(value: Texture, uvNode?: Node, levelNode?: Node | null);
+}

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

@@ -0,0 +1,8 @@
+import AttributeNode from '../core/AttributeNode';
+
+export default class UVNode extends AttributeNode {
+    isUVNode: true;
+    index: number;
+
+    constructor(index?: number);
+}

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

@@ -0,0 +1,7 @@
+import { NodeTypeOption, NodeUserData } from '../core/constants';
+import ReferenceNode from './ReferenceNode';
+
+export default class UserDataNode extends ReferenceNode<NodeUserData> {
+    userData: NodeUserData | null;
+    constructor(property: string, inputType: NodeTypeOption, userData?: NodeUserData | null);
+}

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

@@ -0,0 +1,8 @@
+import UniformNode from './UniformNode';
+import Node from './Node';
+
+export default class ArrayUniformNode extends UniformNode {
+    isArrayUniformNode: true;
+    nodes: Node[];
+    constructor(nodes?: Node[]);
+}

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

@@ -0,0 +1,9 @@
+import { NodeTypeOption } from './constants';
+import Node from './Node';
+import NodeBuilder from './NodeBuilder';
+
+export default class AttributeNode extends Node {
+    constructor(attributeName: string, nodeType?: NodeTypeOption | null);
+    setAttributeName(attributeName: string): this;
+    getAttributeName(builder: NodeBuilder): string;
+}

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

@@ -0,0 +1,9 @@
+import Node from './Node';
+
+export default class BypassNode extends Node {
+    isBypassNode: true;
+    outputNode: Node;
+    callNode: Node;
+
+    constructor(returnNode: Node, callNode: Node);
+}

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

@@ -0,0 +1,16 @@
+import { NodeTypeOption } from './constants';
+import Node from './Node';
+import NodeBuilder from './NodeBuilder';
+
+export interface CodeNodeInclude {
+    build(): void;
+}
+
+export default class CodeNode extends Node {
+    isCodeNode: true;
+    code: string;
+    constructor(code: string, nodeType?: NodeTypeOption);
+
+    setIncludes(includes: CodeNodeInclude[]): this;
+    getIncludes(builder: NodeBuilder): CodeNodeInclude[];
+}

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

@@ -0,0 +1,10 @@
+import { NodeTypeOption, NodeValueOption } from './constants';
+import InputNode from './InputNode';
+import NodeBuilder from './NodeBuilder';
+
+export default class ConstNode extends InputNode {
+    isConstNode: true;
+    constructor(value: NodeValueOption, nodeType?: NodeTypeOption | null);
+
+    generateConst(builder: NodeBuilder): string;
+}

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

@@ -0,0 +1,10 @@
+import Node from './Node';
+import { NodeBuilderContext } from './NodeBuilder';
+
+export default class ContextNode extends Node {
+    isContextNode: true;
+    node: Node;
+    context: NodeBuilderContext;
+
+    constructor(node: Node, context: NodeBuilderContext);
+}

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

@@ -0,0 +1,7 @@
+import { NodeTypeOption } from './constants';
+import TempNode from './TempNode';
+
+export default class ExpressionNode extends TempNode {
+    snipped: string; /* sic */
+    constructor(snipped?: string, nodeType?: NodeTypeOption);
+}