@types/three 0.179.0 → 0.181.0

three/src/nodes/tsl/TSLCore.d.ts

@@ -11,38 +11,15 @@ import NodeBuilder from "../core/NodeBuilder.js";
 import StackNode from "../core/StackNode.js";
 import JoinNode from "../utils/JoinNode.js";
 
-export interface NodeElements {
-    toStack: typeof Stack;
-
-    toColor: (node: Node) => ShaderNodeObject<Node>;
-    toFloat: (node: Node) => ShaderNodeObject<Node>;
-    toInt: (node: Node) => ShaderNodeObject<Node>;
-    toUint: (node: Node) => ShaderNodeObject<Node>;
-    toBool: (node: Node) => ShaderNodeObject<Node>;
-    toVec2: (node: Node) => ShaderNodeObject<Node>;
-    toIvec2: (node: Node) => ShaderNodeObject<Node>;
-    toUvec2: (node: Node) => ShaderNodeObject<Node>;
-    toBvec2: (node: Node) => ShaderNodeObject<Node>;
-    toVec3: (node: Node) => ShaderNodeObject<Node>;
-    toIvec3: (node: Node) => ShaderNodeObject<Node>;
-    toUvec3: (node: Node) => ShaderNodeObject<Node>;
-    toBvec3: (node: Node) => ShaderNodeObject<Node>;
-    toVec4: (node: Node) => ShaderNodeObject<Node>;
-    toIvec4: (node: Node) => ShaderNodeObject<Node>;
-    toUvec4: (node: Node) => ShaderNodeObject<Node>;
-    toBvec4: (node: Node) => ShaderNodeObject<Node>;
-    toMat2: (node: Node) => ShaderNodeObject<Node>;
-    toMat3: (node: Node) => ShaderNodeObject<Node>;
-    toMat4: (node: Node) => ShaderNodeObject<Node>;
-
-    element: typeof element;
-    convert: typeof convert;
-
-    append: typeof append;
-}
-
 export function addMethodChaining(name: string, nodeElement: unknown): void;
 
+declare module "../Nodes.js" {
+    interface Node {
+        assign: (sourceNode: Node | number) => this;
+        get: (value: string) => Node;
+    }
+}
+
 type XYZWCharacter = "x" | "y" | "z" | "w";
 type RGBACharacter = "r" | "g" | "b" | "a";
 type STPQCharacter = "s" | "t" | "p" | "q";
@@ -67,42 +44,65 @@ type STPQSwizzle =
 
 export type SwizzleOption = XYZWSwizzle | RGBASwizzle | STPQSwizzle;
 
-export type Swizzable<T extends Node = Node> =
-    & T
+export type ArrayElementIndex =
+    | 0
+    | 1
+    | 2
+    | 3
+    | 4
+    | 5
+    | 6
+    | 7
+    | 8
+    | 9
+    | 10
+    | 11
+    | 12
+    | 13
+    | 14
+    | 15
+    | 16
+    | 17
+    | 18
+    | 19
+    | 20
+    | 21
+    | 22
+    | 23
+    | 24
+    | 25
+    | 26
+    | 27
+    | 28
+    | 29
+    | 30
+    | 31;
+
+export type Swizzable =
     & {
-        [Key in SwizzleOption | number]: ShaderNodeObject<Node>;
+        [Key in SwizzleOption | ArrayElementIndex]: Node;
     }
     & {
-        [Key in SwizzleOption as `set${Uppercase<Key>}`]: (value: Node) => ShaderNodeObject<Node>;
+        [Key in SwizzleOption as `set${Uppercase<Key>}`]: (value: Node) => Node;
     }
     & {
-        [Key in SwizzleOption as `flip${Uppercase<Key>}`]: () => ShaderNodeObject<Node>;
+        [Key in SwizzleOption as `flip${Uppercase<Key>}`]: () => Node;
     };
 
-export type ShaderNodeObject<T extends Node> =
-    & T
-    & {
-        [Key in keyof NodeElements]: T extends { [K in Key]: infer M } ? M
-            : NodeElements[Key] extends (node: T, ...args: infer Args) => infer R ? (...args: Args) => R
-            : never;
+declare module "../Nodes.js" {
+    interface Node extends Swizzable {
     }
-    & {
-        [Key in keyof NodeElements as `${Key}Assign`]: T extends { [K in Key]: infer M } ? M
-            : NodeElements[Key] extends (node: T, ...args: infer Args) => unknown
-                ? (...args: Args) => ShaderNodeObject<T>
-            : never;
-    }
-    & Swizzable<T>;
+}
 
 /** anything that can be passed to {@link nodeObject} */
 export type NodeObjectOption = Node | number | string;
 
-// 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>>
+// same logic as in ShaderNodeObject: number,boolean,node->node, otherwise do nothing
+export type NodeObject<T> = T extends Node ? T
+    : T extends number | boolean ? ConstNode<number | boolean>
     : T;
 
-// opposite of NodeObject: node -> node|ShaderNodeObject|boolean|number, otherwise do nothing
+// opposite of NodeObject: node -> node|boolean|number, otherwise do nothing
 type Proxied<T> = T extends Node | number ? Node | number : T;
 // https://github.com/microsoft/TypeScript/issues/42435#issuecomment-765557874
 export type ProxiedTuple<T extends readonly [...unknown[]]> = [...{ [index in keyof T]: Proxied<T[index]> }];
@@ -204,9 +204,9 @@ export const getConstNodeType: (value: NodeOrType) => string | null;
 export class ShaderNode<T = {}, R extends Node = Node> {
     constructor(jsFunc: (inputs: NodeObjects<T>, builder: NodeBuilder) => Node);
     call: (
-        inputs: { [key in keyof T]: T[key] extends Node ? ShaderNodeObject<Node> | Node : T[key] },
+        inputs: { [key in keyof T]: T[key] extends Node ? Node : T[key] },
         builder?: NodeBuilder,
-    ) => ShaderNodeObject<R>;
+    ) => R;
 }
 
 export function nodeObject<T extends NodeObjectOption>(obj: T): NodeObject<T>;
@@ -217,38 +217,38 @@ export function nodeArray<T extends NodeObjectOption[]>(obj: readonly [...T]): N
 
 export function nodeProxy<T>(
     nodeClass: T,
-): (...params: ProxiedTuple<GetConstructors<T>>) => ShaderNodeObject<ConstructedNode<T>>;
+): (...params: ProxiedTuple<GetConstructors<T>>) => ConstructedNode<T>;
 
 export function nodeProxy<T, S extends GetPossibleScopes<T>>(
     nodeClass: T,
     scope: S,
-): (...params: ProxiedTuple<RemoveTail<GetConstructorsByScope<T, S>>>) => ShaderNodeObject<ConstructedNode<T>>;
+): (...params: ProxiedTuple<RemoveTail<GetConstructorsByScope<T, S>>>) => ConstructedNode<T>;
 
 export function nodeProxy<T, S extends GetPossibleScopes<T>>(
     nodeClass: T,
     scope: S,
     factor: NodeObjectOption,
-): (...params: ProxiedTuple<RemoveHeadAndTail<GetConstructorsByScope<T, S>>>) => ShaderNodeObject<ConstructedNode<T>>;
+): (...params: ProxiedTuple<RemoveHeadAndTail<GetConstructorsByScope<T, S>>>) => ConstructedNode<T>;
 
 export function nodeImmutable<T>(
     nodeClass: T,
     ...params: ProxiedTuple<GetConstructors<T>>
-): ShaderNodeObject<ConstructedNode<T>>;
+): ConstructedNode<T>;
 
 export function nodeProxyIntent<T>(
     nodeClass: T,
-): (...params: ProxiedTuple<GetConstructors<T>>) => ShaderNodeObject<ConstructedNode<T>>;
+): (...params: ProxiedTuple<GetConstructors<T>>) => ConstructedNode<T>;
 
 export function nodeProxyIntent<T, S extends GetPossibleScopes<T>>(
     nodeClass: T,
     scope: S,
-): (...params: ProxiedTuple<RemoveTail<GetConstructorsByScope<T, S>>>) => ShaderNodeObject<ConstructedNode<T>>;
+): (...params: ProxiedTuple<RemoveTail<GetConstructorsByScope<T, S>>>) => ConstructedNode<T>;
 
 export function nodeProxyIntent<T, S extends GetPossibleScopes<T>>(
     nodeClass: T,
     scope: S,
     factor: NodeObjectOption,
-): (...params: ProxiedTuple<RemoveHeadAndTail<GetConstructorsByScope<T, S>>>) => ShaderNodeObject<ConstructedNode<T>>;
+): (...params: ProxiedTuple<RemoveHeadAndTail<GetConstructorsByScope<T, S>>>) => ConstructedNode<T>;
 
 interface Layout {
     name: string;
@@ -260,10 +260,10 @@ interface Layout {
     }[];
 }
 
-interface ShaderNodeFn<Args extends readonly unknown[]> {
-    (...args: Args): ShaderNodeObject<ShaderCallNodeInternal>;
+export interface ShaderNodeFn<Args extends readonly unknown[]> {
+    (...args: Args): ShaderCallNodeInternal;
 
-    shaderNode: ShaderNodeObject<ShaderNodeInternal>;
+    shaderNode: ShaderNodeInternal;
     id: number;
 
     getNodeType: (builder: NodeBuilder) => string | null;
@@ -274,12 +274,14 @@ interface ShaderNodeFn<Args extends readonly unknown[]> {
     once: (subBuilds?: string[] | null) => this;
 }
 
-export function Fn(jsFunc: (builder: NodeBuilder) => void): ShaderNodeFn<[]>;
+export function Fn(jsFunc: (builder: NodeBuilder) => void, layout?: string | Record<string, string>): ShaderNodeFn<[]>;
 export function Fn<T extends readonly unknown[]>(
     jsFunc: (args: T, builder: NodeBuilder) => void,
+    layout?: string | Record<string, string>,
 ): ShaderNodeFn<ProxiedTuple<T>>;
 export function Fn<T extends { readonly [key: string]: unknown }>(
     jsFunc: (args: T, builder: NodeBuilder) => void,
+    layout?: string | Record<string, string>,
 ): ShaderNodeFn<[ProxiedObject<T>]>;
 
 export const setCurrentStack: (stack: StackNode | null) => void;
@@ -291,17 +293,24 @@ export const Switch: (expression: Node) => StackNode;
 
 export function Stack(node: Node): Node;
 
+declare module "../Nodes.js" {
+    interface Node {
+        toStack: () => Node;
+        toStackAssign: () => this;
+    }
+}
+
 interface ColorFunction {
     // The first branch in `ConvertType` will forward the parameters to the `Color` constructor if there are no
     //   parameters or all the parameters are non-objects
-    (color?: string | number): ShaderNodeObject<ConstNode<Color>>;
-    (r: number, g: number, b: number): ShaderNodeObject<ConstNode<Color>>;
+    (color?: string | number): ConstNode<Color>;
+    (r: number, g: number, b: number): ConstNode<Color>;
 
     // The second branch does not apply because `cacheMap` is `null`
 
     // The third branch will be triggered if there is a single parameter.
-    (color: Color): ShaderNodeObject<ConstNode<Color>>;
-    (node: Node): ShaderNodeObject<Node>;
+    (color: Color): ConstNode<Color>;
+    (node: Node): Node;
 
     // The fall-through branch will be triggered if there is more than one parameter, or one of the parameters is an
     // object. Not sure which cases are worth considering here.
@@ -310,8 +319,8 @@ interface ColorFunction {
 export const color: ColorFunction;
 
 interface NumberFunction {
-    (value?: number): ShaderNodeObject<ConstNode<number>>;
-    (node: Node): ShaderNodeObject<Node>;
+    (value?: number): ConstNode<number>;
+    (node: Node): Node;
 }
 
 export const float: NumberFunction;
@@ -319,8 +328,8 @@ export const int: NumberFunction;
 export const uint: NumberFunction;
 
 interface BooleanFunction {
-    (value?: boolean): ShaderNodeObject<ConstNode<boolean>>;
-    (node: Node): ShaderNodeObject<Node>;
+    (value?: boolean): ConstNode<boolean>;
+    (node: Node): Node;
 }
 
 export const bool: BooleanFunction;
@@ -328,126 +337,224 @@ export const bool: BooleanFunction;
 interface Vector2Function {
     // The first branch in `ConvertType` will forward the parameters to the `Vector2` constructor if there are no
     //   parameters or all the parameters are non-objects
-    (x?: number, y?: number): ShaderNodeObject<ConstNode<Vector2>>;
+    (x?: number, y?: number): ConstNode<Vector2>;
 
     // The second branch does not apply because `cacheMap` is `null`
 
     // The third branch will be triggered if there is a single parameter.
-    (value: Vector2): ShaderNodeObject<ConstNode<Vector2>>;
-    (node: Node): ShaderNodeObject<Node>;
+    (value: Vector2): ConstNode<Vector2>;
+    (node: Node): Node;
 
     // The fall-through branch will be triggered if there is more than one parameter, or one of the parameters is an
     // object.
-    (x: Node | number, y: Node | number): ShaderNodeObject<JoinNode>;
+    (x: Node | number, y: Node | number): JoinNode;
 }
 
 export const vec2: Vector2Function;
 export const ivec2: Vector2Function;
 export const uvec2: Vector2Function;
-export const bvec2: (node: Node) => ShaderNodeObject<Node>;
+export const bvec2: (node: Node) => Node;
 
 interface Vector3Function {
     // The first branch in `ConvertType` will forward the parameters to the `Vector3` constructor if there are no
     //   parameters or all the parameters are non-objects
-    (x?: number, y?: number, z?: number): ShaderNodeObject<ConstNode<Vector3>>;
+    (x?: number, y?: number, z?: number): ConstNode<Vector3>;
 
     // The second branch does not apply because `cacheMap` is `null`
 
     // The third branch will be triggered if there is a single parameter.
-    (value: Vector3): ShaderNodeObject<ConstNode<Vector3>>;
-    (node: Node): ShaderNodeObject<Node>;
+    (value: Vector3): ConstNode<Vector3>;
+    (node: Node): Node;
 
     // The fall-through branch will be triggered if there is more than one parameter, or one of the parameters is an
     // object.
-    (x: Node | number, y: Node | number, z?: Node | number): ShaderNodeObject<JoinNode>;
+    (x: Node | number, y: Node | number, z?: Node | number): JoinNode;
 }
 
 export const vec3: Vector3Function;
 export const ivec3: Vector3Function;
 export const uvec3: Vector3Function;
-export const bvec3: (node: Node) => ShaderNodeObject<Node>;
+export const bvec3: (node: Node) => Node;
 
 interface Vector4Function {
     // The first branch in `ConvertType` will forward the parameters to the `Vector4` constructor if there are no
     //   parameters or all the parameters are non-objects
-    (x?: number, y?: number, z?: number, w?: number): ShaderNodeObject<ConstNode<Vector4>>;
+    (x?: number, y?: number, z?: number, w?: number): ConstNode<Vector4>;
 
     // The second branch does not apply because `cacheMap` is `null`
 
     // The third branch will be triggered if there is a single parameter.
-    (value: Vector4): ShaderNodeObject<ConstNode<Vector4>>;
-    (node: Node): ShaderNodeObject<Node>;
+    (value: Vector4): ConstNode<Vector4>;
+    (node: Node): Node;
 
     // The fall-through branch will be triggered if there is more than one parameter, or one of the parameters is an
     // object.
-    (x: Node | number, y: Node | number, z?: Node | number, w?: Node | number): ShaderNodeObject<JoinNode>;
+    (x: Node | number, y: Node | number, z?: Node | number, w?: Node | number): JoinNode;
 }
 
 export const vec4: Vector4Function;
 export const ivec4: Vector4Function;
 export const uvec4: Vector4Function;
-export const bvec4: (node: Node) => ShaderNodeObject<Node>;
+export const bvec4: (node: Node) => Node;
 
 interface Matrix2Function {
-    (value: Matrix2): ShaderNodeObject<ConstNode<Matrix2>>;
-    (node: Node): ShaderNodeObject<Node>;
+    (value: Matrix2): ConstNode<Matrix2>;
+    (node: Node): Node;
 }
 
 export const mat2: Matrix2Function;
 
 interface Matrix3Function {
-    (value: Matrix3): ShaderNodeObject<ConstNode<Matrix3>>;
+    (value: Matrix3): ConstNode<Matrix3>;
+    (
+        n11: number | Node,
+        n12: number | Node,
+        n13: number | Node,
+        n21: number | Node,
+        n22: number | Node,
+        n23: number | Node,
+        n31: number | Node,
+        n32: number | Node,
+        n33: number | Node,
+    ): Node;
+    (): ConstNode<Matrix3>;
     (
-        n11: number,
-        n12: number,
-        n13: number,
-        n21: number,
-        n22: number,
-        n23: number,
-        n31: number,
-        n32: number,
-        n33: number,
-    ): ShaderNodeObject<ConstNode<Matrix3>>;
-    (): ShaderNodeObject<ConstNode<Matrix3>>;
-    (node: Node): ShaderNodeObject<Node>;
+        p1: Node,
+        p2: Node,
+        p3: Node,
+    ): Node;
+    (node: Node): Node;
 }
 
 export const mat3: Matrix3Function;
 
 interface Matrix4Function {
-    (value: Matrix4): ShaderNodeObject<ConstNode<Matrix4>>;
+    (value: Matrix4): ConstNode<Matrix4>;
+    (
+        n11: number | Node,
+        n12: number | Node,
+        n13: number | Node,
+        n14: number | Node,
+        n21: number | Node,
+        n22: number | Node,
+        n23: number | Node,
+        n24: number | Node,
+        n31: number | Node,
+        n32: number | Node,
+        n33: number | Node,
+        n34: number | Node,
+        n41: number | Node,
+        n42: number | Node,
+        n43: number | Node,
+        n44: number | Node,
+    ): Node;
+    (): ConstNode<Matrix4>;
     (
-        n11: number,
-        n12: number,
-        n13: number,
-        n14: number,
-        n21: number,
-        n22: number,
-        n23: number,
-        n24: number,
-        n31: number,
-        n32: number,
-        n33: number,
-        n34: number,
-        n41: number,
-        n42: number,
-        n43: number,
-        n44: number,
-    ): ShaderNodeObject<ConstNode<Matrix4>>;
-    (): ShaderNodeObject<ConstNode<Matrix4>>;
-    (node: Node): ShaderNodeObject<Node>;
+        p1: Node,
+        p2: Node,
+        p3: Node,
+        p4: Node,
+    ): Node;
+    (node: Node): Node;
 }
 
 export const mat4: Matrix4Function;
 
-export const string: (value?: string) => ShaderNodeObject<ConstNode<string>>;
-export const arrayBuffer: (value: ArrayBuffer) => ShaderNodeObject<ConstNode<ArrayBuffer>>;
+export const string: (value?: string) => ConstNode<string>;
+export const arrayBuffer: (value: ArrayBuffer) => ConstNode<ArrayBuffer>;
+
+declare module "../Nodes.js" {
+    interface Node {
+        toColor: () => Node;
+        toColorAssign: () => this;
+
+        toFloat: () => Node;
+        toFloatAssign: () => this;
+
+        toInt: () => Node;
+        toIntAssign: () => this;
+
+        toUint: () => Node;
+        toUintAssign: () => this;
+
+        toBool: () => Node;
+        toBoolAssign: () => this;
+
+        toVec2: () => Node;
+        toVec2Assign: () => this;
+
+        toIvec2: () => Node;
+        toIvec2Assign: () => this;
+
+        toUvec2: () => Node;
+        toUvec2Assign: () => this;
 
-export const element: (node: Node, indexNode: Node) => ShaderNodeObject<Node>;
-export const convert: (node: Node, types: string) => ShaderNodeObject<Node>;
-export const split: (node: Node, channels?: string) => ShaderNodeObject<Node>;
+        toBvec2: () => Node;
+        toBvec2Assign: () => this;
+
+        toVec3: () => Node;
+        toVec3Assign: () => this;
+
+        toIvec3: () => Node;
+        toIvec3Assign: () => this;
+
+        toUvec3: () => Node;
+        toUvec3Assign: () => this;
+
+        toBvec3: () => Node;
+        ttoBvec3Assign: () => this;
+
+        toVec4: () => Node;
+        toVec4Assign: () => this;
+
+        toIvec4: () => Node;
+        toIvec4Assign: () => this;
+
+        toUvec4: () => Node;
+        toUvec4Assign: () => this;
+
+        toBvec4: () => Node;
+        toBvec4Assign: () => this;
+
+        toMat2: () => Node;
+        toMat2Assign: () => this;
+
+        toMat3: () => Node;
+        toMat3Assign: () => this;
+
+        toMat4: () => Node;
+        toMat4Assign: () => this;
+    }
+}
+
+export const element: (node: Node, indexNode: Node) => Node;
+export const convert: (node: Node, types: string) => Node;
+export const split: (node: Node, channels?: string) => Node;
+
+declare module "../Nodes.js" {
+    interface Node {
+        element: (indexNode: Node) => Node;
+        elementAssign: (indexNode: Node) => this;
+
+        convert: (types: string) => Node;
+        convertAssign: (types: string) => this;
+    }
+}
 
 /**
  * @deprecated append() has been renamed to Stack().
  */
 export const append: (node: Node) => Node;
+
+declare module "../Nodes.js" {
+    interface Node {
+        /**
+         * @deprecated append() has been renamed to Stack().
+         */
+        append: () => Node;
+        /**
+         * @deprecated append() has been renamed to Stack().
+         */
+        appendAssign: () => this;
+    }
+}

three/src/nodes/utils/CubeMapNode.d.ts

@@ -1,6 +1,5 @@
 import Node from "../core/Node.js";
 import TempNode from "../core/TempNode.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
 declare class CubeMapNode extends TempNode {
     envNode: Node;
@@ -10,4 +9,4 @@ declare class CubeMapNode extends TempNode {
 
 export default CubeMapNode;
 
-export const cubeMapNode: (envNode: Node) => ShaderNodeObject<CubeMapNode>;
+export const cubeMapNode: (envNode: Node) => CubeMapNode;

three/src/nodes/utils/DebugNode.d.ts

@@ -1,7 +1,6 @@
 import Node from "../core/Node.js";
 import NodeBuilder from "../core/NodeBuilder.js";
 import TempNode from "../core/TempNode.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
 declare class DebugNode extends TempNode {
     constructor(node: Node, callback?: ((code: string) => void) | null);
@@ -12,10 +11,15 @@ export default DebugNode;
 export const debug: (
     node: Node,
     callback?: ((node: NodeBuilder, code: string) => void) | null,
-) => ShaderNodeObject<DebugNode>;
+) => DebugNode;
 
-declare module "../tsl/TSLCore.js" {
-    interface NodeElements {
-        debug: typeof debug;
+declare module "../Nodes.js" {
+    interface Node {
+        debug: (
+            callback?: ((node: NodeBuilder, code: string) => void) | null,
+        ) => DebugNode;
+        debugAssign: (
+            callback?: ((node: NodeBuilder, code: string) => void) | null,
+        ) => this;
     }
 }

three/src/nodes/utils/Discard.d.ts

@@ -1,11 +1,11 @@
 import Node from "../core/Node.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
-export const Discard: (conditional?: Node) => ShaderNodeObject<Node>;
-export const Return: () => ShaderNodeObject<Node>;
+export const Discard: (conditional?: Node) => Node;
+export const Return: () => Node;
 
-declare module "../tsl/TSLCore.js" {
-    interface NodeElements {
-        discard: typeof Discard;
+declare module "../Nodes.js" {
+    interface Node {
+        discard: () => Node;
+        discardAssign: () => this;
     }
 }

three/src/nodes/utils/EquirectUV.d.ts

@@ -1,4 +1,3 @@
 import Node from "../core/Node.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
-export const equirectUV: (dirNode?: Node) => ShaderNodeObject<Node>;
+export const equirectUV: (dirNode?: Node) => Node;

three/src/nodes/utils/EventNode.d.ts

@@ -1,6 +1,5 @@
 import Node from "../core/Node.js";
 import NodeFrame from "../core/NodeFrame.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
 export type EventNodeType = typeof EventNode.OBJECT | typeof EventNode.MATERIAL;
 
@@ -12,10 +11,16 @@ declare class EventNode extends Node {
 
     static OBJECT: "object";
     static MATERIAL: "material";
+    static BEFORE_OBJECT: "beforeObject";
+    static BEFORE_MATERIAL: "beforeMaterial";
 }
 
 export default EventNode;
 
-export const OnObjectUpdate: (callback: (frame: NodeFrame) => void) => ShaderNodeObject<Node>;
+export const OnObjectUpdate: (callback: (frame: NodeFrame) => void) => Node;
 
-export const OnMaterialUpdate: (callback: (frame: NodeFrame) => void) => ShaderNodeObject<Node>;
+export const OnMaterialUpdate: (callback: (frame: NodeFrame) => void) => Node;
+
+export const OnBeforeObjectUpdate: (callback: (frame: NodeFrame) => void) => Node;
+
+export const OnBeforeMaterialUpdate: (callback: (frame: NodeFrame) => void) => Node;

three/src/nodes/utils/FunctionOverloadingNode.d.ts

@@ -1,5 +1,4 @@
 import Node from "../core/Node.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
 declare class FunctionOverloadingNode extends Node {
     functionNodes: Node[];
@@ -10,4 +9,4 @@ declare class FunctionOverloadingNode extends Node {
 
 export default FunctionOverloadingNode;
 
-export const overloadingFn: (functionNodes: Node[]) => (...params: Node[]) => ShaderNodeObject<FunctionOverloadingNode>;
+export const overloadingFn: (functionNodes: Node[]) => (...params: Node[]) => FunctionOverloadingNode;