@types/three 0.170.0 → 0.172.0

three/src/nodes/accessors/InstanceNode.d.ts

@@ -1,13 +1,25 @@
+import { InstancedBufferAttribute } from "../../core/InstancedBufferAttribute.js";
 import { InstancedMesh } from "../../objects/InstancedMesh.js";
 import Node from "../core/Node.js";
 import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
 export default class InstanceNode extends Node {
-    instanceMesh: InstancedMesh;
+    count: number;
+    instanceMatrix: InstancedBufferAttribute;
+    instanceColor: InstancedBufferAttribute | null;
+
     instanceMatrixNode: Node | null;
     instanceColorNode: Node | null;
 
-    constructor(instanceMesh: InstancedMesh);
+    constructor(
+        count: number,
+        instanceMatrix: InstancedBufferAttribute,
+        instanceColor: InstancedBufferAttribute | null,
+    );
 }
 
-export const instance: (instanceMesh: InstancedMesh) => ShaderNodeObject<InstanceNode>;
+export const instance: (
+    count: number,
+    instanceMatrix: InstancedBufferAttribute,
+    instanceColor: InstancedBufferAttribute | null,
+) => ShaderNodeObject<InstanceNode>;

three/src/nodes/accessors/InstancedMeshNode.d.ts

@@ -0,0 +1,11 @@
+import { InstancedMesh } from "../../objects/InstancedMesh.js";
+import { ShaderNodeObject } from "../tsl/TSLCore.js";
+import InstanceNode from "./InstanceNode.js";
+
+declare class InstancedMeshNode extends InstanceNode {
+    constructor(instanceMesh: InstancedMesh);
+}
+
+export default InstancedMeshNode;
+
+export const instancedMesh: (instancedMesh: InstancedMesh) => ShaderNodeObject<InstancedMeshNode>;

three/src/nodes/accessors/Lights.d.ts

@@ -0,0 +1,15 @@
+import { Light } from "../../lights/Light.js";
+import Node from "../core/Node.js";
+import { ShaderNodeObject } from "../tsl/TSLCore.js";
+
+export function lightShadowMatrix(light: Light): ShaderNodeObject<Node>;
+
+export function lightProjectionUV(light: Light): ShaderNodeObject<Node>;
+
+export function lightPosition(light: Light): ShaderNodeObject<Node>;
+
+export function lightTargetPosition(light: Light): ShaderNodeObject<Node>;
+
+export function lightViewPosition(light: Light): ShaderNodeObject<Node>;
+
+export const lightTargetDirection: (light: Light) => ShaderNodeObject<Node>;

three/src/nodes/accessors/MaterialNode.d.ts

@@ -40,7 +40,7 @@ export type MaterialNodeScope =
     | typeof MaterialNode.POINT_WIDTH
     | typeof MaterialNode.DISPERSION
     | typeof MaterialNode.LIGHT_MAP
-    | typeof MaterialNode.AO_MAP
+    | typeof MaterialNode.AO
     | typeof MaterialNode.REFRACTION_RATIO;
 
 export default class MaterialNode extends Node {
@@ -80,7 +80,7 @@ export default class MaterialNode extends Node {
     static POINT_WIDTH: "pointWidth";
     static DISPERSION: "dispersion";
     static LIGHT_MAP: "light";
-    static AO_MAP: "ao";
+    static AO: "ao";
     static REFRACTION_RATIO: "refractionRatio";
 
     scope: MaterialNodeScope;
@@ -125,5 +125,5 @@ export const materialLineDashOffset: ShaderNodeObject<MaterialNode>;
 export const materialPointWidth: ShaderNodeObject<MaterialNode>;
 export const materialDispersion: ShaderNodeObject<MaterialNode>;
 export const materialLightMap: ShaderNodeObject<MaterialNode>;
-export const materialAOMap: ShaderNodeObject<MaterialNode>;
+export const materialAO: ShaderNodeObject<MaterialNode>;
 export const materialAnisotropyVector: ShaderNodeObject<UniformNode<Vector2>>;

three/src/nodes/accessors/ModelNode.d.ts

@@ -18,7 +18,15 @@ export const modelScale: ShaderNodeObject<ModelNode>;
 export const modelViewPosition: ShaderNodeObject<ModelNode>;
 export const modelNormalMatrix: ShaderNodeObject<Node>;
 export const modelWorldMatrixInverse: ShaderNodeObject<UniformNode<Matrix4>>;
+
 export const modelViewMatrix: ShaderNodeObject<ModelNode>;
 
-export const highPrecisionModelViewMatrix: ShaderNodeObject<Node>;
-export const highPrecisionModelNormalViewMatrix: ShaderNodeObject<Node>;
+// GPU Precision
+
+export const mediumpModelViewMatrix: ShaderNodeObject<Node>;
+
+// CPU Precision
+
+export const highpModelViewMatrix: ShaderNodeObject<Node>;
+
+export const highpModelNormalViewMatrix: ShaderNodeObject<Node>;

three/src/nodes/accessors/ModelViewProjectionNode.d.ts

@@ -1,8 +1,4 @@
 import Node from "../core/Node.js";
-import { NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
+import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
-export default class ModelViewProjectionNode extends Node {
-    constructor(positionNode?: Node);
-}
-
-export const modelViewProjection: (position?: NodeRepresentation) => ShaderNodeObject<ModelViewProjectionNode>;
+export const modelViewProjection: ShaderNodeObject<Node>;

three/src/nodes/accessors/StorageBufferNode.d.ts

@@ -1,38 +1,51 @@
 import StorageBufferAttribute from "../../renderers/common/StorageBufferAttribute.js";
 import StorageInstancedBufferAttribute from "../../renderers/common/StorageInstancedBufferAttribute.js";
-import { GPUBufferBindingType } from "../../renderers/webgpu/utils/WebGPUConstants.js";
-import { NodeOrType, NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
+import { NodeAccess } from "../core/constants.js";
+import { NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
 import StorageArrayElementNode from "../utils/StorageArrayElementNode.js";
 import BufferNode from "./BufferNode.js";
 
-export default class StorageBufferNode extends BufferNode {
+export default class StorageBufferNode extends BufferNode<StorageBufferAttribute | StorageInstancedBufferAttribute> {
     readonly isStorageBufferNode: true;
-    bufferObject: boolean;
 
-    access: GPUBufferBindingType;
+    access: NodeAccess;
+    isAtomic: boolean;
+    isPBO: boolean;
+
+    bufferObject: boolean;
 
     constructor(
         value: StorageBufferAttribute | StorageInstancedBufferAttribute,
-        bufferType: string,
+        bufferType?: string | null,
         bufferCount?: number,
     );
 
     element(indexNode: NodeRepresentation): ShaderNodeObject<StorageArrayElementNode>;
 
-    setBufferObject(value: boolean): this;
+    setPBO(value: boolean): this;
+
+    getPBO(): boolean;
 
-    setAccess(value: GPUBufferBindingType): this;
+    setAccess(value: NodeAccess): this;
 
     toReadOnly(): this;
+
+    setAtmoic(value: boolean): this;
+
+    toAtomic(): this;
 }
 
 export const storage: (
     value: StorageBufferAttribute | StorageInstancedBufferAttribute,
-    nodeOrType: NodeOrType,
-    count: number,
+    type?: string | null,
+    count?: number,
 ) => ShaderNodeObject<StorageBufferNode>;
+
+/**
+ * @deprecated
+ */
 export const storageObject: (
     value: StorageBufferAttribute | StorageInstancedBufferAttribute,
-    nodeOrType: NodeOrType,
-    count: number,
+    type?: string | null,
+    count?: number,
 ) => ShaderNodeObject<StorageBufferNode>;

three/src/nodes/accessors/StorageTextureNode.d.ts

@@ -1,5 +1,5 @@
-import { GPUStorageTextureAccess } from "../../renderers/webgpu/utils/WebGPUConstants.js";
 import { Texture } from "../../textures/Texture.js";
+import { NodeAccess } from "../core/constants.js";
 import Node from "../core/Node.js";
 import NodeBuilder from "../core/NodeBuilder.js";
 import { NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
@@ -10,7 +10,7 @@ export default class StorageTextureNode extends TextureNode {
 
     readonly isStorageTextureNode: true;
 
-    access: GPUStorageTextureAccess;
+    access: NodeAccess;
 
     constructor(
         value: Texture,
@@ -18,7 +18,9 @@ export default class StorageTextureNode extends TextureNode {
         storeNode?: Node | null,
     );
 
-    setAccess(value: GPUStorageTextureAccess): this;
+    setAccess(value: NodeAccess): this;
+
+    toReadWrite(): this;
 
     toReadOnly(): this;
 

three/src/nodes/accessors/TextureNode.d.ts

@@ -31,8 +31,13 @@ export default class TextureNode extends UniformNode<Texture> {
 
     getSampler(): boolean;
 
+    /**
+     * @deprecated
+     */
     uv(uvNode: NodeRepresentation): ShaderNodeObject<Node>;
 
+    sample(uvNode: NodeRepresentation): ShaderNodeObject<Node>;
+
     blur(amountNode: NodeRepresentation): ShaderNodeObject<Node>;
 
     level(levelNode: NodeRepresentation): ShaderNodeObject<Node>;

three/src/nodes/accessors/UniformArrayNode.d.ts

@@ -7,15 +7,16 @@ declare class UniformArrayElementNode extends ArrayElementNode {
     constructor(arrayBuffer: Node, indexNode: Node);
 }
 
-declare class UniformArrayNode extends BufferNode {
+declare class UniformArrayNode extends BufferNode<unknown[]> {
     array: unknown[];
     elementType: string | null;
+    paddedType: string;
 
     readonly isArrayBufferNode: true;
 
     constructor(value: unknown[], elementType?: string | null);
 
-    getElementLength(): number;
+    getPaddedType(): string;
 
     element(indexNode: NodeRepresentation): ShaderNodeObject<UniformArrayElementNode>;
 }

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

@@ -24,5 +24,7 @@ export default IndexNode;
 
 export const vertexIndex: ShaderNodeObject<IndexNode>;
 export const instanceIndex: ShaderNodeObject<IndexNode>;
+export const subgroupIndex: ShaderNodeObject<IndexNode>;
+export const invocationSubgroupIndex: ShaderNodeObject<IndexNode>;
 export const invocationLocalIndex: ShaderNodeObject<IndexNode>;
 export const drawIndex: ShaderNodeObject<IndexNode>;

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

@@ -57,6 +57,11 @@ interface NodeJSONOutputData {
     images?: unknown[];
     nodes?: NodeJSONOutputData[];
 }
+/**
+ * Base class for all nodes.
+ *
+ * @augments EventDispatcher
+ */
 declare class Node extends EventDispatcher<{
     dispose: {};
 }> {
@@ -73,39 +78,271 @@ declare class Node extends EventDispatcher<{
     readonly isNode: true;
     readonly id: number;
     self?: this;
+    /**
+     * Constructs a new node.
+     *
+     * @param {String?} nodeType - The node type.
+     */
     constructor(nodeType?: string | null);
+    /**
+     * Set this property to `true` when the node should be regenerated.
+     *
+     * @type {Boolean}
+     * @default false
+     * @param {boolean} value
+     */
     set needsUpdate(value: boolean);
+    /**
+     * The type of the class. The value is usually the constructor name.
+     *
+     * @type {String}
+     * @readonly
+     */
     get type(): string | undefined;
+    /**
+     * Convenient method for defining {@link Node#update}.
+     *
+     * @param {Function} callback - The update method.
+     * @param {String} updateType - The update type.
+     * @return {Node} A reference to this node.
+     */
     onUpdate(callback: (this: this, frame: NodeFrame) => unknown, updateType: NodeUpdateType): this;
+    /**
+     * Convenient method for defining {@link Node#update}. Similar to {@link Node#onUpdate}, but
+     * this method automatically sets the update type to `FRAME`.
+     *
+     * @param {Function} callback - The update method.
+     * @return {Node} A reference to this node.
+     */
     onFrameUpdate(callback: (this: this, frame: NodeFrame) => void): this;
+    /**
+     * Convenient method for defining {@link Node#update}. Similar to {@link Node#onUpdate}, but
+     * this method automatically sets the update type to `RENDER`.
+     *
+     * @param {Function} callback - The update method.
+     * @return {Node} A reference to this node.
+     */
     onRenderUpdate(callback: (this: this, frame: NodeFrame) => void): this;
+    /**
+     * Convenient method for defining {@link Node#update}. Similar to {@link Node#onUpdate}, but
+     * this method automatically sets the update type to `OBJECT`.
+     *
+     * @param {Function} callback - The update method.
+     * @return {Node} A reference to this node.
+     */
     onObjectUpdate(callback: (this: this, frame: NodeFrame) => void): this;
+    /**
+     * Convenient method for defining {@link Node#updateReference}.
+     *
+     * @param {Function} callback - The update method.
+     * @return {Node} A reference to this node.
+     */
     onReference(callback: (this: this, frame: NodeBuilder | NodeFrame) => unknown): this;
+    /**
+     * The `this` reference might point to a Proxy so this method can be used
+     * to get the reference to the actual node instance.
+     *
+     * @return {Node} A reference to the node.
+     */
     getSelf(): this;
+    /**
+     * Nodes might refer to other objects like materials. This method allows to dynamically update the reference
+     * to such objects based on a given state (e.g. the current node frame or builder).
+     *
+     * @param {Any} state - This method can be invocated in different contexts so `state` can refer to any object type.
+     * @return {Any} The updated reference.
+     */
     updateReference(state: NodeBuilder | NodeFrame): unknown;
+    /**
+     * By default this method returns the value of the {@link Node#global} flag. This method
+     * can be overwritten in derived classes if an analytical way is required to determine the
+     * global status.
+     *
+     * @param {NodeBuilder} builder - The current node builder.
+     * @return {Boolean} Whether this node is global or not.
+     */
     isGlobal(builder: NodeBuilder): boolean;
+    /**
+     * Generator function that can be used to iterate over the child nodes.
+     *
+     * @generator
+     * @yields {Node} A child node.
+     */
     getChildren(): Generator<Node, void, unknown>;
+    /**
+     * Calling this method dispatches the `dispose` event. This event can be used
+     * to register event listeners for clean up tasks.
+     */
     dispose(): void;
+    /**
+     * Callback for {@link Node#traverse}.
+     *
+     * @callback traverseCallback
+     * @param {Node} node - The current node.
+     */
+    /**
+     * Can be used to traverse through the node's hierarchy.
+     *
+     * @param {traverseCallback} callback - A callback that is executed per node.
+     */
     traverse(callback: (node: Node) => void): void;
+    /**
+     * Returns the cache key for this node.
+     *
+     * @param {Boolean} [force=false] - When set to `true`, a recomputation of the cache key is forced.
+     * @return {Number} The cache key of the node.
+     */
     getCacheKey(force?: boolean): number;
+    /**
+     * Generate a custom cache key for this node.
+     *
+     * @return {Number} The cache key of the node.
+     */
+    customCacheKey(): number;
+    /**
+     * Returns the references to this node which is by default `this`.
+     *
+     * @return {Node} A reference to this node.
+     */
     getScope(): this;
+    /**
+     * Returns the hash of the node which is used to identify the node. By default it's
+     * the {@link Node#uuid} however derived node classes might have to overwrite this method
+     * depending on their implementation.
+     *
+     * @param {NodeBuilder} builder - The current node builder.
+     * @return {String} The hash.
+     */
     getHash(builder: NodeBuilder): string;
+    /**
+     * Returns the update type of {@link Node#update}.
+     *
+     * @return {NodeUpdateType} The update type.
+     */
     getUpdateType(): NodeUpdateType;
+    /**
+     * Returns the update type of {@link Node#updateBefore}.
+     *
+     * @return {NodeUpdateType} The update type.
+     */
     getUpdateBeforeType(): NodeUpdateType;
+    /**
+     * Returns the update type of {@link Node#updateAfter}.
+     *
+     * @return {NodeUpdateType} The update type.
+     */
     getUpdateAfterType(): NodeUpdateType;
+    /**
+     * Certain types are composed of multiple elements. For example a `vec3`
+     * is composed of three `float` values. This method returns the type of
+     * these elements.
+     *
+     * @param {NodeBuilder} builder - The current node builder.
+     * @return {String} The type of the node.
+     */
     getElementType(builder: NodeBuilder): "bool" | "int" | "float" | "vec2" | "vec3" | "vec4" | "uint" | null;
+    /**
+     * Returns the node's type.
+     *
+     * @param {NodeBuilder} builder - The current node builder.
+     * @return {String} The type of the node.
+     */
     getNodeType(builder: NodeBuilder): string | null;
+    /**
+     * 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.
+     *
+     * @param {NodeBuilder} builder - The current node builder.
+     * @return {Node} The shared node if possible. Otherwise `this` is returned.
+     */
     getShared(builder: NodeBuilder): Node;
+    /**
+     * Represents the setup stage which is the first step of the build process, see {@link Node#build} method.
+     * This method is often overwritten in derived modules to prepare the node which is used as the output/result.
+     * The output node must be returned in the `return` statement.
+     *
+     * @param {NodeBuilder} builder - The current node builder.
+     * @return {Node?} The output node.
+     */
     setup(builder: NodeBuilder): unknown;
+    /**
+     * Represents the analyze stage which is the second step of the build process, see {@link Node#build} method.
+     * This stage analyzes the node hierarchy and ensures descendent nodes are built.
+     *
+     * @param {NodeBuilder} builder - The current node builder.
+     */
     analyze(builder: NodeBuilder): void;
+    /**
+     * Represents the generate stage which is the third step of the build process, see {@link Node#build} method.
+     * This state builds the output node and returns the resulting shader string.
+     *
+     * @param {NodeBuilder} builder - The current node builder.
+     * @param {String?} output - Can be used to define the output type.
+     * @return {String?} The generated shader string.
+     */
     generate(builder: NodeBuilder, output?: string | null): string | null | undefined;
+    /**
+     * The method can be implemented to update the node's internal state before it is used to render an object.
+     * The {@link Node#updateBeforeType} property defines how often the update is executed.
+     *
+     * @abstract
+     * @param {NodeFrame} frame - A reference to the current node frame.
+     * @return {Boolean?} An optional bool that indicates whether the implementation actually performed an update or not (e.g. due to caching).
+     */
     updateBefore(frame: NodeFrame): void;
+    /**
+     * The method can be implemented to update the node's internal state after it was used to render an object.
+     * The {@link Node#updateAfterType} property defines how often the update is executed.
+     *
+     * @abstract
+     * @param {NodeFrame} frame - A reference to the current node frame.
+     * @return {Boolean?} An optional bool that indicates whether the implementation actually performed an update or not (e.g. due to caching).
+     */
     updateAfter(frame: NodeFrame): void;
+    /**
+     * The method can be implemented to update the node's internal state when it is used to render an object.
+     * The {@link Node#updateType} property defines how often the update is executed.
+     *
+     * @abstract
+     * @param {NodeFrame} frame - A reference to the current node frame.
+     * @return {Boolean?} An optional bool that indicates whether the implementation actually performed an update or not (e.g. due to caching).
+     */
     update(frame: NodeFrame): void;
+    /**
+     * This method performs the build of a node. The behavior of this method as well as its return value depend
+     * on the current build stage (setup, analyze or generate).
+     *
+     * @param {NodeBuilder} builder - The current node builder.
+     * @param {String?} output - Can be used to define the output type.
+     * @return {String?} When this method is executed in the setup or analyze stage, `null` is returned. In the generate stage, the generated shader string.
+     */
     build(builder: NodeBuilder, output?: string | null): string | null;
+    /**
+     * Returns the child nodes as a JSON object.
+     *
+     * @return {Object} The serialized child objects as JSON.
+     */
     getSerializeChildren(): Generator<import("./NodeUtils.js").NodeChild, void, unknown>;
+    /**
+     * Serializes the node to JSON.
+     *
+     * @param {Object} json - The output JSON object.
+     */
     serialize(json: NodeJSONIntermediateOutputData): void;
+    /**
+     * Deserializes the node from the given JSON.
+     *
+     * @param {Object} json - The JSON object.
+     */
     deserialize(json: NodeJSONInputData): void;
+    /**
+     * Serializes the node into the three.js JSON Object/Scene format.
+     *
+     * @param {Object?} meta - An optional JSON object that already holds serialized data from other scene objects.
+     * @return {Object} The serialized node.
+     */
     toJSON(meta?: NodeJSONMeta | string): NodeJSONOutputData;
 }
 export default Node;

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

@@ -1,9 +1,22 @@
 import Node from "./Node.js";
+/**
+ * {@link NodeBuilder} is going to create instances of this class during the build process
+ * of nodes. They represent the final shader attributes that are going to be generated
+ * by the builder. Arrays of node attributes is maintained in {@link NodeBuilder#attributes}
+ * and {@link NodeBuilder#bufferAttributes} for this purpose.
+ */
 declare class NodeAttribute {
     readonly isNodeAttribute: true;
     name: string;
     type: string | null;
     node: Node | null;
+    /**
+     * Constructs a new node attribute.
+     *
+     * @param {String} name - The name of the attribute.
+     * @param {String} type - The type of the attribute.
+     * @param {Node?} node - An optional reference to the node.
+     */
     constructor(name: string, type: string | null, node?: Node | null);
 }
 export default NodeAttribute;

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

@@ -3,7 +3,6 @@ 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 FogNode from "../fog/FogNode.js";
 import LightsNode from "../lighting/LightsNode.js";
 import { NodeShaderStage } from "./constants.js";
 import Node from "./Node.js";
@@ -41,7 +40,7 @@ export default abstract class NodeBuilder {
     hashNodes: { [hash: string]: Node };
 
     lightsNode: LightsNode;
-    fogNode: FogNode;
+    fogNode: Node;
 
     vertexShader: string;
     fragmentShader: string;

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

@@ -39,13 +39,34 @@ interface NodeData {
 interface BufferAttributeData {
     node: BufferAttributeNode;
 }
+/**
+ * This utility class is used in {@link NodeBuilder} as an internal
+ * cache data structure for node data.
+ */
 declare class NodeCache {
     id: number;
     nodesData: WeakMap<Node | TypedArray | InterleavedBuffer | BufferAttribute, NodeData | BufferAttributeData>;
     parent: NodeCache | null;
+    /**
+     * Constructs a new node 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.
+     */
     getData(node: Node): NodeData | undefined;
     getData(node: TypedArray | InterleavedBuffer | BufferAttribute): BufferAttributeData | undefined;
+    /**
+     * Sets the data for a given node.
+     *
+     * @param {Node} node - The node.
+     * @param {Object} data - The data that should be cached.
+     */
     setData(node: Node, data: NodeData): void;
     setData(node: TypedArray | InterleavedBuffer | BufferAttribute, data: BufferAttributeData): void;
 }

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

@@ -1,5 +1,16 @@
 import NodeFunction from "./NodeFunction.js";
+/**
+ * Base class for node parsers. A derived parser must be implemented
+ * for each supported native shader language.
+ */
 declare abstract class NodeParser {
+    /**
+     * The method parses the given native code an returns a node function.
+     *
+     * @abstract
+     * @param {String} source - The native shader code.
+     * @return {NodeFunction} A node function.
+     */
     abstract parseFunction(source: string): NodeFunction;
 }
 export default NodeParser;

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

@@ -1,14 +1,42 @@
 import UniformNode from "./UniformNode.js";
+/**
+ * {@link NodeBuilder} is going to create instances of this class during the build process
+ * of nodes. They represent the final shader uniforms that are going to be generated
+ * by the builder. A dictionary of node uniforms is maintained in {@link NodeBuilder#uniforms}
+ * for this purpose.
+ */
 declare class NodeUniform<TValue> {
     readonly isNodeUniform: true;
     name: string;
     type: string | null;
     node: UniformNode<TValue>;
     needsUpdate: boolean | undefined;
+    /**
+     * Constructs a new node 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}
+     */
     get value(): TValue;
     set value(val: TValue);
+    /**
+     * The id of the uniform node.
+     *
+     * @type {Number}
+     */
     get id(): number;
+    /**
+     * The uniform node's group.
+     *
+     * @type {UniformGroupNode}
+     */
     get groupNode(): import("./UniformGroupNode.js").default;
 }
 export default NodeUniform;