@types/three 0.158.3 → 0.160.0

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

@@ -1,5 +1,6 @@
 import Node from '../core/Node.js';
 import TempNode from '../core/TempNode.js';
+import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 export type MathNodeMethod1 =
     | typeof MathNode.RADIANS
@@ -27,7 +28,11 @@ export type MathNodeMethod1 =
     | typeof MathNode.ONE_MINUS
     | typeof MathNode.DFDX
     | typeof MathNode.DFDY
-    | typeof MathNode.ROUND;
+    | typeof MathNode.ROUND
+    | typeof MathNode.RECIPROCAL
+    | typeof MathNode.TRUNC
+    | typeof MathNode.FWIDTH
+    | typeof MathNode.BITCAST;
 
 export type MathNodeMethod2 =
     | typeof MathNode.ATAN2
@@ -81,6 +86,9 @@ export default class MathNode extends TempNode {
     static DFDY: 'dFdy';
     static ROUND: 'round';
     static RECIPROCAL: 'reciprocal';
+    static TRUNC: 'trunc';
+    static FWIDTH: 'fwidth';
+    static BITCAST: 'bitcast';
 
     // 2 inputs
 
@@ -113,3 +121,128 @@ export default class MathNode extends TempNode {
     constructor(method: MathNodeMethod2, aNode: Node, bNode: Node);
     constructor(method: MathNodeMethod3, aNode: Node, bNode: Node, cNode: Node);
 }
+
+export const EPSILON: ShaderNodeObject<Node>;
+export const INFINITY: ShaderNodeObject<Node>;
+
+export type Unary = (a: NodeRepresentation) => ShaderNodeObject<MathNode>;
+
+export const radians: Unary;
+export const degrees: Unary;
+export const exp: Unary;
+export const exp2: Unary;
+export const log: Unary;
+export const log2: Unary;
+export const sqrt: Unary;
+export const inverseSqrt: Unary;
+export const floor: Unary;
+export const ceil: Unary;
+export const normalize: Unary;
+export const fract: Unary;
+export const sin: Unary;
+export const cos: Unary;
+export const tan: Unary;
+export const asin: Unary;
+export const acos: Unary;
+export const atan: Unary;
+export const abs: Unary;
+export const sign: Unary;
+export const length: Unary;
+export const negate: Unary;
+export const oneMinus: Unary;
+export const dFdx: Unary;
+export const dFdy: Unary;
+export const round: Unary;
+export const reciprocal: Unary;
+export const trunc: Unary;
+export const fwidth: Unary;
+export const bitcast: Unary;
+
+export type Binary = (a: NodeRepresentation, b: NodeRepresentation) => ShaderNodeObject<MathNode>;
+
+export const atan2: Binary;
+export const min: Binary;
+export const max: Binary;
+export const mod: Binary;
+export const step: Binary;
+export const reflect: Binary;
+export const distance: Binary;
+export const difference: Binary;
+export const dot: Binary;
+export const cross: Binary;
+export const pow: Binary;
+export const pow2: Binary;
+export const pow3: Binary;
+export const pow4: Binary;
+export const transformDirection: Binary;
+
+export type Ternary = (
+    a: NodeRepresentation,
+    b: NodeRepresentation,
+    c: NodeRepresentation,
+) => ShaderNodeObject<MathNode>;
+
+export const mix: Ternary;
+export const clamp: Ternary;
+export const saturate: Ternary;
+export const refract: Ternary;
+export const smoothstep: Ternary;
+export const faceForward: Ternary;
+
+export const mixElement: Ternary;
+export const smoothstepElement: Ternary;
+
+declare module '../shadernode/ShaderNode.js' {
+    interface NodeElements {
+        radians: typeof radians;
+        degrees: typeof degrees;
+        exp: typeof exp;
+        exp2: typeof exp2;
+        log: typeof log;
+        log2: typeof log2;
+        sqrt: typeof sqrt;
+        inverseSqrt: typeof inverseSqrt;
+        floor: typeof floor;
+        ceil: typeof ceil;
+        normalize: typeof normalize;
+        fract: typeof fract;
+        sin: typeof sin;
+        cos: typeof cos;
+        tan: typeof tan;
+        asin: typeof asin;
+        acos: typeof acos;
+        atan: typeof atan;
+        abs: typeof abs;
+        sign: typeof sign;
+        length: typeof length;
+        negate: typeof negate;
+        oneMinus: typeof oneMinus;
+        dFdx: typeof dFdx;
+        dFdy: typeof dFdy;
+        round: typeof round;
+        reciprocal: typeof reciprocal;
+        trunc: typeof trunc;
+        fwidth: typeof fwidth;
+        atan2: typeof atan2;
+        min: typeof min;
+        max: typeof max;
+        mod: typeof mod;
+        step: typeof step;
+        reflect: typeof reflect;
+        distance: typeof distance;
+        dot: typeof dot;
+        cross: typeof cross;
+        pow: typeof pow;
+        pow2: typeof pow2;
+        pow3: typeof pow3;
+        pow4: typeof pow4;
+        transformDirection: typeof transformDirection;
+        mix: typeof mixElement;
+        clamp: typeof clamp;
+        refract: typeof refract;
+        smoothstep: typeof smoothstepElement;
+        faceForward: typeof faceForward;
+        difference: typeof difference;
+        saturate: typeof saturate;
+    }
+}

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

@@ -1,5 +1,6 @@
 import TempNode from '../core/TempNode.js';
 import Node from '../core/Node.js';
+import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 export type OperatorNodeOp =
     | '='
@@ -29,3 +30,53 @@ export default class OperatorNode extends TempNode {
 
     constructor(op: OperatorNodeOp, ...params: [Node, Node, ...Node[]]);
 }
+
+export type Operator = (
+    a: NodeRepresentation,
+    b: NodeRepresentation,
+    ...others: NodeRepresentation[]
+) => ShaderNodeObject<OperatorNode>;
+
+export const add: Operator;
+export const sub: Operator;
+export const mul: Operator;
+export const div: Operator;
+export const remainder: Operator;
+export const equal: Operator;
+export const assign: Operator;
+export const lessThan: Operator;
+export const greaterThan: Operator;
+export const lessThanEqual: Operator;
+export const greaterThanEqual: Operator;
+export const and: Operator;
+export const or: Operator;
+export const xor: Operator;
+export const bitAnd: Operator;
+export const bitOr: Operator;
+export const bitXor: Operator;
+export const shiftLeft: Operator;
+export const shiftRight: Operator;
+
+declare module '../shadernode/ShaderNode.js' {
+    interface NodeElements {
+        add: typeof add;
+        sub: typeof sub;
+        mul: typeof mul;
+        div: typeof div;
+        remainder: typeof remainder;
+        equal: typeof equal;
+        assign: typeof assign;
+        lessThan: typeof lessThan;
+        greaterThan: typeof greaterThan;
+        lessThanEqual: typeof lessThanEqual;
+        greaterThanEqual: typeof greaterThanEqual;
+        and: typeof and;
+        or: typeof or;
+        xor: typeof xor;
+        bitAnd: typeof bitAnd;
+        bitOr: typeof bitOr;
+        bitXor: typeof bitXor;
+        shiftLeft: typeof shiftLeft;
+        shiftRight: typeof shiftRight;
+    }
+}

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

@@ -1,6 +1,9 @@
 import TempNode from '../core/TempNode.js';
+import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 export default class CheckerNode extends TempNode {
     uvNode: Node;
     constructor(uvNode?: Node);
 }
+
+export const checker: (uvNode?: NodeRepresentation) => ShaderNodeObject<CheckerNode>;

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

@@ -1,20 +1,37 @@
-import { ConstNode, Node, NodeBuilder, NodeTypeOption, SwizzleOption } from '../Nodes.js';
-// lot of private typescript magic here
-export {};
+import Node from '../core/Node.js';
+import { NodeTypeOption, SwizzleOption } from '../core/constants.js';
+import ConstNode from '../core/ConstNode.js';
+import NodeBuilder from '../core/NodeBuilder.js';
+import SplitNode from '../utils/SplitNode.js';
+
+export interface NodeElements {}
+
+export function addNodeElement(name: string, nodeElement: unknown): void;
+
 export type Swizzable<T extends Node = Node> = T & {
-    [key in SwizzleOption | number]: Swizzable;
+    [key in SwizzleOption | number]: ShaderNodeObject<SplitNode>;
 };
 
+export type ShaderNodeObject<T extends Node> = T & {
+    [Key in keyof NodeElements]: NodeElements[Key] extends (node: T, ...args: infer Args) => infer R
+        ? (...args: Args) => R
+        : never;
+} & Swizzable<T>;
+
 /** anything that can be passed to {@link nodeObject} and returns a proxy */
-export type NodeRepresentation<T extends Node = Node> = number | boolean | Node | Swizzable<T>;
+export type NodeRepresentation<T extends Node = Node> = number | boolean | Node | ShaderNodeObject<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;
+// same logic as in ShaderNodeObject: number,boolean,node->ShaderNodeObject, otherwise do nothing
+export type NodeObject<T> = T extends Node
+    ? ShaderNodeObject<T>
+    : T extends number | boolean
+    ? ShaderNodeObject<ConstNode<number | boolean>>
+    : T;
 
-// opposite of NodeObject: node -> node|swizzable|boolean|number, otherwise do nothing
+// opposite of NodeObject: node -> node|ShaderNodeObject|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]> }];
@@ -102,11 +119,7 @@ type GetConstructorsByScope<T, S> = ConstructorUnion<FilterConstructorsByScope<O
 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;
-};
+export type ConvertType = (...params: unknown[]) => ShaderNodeObject<Node>;
 
 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] };
@@ -114,7 +127,16 @@ type ConstructedNode<T> = T extends new (...args: any[]) => infer R ? (R extends
 
 export type NodeOrType = Node | NodeTypeOption;
 
-export function getConstNodeType(value: NodeOrType): NodeTypeOption | null;
+export const getConstNodeType: (value: NodeOrType) => NodeTypeOption | null;
+
+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 ? ShaderNodeObject<Node> | Node : T[key] },
+        builder?: NodeBuilder,
+    ) => ShaderNodeObject<R>;
+}
+
 export function nodeObject<T extends NodeObjectOption>(obj: T): NodeObject<T>;
 export function nodeObjects<T>(obj: T): NodeObjects<T>;
 
@@ -122,35 +144,55 @@ export function nodeArray<T extends NodeObjectOption[]>(obj: readonly [...T]): N
 
 export function nodeProxy<T>(
     nodeClass: T,
-): (...params: ProxiedTuple<GetConstructors<T>>) => Swizzable<ConstructedNode<T>>;
+): (...params: ProxiedTuple<GetConstructors<T>>) => ShaderNodeObject<ConstructedNode<T>>;
 
 export function nodeProxy<T, S extends GetPossibleScopes<T>>(
     nodeClass: T,
     scope: S,
-): (...params: ProxiedTuple<RemoveTail<GetConstructorsByScope<T, S>>>) => Swizzable<ConstructedNode<T>>;
+): (...params: ProxiedTuple<RemoveTail<GetConstructorsByScope<T, S>>>) => ShaderNodeObject<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>>;
+): (...params: ProxiedTuple<RemoveHeadAndTail<GetConstructorsByScope<T, S>>>) => ShaderNodeObject<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>;
-};
+): ShaderNodeObject<ConstructedNode<T>>;
+
+export const color: ConvertType;
+
+export const float: ConvertType;
+export const int: ConvertType;
+export const uint: ConvertType;
+export const bool: ConvertType;
+
+export const vec2: ConvertType;
+export const ivec2: ConvertType;
+export const uvec2: ConvertType;
+export const bvec2: ConvertType;
+
+export const vec3: ConvertType;
+export const ivec3: ConvertType;
+export const uvec3: ConvertType;
+export const bvec3: ConvertType;
+
+export const vec4: ConvertType;
+export const ivec4: ConvertType;
+export const uvec4: ConvertType;
+export const bvec4: ConvertType;
+
+export const mat3: ConvertType;
+export const imat3: ConvertType;
+export const umat3: ConvertType;
+export const bmat3: ConvertType;
+
+export const mat4: ConvertType;
+export const imat4: ConvertType;
+export const umat4: ConvertType;
+export const bmat4: ConvertType;
+
+export const element: (node: NodeRepresentation, indexNode: NodeRepresentation) => ShaderNodeObject<Node>;
+export const convert: (node: NodeRepresentation, types: NodeTypeOption) => ShaderNodeObject<Node>;

three/examples/jsm/nodes/utils/EquirectUVNode.d.ts

@@ -1,6 +1,8 @@
 import { PositionNode, TempNode } from '../Nodes.js';
-import { Swizzable } from '../shadernode/ShaderNodeElements.js';
+import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 export default class EquirectUVNode extends TempNode {
-    constructor(dirNode?: Swizzable<PositionNode>);
+    constructor(dirNode?: ShaderNodeObject<PositionNode>);
 }
+
+export const equirectUV: ShaderNodeObject<EquirectUVNode>;

three/examples/jsm/nodes/utils/MatcapUVNode.d.ts

@@ -1,5 +1,8 @@
 import TempNode from '../core/TempNode.js';
+import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 export default class MatcapUVNode extends TempNode {
     constructor();
 }
+
+export const matcapUV: ShaderNodeObject<MatcapUVNode>;

three/examples/jsm/nodes/utils/MaxMipLevelNode.d.ts

@@ -1,11 +1,14 @@
-import UniformNode from '../core/UniformNode.js';
 import { Texture } from '../../../../src/Three.js';
-import { TextureNode } from '../Nodes.js';
+import UniformNode from '../core/UniformNode.js';
+import TextureNode from '../accessors/TextureNode.js';
+import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
-export default class MaxMipLevelNode extends UniformNode {
+export default class MaxMipLevelNode extends UniformNode<0> {
     textureNode: TextureNode;
 
     constructor(textureNode: TextureNode);
 
     get texture(): Texture;
 }
+
+export const maxMipLevel: (texture: Texture) => ShaderNodeObject<MaxMipLevelNode>;

three/examples/jsm/nodes/utils/OscNode.d.ts

@@ -1,4 +1,5 @@
 import Node from '../core/Node.js';
+import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 export type OscNodeMethod =
     | typeof OscNode.SINE
@@ -17,3 +18,8 @@ export default class OscNode extends Node {
 
     constructor(method: OscNodeMethod, timeNode?: Node);
 }
+
+export const oscSine: (timeNode?: NodeRepresentation) => ShaderNodeObject<OscNode>;
+export const oscSquare: (timeNode?: NodeRepresentation) => ShaderNodeObject<OscNode>;
+export const oscTriangle: (timeNode?: NodeRepresentation) => ShaderNodeObject<OscNode>;
+export const oscSawtooth: (timeNode?: NodeRepresentation) => ShaderNodeObject<OscNode>;

three/examples/jsm/nodes/utils/RemapNode.d.ts

@@ -1,4 +1,5 @@
 import Node from '../core/Node.js';
+import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 export default class RemapNode extends Node {
     node: Node;
@@ -11,3 +12,6 @@ export default class RemapNode extends Node {
 
     constructor(node: Node, inLowNode: Node, inHighNode: Node, outLowNode: Node, outHighNode: Node);
 }
+
+export const remap: (node: Node, inLowNode: Node) => ShaderNodeObject<RemapNode>;
+export const remapClamp: (node: Node, inLowNode: Node) => ShaderNodeObject<RemapNode>;

three/examples/jsm/nodes/utils/RotateUVNode.d.ts

@@ -1,5 +1,6 @@
 import TempNode from '../core/TempNode.js';
 import Node from '../core/Node.js';
+import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 export default class RotateUVNode extends TempNode {
     uvNode: Node;
@@ -8,3 +9,5 @@ export default class RotateUVNode extends TempNode {
 
     constructor(uvNode: Node, rotationNode: Node, centerNode?: Node);
 }
+
+export const rotateUV: (uvNode: Node, rotationNode: Node, centerNode?: Node) => ShaderNodeObject<RotateUVNode>;

three/examples/jsm/nodes/utils/SpecularMIPLevelNode.d.ts

@@ -1,4 +1,6 @@
-import { Node, TextureNode } from '../Nodes.js';
+import Node from '../core/Node.js';
+import TextureNode from '../accessors/TextureNode.js';
+import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 export default class SpecularMIPLevelNode extends Node {
     textureNode: TextureNode;
@@ -6,3 +8,5 @@ export default class SpecularMIPLevelNode extends Node {
 
     constructor(textureNode: TextureNode, roughnessNode?: Node | null);
 }
+
+export const specularMIPLevel: () => ShaderNodeObject<SpecularMIPLevelNode>;

three/examples/jsm/nodes/utils/SpriteSheetUVNode.d.ts

@@ -1,4 +1,5 @@
 import Node from '../core/Node.js';
+import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 export default class SpriteSheetUVNode extends Node {
     countNode: Node;
@@ -7,3 +8,9 @@ export default class SpriteSheetUVNode extends Node {
 
     constructor(countNode: Node, uvNode?: Node, frameNode?: Node);
 }
+
+export const spritesheetUV: (
+    countNode: NodeRepresentation,
+    uvNode?: NodeRepresentation,
+    frameNode?: NodeRepresentation,
+) => ShaderNodeObject<SpriteSheetUVNode>;

three/examples/jsm/nodes/utils/TimerNode.d.ts

@@ -1,4 +1,5 @@
 import UniformNode from '../core/UniformNode.js';
+import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 export type TimerNodeScope =
     | typeof TimerNode.LOCAL
@@ -6,7 +7,7 @@ export type TimerNodeScope =
     | typeof TimerNode.DELTA
     | typeof TimerNode.FRAME;
 
-export default class TimerNode extends UniformNode {
+export default class TimerNode extends UniformNode<number> {
     static LOCAL: 'local';
     static GLOBAL: 'global';
     static DELTA: 'delta';
@@ -17,3 +18,8 @@ export default class TimerNode extends UniformNode {
 
     constructor(scope?: TimerNodeScope, scale?: number, value?: number);
 }
+
+export const timerLocal: (timeScale?: number, value?: number) => ShaderNodeObject<TimerNode>;
+export const timerGlobal: (timeScale?: number, value?: number) => ShaderNodeObject<TimerNode>;
+export const timerDelta: (timeScale?: number, value?: number) => ShaderNodeObject<TimerNode>;
+export const frameId: ShaderNodeObject<TimerNode>;

three/examples/jsm/nodes/utils/TriplanarTexturesNode.d.ts

@@ -1,22 +1,37 @@
 import Node from '../core/Node.js';
-import { PositionNode, Swizzable, TextureNode } from '../Nodes.js';
+import PositionNode from '../accessors/PositionNode.js';
+import TextureNode from '../accessors/TextureNode.js';
+import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 export default class TriplanarTexturesNode extends Node {
     textureXNode: TextureNode;
     textureYNode: TextureNode | null;
     textureZNode: TextureNode | null;
 
-    scaleNode: Swizzable;
+    scaleNode: ShaderNodeObject<Node>;
 
-    positionNode: Swizzable<PositionNode>;
-    normalNode: Swizzable<PositionNode>;
+    positionNode: ShaderNodeObject<PositionNode>;
+    normalNode: ShaderNodeObject<PositionNode>;
 
     constructor(
         textureXNode: Node,
         textureYNode?: TextureNode | null,
         textureZNode?: TextureNode | null,
-        scaleNode?: Swizzable,
-        positionNode?: Swizzable<PositionNode>,
-        normalNode?: Swizzable<PositionNode>,
+        scaleNode?: ShaderNodeObject<Node>,
+        positionNode?: ShaderNodeObject<PositionNode>,
+        normalNode?: ShaderNodeObject<PositionNode>,
     );
 }
+
+export const triplanarTextures: (
+    textureXNode: NodeRepresentation,
+    textureYNode?: NodeRepresentation,
+    textureZNode?: NodeRepresentation,
+    scaleNode?: NodeRepresentation,
+    positionNode?: NodeRepresentation,
+    normalNode?: NodeRepresentation,
+) => ShaderNodeObject<TriplanarTexturesNode>;
+export const triplanarTexture: (
+    texture: NodeRepresentation,
+    ...params: NodeRepresentation[]
+) => ShaderNodeObject<TriplanarTexturesNode>;

three/examples/jsm/objects/QuadMesh.d.ts

@@ -0,0 +1,13 @@
+import { Material } from '../../../src/Three.js';
+import Renderer from '../renderers/common/Renderer.js';
+
+export default class QuadMesh {
+    constructor(material?: Material | null);
+
+    dispose(): void;
+
+    render(renderer: Renderer): void;
+
+    get material(): Material;
+    set material(value: Material);
+}