@types/three 0.171.0 → 0.173.0

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

@@ -76,6 +76,9 @@ declare class NodeMaterial extends Material {
     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/NodeMaterials.d.ts

@@ -1,7 +1,3 @@
-export {
-    default as InstancedPointsNodeMaterial,
-    InstancedPointsNodeMaterialParameters,
-} from "./InstancedPointsNodeMaterial.js";
 export { default as Line2NodeMaterial, Line2NodeMaterialParameters } from "./Line2NodeMaterial.js";
 export { default as LineBasicNodeMaterial, LineBasicNodeMaterialParameters } from "./LineBasicNodeMaterial.js";
 export { default as LineDashedNodeMaterial, LineDashedNodeMaterialParameters } from "./LineDashedNodeMaterial.js";

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

@@ -1,21 +1,14 @@
-import { Color } from "../../math/Color.js";
-import { Texture } from "../../textures/Texture.js";
-import { PointsMaterialParameters } from "../PointsMaterial.js";
-import NodeMaterial, { NodeMaterialParameters } from "./NodeMaterial.js";
+import Node from "../../nodes/core/Node.js";
+import SpriteNodeMaterial, { SpriteNodeMaterialParameters } from "./SpriteNodeMaterial.js";
 
-export interface PointsNodeMaterialParameters extends NodeMaterialParameters, PointsMaterialParameters {
+export interface PointsNodeMaterialParameters extends SpriteNodeMaterialParameters {
+    sizeNode?: Node | null | undefined;
 }
 
-export default class PointsNodeMaterial extends NodeMaterial {
-    readonly isPointsNodeMaterial: true;
+export default class PointsNodeMaterial extends SpriteNodeMaterial {
+    sizeNode: Node | null;
 
-    // Properties from PointsMaterial
-    readonly isPointsMaterial: true;
-    color: Color;
-    map: Texture | null;
-    alphaMap: Texture | null;
-    size: number;
-    sizeAttenuation: boolean;
+    readonly isPointsNodeMaterial: true;
 
     constructor(parameters?: PointsNodeMaterialParameters);
 }

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

@@ -68,6 +68,7 @@ interface AttributesData {
 interface RenderObjectData {
     material: MaterialData;
     geometry: {
+        id: number;
         attributes: AttributesData;
         indexVersion: number | null;
         drawRange: {
@@ -78,19 +79,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/math/Matrix4.d.ts

@@ -128,7 +128,8 @@ export class Matrix4 {
     makeRotationFromQuaternion(q: Quaternion): this;
 
     /**
-     * Constructs a rotation matrix, looking from eye towards center with defined up vector.
+     * Sets the rotation component of the transformation matrix, looking from [eye]{@link Vector3} towards
+     * [target]{@link Vector3}, and oriented by the up-direction [up]{@link Vector3}.
      */
     lookAt(eye: Vector3, target: Vector3, up: Vector3): this;
 

three/src/nodes/Nodes.d.ts

@@ -2,6 +2,7 @@
 export * from "./core/constants.js";
 
 // core
+export { default as ArrayNode } from "./core/ArrayNode.js";
 export { default as AssignNode } from "./core/AssignNode.js";
 export { default as AttributeNode } from "./core/AttributeNode.js";
 export { default as BypassNode } from "./core/BypassNode.js";
@@ -37,6 +38,8 @@ export { default as OutputStructNode } from "./core/OutputStructNode.js";
 export { default as ParameterNode } from "./core/ParameterNode.js";
 export { default as PropertyNode } from "./core/PropertyNode.js";
 export { default as StackNode } from "./core/StackNode.js";
+export { default as StructNode } from "./core/StructNode.js";
+export { default as StructTypeNode } from "./core/StructTypeNode.js";
 export { default as TempNode } from "./core/TempNode.js";
 export { default as UniformGroupNode } from "./core/UniformGroupNode.js";
 export { default as UniformNode } from "./core/UniformNode.js";
@@ -55,6 +58,7 @@ export { default as JoinNode } from "./utils/JoinNode.js";
 export { default as LoopNode } from "./utils/LoopNode.js";
 export { default as MatcapUVNode } from "./utils/MatcapUVNode.js";
 export { default as MaxMipLevelNode } from "./utils/MaxMipLevelNode.js";
+export { default as MemberNode } from "./utils/MemberNode.js";
 export { default as ReflectorNode, ReflectorNodeParameters } from "./utils/ReflectorNode.js";
 export { default as RemapNode } from "./utils/RemapNode.js";
 export { default as RotateNode } from "./utils/RotateNode.js";
@@ -75,7 +79,6 @@ 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";
@@ -115,13 +118,8 @@ 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";
+export { default as RangeNode } from "./geometry/RangeNode.js";
 
 // gpgpu
 export { default as ComputeNode } from "./gpgpu/ComputeNode.js";
@@ -142,6 +140,7 @@ 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

@@ -13,6 +13,7 @@ export * from "./core/OutputStructNode.js";
 export * from "./core/ParameterNode.js";
 export * from "./core/PropertyNode.js";
 export * from "./core/StackNode.js";
+export * from "./core/StructNode.js";
 export * from "./core/UniformGroupNode.js";
 export * from "./core/UniformNode.js";
 export * from "./core/VaryingNode.js";
@@ -115,9 +116,7 @@ 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";
@@ -134,6 +133,7 @@ export * from "./accessors/Lights.js";
 export * from "./lighting/LightingContextNode.js";
 export * from "./lighting/LightsNode.js";
 export * from "./lighting/PointLightNode.js";
+export * from "./lighting/ShadowBaseNode.js";
 export * from "./lighting/ShadowNode.js";
 
 // pmrem
@@ -143,6 +143,9 @@ export * from "./pmrem/PMREMUtils.js";
 // procedural
 export * from "./procedural/Checker.js";
 
+// shapes
+export * from "./shapes/Shapes.js";
+
 // materialX
 export * from "./materialx/MaterialXNodes.js";
 

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

@@ -1,6 +1,14 @@
+import { TypedArray } from "../../core/BufferAttribute.js";
+import { Struct } from "../core/StructNode.js";
 import { ShaderNodeObject } from "../tsl/TSLCore.js";
 import StorageBufferNode from "./StorageBufferNode.js";
 
-export const attributeArray: (count: number, type?: string) => ShaderNodeObject<StorageBufferNode>;
+export const attributeArray: (
+    count: TypedArray | number,
+    type?: string | Struct,
+) => ShaderNodeObject<StorageBufferNode>;
 
-export const instancedArray: (count: number, type?: string) => ShaderNodeObject<StorageBufferNode>;
+export const instancedArray: (
+    count: TypedArray | number,
+    type?: string | Struct,
+) => 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 {Boolean} 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/Camera.d.ts

@@ -4,6 +4,7 @@ import { Vector3 } from "../../math/Vector3.js";
 import UniformNode from "../core/UniformNode.js";
 import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
+export const cameraIndex: ShaderNodeObject<UniformNode<number>>;
 export const cameraNear: ShaderNodeObject<UniformNode<number>>;
 export const cameraFar: ShaderNodeObject<UniformNode<number>>;
 export const cameraProjectionMatrix: ShaderNodeObject<UniformNode<Matrix4>>;

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

@@ -37,10 +37,10 @@ export type MaterialNodeScope =
     | typeof MaterialNode.LINE_GAP_SIZE
     | typeof MaterialNode.LINE_WIDTH
     | typeof MaterialNode.LINE_DASH_OFFSET
-    | typeof MaterialNode.POINT_WIDTH
+    | typeof MaterialNode.POINT_SIZE
     | typeof MaterialNode.DISPERSION
     | typeof MaterialNode.LIGHT_MAP
-    | typeof MaterialNode.AO_MAP
+    | typeof MaterialNode.AO
     | typeof MaterialNode.REFRACTION_RATIO;
 
 export default class MaterialNode extends Node {
@@ -77,10 +77,10 @@ export default class MaterialNode extends Node {
     static LINE_GAP_SIZE: "gapSize";
     static LINE_WIDTH: "linewidth";
     static LINE_DASH_OFFSET: "dashOffset";
-    static POINT_WIDTH: "pointWidth";
+    static POINT_SIZE: "size";
     static DISPERSION: "dispersion";
     static LIGHT_MAP: "light";
-    static AO_MAP: "ao";
+    static AO: "ao";
     static REFRACTION_RATIO: "refractionRatio";
 
     scope: MaterialNodeScope;
@@ -122,8 +122,8 @@ export const materialLineDashSize: ShaderNodeObject<MaterialNode>;
 export const materialLineGapSize: ShaderNodeObject<MaterialNode>;
 export const materialLineWidth: ShaderNodeObject<MaterialNode>;
 export const materialLineDashOffset: ShaderNodeObject<MaterialNode>;
-export const materialPointWidth: ShaderNodeObject<MaterialNode>;
+export const materialPointSize: 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,13 +1,17 @@
 import StorageBufferAttribute from "../../renderers/common/StorageBufferAttribute.js";
 import StorageInstancedBufferAttribute from "../../renderers/common/StorageInstancedBufferAttribute.js";
 import { NodeAccess } from "../core/constants.js";
+import { Struct } from "../core/StructNode.js";
+import StructTypeNode from "../core/StructTypeNode.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;
 
+    structTypeNode: StructTypeNode | null;
+
     access: NodeAccess;
     isAtomic: boolean;
     isPBO: boolean;
@@ -16,7 +20,7 @@ export default class StorageBufferNode extends BufferNode {
 
     constructor(
         value: StorageBufferAttribute | StorageInstancedBufferAttribute,
-        bufferType?: string | null,
+        bufferType?: string | Struct | null,
         bufferCount?: number,
     );
 
@@ -29,11 +33,15 @@ export default class StorageBufferNode extends BufferNode {
     setAccess(value: NodeAccess): this;
 
     toReadOnly(): this;
+
+    setAtmoic(value: boolean): this;
+
+    toAtomic(): this;
 }
 
 export const storage: (
     value: StorageBufferAttribute | StorageInstancedBufferAttribute,
-    type?: string | null,
+    type?: string | Struct | null,
     count?: number,
 ) => ShaderNodeObject<StorageBufferNode>;
 
@@ -42,6 +50,6 @@ export const storage: (
  */
 export const storageObject: (
     value: StorageBufferAttribute | StorageInstancedBufferAttribute,
-    type?: string | null,
+    type?: string | Struct | null,
     count?: number,
 ) => ShaderNodeObject<StorageBufferNode>;

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

@@ -0,0 +1,26 @@
+import { ShaderNodeObject } from "../tsl/TSLCore.js";
+import Node from "./Node.js";
+import TempNode from "./TempNode.js";
+
+declare class ArrayNode extends TempNode {
+    count: number;
+    values: Node[];
+    readonly isArrayNode: true;
+
+    constructor(nodeType: string, count: number, values: Node[]);
+}
+
+export default ArrayNode;
+
+interface ArrayFunction {
+    (values: Node[]): ShaderNodeObject<ArrayNode>;
+    (nodeType: string, count: number): ShaderNodeObject<ArrayNode>;
+}
+
+export const array: ArrayFunction;
+
+declare module "../tsl/TSLCore.js" {
+    interface NodeElements {
+        toArray: typeof array;
+    }
+}