@types/three 0.143.0 → 0.143.1

three/examples/jsm/nodes/lighting/LightingNode.d.ts

@@ -0,0 +1,5 @@
+import Node from '../core/Node';
+
+export default abstract class LightingNode extends Node {
+    constructor();
+}

three/examples/jsm/nodes/lighting/LightsNode.d.ts

@@ -0,0 +1,19 @@
+import { Light } from '../../../../src/Three';
+import Node from '../core/Node';
+import LightingNode from './LightingNode';
+
+export default class LightsNode extends Node {
+    lightNodes: LightingNode[];
+
+    constructor(lightNodes?: LightingNode[]);
+
+    get hasLight(): boolean;
+    getLightNodeByHash(hash: string): LightingNode | null;
+
+    fromLights(lights: Light[]): this;
+
+    static setReference<T extends Light>(
+        lightClass: { new (): T },
+        lightNodeClass: { new (light: T): LightingNode },
+    ): void;
+}

three/examples/jsm/nodes/lighting/PunctualLightNode.d.ts

@@ -0,0 +1,12 @@
+import AnalyticLightNode from './AnalyticLightNode';
+import Node from '../core/Node';
+import { PointLight, SpotLight } from '../../../../src/Three';
+
+export type PunctualLight = PointLight | SpotLight;
+
+export default class PunctualLightNode extends AnalyticLightNode<PunctualLight> {
+    cutoffDistanceNode: Node;
+    decayExponentNode: Node;
+
+    constructor(light?: PunctualLight | null);
+}

three/examples/jsm/nodes/loaders/NodeLoader.d.ts

@@ -0,0 +1,21 @@
+import { Loader, LoadingManager, Texture } from '../../../../src/Three';
+import { Node, AnyJson } from '../Nodes';
+
+export interface NodeLoaderResult {
+    [hash: string]: Node;
+}
+
+export default class NodeLoader extends Loader {
+    constructor(manager?: LoadingManager);
+
+    load(
+        url: string,
+        onLoad: (gltf: NodeLoaderResult) => void,
+        onProgress?: (event: ProgressEvent) => void,
+        onError?: (event: ErrorEvent) => void,
+    ): void;
+
+    parseNodes(json: AnyJson): NodeLoaderResult;
+    parse(json: AnyJson): Node;
+    setTextures(textures: { [key: string]: Texture }): this;
+}

three/examples/jsm/nodes/loaders/NodeMaterialLoader.d.ts

@@ -0,0 +1,8 @@
+import { MaterialLoader } from '../../../../src/Three';
+import { NodeLoaderResult } from './NodeLoader';
+
+export default class NodeMaterialLoader extends MaterialLoader {
+    nodes: NodeLoaderResult;
+
+    setNodes(value: NodeLoaderResult): this;
+}

three/examples/jsm/nodes/loaders/NodeObjectLoader.d.ts

@@ -0,0 +1,11 @@
+import { NodeLoaderResult } from './NodeLoader';
+import { Material, ObjectLoader, Texture } from '../../../../src/Three';
+import { AnyJson } from '../core/constants';
+
+export default class NodeObjectLoader extends ObjectLoader {
+    parseNodes(json: AnyJson, textures: { [key: string]: Texture }): NodeLoaderResult;
+
+    // tslint:disable-next-line:comment-format
+    //@ts-expect-error
+    parseMaterials(json: AnyJson, textures: { [key: string]: Texture }): { [key: string]: Material };
+}

three/examples/jsm/nodes/materials/LineBasicNodeMaterial.d.ts

@@ -0,0 +1,16 @@
+import NodeMaterial from './NodeMaterial';
+import { ShaderMaterialParameters } from '../../../../src/Three';
+import { Node } from '../Nodes';
+
+export default class LineBasicNodeMaterial extends NodeMaterial {
+    isLineBasicNodeMaterial: true;
+
+    colorNode: Node | null;
+    opacityNode: Node | null;
+    alphaTestNode: Node | null;
+    lightNode: Node | null;
+    positionNode: Node | null;
+
+    constructor(parameters?: ShaderMaterialParameters);
+    copy(source: LineBasicNodeMaterial): this;
+}

three/examples/jsm/nodes/materials/Materials.d.ts

@@ -0,0 +1,15 @@
+import NodeMaterial from '../materials/NodeMaterial';
+import LineBasicNodeMaterial from '../materials/LineBasicNodeMaterial';
+import MeshBasicNodeMaterial from '../materials/MeshBasicNodeMaterial';
+import MeshStandardNodeMaterial from '../materials/MeshStandardNodeMaterial';
+import PointsNodeMaterial from '../materials/PointsNodeMaterial';
+import SpriteNodeMaterial from '../materials/SpriteNodeMaterial';
+
+export {
+    NodeMaterial,
+    LineBasicNodeMaterial,
+    MeshBasicNodeMaterial,
+    MeshStandardNodeMaterial,
+    PointsNodeMaterial,
+    SpriteNodeMaterial,
+};

three/examples/jsm/nodes/materials/MeshBasicNodeMaterial.d.ts

@@ -0,0 +1,19 @@
+import NodeMaterial from './NodeMaterial';
+import Node from '../core/Node';
+import { ShaderMaterialParameters } from '../../../../src/Three';
+
+export default class MeshBasicNodeMaterial extends NodeMaterial {
+    isMeshBasicNodeMaterial: true;
+    lights: true;
+
+    colorNode: Node | null;
+    opacityNode: Node | null;
+
+    alphaTestNode: Node | null;
+    lightNode: Node | null;
+
+    positionNode: Node | null;
+
+    constructor(paramters?: ShaderMaterialParameters);
+    copy(source: MeshBasicNodeMaterial): this;
+}

three/examples/jsm/nodes/materials/MeshStandardNodeMaterial.d.ts

@@ -0,0 +1,27 @@
+import { ShaderMaterialParameters } from '../../../../src/Three';
+import Node from '../core/Node';
+import NodeMaterial from './NodeMaterial';
+
+export default class MeshStandardNodeMaterial extends NodeMaterial {
+    isMeshStandardNodeMaterial: true;
+
+    colorNode: Node | null;
+    opacityNode: Node | null;
+    alphaTestNode: Node | null;
+    normalNode: Node | null;
+    emissiveNode: Node | null;
+
+    metalnessNode: Node | null;
+    roughnessNode: Node | null;
+
+    clearcoatNode: Node | null;
+    clearcoatRoughnessNode: Node | null;
+
+    envNode: Node | null;
+
+    lightsNode: Node | null;
+    positionNode: Node | null;
+
+    constructor(paramters?: ShaderMaterialParameters);
+    copy(source: MeshStandardNodeMaterial): this;
+}

three/examples/jsm/nodes/materials/NodeMaterial.d.ts

@@ -0,0 +1,22 @@
+import { Material, ShaderMaterial } from '../../../../src/Three';
+import NodeBuilder from '../core/NodeBuilder';
+import Node from '../core/Node';
+import { LightingModelNode } from '../lighting/LightingContextNode';
+
+export default class NodeMaterial extends ShaderMaterial {
+    isNodeMaterial: true;
+    lights: true;
+    type: string;
+    constructor();
+
+    build(builder: NodeBuilder): void;
+    customProgramCacheKey(): string;
+    generatePosition(builder: NodeBuilder): void;
+    generateDiffuseColor(builder: NodeBuilder): void;
+    generateLight(
+        builder: NodeBuilder,
+        lights: { diffuseColorNode: Node; lightingModelNode: LightingModelNode; lightsNode?: Node },
+    ): void;
+    generateOutput(builder: NodeBuilder, lights: { diffuseColorNode: Node; outgoingLightNode: Node }): void;
+    static fromMaterial(m: Material): NodeMaterial;
+}

three/examples/jsm/nodes/materials/PointsNodeMaterial.d.ts

@@ -0,0 +1,15 @@
+import NodeMaterial from './NodeMaterial';
+import { ShaderMaterialParameters } from '../../../../src/Three';
+import { Node } from '../Nodes';
+
+export default class PointsNodeMaterial extends NodeMaterial {
+    isPointsNodeMateria: true;
+    colorNode: Node | null;
+    opacityNode: Node | null;
+    alphaTestNode: Node | null;
+    lightNode: Node | null;
+    sizeNode: Node | null;
+    positionNode: Node | null;
+    constructor(parameters?: ShaderMaterialParameters);
+    copy(source: PointsNodeMaterial): this;
+}

three/examples/jsm/nodes/materials/SpriteNodeMaterial.d.ts

@@ -0,0 +1,23 @@
+import NodeMaterial from './NodeMaterial';
+import { ShaderMaterialParameters } from '../../../../src/Three';
+import { NodeBuilder } from '../Nodes';
+import Node from '../core/Node';
+
+export default class SpriteNodeMaterial extends NodeMaterial {
+    isSpriteNodeMaterial: true;
+
+    colorNode: Node | null;
+    opacityNode: Node | null;
+
+    alphaTestNode: Node | null;
+
+    lightNode: Node | null;
+
+    positionNode: Node | null;
+    rotationNode: Node | null;
+    scaleNode: Node | null;
+
+    constructor(parameters?: ShaderMaterialParameters);
+    generatePosition(builder: NodeBuilder): void;
+    copy(source: SpriteNodeMaterial): this;
+}

three/examples/jsm/nodes/math/CondNode.d.ts

@@ -0,0 +1,9 @@
+import Node from '../core/Node';
+
+export default class CondNode extends Node {
+    condNode: Node;
+    ifNode: Node;
+    elseNode: Node;
+
+    constructor(condNode: Node, ifNode: Node, elseNode: Node);
+}

three/examples/jsm/nodes/math/MathNode.d.ts

@@ -0,0 +1,116 @@
+import Node from '../core/Node';
+import TempNode from '../core/TempNode';
+
+export type MathNodeMethod1 =
+    | typeof MathNode.RADIANS
+    | typeof MathNode.DEGREES
+    | typeof MathNode.EXP
+    | typeof MathNode.EXP2
+    | typeof MathNode.LOG
+    | typeof MathNode.LOG2
+    | typeof MathNode.SQRT
+    | typeof MathNode.INVERSE_SQRT
+    | typeof MathNode.FLOOR
+    | typeof MathNode.CEIL
+    | typeof MathNode.NORMALIZE
+    | typeof MathNode.FRACT
+    | typeof MathNode.SIN
+    | typeof MathNode.COS
+    | typeof MathNode.TAN
+    | typeof MathNode.ASIN
+    | typeof MathNode.ACOS
+    | typeof MathNode.ATAN
+    | typeof MathNode.ABS
+    | typeof MathNode.SIGN
+    | typeof MathNode.LENGTH
+    | typeof MathNode.NEGATE
+    | typeof MathNode.INVERT
+    | typeof MathNode.DFDX
+    | typeof MathNode.DFDY
+    | typeof MathNode.SATURATE
+    | typeof MathNode.ROUND;
+
+export type MathNodeMethod2 =
+    | typeof MathNode.ATAN2
+    | typeof MathNode.MIN
+    | typeof MathNode.MAX
+    | typeof MathNode.MOD
+    | typeof MathNode.STEP
+    | typeof MathNode.REFLECT
+    | typeof MathNode.DISTANCE
+    | typeof MathNode.DOT
+    | typeof MathNode.CROSS
+    | typeof MathNode.POW
+    | typeof MathNode.TRANSFORM_DIRECTION;
+
+export type MathNodeMethod3 =
+    | typeof MathNode.MIX
+    | typeof MathNode.CLAMP
+    | typeof MathNode.REFRACT
+    | typeof MathNode.SMOOTHSTEP
+    | typeof MathNode.FACEFORWARD;
+
+export type MathNodeMethod = MathNodeMethod1 | MathNodeMethod2 | MathNodeMethod3;
+
+export default class MathNode extends TempNode {
+    // 1 input
+
+    static RADIANS: 'radians';
+    static DEGREES: 'degrees';
+    static EXP: 'exp';
+    static EXP2: 'exp2';
+    static LOG: 'log';
+    static LOG2: 'log2';
+    static SQRT: 'sqrt';
+    static INVERSE_SQRT: 'inversesqrt';
+    static FLOOR: 'floor';
+    static CEIL: 'ceil';
+    static NORMALIZE: 'normalize';
+    static FRACT: 'fract';
+    static SIN: 'sin';
+    static COS: 'cos';
+    static TAN: 'tan';
+    static ASIN: 'asin';
+    static ACOS: 'acos';
+    static ATAN: 'atan';
+    static ABS: 'abs';
+    static SIGN: 'sign';
+    static LENGTH: 'length';
+    static NEGATE: 'negate';
+    static INVERT: 'invert';
+    static DFDX: 'dFdx';
+    static DFDY: 'dFdy';
+    static SATURATE: 'saturate';
+    static ROUND: 'round';
+
+    // 2 inputs
+
+    static ATAN2: 'atan2';
+    static MIN: 'min';
+    static MAX: 'max';
+    static MOD: 'mod';
+    static STEP: 'step';
+    static REFLECT: 'reflect';
+    static DISTANCE: 'distance';
+    static DOT: 'dot';
+    static CROSS: 'cross';
+    static POW: 'pow';
+    static TRANSFORM_DIRECTION: 'transformDirection';
+
+    // 3 inputs
+
+    static MIX: 'mix';
+    static CLAMP: 'clamp';
+    static REFRACT: 'refract';
+    static SMOOTHSTEP: 'smoothstep';
+    static FACEFORWARD: 'faceforward';
+
+    method: MathNodeMethod;
+    aNode: Node;
+    bNode: Node | null;
+    cNode: Node | null;
+
+    constructor(method: MathNodeMethod1, aNode: Node);
+    constructor(method: MathNodeMethod2, aNode: Node, bNode: Node);
+    constructor(method: MathNodeMethod3, aNode: Node, bNode: Node, cNode: Node);
+}

three/examples/jsm/nodes/math/OperatorNode.d.ts

@@ -0,0 +1,31 @@
+import TempNode from '../core/TempNode';
+import Node from '../core/Node';
+
+export type OperatorNodeOp =
+    | '='
+    | '%'
+    | '&'
+    | '|'
+    | '^'
+    | '>>'
+    | '<<'
+    | '=='
+    | '&&'
+    | '||'
+    | '^^'
+    | '<'
+    | '>'
+    | '<='
+    | '>='
+    | '+'
+    | '-'
+    | '*'
+    | '/';
+
+export default class OperatorNode extends TempNode {
+    aNode: Node;
+    bNode: Node;
+    op: OperatorNodeOp;
+
+    constructor(op: OperatorNodeOp, ...params: [Node, Node, ...Node[]]);
+}

three/examples/jsm/nodes/procedural/CheckerNode.d.ts

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

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

@@ -0,0 +1,155 @@
+import { ConstNode, Node, NodeBuilder, NodeTypeOption, SwizzleOption } from '../Nodes';
+// lot of private typescript magic here
+export {};
+export type Swizzable<T extends Node = Node> = T &
+    {
+        [key in SwizzleOption | number]: Swizzable;
+    };
+
+/** anything that can be passed to {@link nodeObject} and returns a proxy */
+export type NodeRepresentation = number | boolean | Node | Swizzable;
+
+/** anything that can be passed to {@link nodeObject} */
+export type NodeObjectOption = NodeRepresentation | string;
+
+// same logic as in ShaderNodeObject
+export type NodeObject<T> = T extends Node ? Swizzable<T> : T extends number | boolean ? Swizzable<ConstNode> : T;
+
+type MakeObjectOption<T> = T extends Node ? NodeRepresentation : T;
+// https://github.com/microsoft/TypeScript/issues/42435#issuecomment-765557874
+type MakeObjectOptions<T extends readonly [...unknown[]]> = [...{ [index in keyof T]: MakeObjectOption<T[index]> }];
+type RemoveTail<T extends readonly [...unknown[]]> = T extends [unknown, ...infer X] ? X : [];
+type RemoveHeadAndTail<T extends readonly [...unknown[]]> = T extends [unknown, ...infer X, unknown] ? X : [];
+
+/**
+ * Temporary type to save signatures of 4 constructors. Each element may be tuple or undefined.
+ *
+ * We use an object instead of tuple or union as it makes stuff easier, especially in Typescript 4.0.
+ */
+interface Construtors<
+    A extends undefined | [...unknown[]],
+    B extends undefined | [...unknown[]],
+    C extends undefined | [...unknown[]],
+    D extends undefined | [...unknown[]],
+> {
+    a: A;
+    b: B;
+    c: C;
+    d: D;
+}
+
+/**
+ * Returns all constructors
+ *
+ * <https://github.com/microsoft/TypeScript/issues/37079>
+ * <https://stackoverflow.com/a/52761156/1623826>
+ */
+type OverloadedConstructorsOf<T> = T extends {
+    new (...args: infer A1): unknown;
+    new (...args: infer A2): unknown;
+    new (...args: infer A3): unknown;
+    new (...args: infer A4): unknown;
+}
+    ? Construtors<A1, A2, A3, A4>
+    : T extends {
+          new (...args: infer A1): unknown;
+          new (...args: infer A2): unknown;
+          new (...args: infer A3): unknown;
+      }
+    ? Construtors<A1, A2, A3, undefined>
+    : T extends {
+          new (...args: infer A1): unknown;
+          new (...args: infer A2): unknown;
+      }
+    ? Construtors<A1, A2, undefined, undefined>
+    : T extends new (...args: infer A) => unknown
+    ? Construtors<A, undefined, undefined, undefined>
+    : Construtors<undefined, undefined, undefined, undefined>;
+
+type AnyConstructors = Construtors<any, any, any, any>;
+
+/**
+ * Returns all constructors where the first paramter is assignable to given "scope"
+ */
+// tslint:disable-next-line:interface-over-type-literal
+type FilterConstructorsByScope<T extends AnyConstructors, S> = {
+    a: S extends T['a'][0] ? T['a'] : undefined;
+    b: S extends T['b'][0] ? T['b'] : undefined;
+    c: S extends T['c'][0] ? T['c'] : undefined;
+    d: S extends T['d'][0] ? T['d'] : undefined;
+};
+/**
+ * "flattens" the tuple into an union type
+ */
+type ConstructorUnion<T extends AnyConstructors> =
+    | (T['a'] extends undefined ? never : T['a'])
+    | (T['b'] extends undefined ? never : T['b'])
+    | (T['c'] extends undefined ? never : T['c'])
+    | (T['d'] extends undefined ? never : T['d']);
+
+/**
+ * Extract list of possible scopes - union of the first paramter
+ * of all constructors, should it be string
+ */
+type ExtractScopes<T extends AnyConstructors> =
+    | (T['a'][0] extends string ? T['a'][0] : never)
+    | (T['b'][0] extends string ? T['b'][0] : never)
+    | (T['c'][0] extends string ? T['c'][0] : never)
+    | (T['d'][0] extends string ? T['d'][0] : never);
+
+type GetConstructorsByScope<T, S> = ConstructorUnion<FilterConstructorsByScope<OverloadedConstructorsOf<T>, S>>;
+type GetConstructors<T> = ConstructorUnion<OverloadedConstructorsOf<T>>;
+type GetPossibleScopes<T> = ExtractScopes<OverloadedConstructorsOf<T>>;
+
+export type ConvertType = (...params: unknown[]) => Swizzable;
+
+export const ConvertType: {
+    new (type: NodeTypeOption, cacheMap?: Map<unknown, ConstNode>): ConvertType;
+};
+
+type NodeArray<T extends NodeObjectOption[]> = { [index in keyof T]: NodeObject<T[index]> };
+type NodeObjects<T> = { [key in keyof T]: T[key] extends NodeObjectOption ? NodeObject<T[key]> : T[key] };
+type ConstructedNode<T> = T extends new (...args: any[]) => infer R ? (R extends Node ? R : never) : never;
+
+export type NodeOrType = Node | NodeTypeOption;
+
+export function getConstNodeType(value: NodeOrType): NodeTypeOption | null;
+export function nodeObject<T extends NodeObjectOption>(obj: T): NodeObject<T>;
+export function nodeObjects<T>(obj: T): NodeObjects<T>;
+
+export function nodeArray<T extends NodeObjectOption[]>(obj: readonly [...T]): NodeArray<T>;
+
+export function nodeProxy<T>(
+    nodeClass: T,
+): (...params: MakeObjectOptions<GetConstructors<T>>) => Swizzable<ConstructedNode<T>>;
+
+export function nodeProxy<T, S extends GetPossibleScopes<T>>(
+    nodeClass: T,
+    scope: S,
+): (...params: MakeObjectOptions<RemoveTail<GetConstructorsByScope<T, S>>>) => Swizzable<ConstructedNode<T>>;
+
+export function nodeProxy<T, S extends GetPossibleScopes<T>>(
+    nodeClass: T,
+    scope: S,
+    factor: NodeObjectOption,
+): (...params: MakeObjectOptions<RemoveHeadAndTail<GetConstructorsByScope<T, S>>>) => Swizzable<ConstructedNode<T>>;
+
+export function nodeImmutable<T>(
+    nodeClass: T,
+    ...params: MakeObjectOptions<GetConstructors<T>>
+): Swizzable<ConstructedNode<T>>;
+
+export class ShaderNode<T = {}, R extends Node = Node> {
+    constructor(jsFunc: (inputs: NodeObjects<T>, builder: NodeBuilder) => NodeRepresentation);
+    call: (
+        inputs: { [key in keyof T]: T[key] extends NodeRepresentation ? Swizzable | Node : T[key] },
+        builder?: NodeBuilder,
+    ) => Swizzable<R>;
+}
+
+export const cacheMaps: {
+    bool: Map<boolean, ConstNode>;
+    uint: Map<number, ConstNode>;
+    int: Map<number, ConstNode>;
+    float: Map<number, ConstNode>;
+};