@types/three 0.157.1 → 0.157.2

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

@@ -0,0 +1,15 @@
+import NodeMaterial from './NodeMaterial.js';
+import { ShaderMaterialParameters } from '../../../../src/Three.js';
+import { Node } from '../Nodes.js';
+
+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.js';
+import { ShaderMaterialParameters } from '../../../../src/Three.js';
+import { NodeBuilder } from '../Nodes.js';
+import Node from '../core/Node.js';
+
+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/materialx/MaterialXNodes.d.ts

@@ -0,0 +1,94 @@
+import { mx_hsvtorgb, mx_rgbtohsv } from './lib/mx_hsv.js';
+import { Swizzable } from '../shadernode/ShaderNodeElements.js';
+import { UVNode, MathNode } from '../Nodes.js';
+import { NodeRepresentation } from '../shadernode/ShaderNode.js';
+
+export function mx_aastep(threshold?: NodeRepresentation, value?: NodeRepresentation): Swizzable<MathNode>;
+
+export function mx_ramplr(
+    valuel?: NodeRepresentation,
+    valuer?: NodeRepresentation,
+    texcoord?: Swizzable<UVNode>,
+): Swizzable<MathNode>;
+export function mx_ramptb(
+    valuet?: NodeRepresentation,
+    valueb?: NodeRepresentation,
+    texcoord?: Swizzable<UVNode>,
+): Swizzable<MathNode>;
+
+export function mx_splitlr(
+    valuel?: NodeRepresentation,
+    valuer?: NodeRepresentation,
+    center?: NodeRepresentation,
+    texcoord?: Swizzable<UVNode>,
+): Swizzable<MathNode>;
+export function mx_splittb(
+    valuet?: NodeRepresentation,
+    valueb?: NodeRepresentation,
+    center?: NodeRepresentation,
+    texcoord?: Swizzable<UVNode>,
+): Swizzable<MathNode>;
+
+export function mx_transform_uv(
+    uv_scale?: NodeRepresentation,
+    uv_offset?: NodeRepresentation,
+    uv_geo?: Swizzable<UVNode>,
+): Swizzable;
+
+export function mx_noise_float(
+    texcoord?: Swizzable<UVNode>,
+    amplitude?: NodeRepresentation,
+    pivot?: NodeRepresentation,
+): Swizzable;
+export function mx_noise_vec2(
+    texcoord?: Swizzable<UVNode>,
+    amplitude?: NodeRepresentation,
+    pivot?: NodeRepresentation,
+): Swizzable;
+export function mx_noise_vec3(
+    texcoord?: Swizzable<UVNode>,
+    amplitude?: NodeRepresentation,
+    pivot?: NodeRepresentation,
+): Swizzable;
+export function mx_noise_vec4(
+    texcoord?: Swizzable<UVNode>,
+    amplitude?: NodeRepresentation,
+    pivot?: NodeRepresentation,
+): Swizzable;
+
+export function mx_worley_noise_float(texcoord?: Swizzable<UVNode>, jitter?: NodeRepresentation): Swizzable;
+export function mx_worley_noise_vec2(texcoord?: Swizzable<UVNode>, jitter?: NodeRepresentation): Swizzable;
+export function mx_worley_noise_vec3(texcoord?: Swizzable<UVNode>, jitter?: NodeRepresentation): Swizzable;
+
+export function mx_cell_noise_float(texcoord?: Swizzable<UVNode>): Swizzable;
+
+export function mx_fractal_noise_float(
+    position?: Swizzable<UVNode>,
+    octaves?: NodeRepresentation,
+    lacunarity?: NodeRepresentation,
+    diminish?: NodeRepresentation,
+    amplitude?: NodeRepresentation,
+): Swizzable;
+export function mx_fractal_noise_vec2(
+    position?: Swizzable<UVNode>,
+    octaves?: NodeRepresentation,
+    lacunarity?: NodeRepresentation,
+    diminish?: NodeRepresentation,
+    amplitude?: NodeRepresentation,
+): Swizzable;
+export function mx_fractal_noise_vec3(
+    position?: Swizzable<UVNode>,
+    octaves?: NodeRepresentation,
+    lacunarity?: NodeRepresentation,
+    diminish?: NodeRepresentation,
+    amplitude?: NodeRepresentation,
+): Swizzable;
+export function mx_fractal_noise_vec4(
+    position?: Swizzable<UVNode>,
+    octaves?: NodeRepresentation,
+    lacunarity?: NodeRepresentation,
+    diminish?: NodeRepresentation,
+    amplitude?: NodeRepresentation,
+): Swizzable;
+
+export { mx_hsvtorgb, mx_rgbtohsv };

three/examples/jsm/nodes/materialx/lib/mx_hsv.d.ts

@@ -0,0 +1,4 @@
+import { Fn, Node, Swizzable } from '../../Nodes.js';
+
+export function mx_hsvtorgb(...params: Fn<[Node]>): Swizzable;
+export function mx_rgbtohsv(...params: Fn<[Node]>): Swizzable;

three/examples/jsm/nodes/materialx/lib/mx_noise.d.ts

@@ -0,0 +1,6 @@
+import { Fn, Node, Swizzable } from '../../Nodes.js';
+
+export function mx_perlin_noise_float(...params: Fn<[Node]>): Swizzable;
+export function mx_cell_noise_float(...params: Fn<[Node]>): Swizzable;
+export function mx_worley_noise_float(...params: Fn<[Node]>): Swizzable;
+export function mx_fractal_noise_float(...params: Fn<[Node, Node, Node, Node]>): Swizzable;

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

@@ -0,0 +1,9 @@
+import Node from '../core/Node.js';
+
+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,115 @@
+import Node from '../core/Node.js';
+import TempNode from '../core/TempNode.js';
+
+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.ONE_MINUS
+    | typeof MathNode.DFDX
+    | typeof MathNode.DFDY
+    | 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 ONE_MINUS: 'oneMinus';
+    static DFDX: 'dFdx';
+    static DFDY: 'dFdy';
+    static ROUND: 'round';
+    static RECIPROCAL: 'reciprocal';
+
+    // 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.js';
+import Node from '../core/Node.js';
+
+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 TempNode from '../core/TempNode.js';
+
+export default class CheckerNode extends TempNode {
+    uvNode: Node;
+    constructor(uvNode?: Node);
+}

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

@@ -0,0 +1,156 @@
+import { ConstNode, Node, NodeBuilder, NodeTypeOption, SwizzleOption } from '../Nodes.js';
+// 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<T extends Node = Node> = number | boolean | Node | Swizzable<T>;
+
+/** anything that can be passed to {@link nodeObject} */
+export type NodeObjectOption = NodeRepresentation | string;
+
+// same logic as in ShaderNodeObject: number,boolean,node->swizzable, otherwise do nothing
+export type NodeObject<T> = T extends Node ? Swizzable<T> : T extends number | boolean ? Swizzable<ConstNode> : T;
+
+// opposite of NodeObject: node -> node|swizzable|boolean|number, otherwise do nothing
+type Proxied<T> = T extends Node ? NodeRepresentation<T> : T;
+// https://github.com/microsoft/TypeScript/issues/42435#issuecomment-765557874
+export type ProxiedTuple<T extends readonly [...unknown[]]> = [...{ [index in keyof T]: Proxied<T[index]> }];
+export type ProxiedObject<T> = { [index in keyof T]: Proxied<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> =
+    | Exclude<T['a'], undefined>
+    | Exclude<T['b'], undefined>
+    | Exclude<T['c'], undefined>
+    | Exclude<T['d'], undefined>;
+
+/**
+ * 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: ProxiedTuple<GetConstructors<T>>) => Swizzable<ConstructedNode<T>>;
+
+export function nodeProxy<T, S extends GetPossibleScopes<T>>(
+    nodeClass: T,
+    scope: S,
+): (...params: ProxiedTuple<RemoveTail<GetConstructorsByScope<T, S>>>) => Swizzable<ConstructedNode<T>>;
+
+export function nodeProxy<T, S extends GetPossibleScopes<T>>(
+    nodeClass: T,
+    scope: S,
+    factor: NodeObjectOption,
+): (...params: ProxiedTuple<RemoveHeadAndTail<GetConstructorsByScope<T, S>>>) => Swizzable<ConstructedNode<T>>;
+
+export function nodeImmutable<T>(
+    nodeClass: T,
+    ...params: ProxiedTuple<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>;
+};