@types/three 0.172.0 → 0.174.0

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

@@ -7,6 +7,7 @@ import NodeCode from "./NodeCode.js";
 import NodeUniform from "./NodeUniform.js";
 import NodeVar from "./NodeVar.js";
 import NodeVarying from "./NodeVarying.js";
+import StructType from "./StructType.js";
 export interface ShaderStageNodeData {
     properties?:
         | (
@@ -20,7 +21,7 @@ export interface ShaderStageNodeData {
         )
         | undefined;
     bufferAttribute?: NodeAttribute | undefined;
-    structType?: Node | undefined;
+    structType?: StructType | undefined;
     uniform?: NodeUniform<unknown> | undefined;
     variable?: NodeVar | undefined;
     varying?: NodeVarying | undefined;
@@ -50,14 +51,14 @@ declare class NodeCache {
     /**
      * Constructs a new node cache.
      *
-     * @param {NodeCache?} parent - A reference to a parent cache.
+     * @param {?NodeCache} parent - A reference to a parent cache.
      */
     constructor(parent?: NodeCache | null);
     /**
      * Returns the data for the given node.
      *
      * @param {Node} node - The node.
-     * @return {Object?} The data for the node.
+     * @return {?Object} The data for the node.
      */
     getData(node: Node): NodeData | undefined;
     getData(node: TypedArray | InterleavedBuffer | BufferAttribute): BufferAttributeData | undefined;

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

@@ -8,7 +8,7 @@ declare abstract class NodeParser {
      * The method parses the given native code an returns a node function.
      *
      * @abstract
-     * @param {String} source - The native shader code.
+     * @param {string} source - The native shader code.
      * @return {NodeFunction} A node function.
      */
     abstract parseFunction(source: string): NodeFunction;

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

@@ -14,22 +14,22 @@ declare class NodeUniform<TValue> {
     /**
      * Constructs a new node uniform.
      *
-     * @param {String} name - The name of the uniform.
-     * @param {String} type - The type of the uniform.
+     * @param {string} name - The name of the uniform.
+     * @param {string} type - The type of the uniform.
      * @param {UniformNode} node - An reference to the node.
      */
     constructor(name: string, type: string | null, node: UniformNode<TValue>);
     /**
      * The value of the uniform node.
      *
-     * @type {Any}
+     * @type {any}
      */
     get value(): TValue;
     set value(val: TValue);
     /**
      * The id of the uniform node.
      *
-     * @type {Number}
+     * @type {number}
      */
     get id(): number;
     /**

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

@@ -7,13 +7,17 @@
 declare class NodeVar {
     readonly isNodeVar: true;
     name: string;
-    type: string | null;
+    type: string;
+    readOnly: boolean;
+    count: number | null;
     /**
      * Constructs a new node variable.
      *
-     * @param {String} name - The name of the variable.
-     * @param {String} type - The type of the variable.
+     * @param {string} name - The name of the variable.
+     * @param {string} type - The type of the variable.
+     * @param {boolean} [readOnly=false] - The read-only flag.
+     * @param {?number} [count=null] - The size.
      */
-    constructor(name: string, type: string | null);
+    constructor(name: string, type: string, readOnly?: boolean, count?: number | null);
 }
 export default NodeVar;

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

@@ -13,8 +13,8 @@ declare class NodeVarying extends NodeVar {
     /**
      * Constructs a new node varying.
      *
-     * @param {String} name - The name of the varying.
-     * @param {String} type - The type of the varying.
+     * @param {string} name - The name of the varying.
+     * @param {string} type - The type of the varying.
      */
     constructor(name: string, type: string | null);
 }

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

@@ -0,0 +1,21 @@
+import { ShaderNodeObject } from "../tsl/TSLCore.js";
+import Node from "./Node.js";
+import StructTypeNode, { MembersLayout } from "./StructTypeNode.js";
+
+declare class StructNode extends Node {
+    values: Node[];
+
+    constructor(structLayoutNode: StructTypeNode, values: Node[]);
+}
+
+export default StructNode;
+
+export interface Struct {
+    (): ShaderNodeObject<StructNode>;
+    (values: Node[]): ShaderNodeObject<StructNode>;
+    (...values: Node[]): ShaderNodeObject<StructNode>;
+    layout: StructTypeNode;
+    isStruct: true;
+}
+
+export const struct: (membersLayout: MembersLayout, name?: string | null) => Struct;

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

@@ -0,0 +1,8 @@
+import { MemberLayout } from "./StructTypeNode.js";
+declare class StructType {
+    name: string;
+    members: MemberLayout[];
+    output: boolean;
+    constructor(name: string, members: MemberLayout[]);
+}
+export default StructType;

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

@@ -1,27 +1,46 @@
 import Node from "./Node.js";
+import NodeBuilder from "./NodeBuilder.js";
+export interface MembersLayout {
+    [name: string]: string | {
+        type: string;
+        atomic?: boolean;
+    };
+}
+export interface MemberLayout {
+    name: string;
+    type: string;
+    atomic: boolean;
+}
 /**
- * {@link NodeBuilder} is going to create instances of this class during the build process
- * of nodes. They represent the final shader struct data that are going to be generated
- * by the builder. A dictionary of struct types is maintained in {@link NodeBuilder#structs}
- * for this purpose.
+ * Represents a struct type node in the node-based system.
+ * This class is used to define and manage the layout and types of struct members.
+ * It extends the base Node class and provides methods to get the length of the struct,
+ * retrieve member types, and generate the struct type for a builder.
+ *
+ * @augments Node
  */
 declare class StructTypeNode extends Node {
     static get type(): string;
-    name: string;
-    types: string[];
-    readonly isStructTypeNode: true;
+    membersLayout: MemberLayout[];
+    name: string | null;
+    readonly isStructLayoutNode: true;
     /**
-     * Constructs a new struct type node.
+     * Creates an instance of StructTypeNode.
      *
-     * @param {String} name - The name of the struct.
-     * @param {Array<String>} types - An array of types.
+     * @param {Object} membersLayout - The layout of the members for the struct.
+     * @param {string} [name=null] - The optional name of the struct.
      */
-    constructor(name: string, types: string[]);
+    constructor(membersLayout: MembersLayout, name?: string | null);
     /**
-     * Returns the member types.
+     * Returns the length of the struct.
+     * The length is calculated by summing the lengths of the struct's members.
      *
-     * @return {Array<String>} The types.
+     * @returns {number} The length of the struct.
      */
-    getMemberTypes(): string[];
+    getLength(): number;
+    getMemberType(builder: NodeBuilder, name: string): string;
+    getNodeType(builder: NodeBuilder): string;
+    setup(builder: NodeBuilder): void;
+    generate(builder: NodeBuilder): string;
 }
 export default StructTypeNode;

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

@@ -4,7 +4,6 @@ import Node from "./Node.js";
 import NodeBuilder from "./NodeBuilder.js";
 import NodeFrame from "./NodeFrame.js";
 import UniformGroupNode from "./UniformGroupNode.js";
-/** @module UniformNode **/
 /**
  * Class for representing a uniform.
  *
@@ -18,14 +17,14 @@ declare class UniformNode<TValue> extends InputNode<TValue> {
     /**
      * Constructs a new uniform node.
      *
-     * @param {Any} value - The value of this node. Usually a JS primitive or three.js object (vector, matrix, color, texture).
-     * @param {String?} nodeType - The node type. If no explicit type is defined, the node tries to derive the type from its value.
+     * @param {any} value - The value of this node. Usually a JS primitive or three.js object (vector, matrix, color, texture).
+     * @param {?string} nodeType - The node type. If no explicit type is defined, the node tries to derive the type from its value.
      */
     constructor(value: TValue, nodeType?: string | null);
     /**
      * Sets the {@link UniformNode#name} property.
      *
-     * @param {String} name - The name of the uniform.
+     * @param {string} name - The name of the uniform.
      * @return {UniformNode} A reference to this node.
      */
     label(name: string): this;
@@ -47,7 +46,7 @@ declare class UniformNode<TValue> extends InputNode<TValue> {
      * classes might overwrite this method with a different implementation.
      *
      * @param {NodeBuilder} builder - The current node builder.
-     * @return {String} The uniform hash.
+     * @return {string} The uniform hash.
      */
     getUniformHash(builder: NodeBuilder): string;
     onUpdate(callback: (frame: NodeFrame, self: this) => TValue | undefined, updateType: NodeUpdateType): this;
@@ -57,9 +56,10 @@ export default UniformNode;
 /**
  * TSL function for creating a uniform node.
  *
+ * @tsl
  * @function
- * @param {Any} arg1 - The value of this node. Usually a JS primitive or three.js object (vector, matrix, color, texture).
- * @param {String?} arg2 - The node type. If no explicit type is defined, the node tries to derive the type from its value.
+ * @param {any} arg1 - The value of this node. Usually a JS primitive or three.js object (vector, matrix, color, texture).
+ * @param {string} [arg2] - The node type. If no explicit type is defined, the node tries to derive the type from its value.
  * @returns {UniformNode}
  */
 export declare const uniform: <TValue>(

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

@@ -7,12 +7,19 @@ export default class VarNode extends Node {
 
     readonly isVarNode: true;
 
-    constructor(node: Node, name?: string | null);
+    readOnly: boolean;
+
+    constructor(node: Node, name?: string | null, readOnly?: boolean);
 }
 
+export const Var: (node: Node, name?: string | null) => ShaderNodeObject<VarNode>;
+
+export const Const: (node: Node, name?: string | null) => ShaderNodeObject<VarNode>;
+
 declare module "../tsl/TSLCore.js" {
     interface NodeElements {
         toVar: (node: NodeRepresentation, name?: string | null) => ShaderNodeObject<VarNode>;
+        toConst: (node: NodeRepresentation, name?: string | null) => ShaderNodeObject<VarNode>;
     }
 }
 

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

@@ -18,7 +18,16 @@ export const vertexStage: (node: NodeRepresentation) => ShaderNodeObject<Varying
 
 declare module "../tsl/TSLCore.js" {
     interface NodeElements {
+        toVarying: typeof varying;
+        toVertexStage: typeof vertexStage;
+
+        /**
+         * @deprecated .varying() has been renamed to .toVarying().
+         */
         varying: typeof varying;
+        /**
+         * @deprecated .vertexStage() has been renamed to .toVertexStage().
+         */
         vertexStage: typeof vertexStage;
     }
 }

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

@@ -1,4 +1,3 @@
-/** @module NodeConstants **/
 /**
  * Possible shader stages.
  *

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

@@ -1,4 +1,5 @@
 import { Camera } from "../../cameras/Camera.js";
+import { Layers } from "../../core/Layers.js";
 import { RenderTarget, RenderTargetOptions } from "../../core/RenderTarget.js";
 import { Scene } from "../../scenes/Scene.js";
 import { Texture } from "../../textures/Texture.js";
@@ -34,6 +35,14 @@ declare class PassNode extends TempNode {
 
     constructor(scope: PassNodeScope, scene: Scene, camera: Camera, options?: RenderTargetOptions);
 
+    setResolution(resolution: number): this;
+
+    getResolution(): number;
+
+    setLayers(layers: Layers): this;
+
+    getLayers(): Layers;
+
     setMRT(mrt: MRTNode | null): this;
 
     getMRT(): MRTNode | null;
@@ -44,7 +53,7 @@ declare class PassNode extends TempNode {
 
     toggleTexture(name: string): void;
 
-    getTextureNode(name?: string): ShaderNodeObject<Node>;
+    getTextureNode(name?: string): ShaderNodeObject<TextureNode>;
 
     getPreviousTextureNode(name?: string): ShaderNodeObject<Node>;
 

three/src/nodes/functions/BSDF/LTC.d.ts

@@ -6,4 +6,8 @@ declare const LTC_Evaluate: (
     args: { N: Node; V: Node; P: Node; mInv: Node; p0: Node; p1: Node; p2: Node; p3: Node },
 ) => Node;
 
-export { LTC_Evaluate, LTC_Uv };
+declare const LTC_Evaluate_Volume: (
+    args: { P: Node; p0: Node; p1: Node; p2: Node; p3: Node },
+) => Node;
+
+export { LTC_Evaluate, LTC_Evaluate_Volume, LTC_Uv };

three/src/nodes/functions/VolumetricLightingModel.d.ts

@@ -0,0 +1,6 @@
+import LightingModel from "../core/LightingModel.js";
+
+declare class VolumetricLightingModel extends LightingModel {
+}
+
+export default VolumetricLightingModel;

three/src/nodes/geometry/RangeNode.d.ts

@@ -1,19 +1,14 @@
-import { Color } from "../../math/Color.js";
-import { Vector2 } from "../../math/Vector2.js";
-import { Vector3 } from "../../math/Vector3.js";
-import { Vector4 } from "../../math/Vector4.js";
 import Node from "../core/Node.js";
 import NodeBuilder from "../core/NodeBuilder.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
-
-export type RangeModeBound = number | Color | Vector2 | Vector3 | Vector4;
+import { NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
 
 export default class RangeNode extends Node {
-    min: RangeModeBound;
-    max: RangeModeBound;
+    minNode: Node;
+    maxNode: Node;
+
+    constructor(minNode: Node, maxNode: Node);
 
-    constructor(min: RangeModeBound, max: RangeModeBound);
     getVectorLength(builder: NodeBuilder): number;
 }
 
-export const range: (min: RangeModeBound, max: RangeModeBound) => ShaderNodeObject<RangeNode>;
+export const range: (minNode: NodeRepresentation, maxNode: NodeRepresentation) => ShaderNodeObject<RangeNode>;

three/src/nodes/gpgpu/AtomicFunctionNode.d.ts

@@ -39,6 +39,11 @@ export const atomicFunc: (
     storeNode?: NodeRepresentation | null,
 ) => ShaderNodeObject<AtomicFunctionNode>;
 
+export const atomicLoad: (
+    pointerNode: NodeRepresentation,
+    storeNode?: NodeRepresentation | null,
+) => ShaderNodeObject<AtomicFunctionNode>;
+
 export const atomicStore: (
     pointerNode: NodeRepresentation,
     valueNode: NodeRepresentation,

three/src/nodes/gpgpu/ComputeBuiltinNode.d.ts

@@ -9,5 +9,6 @@ export default ComputeBuiltinNode;
 
 export const numWorkgroups: ShaderNodeObject<ComputeBuiltinNode>;
 export const workgroupId: ShaderNodeObject<ComputeBuiltinNode>;
+export const globalId: ShaderNodeObject<ComputeBuiltinNode>;
 export const localId: ShaderNodeObject<ComputeBuiltinNode>;
 export const subgroupSize: ShaderNodeObject<ComputeBuiltinNode>;

three/src/nodes/lighting/AnalyticLightNode.d.ts

@@ -1,7 +1,9 @@
 import { Light } from "../../lights/Light.js";
 import Node from "../core/Node.js";
+import NodeBuilder from "../core/NodeBuilder.js";
 import { ShaderNodeObject } from "../tsl/TSLCore.js";
 import LightingNode from "./LightingNode.js";
+import { DirectLightData, DirectRectAreaLightData } from "./LightsNode.js";
 import ShadowNode from "./ShadowNode.js";
 
 declare module "../../lights/LightShadow.js" {
@@ -10,10 +12,20 @@ declare module "../../lights/LightShadow.js" {
     }
 }
 
-export default class AnalyticLightNode<T extends Light> extends LightingNode {
+declare class AnalyticLightNode<T extends Light> extends LightingNode {
     light: T | null;
 
     constructor(light?: T | null);
 
+    getLightVector(builder: NodeBuilder): Node;
+
+    setupDirect(builder: NodeBuilder): DirectLightData | undefined;
+
+    setupDirectRectArea(builder: NodeBuilder): DirectRectAreaLightData | undefined;
+
     setupShadowNode(): ShaderNodeObject<ShadowNode>;
+
+    setupShadow(builder: NodeBuilder): void;
 }
+
+export default AnalyticLightNode;

three/src/nodes/lighting/LightingContextNode.d.ts

@@ -1,7 +1,18 @@
 import ContextNode from "../core/ContextNode.js";
-import LightingModel, { LightingModelIndirectInput } from "../core/LightingModel.js";
+import LightingModel, { LightingModelReflectedLight } from "../core/LightingModel.js";
 import Node from "../core/Node.js";
 import { ShaderNodeObject } from "../tsl/TSLCore.js";
+import LightsNode from "./LightsNode.js";
+
+export interface LightingContext {
+    radiance: Node;
+    irradiance: Node;
+    iblIrradiance: Node;
+    ambientOcclusion: Node;
+    reflectedLight: LightingModelReflectedLight;
+    backdrop: Node;
+    backdropAlpha: Node;
+}
 
 export default class LightingContextNode extends ContextNode {
     lightingModelNode: LightingModel | null;
@@ -9,13 +20,16 @@ export default class LightingContextNode extends ContextNode {
     backdropAlphaNode: Node | null;
 
     constructor(
-        node: Node,
+        lightsNode: LightsNode,
         lightingModel?: LightingModel | null,
         backdropNode?: Node | null,
         backdropAlphaNode?: Node | null,
     );
 
-    getContext(): LightingModelIndirectInput;
+    getContext(): LightingContext;
 }
 
-export const lightingContext: (node: Node, lightingModelNode?: LightingModel) => ShaderNodeObject<LightingContextNode>;
+export const lightingContext: (
+    node: LightsNode,
+    lightingModelNode?: LightingModel,
+) => ShaderNodeObject<LightingContextNode>;

three/src/nodes/lighting/LightsNode.d.ts

@@ -4,13 +4,37 @@ import { NodeBuilder } from "../Nodes.js";
 import { ShaderNodeObject } from "../tsl/TSLCore.js";
 import LightingNode from "./LightingNode.js";
 
+export interface DirectLightData {
+    lightDirection: Node;
+    lightColor: Node;
+}
+
+export interface DirectRectAreaLightData {
+    lightColor: Node;
+    lightPosition: Node;
+    halfWidth: Node;
+    halfHeight: Node;
+    ltc_1: Node;
+    ltc_2: Node;
+}
+
 declare class LightsNode extends Node {
+    totalDiffuseNode: Node;
+    totalSpecularNode: Node;
+    outgoingLightNode: Node;
+
     constructor();
 
     setupLightsNode(builder: NodeBuilder): void;
 
+    setupDirectLight(builder: NodeBuilder, lightNode: Node, lightData: DirectLightData): void;
+
+    setupDirectRectAreaLight(builder: NodeBuilder, lightNode: Node, lightData: DirectRectAreaLightData): void;
+
     setupLights(builder: NodeBuilder, lightNodes: LightingNode[]): void;
 
+    getLightNodes(): LightingNode[];
+
     setLights(lights: Light[]): this;
 
     getLights(): Light[];

three/src/nodes/lighting/PointLightNode.d.ts

@@ -1,15 +1,16 @@
 import { PointLight } from "../../lights/PointLight.js";
 import Node from "../core/Node.js";
-import { NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
+import { ShaderNodeObject } from "../tsl/TSLCore.js";
 import AnalyticLightNode from "./AnalyticLightNode.js";
+import { DirectLightData } from "./LightsNode.js";
 import PointShadowNode from "./PointShadowNode.js";
 
-export const directPointLight: (
-    color: NodeRepresentation,
-    lightViewPosition: NodeRepresentation,
-    cutoffDistance: NodeRepresentation,
-    decayExponent: NodeRepresentation,
-) => ShaderNodeObject<Node>;
+export const directPointLight: (params: {
+    color: ShaderNodeObject<Node>;
+    lightViewPosition: ShaderNodeObject<Node>;
+    cutoffDistance: ShaderNodeObject<Node>;
+    decayExponent: ShaderNodeObject<Node>;
+}) => DirectLightData;
 
 declare class PointLightNode extends AnalyticLightNode<PointLight> {
     cutoffDistanceNode: Node;

three/src/nodes/lighting/ShadowBaseNode.d.ts

@@ -1,5 +1,6 @@
 import { Light } from "../../lights/Light.js";
 import Node from "../core/Node.js";
+import NodeBuilder from "../core/NodeBuilder.js";
 import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
 declare class ShadowBaseNode extends Node {
@@ -8,6 +9,8 @@ declare class ShadowBaseNode extends Node {
     readonly isShadowBasedNode: true;
 
     constructor(light: Light);
+
+    setupShadowPosition(builder: NodeBuilder): void;
 }
 
 export const shadowPositionWorld: ShaderNodeObject<Node>;

three/src/nodes/math/MathNode.d.ts

@@ -122,6 +122,8 @@ export default class MathNode extends TempNode {
     bNode: Node | null;
     cNode: Node | null;
 
+    readonly isMathNode: true;
+
     constructor(method: MathNodeMethod1, aNode: Node);
     constructor(method: MathNodeMethod2, aNode: Node, bNode: Node);
     constructor(method: MathNodeMethod3, aNode: Node, bNode: Node, cNode: Node);

three/src/nodes/math/OperatorNode.d.ts

@@ -28,6 +28,8 @@ export default class OperatorNode extends TempNode {
     bNode: Node;
     op: OperatorNodeOp;
 
+    readonly isOperatorNode: true;
+
     constructor(op: OperatorNodeOp, ...params: [Node, Node, ...Node[]]);
 }
 

three/src/nodes/shapes/Shapes.d.ts

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

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

@@ -1,6 +1,7 @@
 export * from "../accessors/BufferAttributeNode.js";
 export * from "../code/ExpressionNode.js";
 export * from "../code/FunctionCallNode.js";
+export * from "../core/ArrayNode.js";
 export * from "../core/AssignNode.js";
 export * from "../core/BypassNode.js";
 export * from "../core/CacheNode.js";

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

@@ -1,7 +1,10 @@
+import { Color, ColorRepresentation } from "../../math/Color.js";
+import { Vector3 } from "../../math/Vector3.js";
 import ConstNode from "../core/ConstNode.js";
 import Node from "../core/Node.js";
 import NodeBuilder from "../core/NodeBuilder.js";
 import StackNode from "../core/StackNode.js";
+import ConvertNode from "../utils/ConvertNode.js";
 
 export interface NodeElements {
     toGlobal: (node: Node) => Node;
@@ -64,6 +67,9 @@ export type Swizzable<T extends Node = Node> =
     & {
         [Key in SwizzleOption | number]: ShaderNodeObject<Node>;
     }
+    & {
+        [Key in SwizzleOption as `set${Uppercase<Key>}`]: (value: Node) => ShaderNodeObject<Node>;
+    }
     & {
         [Key in SwizzleOption as `flip${Uppercase<Key>}`]: () => ShaderNodeObject<Node>;
     };
@@ -84,7 +90,7 @@ export type ShaderNodeObject<T extends Node> =
     & Swizzable<T>;
 
 /** anything that can be passed to {@link nodeObject} and returns a proxy */
-export type NodeRepresentation<T extends Node = Node> = number | boolean | Node | ShaderNodeObject<T>;
+export type NodeRepresentation<T extends Node = Node> = number | boolean | Vector3 | Node | ShaderNodeObject<T>;
 
 /** anything that can be passed to {@link nodeObject} */
 export type NodeObjectOption = NodeRepresentation | string;
@@ -231,7 +237,11 @@ export function nodeImmutable<T>(
 interface Layout {
     name: string;
     type: string;
-    inputs: { name: string; type: string }[];
+    inputs: {
+        name: string;
+        type: string;
+        qualifier?: "in" | "out" | "inout";
+    }[];
 }
 
 interface ShaderNodeFn<Args extends readonly unknown[]> {
@@ -274,7 +284,13 @@ export const If: (boolNode: Node, method: () => void) => StackNode;
 
 export function append(node: Node): Node;
 
-export const color: ConvertType;
+interface ColorFunction {
+    (color?: ColorRepresentation): ShaderNodeObject<ConstNode<Color>>;
+    (r: number, g: number, b: number): ShaderNodeObject<ConstNode<Color>>;
+    (node: Node): ShaderNodeObject<ConvertNode>;
+}
+
+export const color: ColorFunction;
 
 export const float: ConvertType;
 export const int: ConvertType;

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

@@ -0,0 +1,11 @@
+import Node from "../core/Node.js";
+
+declare class MemberNode extends Node {
+    node: Node;
+    property: string;
+    readonly isMemberNode: true;
+
+    constructor(node: Node, property: string);
+}
+
+export default MemberNode;

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

@@ -32,6 +32,7 @@ declare class ReflectorBaseNode extends Node {
 
     virtualCameras: WeakMap<Camera, Camera>;
     renderTargets: WeakMap<Camera, RenderTarget>;
+    forceUpdate: boolean;
 
     constructor(textureNode: TextureNode, parameters?: ReflectorNodeParameters);