@types/three 0.170.0 → 0.172.0

three/src/cameras/CubeCamera.d.ts

@@ -1,7 +1,24 @@
 import { CoordinateSystem } from "../constants.js";
 import { Object3D } from "../core/Object3D.js";
+import { RenderTarget } from "../core/RenderTarget.js";
 import { WebGLCubeRenderTarget } from "../renderers/WebGLCubeRenderTarget.js";
-import { WebGLRenderer } from "../renderers/WebGLRenderer.js";
+import { Camera } from "./Camera.js";
+
+export interface CubeCameraRenderer {
+    coordinateSystem: CoordinateSystem;
+    getRenderTarget(): RenderTarget | null;
+    getActiveCubeFace(): number;
+    getActiveMipmapLevel(): number;
+    xr: {
+        enabled: boolean;
+    };
+    setRenderTarget(
+        renderTarget: WebGLCubeRenderTarget | null,
+        activeCubeFace?: number,
+        activeMipmapLevel?: number,
+    ): void;
+    render(scene: Object3D, camera: Camera): void;
+}
 
 /**
  * Creates **6** {@link THREE.PerspectiveCamera | cameras} that render to a {@link THREE.WebGLCubeRenderTarget | WebGLCubeRenderTarget}.
@@ -64,5 +81,5 @@ export class CubeCamera extends Object3D {
      * @param renderer The current WebGL renderer
      * @param scene The current scene
      */
-    update(renderer: WebGLRenderer, scene: Object3D): void;
+    update(renderer: CubeCameraRenderer, scene: Object3D): void;
 }

three/src/core/Clock.d.ts

@@ -1,10 +1,8 @@
 /**
- * Object for keeping track of time
- * @remarks
- * This uses {@link https://developer.mozilla.org/en-US/docs/Web/API/Performance/now | performance.now} if it is available,
- * otherwise it reverts to the less accurate {@link https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/Date/now | Date.now}.
- * @see {@link https://threejs.org/docs/index.html#api/en/core/Clock | Official Documentation}
- * @see {@link https://github.com/mrdoob/three.js/blob/master/src/core/Clock.js | Source}
+ * Object for keeping track of time. This uses
+ * [performance.now]{@link https://developer.mozilla.org/en-US/docs/Web/API/Performance/now}.
+ * @see [Official Documentation]{@link https://threejs.org/docs/index.html#api/en/core/Clock}
+ * @see [Source]{@link https://github.com/mrdoob/three.js/blob/master/src/core/Clock.js}
  */
 export class Clock {
     /**

three/src/core/InterleavedBuffer.d.ts

@@ -85,6 +85,18 @@ export class InterleavedBuffer {
      */
     uuid: string;
 
+    /**
+     * A callback function that is executed after the Renderer has transferred the geometry data to the GPU.
+     */
+    onUploadCallback: () => void;
+
+    /**
+     * Sets the value of the {@link onUploadCallback} property.
+     * @see {@link onUploadCallback}
+     * @param callback function that is executed after the Renderer has transferred the geometry data to the GPU.
+     */
+    onUpload(callback: () => void): this;
+
     /**
      * Calls {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/set | TypedArray.set}( {@link value}, {@link offset} )
      * on the {@link BufferAttribute.array | array}.

three/src/core/RenderTarget.d.ts

@@ -72,11 +72,6 @@ export class RenderTarget<TTexture extends Texture | Texture[] = Texture> extend
      */
     resolveStencilBuffer: boolean;
 
-    /**
-     * @default null
-     */
-    depthTexture: DepthTexture | null;
-
     /**
      * Defines the count of MSAA samples. Can only be used with WebGL 2. Default is **0**.
      * @default 0
@@ -88,6 +83,9 @@ export class RenderTarget<TTexture extends Texture | Texture[] = Texture> extend
     get texture(): TTexture;
     set texture(value: TTexture);
 
+    set depthTexture(current: DepthTexture | null);
+    get depthTexture(): DepthTexture | null;
+
     setSize(width: number, height: number, depth?: number): void;
     clone(): this;
     copy(source: RenderTarget): this;

three/src/core/RenderTarget3D.d.ts

@@ -0,0 +1,9 @@
+import { RenderTarget, RenderTargetOptions } from "./RenderTarget.js";
+
+declare class RenderTarget3D extends RenderTarget {
+    readonly isRenderTarget3D: true;
+
+    constructor(width?: number, height?: number, depth?: number, options?: RenderTargetOptions);
+}
+
+export { RenderTarget3D };

three/src/core/RenderTargetArray.d.ts

@@ -0,0 +1,9 @@
+import { RenderTarget, RenderTargetOptions } from "./RenderTarget.js";
+
+declare class RenderTargetArray extends RenderTarget {
+    readonly isRenderTargetArray: true;
+
+    constructor(width?: number, height?: number, depth?: number, options?: RenderTargetOptions);
+}
+
+export { RenderTargetArray };

three/src/materials/Material.d.ts

@@ -234,10 +234,6 @@ export interface MaterialJSON {
  * Materials describe the appearance of objects. They are defined in a (mostly) renderer-independent way, so you don't have to rewrite materials if you decide to use a different renderer.
  */
 export class Material extends EventDispatcher<{ dispose: {} }> {
-    static get type(): string;
-
-    get type(): string;
-
     constructor();
 
     /**
@@ -247,6 +243,12 @@ export class Material extends EventDispatcher<{ dispose: {} }> {
      */
     readonly isMaterial: true;
 
+    /**
+     * Value is the string 'Material'. This shouldn't be changed, and can be used to find all objects of this type in a
+     * scene.
+     */
+    type: string;
+
     /**
      * Enables alpha hashed transparency, an alternative to {@link .transparent} or {@link .alphaTest}. The material
      * will not be rendered if opacity is lower than a random threshold. Randomization introduces some grain or noise,
@@ -571,7 +573,9 @@ export class Material extends EventDispatcher<{ dispose: {} }> {
     /**
      * An optional callback that is executed immediately before the shader program is compiled.
      * This function is called with the shader source code as a parameter.
-     * Useful for the modification of built-in materials.
+     * Useful for the modification of built-in materials, but the recommended approach moving forward is to use
+     * `WebGPURenderer` with the new Node Material system and
+     * [TSL]{@link https://github.com/mrdoob/three.js/wiki/Three.js-Shading-Language}.
      * Unlike properties, the callback is not supported by {@link .clone()}, {@link .copy()} and {@link .toJSON()}.
      * This callback is only supported in `WebGLRenderer` (not `WebGPURenderer`).
      * @param parameters WebGL program parameters

three/src/materials/MeshDepthMaterial.d.ts

@@ -62,10 +62,5 @@ export class MeshDepthMaterial extends Material {
      */
     wireframeLinewidth: number;
 
-    /**
-     * @default false
-     */
-    fog: boolean;
-
     setValues(parameters: MeshDepthMaterialParameters): void;
 }

three/src/materials/MeshDistanceMaterial.d.ts

@@ -48,10 +48,5 @@ export class MeshDistanceMaterial extends Material {
      */
     displacementBias: number;
 
-    /**
-     * @default false
-     */
-    fog: boolean;
-
     setValues(parameters: MeshDistanceMaterialParameters): void;
 }

three/src/materials/nodes/Line2NodeMaterial.d.ts

@@ -5,6 +5,7 @@ import { LineDashedMaterialParameters } from "../LineDashedMaterial.js";
 import NodeMaterial, { NodeMaterialParameters } from "./NodeMaterial.js";
 
 export interface Line2NodeMaterialParameters extends NodeMaterialParameters, LineDashedMaterialParameters {
+    worldUnits?: boolean | undefined;
     dashed?: boolean | undefined;
 }
 

three/src/materials/nodes/LineDashedNodeMaterial.d.ts

@@ -3,6 +3,7 @@ import { LineDashedMaterialParameters } from "../LineDashedMaterial.js";
 import NodeMaterial, { NodeMaterialParameters } from "./NodeMaterial.js";
 
 export interface LineDashedNodeMaterialParameters extends NodeMaterialParameters, LineDashedMaterialParameters {
+    dashOffset?: number | undefined;
     offsetNode?: Node | null | undefined;
     dashScaleNode?: Node | null | undefined;
     dashSizeNode?: Node | null | undefined;
@@ -12,6 +13,8 @@ export interface LineDashedNodeMaterialParameters extends NodeMaterialParameters
 declare class LineDashedNodeMaterial extends NodeMaterial {
     readonly isLineDashedNodeMaterial: true;
 
+    dashOffset: number;
+
     offsetNode: Node | null;
     dashScaleNode: Node | null;
     dashSizeNode: Node | null;

three/src/materials/nodes/MeshSSSNodeMaterial.d.ts

@@ -1,14 +1,14 @@
-import ConstNode from "../../nodes/core/ConstNode.js";
+import InputNode from "../../nodes/core/InputNode.js";
 import Node from "../../nodes/core/Node.js";
 import MeshPhysicalNodeMaterial, { MeshPhysicalNodeMaterialParameters } from "./MeshPhysicalNodeMaterial.js";
 
 export default class MeshSSSNodeMaterial extends MeshPhysicalNodeMaterial {
     thicknessColorNode: Node | null;
-    thicknessDistortionNode: ConstNode<number>;
-    thicknessAmbientNode: ConstNode<number>;
-    thicknessAttenuationNode: ConstNode<number>;
-    thicknessPowerNode: ConstNode<number>;
-    thicknessScaleNode: ConstNode<number>;
+    thicknessDistortionNode: InputNode<number>;
+    thicknessAmbientNode: InputNode<number>;
+    thicknessAttenuationNode: InputNode<number>;
+    thicknessPowerNode: InputNode<number>;
+    thicknessScaleNode: InputNode<number>;
 
     constructor(parameters?: MeshPhysicalNodeMaterialParameters);
 

three/src/materials/nodes/NodeMaterial.d.ts

@@ -42,6 +42,7 @@ declare class NodeMaterial extends Material {
 
     fog: boolean;
     lights: boolean;
+    hardwareClipping: boolean;
 
     lightsNode: LightsNode | null;
     envNode: Node | null;
@@ -58,8 +59,9 @@ declare class NodeMaterial extends Material {
     geometryNode: Node | null;
 
     depthNode: Node | null;
-    shadowNode: Node | null;
     shadowPositionNode: Node | null;
+    receivedShadowNode: Node | null;
+    castShadowNode: Node | null;
 
     outputNode: Node | null;
     mrtNode: MRTNode | null;
@@ -72,7 +74,11 @@ declare class NodeMaterial extends Material {
     build(builder: NodeBuilder): void;
     setup(builder: NodeBuilder): void;
     setupClipping(builder: NodeBuilder): ClippingNode | null;
+    setupHardwareClipping(builder: NodeBuilder): void;
     setupDepth(builder: NodeBuilder): void;
+    setupPositionView(): Node;
+    setupModelViewProjection(): Node;
+    setupVertex(builder: NodeBuilder): Node;
     setupPosition(builder: NodeBuilder): Node;
     setupDiffuseColor(builder: NodeBuilder): void;
     setupVariants(builder: NodeBuilder): void;

three/src/materials/nodes/manager/NodeMaterialObserver.d.ts

@@ -78,19 +78,75 @@ interface RenderObjectData {
     worldMatrix: Matrix4;
     version?: number;
 }
+/**
+ * This class is used by {@link WebGPURenderer} as management component.
+ * It's primary purpose is to determine whether render objects require a
+ * refresh right before they are going to be rendered or not.
+ */
 declare class NodeMaterialObserver {
     renderObjects: WeakMap<RenderObject, RenderObjectData>;
     hasNode: boolean;
     hasAnimation: boolean;
     refreshUniforms: readonly RefreshUniform[];
     renderId: number;
+    /**
+     * Constructs a new node material observer.
+     *
+     * @param {NodeBuilder} builder - The node builder.
+     */
     constructor(builder: NodeBuilder);
+    /**
+     * Returns `true` if the given render object is verified for the first time of this observer.
+     *
+     * @param {RenderObject} renderObject - The render object.
+     * @return {Boolean} Whether the given render object is verified for the first time of this observer.
+     */
     firstInitialization(renderObject: RenderObject): boolean;
+    /**
+     * Returns monitoring data for the given render object.
+     *
+     * @param {RenderObject} renderObject - The render object.
+     * @return {Object} The monitoring data.
+     */
     getRenderObjectData(renderObject: RenderObject): RenderObjectData;
+    /**
+     * Returns an attribute data structure holding the attributes versions for
+     * monitoring.
+     *
+     * @param {Object} attributes - The geometry attributes.
+     * @return {Object} An object for monitoring the versions of attributes.
+     */
     getAttributesData(attributes: Record<string, BufferAttribute>): AttributesData;
+    /**
+     * Returns `true` if the node builder's material uses
+     * node properties.
+     *
+     * @param {NodeBuilder} builder - The current node builder.
+     * @return {Boolean} Whether the node builder's material uses node properties or not.
+     */
     containsNode(builder: NodeBuilder): boolean;
+    /**
+     * Returns a material data structure holding the material property values for
+     * monitoring.
+     *
+     * @param {Material} material - The material.
+     * @return {Object} An object for monitoring material properties.
+     */
     getMaterialData(material: Material): MaterialData;
+    /**
+     * Returns `true` if the given render object has not changed its state.
+     *
+     * @param {RenderObject} renderObject - The render object.
+     * @return {Boolean} Whether the given render object has changed its state or not.
+     */
     equals(renderObject: RenderObject): boolean;
+    /**
+     * Checks if the given render object requires a refresh.
+     *
+     * @param {RenderObject} renderObject - The render object.
+     * @param {NodeFrame} nodeFrame - The current node frame.
+     * @return {Boolean} Whether the given render object requires a refresh or not.
+     */
     needsRefresh(renderObject: RenderObject, nodeFrame: NodeFrame): boolean;
 }
 export default NodeMaterialObserver;

three/src/nodes/Nodes.d.ts

@@ -70,11 +70,11 @@ export { default as BatchNode } from "./accessors/BatchNode.js";
 export { default as BufferAttributeNode } from "./accessors/BufferAttributeNode.js";
 export { default as BufferNode } from "./accessors/BufferNode.js";
 export { default as CubeTextureNode } from "./accessors/CubeTextureNode.js";
+export { default as InstancedMeshNode } from "./accessors/InstancedMeshNode.js";
 export { default as InstanceNode } from "./accessors/InstanceNode.js";
 export { default as MaterialNode, MaterialNodeScope } from "./accessors/MaterialNode.js";
 export { default as MaterialReferenceNode } from "./accessors/MaterialReferenceNode.js";
 export { default as ModelNode } from "./accessors/ModelNode.js";
-export { default as ModelViewProjectionNode } from "./accessors/ModelViewProjectionNode.js";
 export { default as MorphNode } from "./accessors/MorphNode.js";
 export { default as Object3DNode } from "./accessors/Object3DNode.js";
 export { default as PointUVNode } from "./accessors/PointUVNode.js";
@@ -114,11 +114,6 @@ export { default as FunctionNode } from "./code/FunctionNode.js";
 export { default as ScriptableNode } from "./code/ScriptableNode.js";
 export { default as ScriptableValueNode } from "./code/ScriptableValueNode.js";
 
-// fog
-export { default as FogExp2Node } from "./fog/FogExp2Node.js";
-export { default as FogNode } from "./fog/FogNode.js";
-export { default as FogRangeNode } from "./fog/FogRangeNode.js";
-
 // geometry
 export { default as RangeNode, RangeModeBound } from "./geometry/RangeNode.js";
 
@@ -137,11 +132,11 @@ export { default as IESSpotLightNode } from "./lighting/IESSpotLightNode.js";
 export { default as IrradianceNode } from "./lighting/IrradianceNode.js";
 export { default as LightingContextNode } from "./lighting/LightingContextNode.js";
 export { default as LightingNode } from "./lighting/LightingNode.js";
-export { default as LightNode, LightNodeScope } from "./lighting/LightNode.js";
 export { default as LightProbeNode } from "./lighting/LightProbeNode.js";
 export { default as LightsNode } from "./lighting/LightsNode.js";
 export { default as PointLightNode } from "./lighting/PointLightNode.js";
 export { default as RectAreaLightNode, RectAreaLightTexturesLib } from "./lighting/RectAreaLightNode.js";
+export { default as ShadowBaseNode } from "./lighting/ShadowBaseNode.js";
 export { default as ShadowNode } from "./lighting/ShadowNode.js";
 export { default as SpotLightNode } from "./lighting/SpotLightNode.js";
 

three/src/nodes/TSL.d.ts

@@ -47,12 +47,14 @@ export * from "./tsl/TSLBase.js";
 
 // accessors
 export * from "./accessors/AccessorsUtils.js";
+export * from "./accessors/Arrays.js";
 export * from "./accessors/BatchNode.js";
 export * from "./accessors/Bitangent.js";
 export * from "./accessors/BufferAttributeNode.js";
 export * from "./accessors/BufferNode.js";
 export * from "./accessors/Camera.js";
 export * from "./accessors/CubeTextureNode.js";
+export * from "./accessors/InstancedMeshNode.js";
 export * from "./accessors/InstanceNode.js";
 export * from "./accessors/MaterialNode.js";
 export * from "./accessors/MaterialProperties.js";
@@ -83,7 +85,7 @@ export * from "./accessors/VelocityNode.js";
 export * from "./accessors/VertexColorNode.js";
 
 // display
-export * from "./display/BlendMode.js";
+export * from "./display/BlendModes.js";
 export * from "./display/BumpMapNode.js";
 export * from "./display/ColorAdjustment.js";
 export * from "./display/ColorSpaceNode.js";
@@ -113,21 +115,24 @@ export * from "./code/ScriptableNode.js";
 export * from "./code/ScriptableValueNode.js";
 
 // fog
-export * from "./fog/FogExp2Node.js";
-export * from "./fog/FogNode.js";
-export * from "./fog/FogRangeNode.js";
+export * from "./fog/Fog.js";
 
 // geometry
 export * from "./geometry/RangeNode.js";
 
 // gpgpu
+export * from "./gpgpu/AtomicFunctionNode.js";
+export * from "./gpgpu/BarrierNode.js";
+export * from "./gpgpu/ComputeBuiltinNode.js";
 export * from "./gpgpu/ComputeNode.js";
+export * from "./gpgpu/WorkgroupInfoNode.js";
 
 // lighting
+export * from "./accessors/Lights.js";
 export * from "./lighting/LightingContextNode.js";
-export * from "./lighting/LightNode.js";
 export * from "./lighting/LightsNode.js";
 export * from "./lighting/PointLightNode.js";
+export * from "./lighting/ShadowBaseNode.js";
 export * from "./lighting/ShadowNode.js";
 
 // pmrem

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

@@ -0,0 +1,7 @@
+import { TypedArray } from "../../core/BufferAttribute.js";
+import { ShaderNodeObject } from "../tsl/TSLCore.js";
+import StorageBufferNode from "./StorageBufferNode.js";
+
+export const attributeArray: (count: TypedArray | number, type?: string) => ShaderNodeObject<StorageBufferNode>;
+
+export const instancedArray: (count: TypedArray | number, type?: string) => ShaderNodeObject<StorageBufferNode>;

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/BuiltinNode.d.ts

@@ -0,0 +1,14 @@
+import Node from "../core/Node.js";
+import { ShaderNodeObject } from "../tsl/TSLCore.js";
+
+declare class BuiltinNode extends Node {
+    name: string;
+
+    readonly isBuiltinNode: true;
+
+    constructor(name: string);
+}
+
+export default BuiltinNode;
+
+export const builtin: (name: string) => ShaderNodeObject<BuiltinNode>;

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

@@ -1,4 +1,6 @@
+import { Plane } from "../../math/Plane.js";
 import Node from "../core/Node.js";
+import NodeBuilder from "../core/NodeBuilder.js";
 import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
 export type ClippingNodeScope = typeof ClippingNode.ALPHA_TO_COVERAGE | typeof ClippingNode.DEFAULT;
@@ -6,11 +8,15 @@ export type ClippingNodeScope = typeof ClippingNode.ALPHA_TO_COVERAGE | typeof C
 export default class ClippingNode extends Node {
     scope: ClippingNodeScope;
 
+    hardwareClipping?: boolean;
+
     constructor(scope?: ClippingNodeScope);
 
     static ALPHA_TO_COVERAGE: "alphaToCoverage";
     static DEFAULT: "default";
+    static HARDWARE: "hardware";
 }
 
 export const clipping: () => ShaderNodeObject<ClippingNode>;
 export const clippingAlpha: () => ShaderNodeObject<ClippingNode>;
+export const hardwareClipping: () => ShaderNodeObject<ClippingNode>;