@types/three 0.184.1 → 0.185.0

three/src/math/interpolants/QuaternionLinearInterpolant.d.ts

@@ -1,7 +1,11 @@
+import { TypedArray } from "../../core/BufferAttribute.js";
 import { Interpolant } from "../Interpolant.js";
 
+/**
+ * Spherical linear unit quaternion interpolant.
+ *
+ * @augments Interpolant
+ */
 export class QuaternionLinearInterpolant extends Interpolant {
-    constructor(parameterPositions: any, samplesValues: any, sampleSize: number, resultBuffer?: any);
-
-    interpolate_(i1: number, t0: number, t: number, t1: number): any;
+    interpolate_(i1: number, t0: number, t: number, t1: number): TypedArray;
 }

three/src/nodes/Nodes.d.ts

@@ -21,13 +21,7 @@ export {
 export { default as MRTNode } from "./core/MRTNode.js";
 export { default as Node, NodeJSONInputData, NodeJSONIntermediateOutputData } from "./core/Node.js";
 export { default as NodeAttribute } from "./core/NodeAttribute.js";
-export {
-    BuildStageOption,
-    default as NodeBuilder,
-    FlowData,
-    NodeBuilderContext,
-    NodeData,
-} from "./core/NodeBuilder.js";
+export { default as NodeBuilder } from "./core/NodeBuilder.js";
 export { default as NodeCache } from "./core/NodeCache.js";
 export { default as NodeCode } from "./core/NodeCode.js";
 export { default as NodeError } from "./core/NodeError.js";
@@ -37,6 +31,7 @@ export { default as NodeUniform } from "./core/NodeUniform.js";
 export { default as NodeVar } from "./core/NodeVar.js";
 export { default as NodeVarying } from "./core/NodeVarying.js";
 export { default as OutputStructNode } from "./core/OutputStructNode.js";
+export { default as OverrideContextNode } from "./core/OverrideContextNode.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";
@@ -54,25 +49,21 @@ import * as NodeUtils from "./core/NodeUtils.js";
 export { NodeUtils };
 
 // accessors
-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 BuiltinNode } from "./accessors/BuiltinNode.js";
 export { default as ClippingNode } from "./accessors/ClippingNode.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 MorphNode } from "./accessors/MorphNode.js";
 export { default as Object3DNode } from "./accessors/Object3DNode.js";
 export { default as PointUVNode } from "./accessors/PointUVNode.js";
 export { default as ReferenceBaseNode } from "./accessors/ReferenceBaseNode.js";
 export { default as ReferenceNode } from "./accessors/ReferenceNode.js";
 export { default as RendererReferenceNode } from "./accessors/RendererReferenceNode.js";
-export { default as SkinningNode } from "./accessors/SkinningNode.js";
 export { default as StorageBufferNode } from "./accessors/StorageBufferNode.js";
+export { default as StorageTexture3DNode } from "./accessors/StorageTexture3DNode.js";
 export { default as StorageTextureNode } from "./accessors/StorageTextureNode.js";
 export { default as Texture3DNode } from "./accessors/Texture3DNode.js";
 export { default as TextureNode } from "./accessors/TextureNode.js";
@@ -166,7 +157,7 @@ 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 RotateNode } from "./utils/RotateNode.js";
-export { default as RTTNode, RTTNodeOptions } from "./utils/RTTNode.js";
+export { default as RTTNode } from "./utils/RTTNode.js";
 export { default as SampleNode } from "./utils/SampleNode.js";
 export { default as SetNode } from "./utils/SetNode.js";
 export { default as SplitNode } from "./utils/SplitNode.js";

three/src/nodes/TSL.d.ts

@@ -10,6 +10,7 @@ export * from "./core/IndexNode.js";
 export * from "./core/IsolateNode.js";
 export * from "./core/MRTNode.js";
 export * from "./core/OutputStructNode.js";
+export * from "./core/OverrideContextNode.js";
 export * from "./core/ParameterNode.js";
 export * from "./core/PropertyNode.js";
 export * from "./core/StackNode.js";
@@ -55,21 +56,20 @@ export * from "./tsl/TSLBase.js";
 // accessors
 export * from "./accessors/AccessorsUtils.js";
 export * from "./accessors/Arrays.js";
-export * from "./accessors/BatchNode.js";
+export * from "./accessors/Batch.js";
 export * from "./accessors/Bitangent.js";
 export * from "./accessors/BufferAttributeNode.js";
 export * from "./accessors/BufferNode.js";
 export * from "./accessors/BuiltinNode.js";
 export * from "./accessors/Camera.js";
 export * from "./accessors/CubeTextureNode.js";
-export * from "./accessors/InstancedMeshNode.js";
-export * from "./accessors/InstanceNode.js";
+export * from "./accessors/Instance.js";
 export * from "./accessors/MaterialNode.js";
 export * from "./accessors/MaterialProperties.js";
 export * from "./accessors/MaterialReferenceNode.js";
 export * from "./accessors/ModelNode.js";
 export * from "./accessors/ModelViewProjectionNode.js";
-export * from "./accessors/MorphNode.js";
+export * from "./accessors/Morph.js";
 export * from "./accessors/Normal.js";
 export * from "./accessors/Object3DNode.js";
 export * from "./accessors/PointUVNode.js";
@@ -78,8 +78,9 @@ export * from "./accessors/ReferenceNode.js";
 export * from "./accessors/ReflectVector.js";
 export * from "./accessors/RendererReferenceNode.js";
 export * from "./accessors/SceneProperties.js";
-export * from "./accessors/SkinningNode.js";
+export * from "./accessors/Skinning.js";
 export * from "./accessors/StorageBufferNode.js";
+export * from "./accessors/StorageTexture3DNode.js";
 export * from "./accessors/StorageTextureNode.js";
 export * from "./accessors/Tangent.js";
 export * from "./accessors/Texture3DNode.js";
@@ -99,6 +100,7 @@ export * from "./display/ColorAdjustment.js";
 export * from "./display/ColorSpaceNode.js";
 export * from "./display/FrontFacingNode.js";
 export * from "./display/NormalMapNode.js";
+export * from "./display/PremultiplyAlphaFunctions.js";
 export * from "./display/RenderOutputNode.js";
 export * from "./display/ScreenNode.js";
 export * from "./display/ToneMappingNode.js";

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

@@ -0,0 +1,19 @@
+import { BatchedMesh } from "../../objects/BatchedMesh.js";
+import VaryingNode from "../core/VaryingNode.js";
+
+/**
+ * TSL object representing a varying property for the batching color vector.
+ *
+ * @type {VaryingNode<vec4>}
+ */
+export const batchColor: VaryingNode<"vec4">;
+/**
+ * TSL function representing the vertex shader batching setup.
+ * Applies the batch transformation matrix to positionLocal, normalLocal, and tangentLocal.
+ * Also assigns the batch color if a color texture is present.
+ *
+ * @tsl
+ * @function
+ * @param {BatchedMesh} batchMesh - The batched mesh.
+ */
+export const batch: (batchMesh: BatchedMesh) => void;

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

@@ -0,0 +1,34 @@
+import { InstancedBufferAttribute } from "../../core/InstancedBufferAttribute.js";
+import { InstancedMesh } from "../../objects/InstancedMesh.js";
+import StorageInstancedBufferAttribute from "../../renderers/common/StorageInstancedBufferAttribute.js";
+import VaryingNode from "../core/VaryingNode.js";
+
+/**
+ * TSL object representing a varying property for the instanced color vector.
+ *
+ * @type {VaryingNode<vec3>}
+ */
+export const instanceColor: VaryingNode<"vec3">;
+/**
+ * TSL function representing the standard instancing vertex shader setup.
+ * Transforms positionLocal and normalLocal, and assigns varying color in-place.
+ *
+ * @tsl
+ * @function
+ * @param {number} count - The instance count.
+ * @param {InstancedBufferAttribute|StorageInstancedBufferAttribute} matrices - The instanced transformation matrices.
+ * @param {?InstancedBufferAttribute|StorageInstancedBufferAttribute} [colors=null] - The optional instanced colors.
+ */
+export const instance: (
+    count: number,
+    matrices: InstancedBufferAttribute | StorageInstancedBufferAttribute,
+    colors?: InstancedBufferAttribute | StorageInstancedBufferAttribute | null,
+) => void;
+/**
+ * TSL wrapper for applying instanced mesh rendering setup.
+ *
+ * @tsl
+ * @function
+ * @param {InstancedMesh} instancedMesh - The instanced mesh.
+ */
+export const instancedMesh: (instancedMesh: InstancedMesh) => void;

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

@@ -40,87 +40,94 @@ export type MaterialNodeScope =
     | typeof MaterialNode.AO
     | typeof MaterialNode.REFRACTION_RATIO;
 
-export default class MaterialNode extends Node {
-    static ALPHA_TEST: "alphaTest";
-    static COLOR: "color";
-    static OPACITY: "opacity";
-    static SHININESS: "shininess";
-    static SPECULAR: "specular";
-    static SPECULAR_STRENGTH: "specularStrength";
-    static SPECULAR_INTENSITY: "specularIntensity";
-    static SPECULAR_COLOR: "specularColor";
-    static REFLECTIVITY: "reflectivity";
-    static ROUGHNESS: "roughness";
-    static METALNESS: "metalness";
-    static NORMAL: "normal";
-    static CLEARCOAT: "clearcoat";
-    static CLEARCOAT_ROUGHNESS: "clearcoatRoughness";
-    static CLEARCOAT_NORMAL: "clearcoatNormal";
-    static EMISSIVE: "emissive";
-    static ROTATION: "rotation";
-    static SHEEN: "sheen";
-    static SHEEN_ROUGHNESS: "sheenRoughness";
-    static ANISOTROPY: "anisotropy";
-    static IRIDESCENCE: "iridescence";
-    static IRIDESCENCE_IOR: "iridescenceIOR";
-    static IRIDESCENCE_THICKNESS: "iridescenceThickness";
-    static IOR: "ior";
-    static TRANSMISSION: "transmission";
-    static THICKNESS: "thickness";
-    static ATTENUATION_DISTANCE: "attenuationDistance";
-    static ATTENUATION_COLOR: "attenuationColor";
-    static LINE_SCALE: "scale";
-    static LINE_DASH_SIZE: "dashSize";
-    static LINE_GAP_SIZE: "gapSize";
-    static LINE_WIDTH: "linewidth";
-    static LINE_DASH_OFFSET: "dashOffset";
-    static POINT_SIZE: "size";
-    static DISPERSION: "dispersion";
-    static LIGHT_MAP: "light";
-    static AO: "ao";
-    static REFRACTION_RATIO: "refractionRatio";
-
+interface MaterialNodeInterface {
     scope: MaterialNodeScope;
-    constructor(scope?: MaterialNodeScope);
 }
 
-export const materialAlphaTest: MaterialNode;
-export const materialColor: MaterialNode;
-export const materialShininess: MaterialNode;
-export const materialEmissive: MaterialNode;
-export const materialOpacity: MaterialNode;
-export const materialSpecular: MaterialNode;
+declare const MaterialNode: {
+    new<TNodeType>(scope: MaterialNodeScope): MaterialNode<TNodeType>;
+
+    ALPHA_TEST: "alphaTest";
+    COLOR: "color";
+    OPACITY: "opacity";
+    SHININESS: "shininess";
+    SPECULAR: "specular";
+    SPECULAR_STRENGTH: "specularStrength";
+    SPECULAR_INTENSITY: "specularIntensity";
+    SPECULAR_COLOR: "specularColor";
+    REFLECTIVITY: "reflectivity";
+    ROUGHNESS: "roughness";
+    METALNESS: "metalness";
+    NORMAL: "normal";
+    CLEARCOAT: "clearcoat";
+    CLEARCOAT_ROUGHNESS: "clearcoatRoughness";
+    CLEARCOAT_NORMAL: "clearcoatNormal";
+    EMISSIVE: "emissive";
+    ROTATION: "rotation";
+    SHEEN: "sheen";
+    SHEEN_ROUGHNESS: "sheenRoughness";
+    ANISOTROPY: "anisotropy";
+    IRIDESCENCE: "iridescence";
+    IRIDESCENCE_IOR: "iridescenceIOR";
+    IRIDESCENCE_THICKNESS: "iridescenceThickness";
+    IOR: "ior";
+    TRANSMISSION: "transmission";
+    THICKNESS: "thickness";
+    ATTENUATION_DISTANCE: "attenuationDistance";
+    ATTENUATION_COLOR: "attenuationColor";
+    LINE_SCALE: "scale";
+    LINE_DASH_SIZE: "dashSize";
+    LINE_GAP_SIZE: "gapSize";
+    LINE_WIDTH: "linewidth";
+    LINE_DASH_OFFSET: "dashOffset";
+    POINT_SIZE: "size";
+    DISPERSION: "dispersion";
+    LIGHT_MAP: "light";
+    AO: "ao";
+    REFRACTION_RATIO: "refractionRatio";
+};
+
+type MaterialNode<TNodeType> = MaterialNodeInterface & Node<TNodeType>;
+
+export default MaterialNode;
+
+export const materialAlphaTest: MaterialNode<"float">;
+export const materialColor: MaterialNode<"vec3">;
+export const materialShininess: MaterialNode<"float">;
+export const materialEmissive: MaterialNode<"vec3">;
+export const materialOpacity: MaterialNode<"float">;
+export const materialSpecular: MaterialNode<"vec3">;
 
-export const materialSpecularIntensity: MaterialNode;
-export const materialSpecularColor: MaterialNode;
+export const materialSpecularIntensity: MaterialNode<"float">;
+export const materialSpecularColor: MaterialNode<"vec3">;
 
-export const materialSpecularStrength: MaterialNode;
-export const materialReflectivity: MaterialNode;
-export const materialRoughness: MaterialNode;
-export const materialMetalness: MaterialNode;
-export const materialNormal: Node;
-export const materialClearcoat: MaterialNode;
-export const materialClearcoatRoughness: MaterialNode;
-export const materialClearcoatNormal: Node;
-export const materialRotation: MaterialNode;
-export const materialSheen: MaterialNode;
-export const materialSheenRoughness: MaterialNode;
-export const materialAnisotropy: MaterialNode;
-export const materialIridescence: MaterialNode;
-export const materialIridescenceIOR: MaterialNode;
-export const materialIridescenceThickness: MaterialNode;
-export const materialTransmission: MaterialNode;
-export const materialThickness: MaterialNode;
-export const materialIOR: MaterialNode;
-export const materialAttenuationDistance: MaterialNode;
-export const materialAttenuationColor: MaterialNode;
-export const materialLineScale: MaterialNode;
-export const materialLineDashSize: MaterialNode;
-export const materialLineGapSize: MaterialNode;
-export const materialLineWidth: MaterialNode;
-export const materialLineDashOffset: MaterialNode;
-export const materialPointSize: MaterialNode;
-export const materialDispersion: MaterialNode;
-export const materialLightMap: MaterialNode;
-export const materialAO: MaterialNode;
-export const materialAnisotropyVector: MaterialNode;
+export const materialSpecularStrength: MaterialNode<"float">;
+export const materialReflectivity: MaterialNode<"float">;
+export const materialRoughness: MaterialNode<"float">;
+export const materialMetalness: MaterialNode<"float">;
+export const materialNormal: MaterialNode<"vec3">;
+export const materialClearcoat: MaterialNode<"float">;
+export const materialClearcoatRoughness: MaterialNode<"float">;
+export const materialClearcoatNormal: MaterialNode<"vec3">;
+export const materialRotation: MaterialNode<"float">;
+export const materialSheen: MaterialNode<"vec3">;
+export const materialSheenRoughness: MaterialNode<"float">;
+export const materialAnisotropy: MaterialNode<"vec2">;
+export const materialIridescence: MaterialNode<"float">;
+export const materialIridescenceIOR: MaterialNode<"float">;
+export const materialIridescenceThickness: MaterialNode<"float">;
+export const materialTransmission: MaterialNode<"float">;
+export const materialThickness: MaterialNode<"float">;
+export const materialIOR: MaterialNode<"float">;
+export const materialAttenuationDistance: MaterialNode<"float">;
+export const materialAttenuationColor: MaterialNode<"vec3">;
+export const materialLineScale: MaterialNode<"float">;
+export const materialLineDashSize: MaterialNode<"float">;
+export const materialLineGapSize: MaterialNode<"float">;
+export const materialLineWidth: MaterialNode<"float">;
+export const materialLineDashOffset: MaterialNode<"float">;
+export const materialPointSize: MaterialNode<"float">;
+export const materialDispersion: MaterialNode<"float">;
+export const materialLightMap: MaterialNode<"vec3">;
+export const materialAO: MaterialNode<"float">;
+export const materialAnisotropyVector: Node<"vec2">;

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

@@ -0,0 +1,11 @@
+import { Mesh } from "../../objects/Mesh.js";
+
+/**
+ * TSL function representing the vertex shader morph targets blend setup.
+ * Dynamically computes morph targets weights and updates positionLocal and normalLocal in-place.
+ *
+ * @tsl
+ * @function
+ * @param {Mesh} mesh - The mesh.
+ */
+export const morphReference: (mesh: Mesh) => void;

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

@@ -0,0 +1,23 @@
+import { Vector3 } from "../../math/Vector3.js";
+import { SkinnedMesh } from "../../objects/SkinnedMesh.js";
+import Node from "../core/Node.js";
+
+/**
+ * TSL function representing the standard skeletal animation vertex shader setup.
+ * Transforms positionLocal, normalLocal, and tangentLocal in-place.
+ *
+ * @tsl
+ * @function
+ * @param {SkinnedMesh} skinnedMesh - The skinned mesh.
+ */
+export const skinning: (skinnedMesh: SkinnedMesh) => void;
+/**
+ * TSL function that computes skeletal animation for custom compute passes.
+ *
+ * @tsl
+ * @function
+ * @param {SkinnedMesh} skinnedMesh - The skinned mesh.
+ * @param {Node<vec3>} [toPosition=null] - The target position node to assign.
+ * @returns {Node<vec3>} The computed skinned position node.
+ */
+export const computeSkinning: (skinnedMesh: SkinnedMesh, toPosition?: Node<"vec3"> | Vector3 | null) => void;

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

@@ -47,32 +47,29 @@ type StorageBufferNode<TNodeType> =
 
 export default StorageBufferNode;
 
+type StorageNodeType =
+    | "float"
+    | "uint"
+    | "int"
+    | "vec2"
+    | "uvec2"
+    | "ivec2"
+    | "vec3"
+    | "uvec3"
+    | "ivec3"
+    | "vec4"
+    | "uvec4"
+    | "ivec4"
+    | "mat2"
+    | "mat3"
+    | "mat4";
+
 interface Storage {
-    (
-        value: StorageBufferAttribute | StorageInstancedBufferAttribute | BufferAttribute,
-        type: "float",
-        count: number,
-    ): StorageBufferNode<"float">;
-    (
-        value: StorageBufferAttribute | StorageInstancedBufferAttribute | BufferAttribute,
-        type: "uint",
-        count: number,
-    ): StorageBufferNode<"uint">;
-    (
+    <const TNodeType extends StorageNodeType>(
         value: StorageBufferAttribute | StorageInstancedBufferAttribute | BufferAttribute,
-        type: "vec2",
+        type: TNodeType,
         count: number,
-    ): StorageBufferNode<"vec2">;
-    (
-        value: StorageBufferAttribute | StorageInstancedBufferAttribute | BufferAttribute,
-        type: "vec3",
-        count: number,
-    ): StorageBufferNode<"vec3">;
-    (
-        value: StorageBufferAttribute | StorageInstancedBufferAttribute | BufferAttribute,
-        type: "vec4",
-        count: number,
-    ): StorageBufferNode<"vec4">;
+    ): StorageBufferNode<TNodeType>;
     (
         value: StorageBufferAttribute | StorageInstancedBufferAttribute | BufferAttribute,
         type: Struct,
@@ -81,3 +78,5 @@ interface Storage {
 }
 
 export const storage: Storage;
+
+export {};

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

@@ -0,0 +1,17 @@
+import Storage3DTexture from "../../renderers/common/Storage3DTexture.js";
+import Node from "../core/Node.js";
+import StorageTextureNode from "./StorageTextureNode.js";
+
+declare class StorageTexture3DNode extends StorageTextureNode {
+    readonly isStorageTexture3DNode: boolean;
+
+    constructor(value: Storage3DTexture, uvNode?: Node<"vec3"> | null, storeNode?: Node | null);
+}
+
+export default StorageTexture3DNode;
+
+export const storageTexture3D: (
+    value: Storage3DTexture,
+    uvNode?: Node<"vec3"> | null,
+    storeNode?: Node | null,
+) => StorageTexture3DNode;

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

@@ -1,4 +1,4 @@
-import { Texture } from "../../textures/Texture.js";
+import StorageTexture from "../../renderers/common/StorageTexture.js";
 import { NodeAccess } from "../core/constants.js";
 import Node from "../core/Node.js";
 import NodeBuilder from "../core/NodeBuilder.js";
@@ -14,7 +14,7 @@ export default class StorageTextureNode extends TextureNode {
     access: NodeAccess;
 
     constructor(
-        value: Texture,
+        value: StorageTexture,
         uvNode?: Node | null,
         storeNode?: Node | null,
     );
@@ -29,17 +29,19 @@ export default class StorageTextureNode extends TextureNode {
 
     toWriteOnly(): this;
 
+    store(uvNode: Node, storeNode?: Node | null): StorageTextureNode;
+
     generateStore(builder: NodeBuilder): void;
 }
 
 export const storageTexture: (
-    value: Texture,
+    value: StorageTexture,
     uvNode?: Node | null,
     storeNode?: Node,
 ) => StorageTextureNode;
 
 export const textureStore: (
-    value: Texture | StorageTextureNode,
+    value: StorageTexture | StorageTextureNode,
     uvNode?: Node | null,
     storeNode?: Node,
 ) => StorageTextureNode;

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

@@ -2,7 +2,7 @@ import { Texture } from "../../textures/Texture.js";
 import Node from "../core/Node.js";
 import UniformNode from "../core/UniformNode.js";
 
-interface TextureNodeInterface<TNodeType> {
+interface TextureNodeInterface {
     readonly isTextureNode: true;
 
     uvNode: Node<"vec2"> | Node<"vec3"> | null;
@@ -11,6 +11,7 @@ interface TextureNodeInterface<TNodeType> {
     compareNode: Node | null;
     depthNode: Node | null;
     gradNode: Node | null;
+    gatherNode: Node<"int"> | null;
 
     sampler: boolean;
     updateMatrix: boolean;
@@ -23,25 +24,29 @@ interface TextureNodeInterface<TNodeType> {
 
     getSampler(): boolean;
 
-    sample(uvNode: Node): Node<TNodeType>;
+    sample(uvNode: Node): this;
 
-    load(uvNode: Node): Node<TNodeType>;
+    load(uvNode: Node): this;
 
-    blur(amountNode: Node): Node;
+    blur(amountNode: Node): this;
 
-    level(levelNode: Node): Node;
+    level(levelNode: Node): this;
 
     size(levelNode: Node): Node;
 
-    bias(biasNode: Node): Node;
+    bias(biasNode: Node): this;
 
     getBase(): TextureNode;
 
-    compare(compareNode: Node): Node;
+    compare(compareNode: Node<"float"> | number): this;
 
-    grad(gradeNodeX: Node, gradeNodeY: Node): TextureNode;
+    grad(gradeNodeX: Node, gradeNodeY: Node): this;
 
-    depth(depthNode: Node): TextureNode;
+    gather(gatherNode?: Node<"int"> | number): this;
+
+    depth(depthNode: Node): this;
+
+    offset(offsetNode: Node<"ivec2">): this;
 
     clone(): this;
 }
@@ -55,7 +60,7 @@ declare const TextureNode: {
     ): TextureNode;
 };
 
-type TextureNode<TNodeType = "vec4"> = TextureNodeInterface<TNodeType> & UniformNode<TNodeType, Texture>;
+type TextureNode<TNodeType = "vec4"> = TextureNodeInterface & UniformNode<TNodeType, Texture>;
 
 export default TextureNode;
 

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

@@ -1,25 +1,33 @@
 import Node from "./Node.js";
 import TempNode from "./TempNode.js";
 
-declare class ArrayNode extends TempNode {
+export interface ArrayNodeInterface<TNodeType> {
     count: number;
-    values: Node[];
+    values: Node<TNodeType>[] | null;
     readonly isArrayNode: true;
-
-    constructor(nodeType: string, count: number, values: Node[]);
 }
 
+declare const ArrayNode: {
+    new<TNodeType>(
+        nodeType: TNodeType | null,
+        count: number,
+        values?: Node<TNodeType>[] | null,
+    ): ArrayNode<TNodeType>;
+};
+
+type ArrayNode<TNodeType> = TempNode<TNodeType> & ArrayNodeInterface<TNodeType>;
+
 export default ArrayNode;
 
 interface ArrayFunction {
-    (values: Node[]): ArrayNode;
-    (nodeType: string, count: number): ArrayNode;
+    <TNodeType>(values: Node<TNodeType>[]): ArrayNode<TNodeType>;
+    <TNodeType extends string>(nodeType: TNodeType, count: number): ArrayNode<TNodeType>;
 }
 
 export const array: ArrayFunction;
 
 declare module "./Node.js" {
-    interface NodeElements {
-        toArray: (count: number) => ArrayNode;
+    interface NodeExtensions<TNodeType> {
+        toArray: (count: number) => ArrayNode<TNodeType>;
     }
 }

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

@@ -1,16 +1,15 @@
 import { Light } from "../../lights/Light.js";
 import Node from "./Node.js";
-import { NodeBuilderContext } from "./NodeBuilder.js";
 
 declare class ContextNodeInterface<TNodeType> extends Node {
     readonly isContextNode: true;
 
     node: Node<TNodeType> | null;
-    value: NodeBuilderContext;
+    value: unknown;
 }
 
 declare const ContextNode: {
-    new<TNodeType>(node?: Node<TNodeType> | null, value?: NodeBuilderContext): ContextNode<TNodeType>;
+    new<TNodeType>(node?: Node<TNodeType> | null, value?: unknown): ContextNode<TNodeType>;
 };
 
 type ContextNode<TNodeType> = ContextNodeInterface<TNodeType> & Node<TNodeType>;
@@ -18,8 +17,8 @@ type ContextNode<TNodeType> = ContextNodeInterface<TNodeType> & Node<TNodeType>;
 export default ContextNode;
 
 interface ContextFunction {
-    (value?: NodeBuilderContext): ContextNode<unknown>;
-    <TNodeType>(node: Node<TNodeType>, value?: NodeBuilderContext): ContextNode<TNodeType>;
+    (value?: unknown): ContextNode<unknown>;
+    <TNodeType>(node: Node<TNodeType>, value?: unknown): ContextNode<TNodeType>;
 }
 
 export const context: ContextFunction;
@@ -39,7 +38,7 @@ export function label<TNodeType>(node: Node<TNodeType>, label: string): Node<TNo
 
 declare module "./Node.js" {
     interface NodeExtensions<TNodeType> {
-        context: (context?: NodeBuilderContext) => ContextNode<TNodeType>;
+        context: (context?: unknown) => ContextNode<TNodeType>;
 
         /**
          * @deprecated "label()" has been deprecated. Use "setName()" instead.

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

@@ -25,6 +25,8 @@ declare class LightingModel {
     direct(lightData: LightingModelDirectInput, builder: NodeBuilder): void;
     directRectArea(lightData: LightingModelDirectRectAreaInput, builder: NodeBuilder): void;
     indirect(builder: NodeBuilder): void;
+    indirectDiffuse(builder: NodeBuilder): void;
+    indirectSpecular(builder: NodeBuilder): void;
     ambientOcclusion(builder: NodeBuilder): void;
 }