@types/three 0.143.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: Thu, 28 Jul 2022 16:32:18 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/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);
+}

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

@@ -0,0 +1,13 @@
+import FunctionNode from './FunctionNode';
+import TempNode from './TempNode';
+import Node from './Node';
+
+export default class FunctionCallNode extends TempNode {
+    functionNode: FunctionNode;
+    parameters: { [name: string]: Node };
+
+    constructor(functionNode?: FunctionNode, parameters?: { [name: string]: Node });
+
+    setParameters(parameters: { [name: string]: Node }): this;
+    getParameters(): { [name: string]: Node };
+}

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

@@ -0,0 +1,15 @@
+import CodeNode from './CodeNode';
+import FunctionCallNode from './FunctionCallNode';
+import NodeBuilder from './NodeBuilder';
+import NodeFunction from './NodeFunction';
+import NodeFunctionInput from './NodeFunctionInput';
+import Node from './Node';
+
+export default class FunctionNode extends CodeNode {
+    keywords: { [key: string]: Node };
+    constructor(code?: string);
+
+    getInputs(builder: NodeBuilder): NodeFunctionInput[];
+    getNodeFunction(builder: NodeBuilder): NodeFunction;
+    call(parameters: { [name: string]: Node }): FunctionCallNode;
+}

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

@@ -0,0 +1,12 @@
+import { NodeTypeOption, NodeValueOption } from './constants';
+import Node from './Node';
+import NodeBuilder from './NodeBuilder';
+
+export default abstract class InputNode extends Node {
+    isInputNode: true;
+    value: NodeValueOption;
+
+    constructor(value: NodeValueOption, nodeType?: NodeTypeOption | null);
+
+    getInputType(builder: NodeBuilder): string | null;
+}

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

@@ -0,0 +1,6 @@
+import Node from './Node';
+
+export default class InstanceIndexNode extends Node {
+    isInstanceIndexNode: true;
+    constructor();
+}

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

@@ -0,0 +1,30 @@
+import { AnyJson, NodeTypeOption, NodeUpdateTypeOption } from './constants';
+import NodeBuilder from './NodeBuilder';
+import NodeFrame from './NodeFrame';
+
+export default abstract class Node {
+    uuid: string;
+    type: string;
+    isNode: true;
+    nodeType: NodeTypeOption | null;
+    updateType: NodeUpdateTypeOption;
+    id: number;
+
+    constructor(nodeType?: NodeTypeOption | null);
+
+    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;
+    generate(builder: NodeBuilder, output?: string | null): string;
+    /** This method must be overriden when {@link updateType} !== 'none' */
+    update(frame: NodeFrame): void;
+    build(builder: NodeBuilder, output?: string | null): string;
+    serialize(json: AnyJson): void;
+    deserialize(json: AnyJson): void;
+    toJSON(meta?: string | { textures: {}; images: {}; nodes: {} }): AnyJson;
+}

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

@@ -0,0 +1,6 @@
+export default class NodeAttribute {
+    isNodeAttribute: true;
+    name: string;
+    type: string;
+    constructor(name: string, type: string);
+}