@types/three 0.183.0 → 0.184.0

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

@@ -1,7 +1,14 @@
 import Node from "../core/Node.js";
 
-export default class ConvertNode extends Node {
+interface ConvertNodeInterface {
     node: Node;
     convertTo: string;
-    constructor(node: Node, convertTo: string);
 }
+
+declare const ConvertNode: {
+    new<TNodeType>(node: Node, convertTo: string): ConvertNode<TNodeType>;
+};
+
+type ConvertNode<TNodeType> = Node<TNodeType> & ConvertNodeInterface;
+
+export default ConvertNode;

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

@@ -11,8 +11,10 @@ declare class EventNode extends Node {
 
     static OBJECT: "object";
     static MATERIAL: "material";
+    static FRAME: "frame";
     static BEFORE_OBJECT: "beforeObject";
     static BEFORE_MATERIAL: "beforeMaterial";
+    static BEFORE_FRAME: "beforeFrame";
 }
 
 export default EventNode;
@@ -21,6 +23,10 @@ export const OnObjectUpdate: (callback: (frame: NodeFrame) => void) => Node;
 
 export const OnMaterialUpdate: (callback: (frame: NodeFrame) => void) => Node;
 
+export const OnFrameUpdate: (callback: (frame: NodeFrame) => void) => Node;
+
 export const OnBeforeObjectUpdate: (callback: (frame: NodeFrame) => void) => Node;
 
 export const OnBeforeMaterialUpdate: (callback: (frame: NodeFrame) => void) => Node;
+
+export const OnBeforeFrameUpdate: (callback: (frame: NodeFrame) => void) => Node;

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

@@ -1,10 +1,14 @@
 import Node from "../core/Node.js";
 import { TempNode } from "../Nodes.js";
 
-/**
- * This node constructs given type from elements, like vec3(a,b,c)
- */
-export default class JoinNode extends TempNode {
+interface JoinNodeInterface {
     nodes: Node[];
-    constructor(nodes: Node[]);
 }
+
+declare const JoinNode: {
+    new<TNodeType>(nodes: Node[]): JoinNode<TNodeType>;
+};
+
+type JoinNode<TNodeType> = TempNode<TNodeType> & JoinNodeInterface;
+
+export default JoinNode;

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

@@ -1,6 +1,5 @@
 import Node from "../core/Node.js";
 import NodeBuilder from "../core/NodeBuilder.js";
-import { VarNode } from "../Nodes.js";
 
 type LoopNodeType = "int" | "uint" | "float";
 
@@ -12,7 +11,7 @@ interface LoopNodeObjectParameter<TNodeType extends LoopNodeType> {
     start: Node<TNodeType> | number;
     end: Node<TNodeType> | number;
     condition?: string;
-    update?: VarNode | number | string;
+    update?: Node | number | string;
 }
 
 declare class LoopNode extends Node<"void"> {

three/src/nodes/utils/{RemapNode.d.ts → Remap.d.ts}

@@ -1,37 +1,20 @@
 import Node from "../core/Node.js";
 
-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<"float">,
-        inLowNode: Node<"float">,
-        inHighNode: Node<"float">,
-        outLowNode?: Node<"float">,
-        outHighNode?: Node<"float">,
-    );
-}
-
 export const remap: (
     node: Node<"float">,
     inLowNode: Node<"float"> | number,
     inHighNode: Node<"float"> | number,
     outLowNode?: Node<"float"> | number,
     outHighNode?: Node<"float"> | number,
-) => RemapNode;
+    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,
-) => RemapNode;
+) => Node<"float">;
 
 declare module "../core/Node.js" {
     interface FloatExtensions {
@@ -40,13 +23,14 @@ declare module "../core/Node.js" {
             inHighNode: Node<"float"> | number,
             outLowNode?: Node<"float"> | number,
             outHighNode?: Node<"float"> | number,
-        ) => RemapNode;
+            doClamp?: Node<"bool"> | boolean,
+        ) => Node<"float">;
 
         remapClamp: (
             inLowNode: Node<"float"> | number,
             inHighNode: Node<"float"> | number,
             outLowNode?: Node<"float"> | number,
             outHighNode?: Node<"float"> | number,
-        ) => RemapNode;
+        ) => Node<"float">;
     }
 }

three/src/objects/BatchedMesh.d.ts

@@ -145,6 +145,8 @@ declare class BatchedMesh extends Mesh<BufferGeometry, Material> {
      * @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, color: Color): Color;
+    getColorAt(instanceId: number, color: Vector4): Vector4;
     getColorAt(instanceId: number, color: Color | Vector4): Color | Vector4;
 
     /**

three/src/objects/InstancedMesh.d.ts

@@ -126,7 +126,7 @@ export class InstancedMesh<
      * @param index The index of an instance. Values have to be in the range `[0, count]`. Expects a `Integer`
      * @param color This color object will be set to the color of the defined instance.
      */
-    getColorAt(index: number, color: Color): void;
+    getColorAt(index: number, color: Color): Color;
 
     /**
      * Sets the given color to the defined instance
@@ -135,14 +135,14 @@ export class InstancedMesh<
      * @param index The index of an instance. Values have to be in the range `[0, count]`. Expects a `Integer`
      * @param color The color of a single instance.
      */
-    setColorAt(index: number, color: Color): void;
+    setColorAt(index: number, color: Color): this;
 
     /**
      * Get the local transformation matrix of the defined instance.
      * @param index The index of an instance Values have to be in the range `[0, count]`. Expects a `Integer`
      * @param matrix This 4x4 matrix will be set to the local transformation matrix of the defined instance.
      */
-    getMatrixAt(index: number, matrix: Matrix4): void;
+    getMatrixAt(index: number, matrix: Matrix4): Matrix4;
 
     /**
      * Get the morph target weights of the defined instance.
@@ -159,7 +159,7 @@ export class InstancedMesh<
      * @param index The index of an instance. Values have to be in the range `[0, count]`. Expects a `Integer`
      * @param matrix A 4x4 matrix representing the local transformation of a single instance.
      */
-    setMatrixAt(index: number, matrix: Matrix4): void;
+    setMatrixAt(index: number, matrix: Matrix4): this;
 
     /**
      * Sets the morph target weights to the defined instance. Make sure you set {@link .morphTexture}{@link .needsUpdate}
@@ -167,7 +167,7 @@ export class InstancedMesh<
      * @param index The index of an instance. Values have to be in the range [0, count].
      * @param mesh A mesh with {@link .morphTargetInfluences} property containing the morph target weights of a single instance.
      */
-    setMorphAt(index: number, mesh: Mesh): void;
+    setMorphAt(index: number, mesh: Mesh): this;
 
     /**
      * No effect in {@link InstancedMesh}.
@@ -181,7 +181,7 @@ export class InstancedMesh<
      * @remarks
      * Call this method whenever this instance is no longer used in your app.
      */
-    dispose(): this;
+    dispose(): void;
 
     toJSON(meta?: JSONMeta): InstancedMeshJSON;
 }

three/src/objects/SkinnedMesh.d.ts

@@ -6,6 +6,7 @@ import { Box3 } from "../math/Box3.js";
 import { Matrix4, Matrix4Tuple } from "../math/Matrix4.js";
 import { Sphere } from "../math/Sphere.js";
 import { Vector3 } from "../math/Vector3.js";
+import { Vector4 } from "../math/Vector4.js";
 import { Mesh, MeshJSON, MeshJSONObject } from "./Mesh.js";
 import { Skeleton } from "./Skeleton.js";
 
@@ -155,6 +156,8 @@ export class SkinnedMesh<
      * @param vector
      */
     applyBoneTransform(index: number, vector: Vector3): Vector3;
+    applyBoneTransform(index: number, vector: Vector4): Vector4;
+    applyBoneTransform(index: number, vector: Vector3 | Vector4): Vector3 | Vector4;
 
     toJSON(meta?: JSONMeta): SkinnedMeshJSON;
 }

three/src/renderers/WebGLRenderer.d.ts

@@ -17,6 +17,7 @@ import { WebGLCapabilities, WebGLCapabilitiesParameters } from "./webgl/WebGLCap
 import { WebGLExtensions } from "./webgl/WebGLExtensions.js";
 import { WebGLInfo } from "./webgl/WebGLInfo.js";
 import { WebGLProgram } from "./webgl/WebGLProgram.js";
+import { WebGLProgramParametersWithUniforms } from "./webgl/WebGLPrograms.js";
 import { WebGLProperties } from "./webgl/WebGLProperties.js";
 import { WebGLRenderLists } from "./webgl/WebGLRenderLists.js";
 import { WebGLShadowMap } from "./webgl/WebGLShadowMap.js";
@@ -116,6 +117,13 @@ export interface Effect {
     ): void;
 }
 
+export interface NodesHandler {
+    setRenderer(renderer: WebGLRenderer): void;
+    renderStart(scene: Object3D, camera: Camera): void;
+    renderEnd(): void;
+    build(material: Material, object: Object3D, parameters: WebGLProgramParametersWithUniforms): void;
+}
+
 /**
  * The WebGL renderer displays your beautifully crafted scenes using WebGL, if your device supports it.
  * This renderer has way better performance than CanvasRenderer.
@@ -315,7 +323,8 @@ export class WebGLRenderer {
     clearColor(): void;
     clearDepth(): void;
     clearStencil(): void;
-    clearTarget(renderTarget: WebGLRenderTarget, color: boolean, depth: boolean, stencil: boolean): void;
+
+    setNodesHandler(nodesHandler: NodesHandler): void;
 
     dispose(): void;
 

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

@@ -17,7 +17,7 @@ declare class Animation {
      * Constructs a new animation loop management component.
      *
      * @param {Renderer} renderer - A reference to the main renderer.
-     * @param {Nodes} nodes - Renderer component for managing nodes related logic.
+     * @param {NodeManager} nodes - Renderer component for managing nodes related logic.
      * @param {Info} info - Renderer component for managing metrics and monitoring data.
      */
     constructor(renderer: Renderer, nodes: NodeManager, info: Info);
@@ -30,7 +30,7 @@ declare class Animation {
     /**
      * Renderer component for managing nodes related logic.
      *
-     * @type {Nodes}
+     * @type {NodeManager}
      */
     nodes: NodeManager;
     /**

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

@@ -3,6 +3,7 @@ import { InterleavedBuffer } from "../../core/InterleavedBuffer.js";
 import { InterleavedBufferAttribute } from "../../core/InterleavedBufferAttribute.js";
 import Backend from "./Backend.js";
 import DataMap from "./DataMap.js";
+import Info from "./Info.js";
 
 /**
  * This renderer module manages geometry attributes.
@@ -15,14 +16,21 @@ declare class Attributes extends DataMap {
      * Constructs a new attribute management component.
      *
      * @param {Backend} backend - The renderer's backend.
+     * @param {Info} info - Renderer component for managing metrics and monitoring data.
      */
-    constructor(backend: Backend);
+    constructor(backend: Backend, info: Info);
     /**
      * The renderer's backend.
      *
      * @type {Backend}
      */
     backend: Backend;
+    /**
+     * Renderer component for managing metrics and monitoring data.
+     *
+     * @type {Info}
+     */
+    info: Info;
     /**
      * Deletes the data for the given attribute.
      *

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

@@ -1,5 +1,7 @@
 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 {
@@ -25,4 +27,6 @@ export default abstract class Backend {
     abstract get coordinateSystem(): CoordinateSystem;
 
     getDomElement(): HTMLCanvasElement | OffscreenCanvas;
+
+    createNodeBuilder(renderObject: RenderObject, renderer: Renderer): NodeBuilder;
 }

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

@@ -16,7 +16,7 @@ declare class Background extends DataMap {
      * Constructs a new background management component.
      *
      * @param {Renderer} renderer - The renderer.
-     * @param {Nodes} nodes - Renderer component for managing nodes related logic.
+     * @param {NodeManager} nodes - Renderer component for managing nodes related logic.
      */
     constructor(renderer: Renderer, nodes: NodeManager);
     /**
@@ -28,7 +28,7 @@ declare class Background extends DataMap {
     /**
      * Renderer component for managing nodes related logic.
      *
-     * @type {Nodes}
+     * @type {NodeManager}
      */
     nodes: NodeManager;
     /**

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

@@ -28,12 +28,6 @@ declare class BindGroup {
      * @type {Array<Binding>}
      */
     bindings: Binding[];
-    /**
-     * The group index.
-     *
-     * @type {number}
-     */
-    index: number;
     /**
      * The group's ID.
      *

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

@@ -20,7 +20,7 @@ declare class Bindings extends DataMap {
      * Constructs a new bindings management component.
      *
      * @param {Backend} backend - The renderer's backend.
-     * @param {Nodes} nodes - Renderer component for managing nodes related logic.
+     * @param {NodeManager} nodes - Renderer component for managing nodes related logic.
      * @param {Textures} textures - Renderer component for managing textures.
      * @param {Attributes} attributes - Renderer component for managing attributes.
      * @param {Pipelines} pipelines - Renderer component for managing pipelines.
@@ -61,7 +61,7 @@ declare class Bindings extends DataMap {
     /**
      * Renderer component for managing nodes related logic.
      *
-     * @type {Nodes}
+     * @type {NodeManager}
      */
     nodes: NodeManager;
     /**

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

@@ -14,7 +14,9 @@ export interface CanvasTargetEventMap {
  *
  * @augments EventDispatcher
  */
-declare class CanvasTarget extends EventDispatcher<CanvasTargetEventMap> {
+declare class CanvasTarget<TEventMap extends CanvasTargetEventMap = CanvasTargetEventMap>
+    extends EventDispatcher<TEventMap>
+{
     /**
      * Constructs a new CanvasTarget.
      *

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

@@ -9,7 +9,7 @@ import ProgrammableStage from "./ProgrammableStage.js";
  */
 declare class ComputePipeline extends Pipeline {
     /**
-     * Constructs a new render pipeline.
+     * Constructs a new compute pipeline.
      *
      * @param {string} cacheKey - The pipeline's cache key.
      * @param {ProgrammableStage} computeProgram - The pipeline's compute shader.

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

@@ -1,4 +1,8 @@
+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";
 
 /**
  * This renderer module provides a series of statistical information
@@ -76,12 +80,49 @@ declare class Info {
      * @type {Object}
      * @readonly
      * @property {number} geometries - The number of active geometries.
-     * @property {number} frameCalls - The number of active textures.
+     * @property {number} textures - The number of active textures.
+     * @property {number} attributes - The number of active attributes.
+     * @property {number} indexAttributes - The number of active index attributes.
+     * @property {number} storageAttributes - The number of active storage attributes.
+     * @property {number} indirectStorageAttributes - The number of active indirect storage attributes.
+     * @property {number} readbackBuffers - The number of active readback buffers.
+     * @property {number} programs - The number of active programs.
+     * @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} 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.
      */
     readonly memory: {
         geometries: number;
         textures: number;
+        attributes: number;
+        indexAttributes: number;
+        storageAttributes: number;
+        indirectStorageAttributes: number;
+        readbackBuffers: number;
+        programs: number;
+        renderTargets: number;
+        total: number;
+        texturesSize: number;
+        attributesSize: number;
+        indexAttributesSize: number;
+        storageAttributesSize: number;
+        indirectStorageAttributesSize: number;
+        readbackBuffersSize: number;
+        programsSize: 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.
      *
@@ -98,6 +139,96 @@ declare class Info {
      * Performs a complete reset of the object.
      */
     dispose(): void;
+    /**
+     * Tracks texture memory explicitly, updating counts and byte tracking.
+     *
+     * @param {Texture} texture
+     */
+    createTexture(texture: Texture): void;
+    /**
+     * Tracks texture memory explicitly, updating counts and byte tracking.
+     *
+     * @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.
+     *
+     * @param {BufferAttribute} attribute - The attribute to track.
+     */
+    createAttribute(attribute: BufferAttribute): void;
+    /**
+     * Tracks an index attribute memory explicitly.
+     *
+     * @param {BufferAttribute} attribute - The index attribute to track.
+     */
+    createIndexAttribute(attribute: BufferAttribute): void;
+    /**
+     * Tracks a storage attribute memory explicitly.
+     *
+     * @param {BufferAttribute} attribute - The storage attribute to track.
+     */
+    createStorageAttribute(attribute: BufferAttribute): void;
+    /**
+     * Tracks an indirect storage attribute memory explicitly.
+     *
+     * @param {BufferAttribute} attribute - The indirect storage attribute to track.
+     */
+    createIndirectStorageAttribute(attribute: BufferAttribute): void;
+    /**
+     * Tracks attribute memory explicitly, updating counts and byte tracking.
+     *
+     * @param {BufferAttribute} attribute
+     */
+    destroyAttribute(attribute: BufferAttribute): void;
+    /**
+     * Tracks a readback buffer memory explicitly.
+     *
+     * @param {ReadbackBuffer} readbackBuffer - The readback buffer to track.
+     */
+    createReadbackBuffer(readbackBuffer: ReadbackBuffer): void;
+    /**
+     * Tracks a readback buffer memory explicitly.
+     *
+     * @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;

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

@@ -1,4 +1,5 @@
 import { Camera } from "../../cameras/Camera.js";
+import { EventDispatcher } from "../../core/EventDispatcher.js";
 import { RenderTarget } from "../../core/RenderTarget.js";
 import Node from "../../nodes/core/Node.js";
 import NodeFrame from "../../nodes/core/NodeFrame.js";
@@ -7,12 +8,17 @@ import { Scene } from "../../scenes/Scene.js";
 import { Texture } from "../../textures/Texture.js";
 import Renderer from "./Renderer.js";
 
+export interface InspectorBaseEventMap {
+}
+
 /**
  * InspectorBase is the base class for all inspectors.
  *
  * @class InspectorBase
  */
-declare class InspectorBase {
+declare class InspectorBase<TEventMap extends InspectorBaseEventMap = InspectorBaseEventMap>
+    extends EventDispatcher<TEventMap>
+{
     /**
      * The renderer associated with this inspector.
      *

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

@@ -4,6 +4,7 @@ import BindGroup from "./BindGroup.js";
 import Bindings from "./Bindings.js";
 import ComputePipeline from "./ComputePipeline.js";
 import DataMap from "./DataMap.js";
+import Info from "./Info.js";
 import NodeManager from "./nodes/NodeManager.js";
 import Pipeline from "./Pipeline.js";
 import ProgrammableStage from "./ProgrammableStage.js";
@@ -21,9 +22,10 @@ declare class Pipelines extends DataMap {
      * Constructs a new pipeline management component.
      *
      * @param {Backend} backend - The renderer's backend.
-     * @param {Nodes} nodes - Renderer component for managing nodes related logic.
+     * @param {NodeManager} nodes - Renderer component for managing nodes related logic.
+     * @param {Info} info - Renderer component for managing metrics and monitoring data.
      */
-    constructor(backend: Backend, nodes: NodeManager);
+    constructor(backend: Backend, nodes: NodeManager, info: Info);
     /**
      * The renderer's backend.
      *
@@ -33,9 +35,15 @@ declare class Pipelines extends DataMap {
     /**
      * Renderer component for managing nodes related logic.
      *
-     * @type {Nodes}
+     * @type {NodeManager}
      */
     nodes: NodeManager;
+    /**
+     * Renderer component for managing metrics and monitoring data.
+     *
+     * @type {Info}
+     */
+    info: Info;
     /**
      * A references to the bindings management component.
      * This reference will be set inside the `Bindings`
@@ -80,6 +88,14 @@ declare class Pipelines extends DataMap {
      * @return {RenderObjectPipeline} The render pipeline.
      */
     getForRender(renderObject: RenderObject, promises?: Promise<void>[] | null): RenderObjectPipeline;
+    /**
+     * Checks if the render pipeline for the given render object is ready for drawing.
+     * Returns false if the GPU pipeline is still being compiled asynchronously.
+     *
+     * @param {RenderObject} renderObject - The render object.
+     * @return {boolean} True if the pipeline is ready for drawing.
+     */
+    isReady(renderObject: RenderObject): boolean;
     /**
      * Deletes the pipeline for the given render object.
      *