@types/three 0.181.0 → 0.183.0

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

@@ -1,31 +1,18 @@
 import { BufferAttribute } from "../../core/BufferAttribute.js";
 import { BufferGeometry } from "../../core/BufferGeometry.js";
-import { InterleavedBuffer } from "../../core/InterleavedBuffer.js";
-import { InterleavedBufferAttribute } from "../../core/InterleavedBufferAttribute.js";
 import Attributes from "./Attributes.js";
 import { AttributeType } from "./Constants.js";
 import DataMap from "./DataMap.js";
 import Info from "./Info.js";
 import RenderObject from "./RenderObject.js";
-interface GeometryData {
-    initialized?: boolean | undefined;
-}
+
 /**
  * This renderer module manages geometries.
  *
  * @private
  * @augments DataMap
  */
-declare class Geometries extends DataMap<{
-    geometry: {
-        key: BufferGeometry;
-        value: GeometryData;
-    };
-}> {
-    attributes: Attributes;
-    info: Info;
-    wireframes: WeakMap<BufferGeometry, BufferAttribute>;
-    attributeCall: WeakMap<BufferAttribute | InterleavedBufferAttribute | InterleavedBuffer, number>;
+declare class Geometries extends DataMap {
     /**
      * Constructs a new geometry management component.
      *
@@ -33,13 +20,45 @@ declare class Geometries extends DataMap<{
      * @param {Info} info - Renderer component for managing metrics and monitoring data.
      */
     constructor(attributes: Attributes, info: Info);
+    /**
+     * Renderer component for managing attributes.
+     *
+     * @type {Attributes}
+     */
+    attributes: Attributes;
+    /**
+     * Renderer component for managing metrics and monitoring data.
+     *
+     * @type {Info}
+     */
+    info: Info;
+    /**
+     * Weak Map for managing attributes for wireframe rendering.
+     *
+     * @type {WeakMap<BufferGeometry,BufferAttribute>}
+     */
+    wireframes: WeakMap<BufferGeometry, BufferAttribute>;
+    /**
+     * This Weak Map is used to make sure buffer attributes are
+     * updated only once per render call.
+     *
+     * @type {WeakMap<BufferAttribute,number>}
+     */
+    attributeCall: WeakMap<BufferAttribute, number>;
+    /**
+     * Stores the event listeners attached to geometries.
+     *
+     * @private
+     * @type {Map<BufferGeometry,Function>}
+     */
+    private _geometryDisposeListeners;
     /**
      * Returns `true` if the given render object has an initialized geometry.
      *
      * @param {RenderObject} renderObject - The render object.
      * @return {boolean} Whether if the given render object has an initialized geometry or not.
      */
-    has(renderObject: RenderObject | BufferGeometry): boolean;
+    has(renderObject: RenderObject): boolean;
     /**
      * Prepares the geometry of the given render object for rendering.
      *
@@ -64,14 +83,21 @@ declare class Geometries extends DataMap<{
      * @param {BufferAttribute} attribute - The attribute to update.
      * @param {number} type - The attribute type.
      */
-    updateAttribute(attribute: BufferAttribute | InterleavedBufferAttribute, type: AttributeType): void;
+    updateAttribute(attribute: BufferAttribute, type: AttributeType): void;
     /**
      * Returns the indirect buffer attribute of the given render object.
      *
      * @param {RenderObject} renderObject - The render object.
      * @return {?BufferAttribute} The indirect attribute. `null` if no indirect drawing is used.
      */
-    getIndirect(renderObject: RenderObject): import("./IndirectStorageBufferAttribute.js").default | null;
+    getIndirect(renderObject: RenderObject): BufferAttribute | null;
+    /**
+     * Returns the byte offset into the indirect attribute buffer of the given render object.
+     *
+     * @param {RenderObject} renderObject - The render object.
+     * @return {number} The byte offset into the indirect attribute buffer.
+     */
+    getIndirectOffset(renderObject: RenderObject): number;
     /**
      * Returns the index of the given render object's geometry. This is implemented
      * in a method to return a wireframe index if necessary.
@@ -80,6 +106,6 @@ declare class Geometries extends DataMap<{
      * @return {?BufferAttribute} The index. Returns `null` for non-indexed geometries.
      */
     getIndex(renderObject: RenderObject): BufferAttribute | null;
-    dispose(): void;
 }
+
 export default Geometries;

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

@@ -1,14 +1,53 @@
 import { Object3D } from "../../core/Object3D.js";
+
 /**
  * This renderer module provides a series of statistical information
  * about the GPU memory and the rendering process. Useful for debugging
  * and monitoring.
  */
 declare class Info {
+    /**
+     * Whether frame related metrics should automatically
+     * be resetted or not. This property should be set to `false`
+     * by apps which manage their own animation loop. They must
+     * then call `renderer.info.reset()` once per frame manually.
+     *
+     * @type {boolean}
+     * @default true
+     */
     autoReset: boolean;
-    frame: number;
-    calls: number;
-    render: {
+    /**
+     * The current frame ID. This ID is managed
+     * by `NodeFrame`.
+     *
+     * @type {number}
+     * @readonly
+     * @default 0
+     */
+    readonly frame: number;
+    /**
+     * The number of render calls since the
+     * app has been started.
+     *
+     * @type {number}
+     * @readonly
+     * @default 0
+     */
+    readonly calls: number;
+    /**
+     * Render related metrics.
+     *
+     * @type {Object}
+     * @readonly
+     * @property {number} calls - The number of render calls since the app has been started.
+     * @property {number} frameCalls - The number of render calls of the current frame.
+     * @property {number} drawCalls - The number of draw calls of the current frame.
+     * @property {number} triangles - The number of rendered triangle primitives of the current frame.
+     * @property {number} points - The number of rendered point primitives of the current frame.
+     * @property {number} lines - The number of rendered line primitives of the current frame.
+     * @property {number} timestamp - The timestamp of the frame.
+     */
+    readonly render: {
         calls: number;
         frameCalls: number;
         drawCalls: number;
@@ -17,19 +56,32 @@ declare class Info {
         lines: number;
         timestamp: number;
     };
-    compute: {
+    /**
+     * Compute related metrics.
+     *
+     * @type {Object}
+     * @readonly
+     * @property {number} calls - The number of compute calls since the app has been started.
+     * @property {number} frameCalls - The number of compute calls of the current frame.
+     * @property {number} timestamp - The timestamp of the frame when using `renderer.computeAsync()`.
+     */
+    readonly compute: {
         calls: number;
         frameCalls: number;
         timestamp: number;
     };
-    memory: {
+    /**
+     * Memory related metrics.
+     *
+     * @type {Object}
+     * @readonly
+     * @property {number} geometries - The number of active geometries.
+     * @property {number} frameCalls - The number of active textures.
+     */
+    readonly memory: {
         geometries: number;
         textures: number;
     };
-    /**
-     * Constructs a new info component.
-     */
-    constructor();
     /**
      * This method should be executed per draw call and updates the corresponding metrics.
      *
@@ -47,4 +99,5 @@ declare class Info {
      */
     dispose(): void;
 }
+
 export default Info;

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

@@ -1,39 +1,50 @@
 import { Camera } from "../../cameras/Camera.js";
 import { RenderTarget } from "../../core/RenderTarget.js";
+import Node from "../../nodes/core/Node.js";
+import NodeFrame from "../../nodes/core/NodeFrame.js";
 import ComputeNode from "../../nodes/gpgpu/ComputeNode.js";
 import { Scene } from "../../scenes/Scene.js";
 import { Texture } from "../../textures/Texture.js";
 import Renderer from "./Renderer.js";
+
 /**
  * InspectorBase is the base class for all inspectors.
  *
  * @class InspectorBase
  */
 declare class InspectorBase {
-    _renderer: Renderer | null;
     /**
-     * Creates a new InspectorBase.
+     * The renderer associated with this inspector.
+     *
+     * @type {WebGLRenderer}
+     * @private
+     */
+    private _renderer;
+    /**
+     * The current frame being processed.
+     *
+     * @type {Object}
      */
-    constructor();
+    currentFrame: unknown;
     /**
      * Returns the node frame for the current renderer.
      *
      * @return {Object} The node frame.
      */
-    get nodeFrame(): import("../../Three.WebGPU.Nodes.js").NodeFrame;
+    get nodeFrame(): NodeFrame;
     /**
      * Sets the renderer for this inspector.
      *
      * @param {WebGLRenderer} renderer - The renderer to associate with this inspector.
      * @return {InspectorBase} This inspector instance.
      */
-    setRenderer(renderer: Renderer | null): this;
+    setRenderer(renderer: Renderer): InspectorBase;
     /**
      * Returns the renderer associated with this inspector.
      *
      * @return {WebGLRenderer} The associated renderer.
      */
-    getRenderer(): Renderer | null;
+    getRenderer(): Renderer;
     /**
      * Initializes the inspector.
      */
@@ -51,7 +62,7 @@ declare class InspectorBase {
      *
      * @param {Node} node - The node to inspect.
      */
-    inspect(): void;
+    inspect(node: Node): void;
     /**
      * When a compute operation is performed.
      *
@@ -102,4 +113,5 @@ declare class InspectorBase {
      */
     copyFramebufferToTexture(framebufferTexture: Texture): void;
 }
+
 export default InspectorBase;

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

@@ -1,15 +1,11 @@
-import { Camera } from "../../cameras/Camera.js";
 import { Object3D } from "../../core/Object3D.js";
 import { Light } from "../../lights/Light.js";
 import LightsNode from "../../nodes/lighting/LightsNode.js";
-import ChainMap from "./ChainMap.js";
-
-declare class Lighting extends ChainMap<[Object3D, Camera], LightsNode> {
-    constructor();
 
+declare class Lighting {
     createNode(lights?: Light[]): LightsNode;
 
-    getNode(scene: Object3D, camera: Camera): LightsNode;
+    getNode(scene: Object3D): LightsNode;
 }
 
 export default Lighting;

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

@@ -5,13 +5,25 @@
  * @abstract
  */
 declare class Pipeline {
-    cacheKey: string;
-    usedTimes: number;
     /**
      * Constructs a new pipeline.
      *
      * @param {string} cacheKey - The pipeline's cache key.
      */
     constructor(cacheKey: string);
+    /**
+     * The pipeline's cache key.
+     *
+     * @type {string}
+     */
+    cacheKey: string;
+    /**
+     * How often the pipeline is currently in use.
+     *
+     * @type {number}
+     * @default 0
+     */
+    usedTimes: number;
 }
+
 export default Pipeline;

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

@@ -1,53 +1,69 @@
 import ComputeNode from "../../nodes/gpgpu/ComputeNode.js";
 import Backend from "./Backend.js";
-import Binding from "./Binding.js";
+import BindGroup from "./BindGroup.js";
 import Bindings from "./Bindings.js";
 import ComputePipeline from "./ComputePipeline.js";
 import DataMap from "./DataMap.js";
-import Nodes from "./nodes/Nodes.js";
+import NodeManager from "./nodes/NodeManager.js";
 import Pipeline from "./Pipeline.js";
 import ProgrammableStage from "./ProgrammableStage.js";
 import RenderObject from "./RenderObject.js";
-import RenderPipeline from "./RenderPipeline.js";
-interface ComputeNodeData {
-    version: number;
-    pipeline: ComputePipeline;
-}
-interface RenderObjectData {
-    pipeline: RenderPipeline;
-}
+import RenderObjectPipeline from "./RenderObjectPipeline.js";
+
 /**
  * This renderer module manages the pipelines of the renderer.
  *
  * @private
  * @augments DataMap
  */
-declare class Pipelines extends DataMap<{
-    computeNode: {
-        key: ComputeNode;
-        value: ComputeNodeData;
-    };
-    renderObject: {
-        key: RenderObject;
-        value: RenderObjectData;
-    };
-}> {
+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.
+     */
+    constructor(backend: Backend, nodes: NodeManager);
+    /**
+     * The renderer's backend.
+     *
+     * @type {Backend}
+     */
     backend: Backend;
-    nodes: Nodes;
+    /**
+     * Renderer component for managing nodes related logic.
+     *
+     * @type {Nodes}
+     */
+    nodes: NodeManager;
+    /**
+     * A references to the bindings management component.
+     * This reference will be set inside the `Bindings`
+     * constructor.
+     *
+     * @type {?Bindings}
+     * @default null
+     */
     bindings: Bindings | null;
+    /**
+     * Internal cache for maintaining pipelines.
+     * The key of the map is a cache key, the value the pipeline.
+     *
+     * @type {Map<string,Pipeline>}
+     */
     caches: Map<string, Pipeline>;
+    /**
+     * This dictionary maintains for each shader stage type (vertex,
+     * fragment and compute) the programmable stage objects which
+     * represent the actual shader code.
+     *
+     * @type {Object<string,Map<string, ProgrammableStage>>}
+     */
     programs: {
         vertex: Map<string, ProgrammableStage>;
         fragment: Map<string, ProgrammableStage>;
         compute: Map<string, ProgrammableStage>;
     };
-    /**
-     * Constructs a new pipeline management component.
-     *
-     * @param {Backend} backend - The renderer's backend.
-     * @param {Nodes} nodes - Renderer component for managing nodes related logic.
-     */
-    constructor(backend: Backend, nodes: Nodes);
     /**
      * Returns a compute pipeline for the given compute node.
      *
@@ -55,26 +71,22 @@ declare class Pipelines extends DataMap<{
      * @param {Array<BindGroup>} bindings - The bindings.
      * @return {ComputePipeline} The compute pipeline.
      */
-    getForCompute(computeNode: ComputeNode, bindings: Binding[]): ComputePipeline;
+    getForCompute(computeNode: ComputeNode, bindings: BindGroup[]): ComputePipeline;
     /**
      * Returns a render pipeline for the given render object.
      *
      * @param {RenderObject} renderObject - The render object.
      * @param {?Array<Promise>} [promises=null] - An array of compilation promises which is only relevant in context of `Renderer.compileAsync()`.
-     * @return {RenderPipeline} The render pipeline.
+     * @return {RenderObjectPipeline} The render pipeline.
      */
-    getForRender(renderObject: RenderObject, promises?: Promise<void>[] | null): RenderPipeline;
+    getForRender(renderObject: RenderObject, promises?: Promise<void>[] | null): RenderObjectPipeline;
     /**
      * Deletes the pipeline for the given render object.
      *
      * @param {RenderObject} object - The render object.
      * @return {?Object} The deleted dictionary.
      */
-    delete(object: ComputeNode | RenderObject): never;
-    /**
-     * Frees internal resources.
-     */
-    dispose(): void;
+    delete(object: RenderObject): unknown;
     /**
      * Updates the pipeline for the given render object.
      *
@@ -91,12 +103,7 @@ declare class Pipelines extends DataMap<{
      * @param {Array<BindGroup>} bindings - The bindings.
      * @return {ComputePipeline} The compute pipeline.
      */
-    _getComputePipeline(
-        computeNode: ComputeNode,
-        stageCompute: ProgrammableStage,
-        cacheKey: string,
-        bindings: Binding[],
-    ): ComputePipeline;
+    private _getComputePipeline;
     /**
      * Returns a render pipeline for the given parameters.
      *
@@ -106,15 +113,9 @@ declare class Pipelines extends DataMap<{
      * @param {ProgrammableStage} stageFragment - The programmable stage representing the fragment shader.
      * @param {string} cacheKey - The cache key.
      * @param {?Array<Promise>} promises - An array of compilation promises which is only relevant in context of `Renderer.compileAsync()`.
-     * @return {ComputePipeline} The compute pipeline.
+     * @return {RenderObjectPipeline} The render pipeline.
      */
-    _getRenderPipeline(
-        renderObject: RenderObject,
-        stageVertex: ProgrammableStage,
-        stageFragment: ProgrammableStage,
-        cacheKey: string,
-        promises: Promise<void>[] | null,
-    ): RenderPipeline;
+    private _getRenderPipeline;
     /**
      * Computes a cache key representing a compute pipeline.
      *
@@ -123,7 +124,7 @@ declare class Pipelines extends DataMap<{
      * @param {ProgrammableStage} stageCompute - The programmable stage representing the compute shader.
      * @return {string} The cache key.
      */
-    _getComputeCacheKey(computeNode: ComputeNode, stageCompute: ProgrammableStage): string;
+    private _getComputeCacheKey;
     /**
      * Computes a cache key representing a render pipeline.
      *
@@ -133,25 +134,21 @@ declare class Pipelines extends DataMap<{
      * @param {ProgrammableStage} stageFragment - The programmable stage representing the fragment shader.
      * @return {string} The cache key.
      */
-    _getRenderCacheKey(
-        renderObject: RenderObject,
-        stageVertex: ProgrammableStage,
-        stageFragment: ProgrammableStage,
-    ): string;
+    private _getRenderCacheKey;
     /**
      * Releases the given pipeline.
      *
      * @private
      * @param {Pipeline} pipeline - The pipeline to release.
      */
-    _releasePipeline(pipeline: Pipeline): void;
+    private _releasePipeline;
     /**
      * Releases the shader program.
      *
      * @private
      * @param {Object} program - The shader program to release.
      */
-    _releaseProgram(program: ProgrammableStage): void;
+    private _releaseProgram;
     /**
      * Returns `true` if the compute pipeline for the given compute node requires an update.
      *
@@ -159,7 +156,7 @@ declare class Pipelines extends DataMap<{
      * @param {Node} computeNode - The compute node.
      * @return {boolean} Whether the compute pipeline for the given compute node requires an update or not.
      */
-    _needsComputeUpdate(computeNode: ComputeNode): boolean;
+    private _needsComputeUpdate;
     /**
      * Returns `true` if the render pipeline for the given render object requires an update.
      *
@@ -167,6 +164,7 @@ declare class Pipelines extends DataMap<{
      * @param {RenderObject} renderObject - The render object.
      * @return {boolean} Whether the render object for the given render object requires an update or not.
      */
-    _needsRenderUpdate(renderObject: RenderObject): true | void;
+    private _needsRenderUpdate;
 }
+
 export default Pipelines;

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

@@ -1,24 +1,21 @@
 import { Node } from "../../nodes/Nodes.js";
 import Renderer from "./Renderer.js";
-
-declare class PostProcessing {
-    renderer: Renderer;
-    outputNode: Node;
-
-    outputColorTransform: boolean;
-
-    needsUpdate: boolean;
-
-    constructor(renderer: Renderer, outputNode?: Node);
-
-    render(): void;
-
-    dispose(): void;
-
+import RenderPipeline from "./RenderPipeline.js";
+
+/**
+ * @deprecated Use {@link RenderPipeline} instead. PostProcessing has been renamed to RenderPipeline.
+ *
+ * This class is a wrapper for backward compatibility and will be removed in a future version.
+ */
+declare class PostProcessing extends RenderPipeline {
     /**
-     * @deprecated "renderAsync()" has been deprecated. Use "render()" and "await renderer.init();" when creating the renderer.
+     * Constructs a new post processing management module.
+     *
+     * @param {Renderer} renderer - A reference to the renderer.
+     * @param {Node<vec4>} outputNode - An optional output node.
+     * @deprecated since r183. Use {@link RenderPipeline} instead.
      */
-    renderAsync(): Promise<void>;
+    constructor(renderer: Renderer, outputNode?: Node);
 }
 
 export default PostProcessing;

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

@@ -1,4 +1,5 @@
 import NodeAttribute from "../../nodes/core/NodeAttribute.js";
+
 /**
  * Class for representing programmable stages which are vertex,
  * fragment or compute shaders. Unlike fixed-function states (like blending),
@@ -7,12 +8,6 @@ import NodeAttribute from "../../nodes/core/NodeAttribute.js";
  * @private
  */
 declare class ProgrammableStage {
-    id: number;
-    code: string;
-    stage: "compute" | "vertex" | "fragment";
-    name: string;
-    attributes: NodeAttribute[] | null;
-    usedTimes: number;
     /**
      * Constructs a new programmable stage.
      *
@@ -24,10 +19,55 @@ declare class ProgrammableStage {
      */
     constructor(
         code: string,
-        stage: "compute" | "vertex" | "fragment",
+        stage: "vertex" | "fragment" | "compute",
         name: string,
-        transforms?: null,
+        transforms?: unknown[] | null,
         attributes?: NodeAttribute[] | null,
     );
+    /**
+     * The id of the programmable stage.
+     *
+     * @type {number}
+     */
+    id: number;
+    /**
+     * The shader code.
+     *
+     * @type {string}
+     */
+    code: string;
+    /**
+     * The type of stage.
+     *
+     * @type {string}
+     */
+    stage: "vertex" | "fragment" | "compute";
+    /**
+     * The name of the stage.
+     * This is used for debugging purposes.
+     *
+     * @type {string}
+     */
+    name: string;
+    /**
+     * The transforms (only relevant for compute stages with WebGL 2 which uses Transform Feedback).
+     *
+     * @type {?Array<Object>}
+     */
+    transforms: unknown[] | null;
+    /**
+     * The attributes (only relevant for compute stages with WebGL 2 which uses Transform Feedback).
+     *
+     * @type {?Array<Object>}
+     */
+    attributes: NodeAttribute[] | null;
+    /**
+     * How often the programmable stage is currently in use.
+     *
+     * @type {number}
+     * @default 0
+     */
+    usedTimes: number;
 }
+
 export default ProgrammableStage;

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

@@ -1,5 +1,6 @@
 import { Camera } from "../../cameras/Camera.js";
 import BundleGroup from "./BundleGroup.js";
+
 /**
  * This module is used to represent render bundles inside the renderer
  * for further processing.
@@ -7,8 +8,6 @@ import BundleGroup from "./BundleGroup.js";
  * @private
  */
 declare class RenderBundle {
-    bundleGroup: BundleGroup;
-    camera: Camera;
     /**
      * Constructs a new bundle group.
      *
@@ -16,5 +15,8 @@ declare class RenderBundle {
      * @param {Camera} camera - The camera the bundle group is rendered with.
      */
     constructor(bundleGroup: BundleGroup, camera: Camera);
+    bundleGroup: BundleGroup;
+    camera: Camera;
 }
+
 export default RenderBundle;