@types/three 0.171.0 → 0.172.0

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

@@ -4,6 +4,29 @@ import { InterleavedBuffer } from "../../core/InterleavedBuffer.js";
 import { InterleavedBufferAttribute } from "../../core/InterleavedBufferAttribute.js";
 import InputNode from "../core/InputNode.js";
 import NodeBuilder from "../core/NodeBuilder.js";
+/** @module BufferAttributeNode **/
+/**
+ * In earlier `three.js` versions it was only possible to define attribute data
+ * on geometry level. With `BufferAttributeNode`, it is also possible to do this
+ * on the node level.
+ * ```js
+ * const geometry = new THREE.PlaneGeometry();
+ * const positionAttribute = geometry.getAttribute( 'position' );
+ *
+ * const colors = [];
+ * for ( let i = 0; i < position.count; i ++ ) {
+ * 	colors.push( 1, 0, 0 );
+ * }
+ *
+ * material.colorNode = bufferAttribute( new THREE.Float32BufferAttribute( colors, 3 ) );
+ * ```
+ * This new approach is especially interesting when geometry data are generated via
+ * compute shaders. The below line converts a storage buffer into an attribute node.
+ * ```js
+ * material.positionNode = positionBuffer.toAttribute();
+ * ```
+ * @augments InputNode
+ */
 declare class BufferAttributeNode extends InputNode<TypedArray | InterleavedBuffer | BufferAttribute> {
     static get type(): string;
     readonly isBufferNode: true;
@@ -13,39 +36,133 @@ declare class BufferAttributeNode extends InputNode<TypedArray | InterleavedBuff
     usage: Usage;
     instanced: boolean;
     attribute: BufferAttribute | InterleavedBufferAttribute | null;
+    /**
+     * Constructs a new buffer attribute node.
+     *
+     * @param {BufferAttribute|InterleavedBuffer|TypedArray} value - The attribute data.
+     * @param {String?} [bufferType=null] - The buffer type (e.g. `'vec3'`).
+     * @param {Number} [bufferStride=0] - The buffer stride.
+     * @param {Number} [bufferOffset=0] - The buffer offset.
+     */
     constructor(
         value: TypedArray | InterleavedBuffer | BufferAttribute,
         bufferType?: string | null,
         bufferStride?: number,
         bufferOffset?: number,
     );
+    /**
+     * This method is overwritten since the attribute data might be shared
+     * and thus the hash should be shared as well.
+     *
+     * @param {NodeBuilder} builder - The current node builder.
+     * @return {String} The hash.
+     */
     getHash(builder: NodeBuilder): string;
+    /**
+     * This method is overwritten since the node type is inferred from
+     * the buffer attribute.
+     *
+     * @param {NodeBuilder} builder - The current node builder.
+     * @return {String} The node type.
+     */
     getNodeType(builder: NodeBuilder): string | null;
+    /**
+     * Depending on which value was passed to the node, `setup()` behaves
+     * differently. If no instance of `BufferAttribute` was passed, the method
+     * creates an internal attribute and configures it respectively.
+     *
+     * @param {NodeBuilder} builder - The current node builder.
+     */
     setup(builder: NodeBuilder): void;
+    /**
+     * Generates the code snippet of the buffer attribute node.
+     *
+     * @param {NodeBuilder} builder - The current node builder.
+     * @return {String} The generated code snippet.
+     */
     generate(builder: NodeBuilder): string | null | undefined;
+    /**
+     * Overwrites the default implementation to return a fixed value `'bufferAttribute'`.
+     *
+     * @param {NodeBuilder} builder - The current node builder.
+     * @return {String} The input type.
+     */
     getInputType(): string;
+    /**
+     * Sets the `usage` property to the given value.
+     *
+     * @param {Number} value - The usage to set.
+     * @return {BufferAttributeNode} A reference to this node.
+     */
     setUsage(value: Usage): this;
+    /**
+     * Sets the `instanced` property to the given value.
+     *
+     * @param {Number} value - The value to set.
+     * @return {BufferAttributeNode} A reference to this node.
+     */
     setInstanced(value: boolean): this;
 }
 export default BufferAttributeNode;
+/**
+ * TSL function for creating a buffer attribute node.
+ *
+ * @function
+ * @param {BufferAttribute|InterleavedBuffer|TypedArray} array - The attribute data.
+ * @param {String?} [type=null] - The buffer type (e.g. `'vec3'`).
+ * @param {Number} [stride=0] - The buffer stride.
+ * @param {Number} [offset=0] - The buffer offset.
+ * @returns {BufferAttributeNode}
+ */
 export declare const bufferAttribute: (
     array: TypedArray | InterleavedBuffer | BufferAttribute,
     type?: string | null,
     stride?: number,
     offset?: number,
 ) => import("../tsl/TSLCore.js").ShaderNodeObject<BufferAttributeNode>;
+/**
+ * TSL function for creating a buffer attribute node but with dynamic draw usage.
+ * Use this function if attribute data are updated per frame.
+ *
+ * @function
+ * @param {BufferAttribute|InterleavedBuffer|TypedArray} array - The attribute data.
+ * @param {String?} [type=null] - The buffer type (e.g. `'vec3'`).
+ * @param {Number} [stride=0] - The buffer stride.
+ * @param {Number} [offset=0] - The buffer offset.
+ * @returns {BufferAttributeNode}
+ */
 export declare const dynamicBufferAttribute: (
     array: TypedArray | InterleavedBuffer | BufferAttribute,
     type?: string | null,
     stride?: number,
     offset?: number,
 ) => import("../tsl/TSLCore.js").ShaderNodeObject<BufferAttributeNode>;
+/**
+ * TSL function for creating a buffer attribute node but with enabled instancing
+ *
+ * @function
+ * @param {BufferAttribute|InterleavedBuffer|TypedArray} array - The attribute data.
+ * @param {String?} [type=null] - The buffer type (e.g. `'vec3'`).
+ * @param {Number} [stride=0] - The buffer stride.
+ * @param {Number} [offset=0] - The buffer offset.
+ * @returns {BufferAttributeNode}
+ */
 export declare const instancedBufferAttribute: (
     array: TypedArray | InterleavedBuffer | BufferAttribute,
     type?: string | null,
     stride?: number,
     offset?: number,
 ) => import("../tsl/TSLCore.js").ShaderNodeObject<BufferAttributeNode>;
+/**
+ * TSL function for creating a buffer attribute node but with dynamic draw usage and enabled instancing
+ *
+ * @function
+ * @param {BufferAttribute|InterleavedBuffer|TypedArray} array - The attribute data.
+ * @param {String?} [type=null] - The buffer type (e.g. `'vec3'`).
+ * @param {Number} [stride=0] - The buffer stride.
+ * @param {Number} [offset=0] - The buffer offset.
+ * @returns {BufferAttributeNode}
+ */
 export declare const instancedDynamicBufferAttribute: (
     array: TypedArray | InterleavedBuffer | BufferAttribute,
     type?: string | null,

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

@@ -1,17 +1,17 @@
 import UniformNode from "../core/UniformNode.js";
 import { NodeOrType, ShaderNodeObject } from "../tsl/TSLCore.js";
 
-export default class BufferNode extends UniformNode<unknown> {
+export default class BufferNode<TValue> extends UniformNode<TValue> {
     isBufferNode: true;
 
     bufferType: string;
     bufferCount: number;
 
-    constructor(value: unknown, bufferType: string, bufferCount?: number);
+    constructor(value: TValue, bufferType: string, bufferCount?: number);
 }
 
-export const buffer: (
+export const buffer: <TValue>(
     value: unknown,
     nodeOrType: NodeOrType,
     count: number,
-) => ShaderNodeObject<BufferNode>;
+) => ShaderNodeObject<BufferNode<TValue>>;

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

@@ -5,7 +5,7 @@ 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;
 
     access: NodeAccess;
@@ -29,6 +29,10 @@ export default class StorageBufferNode extends BufferNode {
     setAccess(value: NodeAccess): this;
 
     toReadOnly(): this;
+
+    setAtmoic(value: boolean): this;
+
+    toAtomic(): this;
 }
 
 export const storage: (

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/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;