@types/three 0.157.1 → 0.158.0

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

@@ -0,0 +1,13 @@
+import { SkinnedMesh } from '../../../../src/Three.js';
+import Node from '../core/Node.js';
+
+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.js';
+import BufferNode from './BufferNode.js';
+
+export default class StorageBufferNode extends BufferNode {
+    constructor(value: ArrayLike<number>, bufferType: NodeTypeOption, bufferCount?: number);
+}

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,17 @@
+import CodeNode, { CodeNodeInclude } from './CodeNode.js';
+import FunctionCallNode from './FunctionCallNode.js';
+import NodeBuilder from '../core/NodeBuilder.js';
+import NodeFunction from '../core/NodeFunction.js';
+import NodeFunctionInput from '../core/NodeFunctionInput.js';
+import Node from '../core/Node.js';
+
+export type FunctionNodeArguments = Node[] | { [name: string]: Node };
+
+export default class FunctionNode<P extends Node[] | { [name: string]: Node }> extends CodeNode {
+    keywords: { [key: string]: Node };
+    constructor(code?: string, includes?: CodeNodeInclude[]);
+
+    getInputs(builder: NodeBuilder): NodeFunctionInput[];
+    getNodeFunction(builder: NodeBuilder): NodeFunction;
+    call(parameters: P): FunctionCallNode<P>;
+}

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

@@ -0,0 +1,8 @@
+import UniformNode from './UniformNode.js';
+import Node from './Node.js';
+
+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.js';
+import Node from './Node.js';
+import NodeBuilder from './NodeBuilder.js';
+
+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.js';
+
+export default class BypassNode extends Node {
+    isBypassNode: true;
+    outputNode: Node;
+    callNode: Node;
+
+    constructor(returnNode: Node, callNode: Node);
+}

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

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

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

@@ -0,0 +1,10 @@
+import { NodeTypeOption, NodeValueOption } from './constants.js';
+import InputNode from './InputNode.js';
+import NodeBuilder from './NodeBuilder.js';
+
+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.js';
+import { NodeBuilderContext } from './NodeBuilder.js';
+
+export default class ContextNode extends Node {
+    isContextNode: true;
+    node: Node;
+    context: NodeBuilderContext;
+
+    constructor(node: Node, context: NodeBuilderContext);
+}

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

@@ -0,0 +1,16 @@
+import { NodeTypeOption, NodeValueOption } from './constants.js';
+import Node from './Node.js';
+import NodeBuilder from './NodeBuilder.js';
+
+export type Precision = 'low' | 'medium' | 'high';
+
+export default abstract class InputNode extends Node {
+    isInputNode: true;
+    value: NodeValueOption;
+    precision: Precision | null;
+
+    constructor(value: NodeValueOption, nodeType?: NodeTypeOption | null);
+
+    getInputType(builder: NodeBuilder): string | null;
+    setPrecision(precision: Precision): this;
+}

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

@@ -0,0 +1,31 @@
+import { AnyJson, NodeTypeOption, NodeUpdateTypeOption } from './constants.js';
+import NodeBuilder from './NodeBuilder.js';
+import NodeFrame from './NodeFrame.js';
+
+export default abstract class Node {
+    uuid: string;
+    type: string;
+    isNode: true;
+    nodeType: NodeTypeOption | null;
+    updateType: NodeUpdateTypeOption;
+    id: number;
+
+    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;
+    getReference(builder: NodeBuilder): Node;
+    setup(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;
+    getCacheKey(): string;
+}

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

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

@@ -0,0 +1,138 @@
+import {
+    BufferGeometry,
+    Material,
+    Object3D,
+    Renderer,
+    Scene,
+    Texture,
+    TextureEncoding,
+    WebGLRenderTarget,
+} from '../../../../src/Three.js';
+import FogNode from '../fog/FogNode.js';
+import LightsNode from '../lighting/LightsNode.js';
+import { nodeObject } from '../Nodes.js';
+import { AnyObject, NodeShaderStageOption, NodeTypeOption } from './constants.js';
+import Node from './Node.js';
+import NodeAttribute from './NodeAttribute.js';
+import NodeCache from './NodeCache.js';
+import NodeParser from './NodeParser.js';
+import NodeUniform from './NodeUniform.js';
+import NodeVar from './NodeVar.js';
+import NodeVarying from './NodeVarying.js';
+
+export type BuildStageOption = 'construct' | 'analyze' | 'generate';
+
+export interface FlowData {
+    code: string;
+}
+
+export interface NodeData {
+    vertex: AnyObject;
+    fragment: AnyObject;
+    compute: AnyObject;
+}
+
+export type NodeBuilderContext = AnyObject;
+
+export default abstract class NodeBuilder {
+    object: Object3D;
+    material: Material;
+    geometry: BufferGeometry;
+    renderer: Renderer;
+    parser: NodeParser;
+
+    nodes: Node[];
+    updateNodes: Node[];
+    hashNodes: { [hash: string]: Node };
+
+    lightsNode: LightsNode;
+    fogNode: FogNode;
+
+    vertexShader: string;
+    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[];
+
+    setHashNode(node: Node, hash: string): void;
+    addNode(node: Node): void;
+    get currentNode(): Node;
+    getMethod(method: string): string;
+    getNodeFromHash(hash: string): Node;
+
+    addFlow(shaderStage: NodeShaderStageOption, node: Node): Node;
+
+    setContext(context: NodeBuilderContext): void;
+    getContext(): NodeBuilderContext;
+    isAvailable(name: string): boolean;
+
+    abstract getInstanceIndex(): string;
+
+    abstract getFrontFacing(): string;
+
+    abstract getFragCoord(): string;
+
+    isFlipY(): boolean;
+
+    // @TODO: rename to .generateConst()
+    getConst(type: NodeTypeOption, value?: unknown): Node;
+    getType(type: NodeTypeOption): NodeTypeOption;
+
+    generateMethod(method: string): string;
+
+    getAttribute(name: string, type: NodeTypeOption): NodeAttribute;
+
+    getPropertyName(node: Node, shaderStage: NodeShaderStageOption): string;
+    isVector(type: NodeTypeOption): boolean;
+
+    isMatrix(type: NodeTypeOption): boolean;
+    isReference(type: NodeTypeOption): boolean;
+    isShaderStage(shaderStage: NodeShaderStageOption): boolean;
+    getTextureEncodingFromMap(map: Texture | WebGLRenderTarget | unknown): TextureEncoding;
+    getComponentType(type: NodeTypeOption): NodeTypeOption;
+    getVectorType(type: NodeTypeOption): NodeTypeOption;
+    getTypeFromLength(length: number): NodeTypeOption;
+    getTypeLength(type: NodeTypeOption): number;
+    getVectorFromMatrix(type: NodeTypeOption): NodeTypeOption;
+    getDataFromNode(node: Node, shaderStage?: NodeShaderStageOption): NodeData;
+    getNodeProperties(node: Node, shaderStage?: NodeShaderStageOption): AnyObject;
+    getUniformFromNode(node: Node, type: NodeTypeOption, shaderStage?: NodeShaderStageOption): NodeUniform;
+    getVarFromNode(node: Node, type: NodeTypeOption, shaderStage?: NodeShaderStageOption): NodeVar;
+    getVaryFromNode(node: Node, type: NodeTypeOption): NodeVarying;
+    getCodeFromNode(node: Node, type: NodeTypeOption, shaderStage?: NodeShaderStageOption): string;
+    addFlowCode(code: string): void;
+    getFlowData(node: Node, shaderStage: NodeShaderStageOption): FlowData;
+    flowNode(node: Node): FlowData;
+    flowChildNode(node: Node, output?: string | null): FlowData;
+    flowNodeFromShaderStage(
+        shaderStage: NodeShaderStageOption,
+        node: Node,
+        output?: string | null,
+        propertyName?: string,
+    ): FlowData;
+    hasGeometryAttribute(name: string): boolean;
+    abstract getAttributes(shaderStage: NodeShaderStageOption): string;
+    abstract getVarys(shaderStage: NodeShaderStageOption): string;
+    getVars(shaderStage: NodeShaderStageOption): string;
+    abstract getUniforms(stage: NodeShaderStageOption): string;
+    getCodes(shaderStage: NodeShaderStageOption): string;
+    getHash(): string;
+    setShaderStage(shaderStage: NodeShaderStageOption): void;
+    getShaderStage(): NodeShaderStageOption;
+    setBuildStage(buildStage: BuildStageOption): void;
+    getBuildStage(): BuildStageOption;
+    abstract buildCode(): void;
+    build(): this;
+    format(snippet: string, fromType: NodeTypeOption, toType: NodeTypeOption): string;
+    getSignature(): string;
+}

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

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

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

@@ -0,0 +1,4 @@
+export default class NodeCode {
+    isNodeCode: true;
+    constructor(name: string, type: string, code?: string);
+}

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

@@ -0,0 +1,19 @@
+import { Camera, Material, Object3D, Renderer } from '../../../../src/Three.js';
+
+import Node from './Node.js';
+
+export default class NodeFrame {
+    time: number;
+    deltaTime: number;
+    frameId: number;
+    startTime: null | number;
+    renderer: null | Renderer;
+    material: null | Material;
+    camera: null | Camera;
+    object: null | Object3D;
+
+    constructor();
+
+    updateNode(node: Node): void;
+    update(): void;
+}

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

@@ -0,0 +1,13 @@
+import NodeFunctionInput from './NodeFunctionInput.js';
+
+export default abstract class NodeFunction {
+    isNodeFunction: true;
+    type: string;
+    inputs: NodeFunctionInput[];
+    name: string;
+    presicion: string;
+
+    constructor(type: string, inputs: NodeFunctionInput[], name?: string, presicion?: string);
+
+    abstract getCode(name?: string): string;
+}

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

@@ -0,0 +1,7 @@
+export default class NodeFunctionInput {
+    isNodeFunctionInput: true;
+    count: null | number;
+    qualifier: string;
+    isConst: boolean;
+    constructor(type: string, name: string, count?: number, qualifier?: string, isConst?: boolean);
+}

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

@@ -0,0 +1,14 @@
+import NodeBuilder from './NodeBuilder.js';
+import Node from './Node.js';
+
+export default class NodeKeywords {
+    keywords: string[];
+    nodes: Node[];
+    keywordsCallback: { [name: string]: (name: string) => Node };
+
+    getNode(name: string): Node;
+    addKeyword(name: string, callback: (name: string) => Node): void;
+
+    parse(code: string): Node[];
+    include(builder: NodeBuilder, code: string): void;
+}

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

@@ -0,0 +1,5 @@
+import Node from './Node.js';
+
+export default abstract class NodeParser {
+    abstract parseFunction(source: string): Node;
+}

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

@@ -0,0 +1,13 @@
+import { NodeValueOption } from './constants.js';
+import InputNode from './InputNode.js';
+
+export default class NodeUniform {
+    isNodeUniform: true;
+    name: string;
+    type: string;
+    node: InputNode;
+    needsUpdate: boolean;
+    value: NodeValueOption;
+
+    constructor(name: string, type: string, node: InputNode, needsUpdate?: boolean);
+}

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

@@ -0,0 +1,13 @@
+import { NodeValueOption } from './constants.js';
+import Node from './Node.js';
+
+export interface NodeChild {
+    property: string;
+    index?: number | string;
+    childNode: Node;
+}
+
+export function getCacheKey(object: Node): string;
+export function getNodeChildren(object: Node): Generator<NodeChild, void>;
+export function getValueType(value: NodeValueOption): string | null;
+export function getValueFromType(type: string, ...params: number[]): NodeValueOption | null;

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

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

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

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

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

@@ -0,0 +1,6 @@
+import { NodeTypeOption } from './constants.js';
+import Node from './Node.js';
+
+export default class PropertyNode extends Node {
+    constructor(name?: string, nodeType?: NodeTypeOption);
+}

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

@@ -0,0 +1,11 @@
+import Node from './Node.js';
+
+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

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

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

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

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

@@ -0,0 +1,16 @@
+import { OperatorNodeOp } from '../math/OperatorNode.js';
+import Node from './Node.js';
+
+export default class VarNode extends Node {
+    node: Node;
+    name: string | null;
+
+    constructor(node: Node, name?: string | null);
+
+    op(op: OperatorNodeOp, ...params: Node[]): this;
+    assign(...params: Node[]): this;
+    add(...params: Node[]): this;
+    sub(...params: Node[]): this;
+    mul(...params: Node[]): this;
+    div(...params: Node[]): this;
+}

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

@@ -0,0 +1,8 @@
+import Node from './Node.js';
+
+export default class VaryingNode extends Node {
+    node: Node;
+    name: string | null;
+
+    constructor(node: Node, name?: string | null);
+}