@types/three 0.182.0 → 0.183.0

three/src/nodes/utils/ArrayElementNode.d.ts

@@ -1,9 +1,14 @@
 import Node from "../core/Node.js";
-import { TempNode } from "../Nodes.js";
 
-export default class ArrayElementNode extends TempNode {
+interface ArrayElementNodeInterface {
     node: Node;
     indexNode: Node;
-
-    constructor(node: Node, indexNode: Node);
 }
+
+declare const ArrayElementNode: {
+    new<TNodeType>(node: Node<TNodeType>, indexNode: Node): ArrayElementNode<TNodeType>;
+};
+
+type ArrayElementNode<TNodeType> = Node<TNodeType> & ArrayElementNodeInterface;
+
+export default ArrayElementNode;

three/src/nodes/utils/DebugNode.d.ts

@@ -13,13 +13,10 @@ export const debug: (
     callback?: ((node: NodeBuilder, code: string) => void) | null,
 ) => DebugNode;
 
-declare module "../Nodes.js" {
-    interface Node {
+declare module "../core/Node.js" {
+    interface NodeElements {
         debug: (
             callback?: ((node: NodeBuilder, code: string) => void) | null,
         ) => DebugNode;
-        debugAssign: (
-            callback?: ((node: NodeBuilder, code: string) => void) | null,
-        ) => this;
     }
 }

three/src/nodes/utils/Discard.d.ts

@@ -3,9 +3,8 @@ import Node from "../core/Node.js";
 export const Discard: (conditional?: Node) => Node;
 export const Return: () => Node;
 
-declare module "../Nodes.js" {
-    interface Node {
+declare module "../core/Node.js" {
+    interface NodeElements {
         discard: () => Node;
-        discardAssign: () => this;
     }
 }

three/src/nodes/utils/FlipNode.d.ts

@@ -0,0 +1,11 @@
+import Node from "../core/Node.js";
+import TempNode from "../core/TempNode.js";
+
+declare class FlipNode extends TempNode {
+    sourceNode: Node;
+    components: string;
+
+    constructor(sourceNode: Node, components: string);
+}
+
+export default FlipNode;

three/src/nodes/utils/LoopNode.d.ts

@@ -2,20 +2,20 @@ import Node from "../core/Node.js";
 import NodeBuilder from "../core/NodeBuilder.js";
 import { VarNode } from "../Nodes.js";
 
-interface LoopNodeObjectParameter {
+type LoopNodeType = "int" | "uint" | "float";
+
+interface LoopNodeObjectParameter<TNodeType extends LoopNodeType> {
     // TODO Expand to other types and update loop function types appropriately
-    type?: "int" | "uint" | "float";
+    type?: TNodeType;
     // TODO The variable name should affect the type of the loop function
     // name?: string;
-    start: number | Node;
-    end: number | Node;
+    start: Node<TNodeType> | number;
+    end: Node<TNodeType> | number;
     condition?: string;
     update?: VarNode | number | string;
 }
 
-type LoopNodeParameter = Node | number | LoopNodeObjectParameter;
-
-declare class LoopNode extends Node {
+declare class LoopNode extends Node<"void"> {
     params: unknown[];
 
     constructor(params?: unknown[]);
@@ -26,12 +26,16 @@ declare class LoopNode extends Node {
 export default LoopNode;
 
 interface Loop {
-    (i: LoopNodeParameter, func: (inputs: { readonly i: Node }) => void): Node;
-    (
-        i: LoopNodeParameter,
-        j: LoopNodeParameter,
-        func: (inputs: { readonly i: Node; readonly j: Node }) => void,
-    ): Node;
+    (i: number, func: (inputs: { readonly i: Node<"int"> }) => void): LoopNode;
+    <TNodeType extends LoopNodeType>(
+        i: LoopNodeObjectParameter<TNodeType>,
+        func: (inputs: { readonly i: Node<TNodeType> }) => void,
+    ): LoopNode;
+    <TNodeType extends LoopNodeType>(
+        i: LoopNodeObjectParameter<TNodeType>,
+        j: LoopNodeObjectParameter<TNodeType>,
+        func: (inputs: { readonly i: Node<TNodeType>; readonly j: Node<TNodeType> }) => void,
+    ): LoopNode;
 }
 
 export const Loop: Loop;

three/src/nodes/utils/MaxMipLevelNode.d.ts

@@ -2,7 +2,7 @@ import { Texture } from "../../textures/Texture.js";
 import TextureNode from "../accessors/TextureNode.js";
 import UniformNode from "../core/UniformNode.js";
 
-export default class MaxMipLevelNode extends UniformNode<0> {
+export default class MaxMipLevelNode extends UniformNode<"float", number> {
     constructor(textureNode: TextureNode);
 
     get textureNode(): TextureNode;

three/src/nodes/utils/Oscillators.d.ts

@@ -1,6 +1,6 @@
 import Node from "../core/Node.js";
 
-export const oscSine: (timeNode?: Node) => Node;
-export const oscSquare: (timeNode?: Node) => Node;
-export const oscTriangle: (timeNode?: Node) => Node;
-export const oscSawtooth: (timeNode?: Node) => Node;
+export const oscSine: (timeNode?: Node) => Node<"float">;
+export const oscSquare: (timeNode?: Node) => Node<"float">;
+export const oscTriangle: (timeNode?: Node) => Node<"float">;
+export const oscSawtooth: (timeNode?: Node) => Node<"float">;

three/src/nodes/utils/Packing.d.ts

@@ -1,5 +1,5 @@
 import Node from "../core/Node.js";
 
-export const directionToColor: (node: Node) => Node;
-export const colorToDirection: (node: Node) => Node;
-export const unpackNormal: (xy: Node) => Node;
+export const directionToColor: (node: Node) => Node<"vec3">;
+export const colorToDirection: (node: Node) => Node<"vec3">;
+export const unpackNormal: (xy: Node) => Node<"vec3">;

three/src/nodes/utils/PostProcessingUtils.d.ts

@@ -13,7 +13,7 @@ export const getViewPosition: (
     screenPosition: Node,
     depth: Node,
     projectionMatrixInverse: Node,
-) => Node;
+) => Node<"vec3">;
 
 /**
  * Computes a screen position expressed as uv coordinates based on a fragment's position in view space and the camera's
@@ -26,7 +26,7 @@ export const getViewPosition: (
 export const getScreenPosition: (
     viewPosition: Node,
     projectionMatrix: Node,
-) => Node;
+) => Node<"vec2">;
 
 /**
  * Computes a normal vector based on depth data. Can be used as a fallback when no normal render target is available or
@@ -41,8 +41,8 @@ export const getNormalFromDepth: (
     uv: Node,
     depthTexture: Node,
     projectionMatrixInverse: Node,
-) => Node;
+) => Node<"vec3">;
 
-export const interleavedGradientNoise: (position: Node) => Node;
+export const interleavedGradientNoise: (position: Node) => Node<"float">;
 
-export const vogelDiskSample: (sampleIndex: Node, samplesCount: Node, phi: Node) => Node;
+export const vogelDiskSample: (sampleIndex: Node, samplesCount: Node, phi: Node) => Node<"vec2">;

three/src/nodes/utils/RemapNode.d.ts

@@ -1,58 +1,52 @@
 import Node from "../core/Node.js";
 
-export default class RemapNode extends Node {
-    node: Node;
-    inLowNode: Node;
-    inHighNode: Node;
-    outLowNode: Node;
-    outHighNode: Node;
+export default class RemapNode extends Node<"float"> {
+    node: Node<"float">;
+    inLowNode: Node<"float">;
+    inHighNode: Node<"float">;
+    outLowNode: Node<"float">;
+    outHighNode: Node<"float">;
 
     doClamp: boolean;
 
-    constructor(node: Node, inLowNode: Node, inHighNode: Node, outLowNode?: Node, outHighNode?: Node);
+    constructor(
+        node: Node<"float">,
+        inLowNode: Node<"float">,
+        inHighNode: Node<"float">,
+        outLowNode?: Node<"float">,
+        outHighNode?: Node<"float">,
+    );
 }
 
 export const remap: (
-    node: Node,
-    inLowNode: Node | number,
-    inHighNode: Node | number,
-    outLowNode?: Node | number,
-    outHighNode?: Node | number,
+    node: Node<"float">,
+    inLowNode: Node<"float"> | number,
+    inHighNode: Node<"float"> | number,
+    outLowNode?: Node<"float"> | number,
+    outHighNode?: Node<"float"> | number,
 ) => RemapNode;
 export const remapClamp: (
-    node: Node,
-    inLowNode: Node | number,
-    inHighNode: Node | number,
-    outLowNode?: Node | number,
-    outHighNode?: Node | number,
+    node: Node<"float">,
+    inLowNode: Node<"float"> | number,
+    inHighNode: Node<"float"> | number,
+    outLowNode?: Node<"float"> | number,
+    outHighNode?: Node<"float"> | number,
 ) => RemapNode;
 
-declare module "../Nodes.js" {
-    interface Node {
+declare module "../core/Node.js" {
+    interface FloatExtensions {
         remap: (
-            inLowNode: Node | number,
-            inHighNode: Node | number,
-            outLowNode?: Node | number,
-            outHighNode?: Node | number,
+            inLowNode: Node<"float"> | number,
+            inHighNode: Node<"float"> | number,
+            outLowNode?: Node<"float"> | number,
+            outHighNode?: Node<"float"> | number,
         ) => RemapNode;
-        remapAssign: (
-            inLowNode: Node | number,
-            inHighNode: Node | number,
-            outLowNode?: Node | number,
-            outHighNode?: Node | number,
-        ) => this;
 
         remapClamp: (
-            inLowNode: Node | number,
-            inHighNode: Node | number,
-            outLowNode?: Node | number,
-            outHighNode?: Node | number,
+            inLowNode: Node<"float"> | number,
+            inHighNode: Node<"float"> | number,
+            outLowNode?: Node<"float"> | number,
+            outHighNode?: Node<"float"> | number,
         ) => RemapNode;
-        remapClampAssign: (
-            inLowNode: Node | number,
-            inHighNode: Node | number,
-            outLowNode?: Node | number,
-            outHighNode?: Node | number,
-        ) => this;
     }
 }

three/src/nodes/utils/RotateNode.d.ts

@@ -1,14 +1,23 @@
 import Node from "../core/Node.js";
 import TempNode from "../core/TempNode.js";
 
-export default class RotateNode extends TempNode {
-    positionNode: Node;
-    rotationNode: Node;
+interface RotateNodeInterface<TNodeType> {
+    positionNode: Node<TNodeType>;
+    rotationNode: Node<"vec3"> | Node<"float">;
+}
+
+declare const RotateNode: {
+    new(positionNode: Node<"vec2">, rotationNode: Node<"float"> | number): RotateNode<"vec2">;
+    new(positionNode: Node<"vec3">, rotationNode: Node<"vec3">): RotateNode<"vec3">;
+};
+
+type RotateNode<TNodeType> = RotateNodeInterface<TNodeType> & TempNode<TNodeType>;
+
+export default RotateNode;
 
-    constructor(positionNode: Node, rotationNode: Node);
+interface Rotate {
+    (positionNode: Node<"vec2">, rotationNode: Node<"float"> | number): RotateNode<"vec2">;
+    (positionNode: Node<"vec3">, rotationNode: Node<"vec3">): RotateNode<"vec3">;
 }
 
-export const rotate: (
-    positionNode: Node,
-    rotationNode: Node | number,
-) => RotateNode;
+export const rotate: Rotate;

three/src/nodes/utils/SplitNode.d.ts

@@ -1,5 +1,4 @@
 import Node from "../core/Node.js";
-import { SwizzleOption } from "../tsl/TSLCore.js";
 
 export default class SplitNode extends Node {
     node: Node;
@@ -9,7 +8,7 @@ export default class SplitNode extends Node {
      * @param node the input node
      * @param components swizzle like string, default = "x"
      */
-    constructor(node: Node, components?: SwizzleOption);
+    constructor(node: Node, components?: string);
 
     getVectorLength(): number;
 }

three/src/nodes/utils/SpriteSheetUV.d.ts

@@ -0,0 +1,7 @@
+import Node from "../core/Node.js";
+
+export const spritesheetUV: (
+    countNode: Node,
+    uvNode?: Node,
+    frameNode?: Node,
+) => Node;

three/src/nodes/utils/StorageArrayElementNode.d.ts

@@ -2,18 +2,27 @@ import StorageBufferNode from "../accessors/StorageBufferNode.js";
 import Node from "../core/Node.js";
 import ArrayElementNode from "./ArrayElementNode.js";
 
-export default class StorageArrayElementNode extends ArrayElementNode {
-    node: StorageBufferNode;
+interface StorageArrayElementNodeInterface<TNodeType> {
+    node: StorageBufferNode<TNodeType>;
 
     readonly isStorageArrayElementNode: true;
 
-    constructor(storageBufferNode: StorageBufferNode, indexNode: Node);
-
-    get storageBufferNode(): StorageBufferNode;
-    set storageBufferNode(value: StorageBufferNode);
+    get storageBufferNode(): StorageBufferNode<TNodeType>;
+    set storageBufferNode(value: StorageBufferNode<TNodeType>);
 }
 
-export const storageElement: (
-    storageBufferNode: Node,
+declare const StorageArrayElementNode: {
+    new<TNodeType>(
+        storageBufferNode: StorageBufferNode<TNodeType>,
+        indexNode: Node,
+    ): StorageArrayElementNode<TNodeType>;
+};
+
+type StorageArrayElementNode<TNodeType> = ArrayElementNode<TNodeType> & StorageArrayElementNodeInterface<TNodeType>;
+
+export default StorageArrayElementNode;
+
+export const storageElement: <TNodeType>(
+    storageBufferNode: Node<TNodeType>,
     indexNode: Node,
-) => StorageArrayElementNode;
+) => StorageArrayElementNode<TNodeType>;

three/src/nodes/utils/Timer.d.ts

@@ -1,5 +1,5 @@
-import Node from "../core/Node.js";
+import UniformNode from "../core/UniformNode.js";
 
-export const time: Node;
-export const deltaTime: Node;
-export const frameId: Node;
+export const time: UniformNode<"float", number>;
+export const deltaTime: UniformNode<"float", number>;
+export const frameId: UniformNode<"uint", number>;

three/src/nodes/utils/TriplanarTextures.d.ts

@@ -7,7 +7,7 @@ export const triplanarTextures: (
     scaleNode?: Node,
     positionNode?: Node,
     normalNode?: Node,
-) => Node;
+) => Node<"vec4">;
 
 export const triplanarTexture: (
     textureXNode: Node,
@@ -16,4 +16,4 @@ export const triplanarTexture: (
     scaleNode?: Node,
     positionNode?: Node,
     normalNode?: Node,
-) => Node;
+) => Node<"vec4">;

three/src/nodes/utils/UVUtils.d.ts

@@ -1,17 +1,19 @@
 import ContextNode from "../core/ContextNode.js";
 import Node from "../core/Node.js";
-import OperatorNode from "../math/OperatorNode.js";
 
-export function replaceDefaultUV(callback: (node: Node) => Node, node?: Node | null): ContextNode;
+export function replaceDefaultUV<TNodeType>(
+    callback: ((node: Node) => Node<"vec2">) | Node<"vec2">,
+    node?: Node<TNodeType> | null,
+): ContextNode<TNodeType>;
 
 export const rotateUV: (
     uv: Node,
     rotation: Node,
     center?: Node,
-) => OperatorNode;
+) => Node<"vec2">;
 
 export const spherizeUV: (
     uv: Node,
     strength: Node | number,
     center?: Node,
-) => OperatorNode;
+) => Node<"vec2">;

three/src/objects/BatchedMesh.d.ts

@@ -5,6 +5,7 @@ import { Box3 } from "../math/Box3.js";
 import { Color } from "../math/Color.js";
 import { Matrix4 } from "../math/Matrix4.js";
 import { Sphere } from "../math/Sphere.js";
+import { Vector4 } from "../math/Vector4.js";
 import { Mesh } from "./Mesh.js";
 
 export interface BatchedMeshGeometryRange {
@@ -141,9 +142,10 @@ declare class BatchedMesh extends Mesh<BufferGeometry, Material> {
     /**
      * Get the color of the defined geometry.
      * @param instanceId The id of an instance to get the color of.
-     * @param target The target object to copy the color in to.
+     * @param color - The target object that is used to store the method's result.
+     * @return The instance's color. Use a `Vector4` to also retrieve alpha.
      */
-    getColorAt(instanceId: number, target: Color): void;
+    getColorAt(instanceId: number, color: Color | Vector4): Color | Vector4;
 
     /**
      * Get the local transformation matrix of the defined instance.
@@ -180,9 +182,9 @@ declare class BatchedMesh extends Mesh<BufferGeometry, Material> {
     /**
      * Sets the given color to the defined geometry instance.
      * @param instanceId The id of the instance to set the color of.
-     * @param color The color to set the instance to.
+     * @param color The color to set the instance to. Use a `Vector4` to also define alpha.
      */
-    setColorAt(instanceId: number, color: Color): void;
+    setColorAt(instanceId: number, color: Color | Vector4): void;
 
     /**
      * Sets the given local transformation matrix to the defined instance.

three/src/objects/InstancedMesh.d.ts

@@ -41,14 +41,6 @@ export class InstancedMesh<
     TMaterial extends Material | Material[] = Material | Material[],
     TEventMap extends InstancedMeshEventMap = InstancedMeshEventMap,
 > extends Mesh<TGeometry, TMaterial, TEventMap> {
-    /**
-     * Create a new instance of {@link InstancedMesh}
-     * @param geometry An instance of {@link BufferGeometry}.
-     * @param material A single or an array of {@link Material}. Default is a new {@link MeshBasicMaterial}.
-     * @param count The **maximum** number of instances of this Mesh. Expects a `Integer`
-     */
-    constructor(geometry: TGeometry | undefined, material: TMaterial | undefined, count: number);
-
     /**
      * Read-only flag to check if a given object is of type {@link InstancedMesh}.
      * @remarks This is a _constant_ value
@@ -57,18 +49,31 @@ export class InstancedMesh<
     readonly isInstancedMesh: true;
 
     /**
-     * This bounding box encloses all instances of the {@link InstancedMesh},, which can be calculated with {@link computeBoundingBox | .computeBoundingBox()}.
-     * @remarks Bounding boxes aren't computed by default. They need to be explicitly computed, otherwise they are `null`.
-     * @defaultValue `null`
+     * Represents the local transformation of all instances.
+     * You have to set {@link InstancedBufferAttribute.needsUpdate | .instanceMatrix.needsUpdate()} flag to `true` if you modify instanced data via {@link setMatrixAt | .setMatrixAt()}.
      */
-    boundingBox: Box3 | null;
+    instanceMatrix: InstancedBufferAttribute;
 
     /**
-     * This bounding sphere encloses all instances of the {@link InstancedMesh}, which can be calculated with {@link computeBoundingSphere | .computeBoundingSphere()}.
-     * @remarks bounding spheres aren't computed by default. They need to be explicitly computed, otherwise they are `null`.
+     * Represents the local transformation of all instances of the previous frame.
+     * Required for computing velocity. Maintained in {@link InstanceNode}.
+     *
+     * @default null
+     */
+    previousInstancedMatrix: InstancedBufferAttribute | null;
+
+    /**
+     * Represents the colors of all instances.
+     * You have to set {@link InstancedBufferAttribute.needsUpdate | .instanceColor.needsUpdate()} flag to `true` if you modify instanced data via {@link setColorAt | .setColorAt()}.
      * @defaultValue `null`
      */
-    boundingSphere: Sphere | null;
+    instanceColor: InstancedBufferAttribute | null;
+
+    /**
+     * Represents the morph target weights of all instances. You have to set its {@link .needsUpdate} flag to true if
+     * you modify instanced data via {@link .setMorphAt}.
+     */
+    morphTexture: DataTexture | null;
 
     /**
      * The number of instances.
@@ -81,23 +86,26 @@ export class InstancedMesh<
     count: number;
 
     /**
-     * Represents the colors of all instances.
-     * You have to set {@link InstancedBufferAttribute.needsUpdate | .instanceColor.needsUpdate()} flag to `true` if you modify instanced data via {@link setColorAt | .setColorAt()}.
+     * This bounding box encloses all instances of the {@link InstancedMesh},, which can be calculated with {@link computeBoundingBox | .computeBoundingBox()}.
+     * @remarks Bounding boxes aren't computed by default. They need to be explicitly computed, otherwise they are `null`.
      * @defaultValue `null`
      */
-    instanceColor: InstancedBufferAttribute | null;
+    boundingBox: Box3 | null;
 
     /**
-     * Represents the local transformation of all instances.
-     * You have to set {@link InstancedBufferAttribute.needsUpdate | .instanceMatrix.needsUpdate()} flag to `true` if you modify instanced data via {@link setMatrixAt | .setMatrixAt()}.
+     * This bounding sphere encloses all instances of the {@link InstancedMesh}, which can be calculated with {@link computeBoundingSphere | .computeBoundingSphere()}.
+     * @remarks bounding spheres aren't computed by default. They need to be explicitly computed, otherwise they are `null`.
+     * @defaultValue `null`
      */
-    instanceMatrix: InstancedBufferAttribute;
+    boundingSphere: Sphere | null;
 
     /**
-     * Represents the morph target weights of all instances. You have to set its {@link .needsUpdate} flag to true if
-     * you modify instanced data via {@link .setMorphAt}.
+     * Create a new instance of {@link InstancedMesh}
+     * @param geometry An instance of {@link BufferGeometry}.
+     * @param material A single or an array of {@link Material}. Default is a new {@link MeshBasicMaterial}.
+     * @param count The **maximum** number of instances of this Mesh. Expects a `Integer`
      */
-    morphTexture: DataTexture | null;
+    constructor(geometry: TGeometry | undefined, material: TMaterial | undefined, count: number);
 
     /**
      * Computes the bounding box of the instanced mesh, and updates the {@link .boundingBox} attribute. The bounding box