@types/three 0.184.1 → 0.185.0

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

@@ -1,5 +1,52 @@
+import { Vector2 } from "../../math/Vector2.js";
+import { Vector3 } from "../../math/Vector3.js";
 import Node from "../core/Node.js";
 
-export const directionToColor: (node: Node) => Node<"vec3">;
-export const colorToDirection: (node: Node) => Node<"vec3">;
-export const unpackNormal: (xy: Node) => Node<"vec3">;
+/**
+ * Packs a normal vector into a color value.
+ *
+ * @tsl
+ * @function
+ * @param {Node<vec3>} node - The direction to pack.
+ * @return {Node<vec3>} The color.
+ */
+export const packNormalToRGB: (node: Node<"vec3"> | Vector3) => Node<"vec3">;
+
+/**
+ * Unpacks a color value into a normal vector.
+ *
+ * @tsl
+ * @function
+ * @param {Node<vec3>} node - The color to unpack.
+ * @return {Node<vec3>} The direction.
+ */
+export const unpackRGBToNormal: (node: Node<"vec3"> | Node<"vec4"> | Vector3) => Node<"vec3">;
+
+/**
+ * Unpacks a tangent space normal, reconstructing the Z component by projecting the X,Y coordinates onto the hemisphere.
+ * The X,Y coordinates are expected to be in the [-1, 1] range.
+ *
+ * @tsl
+ * @function
+ * @param {Node<vec2>} xy - The X,Y coordinates of the normal.
+ * @return {Node<vec3>} The resulting normal.
+ */
+export const unpackNormal: (xy: Node<"vec2"> | Vector2) => Node<"vec3">;
+
+/**
+ * @tsl
+ * @function
+ * @deprecated since r185. Use {@link packNormalToRGB} instead.
+ * @param {Node<vec3>} node - The direction to pack.
+ * @returns {Node<vec3>}
+ */
+export const directionToColor: (node: Node<"vec3"> | Vector3) => Node<"vec3">;
+
+/**
+ * @tsl
+ * @function
+ * @deprecated since r185. Use {@link unpackRGBToNormal} instead.
+ * @param {Node<vec3>} node - The color to unpack.
+ * @returns {Node<vec3>}
+ */
+export const colorToDirection: (node: Node<"vec3"> | Node<"vec4"> | Vector3) => Node<"vec3">;

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

@@ -1,12 +1,7 @@
-import { TextureDataType } from "../../constants.js";
-import { RenderTarget } from "../../core/RenderTarget.js";
+import { RenderTarget, RenderTargetOptions } from "../../core/RenderTarget.js";
 import TextureNode from "../accessors/TextureNode.js";
 import Node from "../core/Node.js";
 
-export interface RTTNodeOptions {
-    type: TextureDataType;
-}
-
 declare class RTTNode extends TextureNode {
     readonly isRTTNode: true;
 
@@ -19,15 +14,15 @@ declare class RTTNode extends TextureNode {
     textureNeedsUpdate: boolean;
     autoUpdate: boolean;
 
-    pixelRatio?: number;
-
-    constructor(node: Node, width?: number | null, height?: number | null, options?: RTTNodeOptions);
+    constructor(node: Node, width?: number | null, height?: number | null, options?: RenderTargetOptions);
 
     get autoResize(): boolean;
 
     setSize(width: number | null, height: number | null): void;
 
-    setPixelRatio(pixelRatio: number): void;
+    setResolutionScale(resolutionScale: number): this;
+
+    getResolutionScale(): number;
 }
 
 export default RTTNode;
@@ -36,11 +31,11 @@ export const rtt: (
     node: Node,
     width?: number | null,
     height?: number | null,
-    options?: RTTNodeOptions,
+    options?: RenderTargetOptions,
 ) => RTTNode;
 export const convertToTexture: (
     node: Node,
     width?: number | null,
     height?: number | null,
-    options?: RTTNodeOptions,
+    options?: RenderTargetOptions,
 ) => RTTNode;

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

@@ -1,36 +1,223 @@
+import { Color } from "../../math/Color.js";
+import { Vector2 } from "../../math/Vector2.js";
+import { Vector3 } from "../../math/Vector3.js";
+import { Vector4 } from "../../math/Vector4.js";
 import Node from "../core/Node.js";
 
-export const remap: (
-    node: Node<"float">,
-    inLowNode: Node<"float"> | number,
-    inHighNode: Node<"float"> | number,
-    outLowNode?: Node<"float"> | number,
-    outHighNode?: Node<"float"> | number,
-    doClamp?: Node<"bool"> | boolean,
-) => Node<"float">;
-export const remapClamp: (
-    node: Node<"float">,
-    inLowNode: Node<"float"> | number,
-    inHighNode: Node<"float"> | number,
-    outLowNode?: Node<"float"> | number,
-    outHighNode?: Node<"float"> | number,
-) => Node<"float">;
+type FloatOrNumber = Node<"float"> | number;
+type Boolean = Node<"bool"> | boolean;
+
+type Vec2 = Node<"vec2"> | Vector2;
+type Vec3 = Node<"vec3"> | Vector3 | Node<"color"> | Color;
+type Vec4 = Node<"vec4"> | Vector4;
+
+type Vec2OrFloat = Vec2 | FloatOrNumber;
+type Vec3OrFloat = Vec3 | FloatOrNumber;
+type Vec4OrFloat = Vec4 | FloatOrNumber;
+
+interface RemapFunction {
+    (
+        node: FloatOrNumber,
+        inLowNode: FloatOrNumber,
+        inHighNode: FloatOrNumber,
+        outLowNode?: FloatOrNumber,
+        outHighNode?: FloatOrNumber,
+        doClamp?: Boolean,
+    ): Node<"float">;
+    (
+        node: Vec2OrFloat,
+        inLowNode: Vec2OrFloat,
+        inHighNode: Vec2OrFloat,
+        outLowNode?: Vec2OrFloat,
+        outHighNode?: Vec2OrFloat,
+        doClamp?: Boolean,
+    ): Node<"vec2">;
+    (
+        node: Vec3OrFloat,
+        inLowNode: Vec3OrFloat,
+        inHighNode: Vec3OrFloat,
+        outLowNode?: Vec3OrFloat,
+        outHighNode?: Vec3OrFloat,
+        doClamp?: Boolean,
+    ): Node<"vec3">;
+    (
+        node: Vec4OrFloat,
+        inLowNode: Vec4OrFloat,
+        inHighNode: Vec4OrFloat,
+        outLowNode?: Vec4OrFloat,
+        outHighNode?: Vec4OrFloat,
+        doClamp?: Boolean,
+    ): Node<"vec4">;
+}
+
+export const remap: RemapFunction;
+
+interface RemapClampFunction {
+    (
+        node: FloatOrNumber,
+        inLowNode: FloatOrNumber,
+        inHighNode: FloatOrNumber,
+        outLowNode?: FloatOrNumber,
+        outHighNode?: FloatOrNumber,
+    ): Node<"float">;
+    (
+        node: Vec2OrFloat,
+        inLowNode: Vec2OrFloat,
+        inHighNode: Vec2OrFloat,
+        outLowNode?: Vec2OrFloat,
+        outHighNode?: Vec2OrFloat,
+    ): Node<"vec2">;
+    (
+        node: Vec3OrFloat,
+        inLowNode: Vec3OrFloat,
+        inHighNode: Vec3OrFloat,
+        outLowNode?: Vec3OrFloat,
+        outHighNode?: Vec3OrFloat,
+    ): Node<"vec3">;
+    (
+        node: Vec4OrFloat,
+        inLowNode: Vec4OrFloat,
+        inHighNode: Vec4OrFloat,
+        outLowNode?: Vec4OrFloat,
+        outHighNode?: Vec4OrFloat,
+    ): Node<"vec4">;
+}
+
+export const remapClamp: RemapClampFunction;
+
+interface RemapFloatExtension {
+    (
+        inLowNode: FloatOrNumber,
+        inHighNode: FloatOrNumber,
+        outLowNode?: FloatOrNumber,
+        outHighNode?: FloatOrNumber,
+        doClamp?: Boolean,
+    ): Node<"float">;
+    (
+        inLowNode: Vec2OrFloat,
+        inHighNode: Vec2OrFloat,
+        outLowNode?: Vec2OrFloat,
+        outHighNode?: Vec2OrFloat,
+        doClamp?: Boolean,
+    ): Node<"vec2">;
+    (
+        inLowNode: Vec3OrFloat,
+        inHighNode: Vec3OrFloat,
+        outLowNode?: Vec3OrFloat,
+        outHighNode?: Vec3OrFloat,
+        doClamp?: Boolean,
+    ): Node<"vec3">;
+    (
+        inLowNode: Vec4OrFloat,
+        inHighNode: Vec4OrFloat,
+        outLowNode?: Vec4OrFloat,
+        outHighNode?: Vec4OrFloat,
+        doClamp?: Boolean,
+    ): Node<"vec4">;
+}
+
+interface RemapClampFloatExtension {
+    (
+        inLowNode: FloatOrNumber,
+        inHighNode: FloatOrNumber,
+        outLowNode?: FloatOrNumber,
+        outHighNode?: FloatOrNumber,
+    ): Node<"float">;
+    (
+        inLowNode: Vec2OrFloat,
+        inHighNode: Vec2OrFloat,
+        outLowNode?: Vec2OrFloat,
+        outHighNode?: Vec2OrFloat,
+    ): Node<"vec2">;
+    (
+        inLowNode: Vec3OrFloat,
+        inHighNode: Vec3OrFloat,
+        outLowNode?: Vec3OrFloat,
+        outHighNode?: Vec3OrFloat,
+    ): Node<"vec3">;
+    (
+        inLowNode: Vec4OrFloat,
+        inHighNode: Vec4OrFloat,
+        outLowNode?: Vec4OrFloat,
+        outHighNode?: Vec4OrFloat,
+    ): Node<"vec4">;
+}
+
+interface RemapVec2Extension {
+    (
+        inLowNode: Vec2OrFloat,
+        inHighNode: Vec2OrFloat,
+        outLowNode?: Vec2OrFloat,
+        outHighNode?: Vec2OrFloat,
+        doClamp?: Boolean,
+    ): Node<"vec2">;
+}
+
+interface RemapClampVec2Extension {
+    (
+        inLowNode: Vec2OrFloat,
+        inHighNode: Vec2OrFloat,
+        outLowNode?: Vec2OrFloat,
+        outHighNode?: Vec2OrFloat,
+    ): Node<"vec2">;
+}
+
+interface RemapVec3Extension {
+    (
+        inLowNode: Vec3OrFloat,
+        inHighNode: Vec3OrFloat,
+        outLowNode?: Vec3OrFloat,
+        outHighNode?: Vec3OrFloat,
+        doClamp?: Boolean,
+    ): Node<"vec3">;
+}
+
+interface RemapClampVec3Extension {
+    (
+        inLowNode: Vec3OrFloat,
+        inHighNode: Vec3OrFloat,
+        outLowNode?: Vec3OrFloat,
+        outHighNode?: Vec3OrFloat,
+        doClamp?: Boolean,
+    ): Node<"vec3">;
+}
+
+interface RemapVec4Extension {
+    (
+        inLowNode: Vec4OrFloat,
+        inHighNode: Vec4OrFloat,
+        outLowNode?: Vec4OrFloat,
+        outHighNode?: Vec4OrFloat,
+        doClamp?: Boolean,
+    ): Node<"vec4">;
+}
+
+interface RemapClampVec4Extension {
+    (
+        inLowNode: Vec4OrFloat,
+        inHighNode: Vec4OrFloat,
+        outLowNode?: Vec4OrFloat,
+        outHighNode?: Vec4OrFloat,
+    ): Node<"vec4">;
+}
 
 declare module "../core/Node.js" {
     interface FloatExtensions {
-        remap: (
-            inLowNode: Node<"float"> | number,
-            inHighNode: Node<"float"> | number,
-            outLowNode?: Node<"float"> | number,
-            outHighNode?: Node<"float"> | number,
-            doClamp?: Node<"bool"> | boolean,
-        ) => Node<"float">;
-
-        remapClamp: (
-            inLowNode: Node<"float"> | number,
-            inHighNode: Node<"float"> | number,
-            outLowNode?: Node<"float"> | number,
-            outHighNode?: Node<"float"> | number,
-        ) => Node<"float">;
+        remap: RemapFloatExtension;
+        remapClamp: RemapClampFloatExtension;
+    }
+    interface Vec2Extensions {
+        remap: RemapVec2Extension;
+        remapClamp: RemapClampVec2Extension;
+    }
+    interface Vec3Extensions {
+        remap: RemapVec3Extension;
+        remapClamp: RemapClampVec3Extension;
+    }
+    interface Vec4Extensions {
+        remap: RemapVec4Extension;
+        remapClamp: RemapClampVec4Extension;
     }
 }
+
+export {};

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

@@ -1,16 +1,26 @@
 import Node from "../core/Node.js";
 
-declare class SampleNode extends Node {
-    callback: (uv: Node) => Node;
-    uvNode: Node | null;
+declare interface SampleNodeInterface<TNodeType> {
+    callback: (uv: Node<"vec2">) => Node<TNodeType>;
+    uvNode: Node<"vec2"> | null;
 
-    readonly isSampleNode: true;
+    readonly isSampleNode: boolean;
 
-    constructor(callback: (uv: Node) => Node, uvNode?: Node | null);
-
-    sample(uv: Node): Node;
+    sample(uv: Node<"vec2">): Node<TNodeType>;
 }
 
+declare const SampleNode: {
+    new<TNodeType>(
+        callback: (uv: Node<"vec2">) => Node<TNodeType>,
+        uvNode?: Node<"vec2"> | null,
+    ): SampleNode<TNodeType>;
+};
+
+type SampleNode<TNodeType> = SampleNodeInterface<TNodeType> & Node<TNodeType>;
+
 export default SampleNode;
 
-export const sample: (callback: (uv: Node) => Node, uv?: Node | null) => SampleNode;
+export const sample: <TNodeType>(
+    callback: (uv: Node<"vec2">) => Node<TNodeType>,
+    uvNode?: Node<"vec2"> | null,
+) => SampleNode<TNodeType>;

three/src/objects/BatchedMesh.d.ts

@@ -127,7 +127,7 @@ declare class BatchedMesh extends Mesh<BufferGeometry, Material> {
      * Frees the GPU-related resources allocated by this instance. Call this method whenever this instance is no longer
      * used in your app.
      */
-    dispose(): this;
+    dispose(): void;
 
     /**
      * Takes a sort a function that is run before render. The function takes a list of instances to sort and a camera.

three/src/objects/InstancedMesh.d.ts

@@ -54,14 +54,6 @@ export class InstancedMesh<
      */
     instanceMatrix: InstancedBufferAttribute;
 
-    /**
-     * 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()}.

three/src/objects/Skeleton.d.ts

@@ -63,8 +63,6 @@ export class Skeleton {
      */
     boneMatrices: Float32Array | null;
 
-    previousBoneMatrices: Float32Array | null;
-
     /**
      * The {@link THREE.DataTexture | DataTexture} holding the bone data when using a vertex texture.
      */

three/src/renderers/common/Backend.d.ts

@@ -1,7 +1,6 @@
 import { CoordinateSystem } from "../../constants.js";
 import NodeBuilder from "../../nodes/core/NodeBuilder.js";
 import Renderer from "./Renderer.js";
-import RenderObject from "./RenderObject.js";
 
 declare module "../../core/Object3D.js" {
     interface Object3D {
@@ -27,6 +26,4 @@ export default abstract class Backend {
     abstract get coordinateSystem(): CoordinateSystem;
 
     getDomElement(): HTMLCanvasElement | OffscreenCanvas;
-
-    createNodeBuilder(renderObject: RenderObject, renderer: Renderer): NodeBuilder;
 }

three/src/renderers/common/CanvasTarget.d.ts

@@ -31,49 +31,6 @@ declare class CanvasTarget<TEventMap extends CanvasTargetEventMap = CanvasTarget
      * @type {HTMLCanvasElement|OffscreenCanvas}
      */
     domElement: HTMLCanvasElement | OffscreenCanvas;
-    /**
-     * The renderer's pixel ratio.
-     *
-     * @private
-     * @type {number}
-     * @default 1
-     */
-    private _pixelRatio;
-    /**
-     * The width of the renderer's default framebuffer in logical pixel unit.
-     *
-     * @private
-     * @type {number}
-     */
-    private _width;
-    /**
-     * The height of the renderer's default framebuffer in logical pixel unit.
-     *
-     * @private
-     * @type {number}
-     */
-    private _height;
-    /**
-     * The viewport of the renderer in logical pixel unit.
-     *
-     * @private
-     * @type {Vector4}
-     */
-    private _viewport;
-    /**
-     * The scissor rectangle of the renderer in logical pixel unit.
-     *
-     * @private
-     * @type {Vector4}
-     */
-    private _scissor;
-    /**
-     * Whether the scissor test should be enabled or not.
-     *
-     * @private
-     * @type {boolean}
-     */
-    private _scissorTest;
     /**
      * The color texture of the default framebuffer.
      *
@@ -189,12 +146,6 @@ declare class CanvasTarget<TEventMap extends CanvasTargetEventMap = CanvasTarget
      * @param {number} maxDepth - The maximum depth value of the viewport. WebGPU only.
      */
     setViewport(x: number, y: number, width: number, height: number, minDepth?: number, maxDepth?: number): void;
-    /**
-     * Dispatches the resize event.
-     *
-     * @private
-     */
-    private _dispatchResize;
     /**
      * Frees the GPU-related resources allocated by this instance. Call this
      * method whenever this instance is no longer used in your app.

three/src/renderers/common/ClippingContext.d.ts

@@ -48,6 +48,12 @@ declare class ClippingContext {
      * @default false
      */
     shadowPass: boolean;
+    /**
+     * The view matrix.
+     *
+     * @type {Matrix4}
+     */
+    viewMatrix: Matrix4;
     /**
      * The view normal matrix.
      *
@@ -79,7 +85,6 @@ declare class ClippingContext {
      * @readonly
      */
     readonly parentVersion: number | null;
-    viewMatrix?: Matrix4;
     /**
      * Projects the given source clipping planes and writes the result into the
      * destination array.

three/src/renderers/common/CubeRenderTarget.d.ts

@@ -1,4 +1,5 @@
 import { RenderTarget, RenderTargetOptions } from "../../core/RenderTarget.js";
+import { CubeTexture } from "../../textures/CubeTexture.js";
 import { Texture } from "../../textures/Texture.js";
 import Renderer from "./Renderer.js";
 
@@ -8,7 +9,7 @@ import Renderer from "./Renderer.js";
  *
  * @augments RenderTarget
  */
-declare class CubeRenderTarget extends RenderTarget {
+declare class CubeRenderTarget extends RenderTarget<CubeTexture> {
     /**
      * Constructs a new cube render target.
      *

three/src/renderers/common/Info.d.ts

@@ -1,7 +1,6 @@
 import { BufferAttribute } from "../../core/BufferAttribute.js";
 import { Object3D } from "../../core/Object3D.js";
 import { Texture } from "../../textures/Texture.js";
-import ProgrammableStage from "./ProgrammableStage.js";
 import ReadbackBuffer from "./ReadbackBuffer.js";
 
 /**
@@ -79,50 +78,47 @@ declare class Info {
      *
      * @type {Object}
      * @readonly
-     * @property {number} geometries - The number of active geometries.
-     * @property {number} textures - The number of active textures.
      * @property {number} attributes - The number of active attributes.
+     * @property {number} attributesSize - The memory size of active attributes in bytes.
+     * @property {number} geometries - The number of active geometries.
      * @property {number} indexAttributes - The number of active index attributes.
-     * @property {number} storageAttributes - The number of active storage attributes.
+     * @property {number} indexAttributesSize - The memory size of active index attributes in bytes.
      * @property {number} indirectStorageAttributes - The number of active indirect storage attributes.
-     * @property {number} readbackBuffers - The number of active readback buffers.
+     * @property {number} indirectStorageAttributesSize - The memory size of active indirect storage attributes in bytes.
      * @property {number} programs - The number of active programs.
+     * @property {number} programsSize - The memory size of active programs in bytes.
+     * @property {number} readbackBuffers - The number of active readback buffers.
+     * @property {number} readbackBuffersSize - The memory size of active readback buffers in bytes.
      * @property {number} renderTargets - The number of active renderTargets.
-     * @property {number} total - The total memory size in bytes.
-     * @property {number} texturesSize - The memory size of active textures in bytes.
-     * @property {number} attributesSize - The memory size of active attributes in bytes.
-     * @property {number} indexAttributesSize - The memory size of active index attributes in bytes.
+     * @property {number} storageAttributes - The number of active storage attributes.
      * @property {number} storageAttributesSize - The memory size of active storage attributes in bytes.
-     * @property {number} indirectStorageAttributesSize - The memory size of active indirect storage attributes in bytes.
-     * @property {number} readbackBuffersSize - The memory size of active readback buffers in bytes.
-     * @property {number} programsSize - The memory size of active programs in bytes.
+     * @property {number} textures - The number of active textures.
+     * @property {number} texturesSize - The memory size of active textures in bytes.
+     * @property {number} uniformBuffers - The number of active uniform buffers.
+     * @property {number} uniformBuffersSize - The memory size of active uniform buffers in bytes.
+     * @property {number} total - The total memory size in bytes.
      */
     readonly memory: {
-        geometries: number;
-        textures: number;
         attributes: number;
+        attributesSize: number;
+        geometries: number;
         indexAttributes: number;
-        storageAttributes: number;
+        indexAttributesSize: number;
         indirectStorageAttributes: number;
-        readbackBuffers: number;
+        indirectStorageAttributesSize: number;
         programs: number;
+        programsSize: number;
+        readbackBuffers: number;
+        readbackBuffersSize: number;
         renderTargets: number;
-        total: number;
-        texturesSize: number;
-        attributesSize: number;
-        indexAttributesSize: number;
+        storageAttributes: number;
         storageAttributesSize: number;
-        indirectStorageAttributesSize: number;
-        readbackBuffersSize: number;
-        programsSize: number;
+        textures: number;
+        texturesSize: number;
+        uniformBuffers: number;
+        uniformBuffersSize: number;
+        total: number;
     };
-    /**
-     * Map for storing calculated byte sizes of tracked objects.
-     *
-     * @type {Map<Object, number>}
-     * @private
-     */
-    private memoryMap;
     /**
      * This method should be executed per draw call and updates the corresponding metrics.
      *
@@ -151,14 +147,6 @@ declare class Info {
      * @param {Texture} texture
      */
     destroyTexture(texture: Texture): void;
-    /**
-     * Tracks attribute memory explicitly, updating counts and byte tracking.
-     *
-     * @param {BufferAttribute} attribute
-     * @param {string} type - type of attribute
-     * @private
-     */
-    private _createAttribute;
     /**
      * Tracks a regular attribute memory explicitly.
      *
@@ -201,34 +189,6 @@ declare class Info {
      * @param {ReadbackBuffer} readbackBuffer - The readback buffer to track.
      */
     destroyReadbackBuffer(readbackBuffer: ReadbackBuffer): void;
-    /**
-     * Tracks program memory explicitly, updating counts and byte tracking.
-     *
-     * @param {ProgrammableStage} program - The program to track.
-     */
-    createProgram(program: ProgrammableStage): void;
-    /**
-     * Tracks program memory explicitly, updating counts and byte tracking.
-     *
-     * @param {Object} program - The program to track.
-     */
-    destroyProgram(program: ProgrammableStage): void;
-    /**
-     * Calculates the memory size of a texture in bytes.
-     *
-     * @param {Texture} texture - The texture to calculate the size for.
-     * @return {number} The calculated size in bytes.
-     * @private
-     */
-    private _getTextureMemorySize;
-    /**
-     * Calculates the memory size of an attribute in bytes.
-     *
-     * @param {BufferAttribute} attribute - The attribute to calculate the size for.
-     * @return {number} The calculated size in bytes.
-     * @private
-     */
-    private _getAttributeMemorySize;
 }
 
 export default Info;