@types/three 0.184.1 → 0.185.0

three/src/nodes/core/Node.d.ts

@@ -154,30 +154,6 @@ declare class NodeClass<TEventMap extends NodeClassEventMap = NodeClassEventMap>
      * @default true
      */
     readonly isNode: boolean;
-    /**
-     * The cache key of this node.
-     *
-     * @private
-     * @type {?number}
-     * @default null
-     */
-    private _cacheKey;
-    /**
-     * The UUID of the node.
-     *
-     * @type {string}
-     * @default null
-     * @private
-     */
-    private _uuid;
-    /**
-     * The cache key's version.
-     *
-     * @private
-     * @type {number}
-     * @default 0
-     */
-    private _cacheKeyVersion;
     /**
      * The unique ID of the node.
      *
@@ -238,7 +214,7 @@ declare class NodeClass<TEventMap extends NodeClassEventMap = NodeClassEventMap>
      * @param {Function} callback - The update method.
      * @return {Node} A reference to this node.
      */
-    onFrameUpdate(callback: (this: this, frame: NodeFrame) => void): this;
+    onFrameUpdate(callback: (this: this, frame: NodeFrame) => unknown): this;
     /**
      * Convenient method for defining {@link Node#update}. Similar to {@link Node#onUpdate}, but
      * this method automatically sets the update type to `RENDER`.
@@ -246,7 +222,7 @@ declare class NodeClass<TEventMap extends NodeClassEventMap = NodeClassEventMap>
      * @param {Function} callback - The update method.
      * @return {Node} A reference to this node.
      */
-    onRenderUpdate(callback: (this: this, frame: NodeFrame) => void): this;
+    onRenderUpdate(callback: (this: this, frame: NodeFrame) => unknown): this;
     /**
      * Convenient method for defining {@link Node#update}. Similar to {@link Node#onUpdate}, but
      * this method automatically sets the update type to `OBJECT`.
@@ -254,7 +230,7 @@ declare class NodeClass<TEventMap extends NodeClassEventMap = NodeClassEventMap>
      * @param {Function} callback - The update method.
      * @return {Node} A reference to this node.
      */
-    onObjectUpdate(callback: (this: this, frame: NodeFrame) => void): this;
+    onObjectUpdate(callback: (this: this, frame: NodeFrame) => unknown): this;
     /**
      * Convenient method for defining {@link Node#updateReference}.
      *
@@ -297,14 +273,6 @@ declare class NodeClass<TEventMap extends NodeClassEventMap = NodeClassEventMap>
      * @param {traverseCallback} callback - A callback that is executed per node.
      */
     traverse(callback: (node: Node) => void): void;
-    /**
-     * Returns the child nodes of this node.
-     *
-     * @private
-     * @param {Set<Node>} [ignores=new Set()] - A set of nodes to ignore during the search to avoid circular references.
-     * @returns {Array<Object>} An array of objects describing the child nodes.
-     */
-    private _getChildren;
     /**
      * Returns the cache key for this node.
      *
@@ -389,7 +357,8 @@ declare class NodeClass<TEventMap extends NodeClassEventMap = NodeClassEventMap>
      * This method is used during the build process of a node and ensures
      * equal nodes are not built multiple times but just once. For example if
      * `attribute( 'uv' )` is used multiple times by the user, the build
-     * process makes sure to process just the first node.
+     * process makes sure to process just the first node. It also handles
+     * node overrides if an override context is set.
      *
      * @param {NodeBuilder} builder - The current node builder.
      * @return {Node} The shared node if possible. Otherwise `this` is returned.
@@ -563,6 +532,18 @@ export interface ColorExtensions {
 export interface FloatVecExtensions<TVec extends FloatVecType> {
 }
 
+export interface FloatOrVecExtensions<TNodeType> {
+}
+
+export interface IntOrVecExtensions<TNodeType> {
+}
+
+export interface UintOrVecExtensions<TNodeType> {
+}
+
+export interface BoolOrVecExtensions<TNodeType> {
+}
+
 export interface Mat2Extensions {
 }
 
@@ -579,36 +560,54 @@ type Node<TNodeType = unknown> =
     & NodeClass
     & NodeElements
     & (unknown extends TNodeType ? {} : NodeExtensions<TNodeType>)
-    & (TNodeType extends "float" ? NumOrBoolExtensions<"float"> & FloatExtensions & NumExtensions<"float">
-        : TNodeType extends "int"
-            ? NumOrBoolExtensions<"int"> & IntExtensions & NumExtensions<"int"> & IntegerExtensions<"int">
-        : TNodeType extends "uint"
-            ? NumOrBoolExtensions<"uint"> & UintExtensions & NumExtensions<"uint"> & IntegerExtensions<"uint">
-        : TNodeType extends "bool" ? NumOrBoolExtensions<"bool"> & BoolExtensions
+    & (TNodeType extends "float"
+        ? NumOrBoolExtensions<"float"> & FloatExtensions & NumExtensions<"float"> & FloatOrVecExtensions<"float">
+        : TNodeType extends "int" ?
+                & NumOrBoolExtensions<"int">
+                & IntExtensions
+                & NumExtensions<"int">
+                & IntegerExtensions<"int">
+                & IntOrVecExtensions<"int">
+        : TNodeType extends "uint" ?
+                & NumOrBoolExtensions<"uint">
+                & UintExtensions
+                & NumExtensions<"uint">
+                & IntegerExtensions<"uint">
+                & IntOrVecExtensions<"uint">
+        : TNodeType extends "bool" ? NumOrBoolExtensions<"bool"> & BoolExtensions & BoolOrVecExtensions<"bool">
         : TNodeType extends "vec2" ?
                 & NumOrBoolVec2Extensions<"float">
                 & Vec2Extensions
                 & NumVec2Extensions<"float">
                 & FloatVecExtensions<"vec2">
-        : TNodeType extends "ivec2" ? NumOrBoolVec2Extensions<"int"> & NumVec2Extensions<"int">
-        : TNodeType extends "uvec2" ? NumOrBoolVec2Extensions<"uint"> & NumVec2Extensions<"uint">
-        : TNodeType extends "bvec2" ? NumOrBoolVec2Extensions<"bool">
+                & FloatOrVecExtensions<"vec2">
+        : TNodeType extends "ivec2"
+            ? NumOrBoolVec2Extensions<"int"> & NumVec2Extensions<"int"> & IntOrVecExtensions<"ivec2">
+        : TNodeType extends "uvec2"
+            ? NumOrBoolVec2Extensions<"uint"> & NumVec2Extensions<"uint"> & IntOrVecExtensions<"uvec2">
+        : TNodeType extends "bvec2" ? NumOrBoolVec2Extensions<"bool"> & BoolOrVecExtensions<"bvec2">
         : TNodeType extends "vec3" ?
                 & NumOrBoolVec3Extensions<"float">
                 & Vec3Extensions
                 & NumVec3Extensions<"float">
                 & FloatVecExtensions<"vec3">
-        : TNodeType extends "ivec3" ? NumOrBoolVec3Extensions<"int"> & NumVec3Extensions<"int">
-        : TNodeType extends "uvec3" ? NumOrBoolVec3Extensions<"uint"> & NumVec3Extensions<"uint">
-        : TNodeType extends "bvec3" ? NumOrBoolVec3Extensions<"bool">
+                & FloatOrVecExtensions<"vec3">
+        : TNodeType extends "ivec3"
+            ? NumOrBoolVec3Extensions<"int"> & NumVec3Extensions<"int"> & IntOrVecExtensions<"ivec3">
+        : TNodeType extends "uvec3"
+            ? NumOrBoolVec3Extensions<"uint"> & NumVec3Extensions<"uint"> & IntOrVecExtensions<"uvec3">
+        : TNodeType extends "bvec3" ? NumOrBoolVec3Extensions<"bool"> & BoolOrVecExtensions<"bvec3">
         : TNodeType extends "vec4" ?
                 & NumOrBoolVec4Extensions<"float">
                 & Vec4Extensions
                 & NumVec4Extensions<"float">
                 & FloatVecExtensions<"vec4">
-        : TNodeType extends "ivec4" ? NumOrBoolVec4Extensions<"int"> & NumVec4Extensions<"int">
-        : TNodeType extends "uvec4" ? NumOrBoolVec4Extensions<"uint"> & NumVec4Extensions<"uint">
-        : TNodeType extends "bvec4" ? NumOrBoolVec4Extensions<"bool">
+                & FloatOrVecExtensions<"vec4">
+        : TNodeType extends "ivec4"
+            ? NumOrBoolVec4Extensions<"int"> & NumVec4Extensions<"int"> & IntOrVecExtensions<"ivec4">
+        : TNodeType extends "uvec4"
+            ? NumOrBoolVec4Extensions<"uint"> & NumVec4Extensions<"uint"> & IntOrVecExtensions<"uvec4">
+        : TNodeType extends "bvec4" ? NumOrBoolVec4Extensions<"bool"> & BoolOrVecExtensions<"bvec4">
         : TNodeType extends "color" ? ColorExtensions
         : TNodeType extends "mat2" ? Mat2Extensions & MatExtensions<"mat2">
         : TNodeType extends "mat3" ? Mat3Extensions & MatExtensions<"mat3">

three/src/nodes/core/NodeBuilder.d.ts

@@ -2,143 +2,11 @@ import { BufferGeometry } from "../../core/BufferGeometry.js";
 import { Object3D } from "../../core/Object3D.js";
 import { Material } from "../../materials/Material.js";
 import Renderer from "../../renderers/common/Renderer.js";
-import { Texture } from "../../textures/Texture.js";
-import LightsNode from "../lighting/LightsNode.js";
-import { NodeShaderStage } 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";
-import StackNode from "./StackNode.js";
-
-export type BuildStageOption = "construct" | "analyze" | "generate";
-
-export interface FlowData {
-    code: string;
-}
-
-export interface NodeData {
-    vertex: { [key: string]: unknown };
-    fragment: { [key: string]: unknown };
-    compute: { [key: string]: unknown };
-}
-
-export interface NodeBuilderContext {
-    [key: string]: unknown;
-}
 
 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: Node;
-
-    vertexShader: string;
-    fragmentShader: string;
-    computeShader: string;
-
-    cache: NodeCache;
-    globalCache: NodeCache;
-
-    /**
-     * @TODO used to be missing. check the actual type later
-     */
-    flowsData: any;
-
-    shaderStage: NodeShaderStage | null;
-    buildStage: BuildStageOption | null;
-    stack: StackNode;
-
-    setHashNode(node: Node, hash: string): void;
-    addNode(node: Node): void;
-    get currentNode(): Node;
-    isFilteredTexture(texture: Texture): boolean;
-    getMethod(method: string): string;
-    getNodeFromHash(hash: string): Node;
-
-    addFlow(shaderStage: NodeShaderStage, node: Node): Node;
-
-    setContext(context: NodeBuilderContext): void;
-    getContext(): NodeBuilderContext;
-    setCache(cache: NodeCache): void;
-    getCache(): NodeCache;
-    getCacheFromNode(node: Node, parent?: boolean): NodeCache;
-    isAvailable(name: string): boolean;
-
-    abstract getInstanceIndex(): string;
-
-    abstract getDrawIndex(): string | null;
-
-    abstract getFrontFacing(): string;
-
-    abstract getFragCoord(): string;
-
-    isFlipY(): boolean;
-
-    // @TODO: rename to .generateConst()
-    getConst(type: string, value?: unknown): Node;
-    getType(type: string): string;
-
-    generateMethod(method: string): string;
-
-    getAttribute(name: string, type: string): NodeAttribute;
-
-    getPropertyName(node: NodeVar | NodeUniform<unknown, unknown>, shaderStage: NodeShaderStage): string;
-    isVector(type: string): boolean;
-
-    isMatrix(type: string): boolean;
-    isReference(type: string): boolean;
-    getElementType(type: string): string | null;
-    getComponentType(type: string): string | null;
-    getVectorType(type: string): string;
-    getTypeFromLength(length: number): string;
-    getTypeLength(type: string): number;
-    getVectorFromMatrix(type: string): string;
-    getDataFromNode(node: Node, shaderStage?: NodeShaderStage): NodeData;
-    getNodeProperties(node: Node, shaderStage?: NodeShaderStage): { [key: string]: unknown };
-    getUniformFromNode(
-        node: Node,
-        type: string,
-        shaderStage?: NodeShaderStage,
-        name?: string | null,
-    ): NodeUniform<unknown, string>;
-    getVarFromNode(node: Node, type: string, shaderStage?: NodeShaderStage): NodeVar;
-    getVaryFromNode(node: Node, type: string): NodeVarying;
-    getCodeFromNode(node: Node, type: string, shaderStage?: NodeShaderStage): string;
-    addFlowCode(code: string): void;
-    getFlowData(node: Node, shaderStage: NodeShaderStage): FlowData;
-    flowNode(node: Node): FlowData;
-    flowChildNode(node: Node, output?: string | null): FlowData;
-    flowNodeFromShaderStage(
-        shaderStage: NodeShaderStage,
-        node: Node,
-        output?: string | null,
-        propertyName?: string,
-    ): FlowData;
-    hasGeometryAttribute(name: string): boolean;
-    abstract getAttributes(shaderStage: NodeShaderStage): string;
-    abstract getVaryings(shaderStage: NodeShaderStage): string;
-    getVars(shaderStage: NodeShaderStage): string;
-    abstract getUniforms(stage: NodeShaderStage): string;
-    getCodes(shaderStage: NodeShaderStage): string;
-    getHash(): string;
-    setShaderStage(shaderStage: NodeShaderStage): void;
-    getShaderStage(): NodeShaderStage;
-    setBuildStage(buildStage: BuildStageOption): void;
-    getBuildStage(): BuildStageOption;
-    abstract buildCode(): void;
-    build(): this;
-    format(snippet: string, fromType: string, toType: string): string;
-    getSignature(): string;
+    context: unknown;
 }

three/src/nodes/core/OverrideContextNode.d.ts

@@ -0,0 +1,92 @@
+import ContextNode from "./ContextNode.js";
+import Node from "./Node.js";
+import NodeBuilder from "./NodeBuilder.js";
+
+/**
+ * A specialized context node designed to override specific target nodes within a
+ * node sub-graph or flow. This allows replacing specific inputs (e.g., normal
+ * and position vectors) dynamically during compilation for a specific flow node,
+ * without having to reconstruct or duplicate the source nodes.
+ *
+ * ```js
+ * // Method chaining example:
+ * node.overrideNode( positionLocal, () => positionLocal.add( vec3( 1, 0, 0 ) ) );
+ *
+ * // Context assignment example:
+ * material.contextNode = overrideNode( positionLocal, () => positionLocal.add( vec3( 1, 0, 0 ) ) );
+ * ```
+ *
+ * @augments ContextNode
+ */
+declare class OverrideContextNode extends ContextNode<unknown> {
+    /**
+     * Constructs a new override context node.
+     *
+     * @param {Map<Node, Function>} overrideNodes - A map mapping target nodes to their respective override callback functions.
+     * @param {Node|null} [flowNode=null] - The node whose context should be modified.
+     */
+    constructor(overrideNodes: Map<Node, (nodeBuilder: NodeBuilder) => Node>, flowNode?: Node | null);
+    /**
+     * This flag can be used for type testing.
+     *
+     * @type {boolean}
+     * @readonly
+     * @default true
+     */
+    readonly isOverrideContextNode: boolean;
+}
+
+export default OverrideContextNode;
+
+/**
+ * TSL function for creating an `OverrideContextNode` to override a single target node.
+ *
+ * ```js
+ * material.contextNode = overrideNode( positionLocal, ( builder ) => positionLocal.add( vec3( 1, 0, 0 ) ) );
+ * ```
+ *
+ * @tsl
+ * @function
+ * @param {Node} targetNode - The target node that should be overridden.
+ * @param {Function|Node|null} [callback=null] - A callback function returning the overriding node (which receives the builder as its argument), or the overriding node itself.
+ * @param {Node|null} [flowNode=null] - The node whose context should be modified.
+ * @return {OverrideContextNode} The created override context node.
+ */
+export function overrideNode(
+    targetNode: Node,
+    callback?: ((nodeBuilder: NodeBuilder) => Node) | Node | null,
+    flowNode?: Node | null,
+): OverrideContextNode;
+
+/**
+ * TSL function for creating an `OverrideContextNode` to override multiple target nodes.
+ *
+ * ```js
+ * material.contextNode = overrideNodes( [
+ * 	[ positionView, customPositionView ],
+ * 	[ positionViewDirection, ( builder ) => customPositionViewDirection ]
+ * ] );
+ * ```
+ *
+ * @tsl
+ * @function
+ * @param {Map<Node, (Function|Node)>|Array<Array<Node|Function|Node>>} overrides - The overrides mapping target nodes to callback functions or overriding nodes.
+ * @param {Node|null} [flowNode=null] - The node whose context should be modified.
+ * @return {OverrideContextNode} The created override context node.
+ */
+export function overrideNodes(
+    overrides:
+        | Map<Node, ((nodeBuilder: NodeBuilder) => Node) | Node | null>
+        | Array<[Node, ((nodeBuilder: NodeBuilder) => Node) | Node | null]>,
+    flowNode?: Node | null,
+): OverrideContextNode;
+
+declare module "./Node.js" {
+    interface NodeElements {
+        overrideNodes: (
+            overrides:
+                | Map<Node, ((nodeBuilder: NodeBuilder) => Node) | Node | null>
+                | Array<[Node, ((nodeBuilder: NodeBuilder) => Node) | Node | null]>,
+        ) => OverrideContextNode;
+    }
+}

three/src/nodes/core/PropertyNode.d.ts

@@ -3,6 +3,7 @@ import Node from "./Node.js";
 interface PropertyNodeInterface {
     name: string | null;
     varying: boolean;
+    placeholderNode: Node;
 
     readonly isPropertyNode: true;
 }
@@ -12,6 +13,7 @@ declare const PropertyNode: {
         nodeType: TNodeType,
         name?: string | null,
         varying?: boolean,
+        placeholderNode?: Node | null,
     ): PropertyNode<TNodeType>;
 };
 
@@ -19,8 +21,16 @@ type PropertyNode<TNodeType> = Node<TNodeType> & PropertyNodeInterface;
 
 export default PropertyNode;
 
-export const property: <const TNodeType>(type: TNodeType, name?: string | null) => PropertyNode<TNodeType>;
-export const varyingProperty: <const TNodeType>(type: TNodeType, name?: string | null) => PropertyNode<TNodeType>;
+export const property: <const TNodeType>(
+    type: TNodeType,
+    name?: string | null,
+    placeholderNode?: Node | null,
+) => PropertyNode<TNodeType>;
+export const varyingProperty: <const TNodeType>(
+    type: TNodeType,
+    name?: string | null,
+    placeholderNode?: Node | null,
+) => PropertyNode<TNodeType>;
 
 export const diffuseColor: PropertyNode<"vec4">;
 export const diffuseContribution: PropertyNode<"vec3">;
@@ -52,3 +62,4 @@ export const thickness: PropertyNode<"float">;
 export const attenuationDistance: PropertyNode<"float">;
 export const attenuationColor: PropertyNode<"color">;
 export const dispersion: PropertyNode<"float">;
+export const ambientOcclusion: PropertyNode<"float">;

three/src/nodes/core/StructNode.d.ts

@@ -13,8 +13,6 @@ export interface Struct {
     (): StructNode;
     (values: Node[]): StructNode;
     (...values: Node[]): StructNode;
-    layout: StructTypeNode;
-    isStruct: true;
 }
 
 export const struct: (membersLayout: MembersLayout, name?: string | null) => Struct;

three/src/nodes/core/StructTypeNode.d.ts

@@ -43,12 +43,13 @@ declare class StructTypeNode extends Node {
      * @readonly
      * @default true
      */
-    readonly isStructLayoutNode: boolean;
+    readonly isStructTypeNode: boolean;
     /**
-     * Returns the length of the struct.
-     * The length is calculated by summing the lengths of the struct's members.
+     * Returns the length of the struct in 4-byte elements (e.g. float or int components).
+     * The length is calculated by summing the lengths of the struct's members, accounting for memory alignment.
+     * To get the size in bytes, multiply the returned value by 4.
      *
-     * @returns {number} The length of the struct.
+     * @returns {number} The length of the struct in 4-byte elements.
      */
     getLength(): number;
 }

three/src/nodes/core/UniformNode.d.ts

@@ -71,9 +71,17 @@ declare class UniformNodeClass<TValue> extends InputNode<unknown, TValue> {
      * @return {string} The uniform hash.
      */
     getUniformHash(builder: NodeBuilder): string;
-    onUpdate(callback: (frame: NodeFrame, self: this) => TValue | undefined, updateType: NodeUpdateType): this;
+    onUpdate(
+        callback: (this: this, frame: NodeFrame, self: this) => TValue | undefined,
+        updateType: NodeUpdateType,
+    ): this;
     getInputType(builder: NodeBuilder): string;
     generate(builder: NodeBuilder, output: string | null): string;
+
+    // In UniformNode, callbacks provided to onUpdate-related functions are called with `this` as the last parameter:
+    onFrameUpdate(callback: (this: this, frame: NodeFrame, self: this) => TValue | undefined): this;
+    onRenderUpdate(callback: (this: this, frame: NodeFrame, self: this) => TValue | undefined): this;
+    onObjectUpdate(callback: (this: this, frame: NodeFrame, self: this) => TValue | undefined): this;
 }
 
 declare const UniformNode: {
@@ -90,16 +98,45 @@ type UniformNode<TNodeType, TValue> = UniformNodeClass<TValue> & InputNode<TNode
 
 export default UniformNode;
 
+interface UniformValue {
+    float: number;
+    int: number;
+    uint: number;
+    bool: boolean;
+    vec2: Vector2;
+    ivec2: Vector2;
+    uvec2: Vector2;
+    vec3: Vector3;
+    ivec3: Vector3;
+    uvec3: Vector3;
+    vec4: Vector4;
+    ivec4: Vector4;
+    uvec4: Vector4;
+    mat2: Matrix2;
+    mat3: Matrix3;
+    mat4: Matrix4;
+    color: Color;
+}
+
 interface Uniform {
+    <const TNodeType extends keyof UniformValue>(type: TNodeType): UniformNode<TNodeType, UniformValue[TNodeType]>;
     (value: number, type?: "float"): UniformNode<"float", number>;
-    (value: boolean): UniformNode<"bool", boolean>;
-    (value: Vector2): UniformNode<"vec2", Vector2>;
-    (value: Vector3): UniformNode<"vec3", Vector3>;
-    (value: Vector4): UniformNode<"vec4", Vector4>;
-    (value: Matrix2): UniformNode<"mat2", Matrix2>;
-    (value: Matrix3): UniformNode<"mat3", Matrix3>;
-    (value: Matrix4): UniformNode<"mat4", Matrix4>;
-    (value: Color): UniformNode<"color", Color>;
+    (value: number, type: "int"): UniformNode<"int", number>;
+    (value: number, type: "uint"): UniformNode<"uint", number>;
+    (value: boolean, type?: "bool"): UniformNode<"bool", boolean>;
+    (value: Vector2, type?: "vec2"): UniformNode<"vec2", Vector2>;
+    (value: Vector2, type: "ivec2"): UniformNode<"ivec2", Vector2>;
+    (value: Vector2, type: "uvec2"): UniformNode<"uvec2", Vector2>;
+    (value: Vector3, type?: "vec3"): UniformNode<"vec3", Vector3>;
+    (value: Vector3, type: "ivec3"): UniformNode<"ivec3", Vector3>;
+    (value: Vector3, type: "uvec3"): UniformNode<"uvec3", Vector3>;
+    (value: Vector4, type?: "vec4"): UniformNode<"vec4", Vector4>;
+    (value: Vector4, type: "ivec4"): UniformNode<"ivec4", Vector4>;
+    (value: Vector4, type: "uvec4"): UniformNode<"uvec4", Vector4>;
+    (value: Matrix2, type?: "mat2"): UniformNode<"mat2", Matrix2>;
+    (value: Matrix3, type?: "mat3"): UniformNode<"mat3", Matrix3>;
+    (value: Matrix4, type?: "mat4"): UniformNode<"mat4", Matrix4>;
+    (value: Color, type?: "color"): UniformNode<"color", Color>;
     <TNodeType, TValue>(value: InputNode<TNodeType, TValue>): UniformNode<TNodeType, TValue>;
     <TNodeType, TValue>(value: VarNode<TNodeType, ConstNode<TNodeType, TValue>>): UniformNode<TNodeType, TValue>;
 }
@@ -113,3 +150,5 @@ interface Uniform {
  * @returns {UniformNode}
  */
 export declare const uniform: Uniform;
+
+export {};

three/src/nodes/display/BlendModes.d.ts

@@ -1,15 +1,76 @@
+import { Color } from "../../math/Color.js";
+import { Vector3 } from "../../math/Vector3.js";
+import { Vector4 } from "../../math/Vector4.js";
 import Node from "../core/Node.js";
 
-export const blendBurn: (base: Node, blend: Node) => Node<"vec3">;
+type ColorParameter = Node<"float"> | number | Node<"vec3"> | Vector3 | Node<"color"> | Color | Node<"vec4"> | Vector4;
 
-export const blendDodge: (base: Node, blend: Node) => Node<"vec3">;
+/**
+ * Represents a "Color Burn" blend mode.
+ *
+ * It's designed to darken the base layer's colors based on the color of the blend layer.
+ * It significantly increases the contrast of the base layer, making the colors more vibrant and saturated.
+ * The darker the color in the blend layer, the stronger the darkening and contrast effect on the base layer.
+ *
+ * @tsl
+ * @function
+ * @param {Node<vec3>} base - The base color.
+ * @param {Node<vec3>} blend - The blend color. A white (#ffffff) blend color does not alter the base color.
+ * @return {Node<vec3>} The result.
+ */
+export const blendBurn: (base: ColorParameter, blend: ColorParameter) => Node<"vec3">;
+/**
+ * Represents a "Color Dodge" blend mode.
+ *
+ * It's designed to lighten the base layer's colors based on the color of the blend layer.
+ * It significantly increases the brightness of the base layer, making the colors lighter and more vibrant.
+ * The brighter the color in the blend layer, the stronger the lightening and contrast effect on the base layer.
+ *
+ * @tsl
+ * @function
+ * @param {Node<vec3>} base - The base color.
+ * @param {Node<vec3>} blend - The blend color. A black (#000000) blend color does not alter the base color.
+ * @return {Node<vec3>} The result.
+ */
+export const blendDodge: (base: ColorParameter, blend: ColorParameter) => Node<"vec3">;
+/**
+ * Represents a "Screen" blend mode.
+ *
+ * Similar to `blendDodge()`, this mode also lightens the base layer's colors based on the color of the blend layer.
+ * The "Screen" blend mode is better for general brightening whereas the "Dodge" results in more subtle and nuanced
+ * effects.
+ *
+ * @tsl
+ * @function
+ * @param {Node<vec3>} base - The base color.
+ * @param {Node<vec3>} blend - The blend color. A black (#000000) blend color does not alter the base color.
+ * @return {Node<vec3>} The result.
+ */
+export const blendScreen: (base: ColorParameter, blend: ColorParameter) => Node<"vec3">;
+/**
+ * Represents a "Overlay" blend mode.
+ *
+ * It's designed to increase the contrast of the base layer based on the color of the blend layer.
+ * It amplifies the existing colors and contrast in the base layer, making lighter areas lighter and darker areas darker.
+ * The color of the blend layer significantly influences the resulting contrast and color shift in the base layer.
+ *
+ * @tsl
+ * @function
+ * @param {Node<vec3>} base - The base color.
+ * @param {Node<vec3>} blend - The blend color
+ * @return {Node<vec3>} The result.
+ */
+export const blendOverlay: (base: ColorParameter, blend: ColorParameter) => Node<"vec3">;
+/**
+ * This function blends two color based on their alpha values by replicating the behavior of `THREE.NormalBlending`.
+ * It assumes both input colors have non-premultiplied alpha.
+ *
+ * @tsl
+ * @function
+ * @param {Node<vec4>} base - The base color.
+ * @param {Node<vec4>} blend - The blend color
+ * @return {Node<vec4>} The result.
+ */
+export const blendColor: (base: ColorParameter, blend: ColorParameter) => Node<"vec4">;
 
-export const blendScreen: (base: Node, blend: Node) => Node<"vec3">;
-
-export const blendOverlay: (base: Node, blend: Node) => Node<"vec3">;
-
-export const blendColor: (base: Node, blend: Node) => Node<"vec4">;
-
-export const premultiplyAlpha: (color: Node) => Node<"vec4">;
-
-export const unpremultiplyAlpha: (color: Node) => Node<"vec4">;
+export {};