@types/three 0.182.0 → 0.183.1

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

@@ -2,21 +2,21 @@ import { Camera } from "../../cameras/Camera.js";
 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 { Object3D } from "../../core/Object3D.js";
 import { Material } from "../../materials/Material.js";
 import NodeMaterialObserver from "../../materials/nodes/manager/NodeMaterialObserver.js";
-import { LightsNode } from "../../nodes/Nodes.js";
+import LightsNode from "../../nodes/lighting/LightsNode.js";
 import { Scene } from "../../scenes/Scene.js";
 import BindGroup from "./BindGroup.js";
 import BundleGroup from "./BundleGroup.js";
 import ClippingContext from "./ClippingContext.js";
 import Geometries from "./Geometries.js";
 import NodeBuilderState from "./nodes/NodeBuilderState.js";
-import Nodes from "./nodes/Nodes.js";
+import NodeManager from "./nodes/NodeManager.js";
 import RenderContext from "./RenderContext.js";
 import Renderer from "./Renderer.js";
 import RenderPipeline from "./RenderPipeline.js";
+
 /**
  * A render object is the renderer's representation of single entity that gets drawn
  * with a draw command. There is no unique mapping of render objects to 3D objects in the
@@ -36,76 +36,256 @@ import RenderPipeline from "./RenderPipeline.js";
  * @private
  */
 declare class RenderObject {
-    _nodes: Nodes;
-    _geometries: Geometries;
+    /**
+     * Constructs a new render object.
+     *
+     * @param {Nodes} nodes - Renderer component for managing nodes related logic.
+     * @param {Geometries} geometries - Renderer component for managing geometries.
+     * @param {Renderer} renderer - The renderer.
+     * @param {Object3D} object - The 3D object.
+     * @param {Material} material - The 3D object's material.
+     * @param {Scene} scene - The scene the 3D object belongs to.
+     * @param {Camera} camera - The camera the object should be rendered with.
+     * @param {LightsNode} lightsNode - The lights node.
+     * @param {RenderContext} renderContext - The render context.
+     * @param {ClippingContext} clippingContext - The clipping context.
+     */
+    constructor(
+        nodes: NodeManager,
+        geometries: Geometries,
+        renderer: Renderer,
+        object: Object3D,
+        material: Material,
+        scene: Scene,
+        camera: Camera,
+        lightsNode: LightsNode,
+        renderContext: RenderContext,
+        clippingContext: ClippingContext,
+    );
     id: number;
+    /**
+     * Renderer component for managing nodes related logic.
+     *
+     * @type {Nodes}
+     * @private
+     */
+    private _nodes;
+    /**
+     * Renderer component for managing geometries.
+     *
+     * @type {Geometries}
+     * @private
+     */
+    private _geometries;
+    /**
+     * The renderer.
+     *
+     * @type {Renderer}
+     */
     renderer: Renderer;
+    /**
+     * The 3D object.
+     *
+     * @type {Object3D}
+     */
     object: Object3D;
+    /**
+     * The 3D object's material.
+     *
+     * @type {Material}
+     */
     material: Material;
+    /**
+     * The scene the 3D object belongs to.
+     *
+     * @type {Scene}
+     */
     scene: Scene;
+    /**
+     * The camera the 3D object should be rendered with.
+     *
+     * @type {Camera}
+     */
     camera: Camera;
+    /**
+     * The lights node.
+     *
+     * @type {LightsNode}
+     */
     lightsNode: LightsNode;
+    /**
+     * The render context.
+     *
+     * @type {RenderContext}
+     */
     context: RenderContext;
+    /**
+     * The 3D object's geometry.
+     *
+     * @type {BufferGeometry}
+     */
     geometry: BufferGeometry;
+    /**
+     * The render object's version.
+     *
+     * @type {number}
+     */
     version: number;
+    /**
+     * The draw range of the geometry.
+     *
+     * @type {?Object}
+     * @default null
+     */
     drawRange: {
         start: number;
         count: number;
     } | null;
-    attributes: Array<BufferAttribute | InterleavedBufferAttribute> | null;
+    /**
+     * An array holding the buffer attributes
+     * of the render object. This entails attribute
+     * definitions on geometry and node level.
+     *
+     * @type {?Array<BufferAttribute>}
+     * @default null
+     */
+    attributes: BufferAttribute[] | null;
+    /**
+     * An object holding the version of the
+     * attributes. The keys are the attribute names
+     * and the values are the attribute versions.
+     *
+     * @type {?Object<string, number>}
+     * @default null
+     */
     attributesId: {
-        [attributeName: string]: number;
+        [x: string]: number;
     } | null;
-    pipeline: RenderPipeline | null;
+    /**
+     * A reference to a render pipeline the render
+     * object is processed with.
+     *
+     * @type {RenderPipeline}
+     * @default null
+     */
+    pipeline: RenderPipeline;
+    /**
+     * Only relevant for objects using
+     * multiple materials. This represents a group entry
+     * from the respective `BufferGeometry`.
+     *
+     * @type {?{start: number, count: number}}
+     * @default null
+     */
     group: {
         start: number;
         count: number;
     } | null;
+    /**
+     * An array holding the vertex buffers which can
+     * be buffer attributes but also interleaved buffers.
+     *
+     * @type {?Array<BufferAttribute|InterleavedBuffer>}
+     * @default null
+     */
     vertexBuffers: Array<BufferAttribute | InterleavedBuffer> | null;
+    /**
+     * The parameters for the draw command.
+     *
+     * @type {?Object}
+     * @default null
+     */
     drawParams: {
         vertexCount: number;
         firstVertex: number;
         instanceCount: number;
         firstInstance: number;
     } | null;
+    /**
+     * If this render object is used inside a render bundle,
+     * this property points to the respective bundle group.
+     *
+     * @type {?BundleGroup}
+     * @default null
+     */
     bundle: BundleGroup | null;
-    clippingContext: ClippingContext | null;
+    /**
+     * The clipping context.
+     *
+     * @type {ClippingContext}
+     */
+    clippingContext: ClippingContext;
+    /**
+     * The clipping context's cache key.
+     *
+     * @type {string}
+     */
     clippingContextCacheKey: string;
+    /**
+     * The initial node cache key.
+     *
+     * @type {number}
+     */
     initialNodesCacheKey: number;
+    /**
+     * The initial cache key.
+     *
+     * @type {number}
+     */
     initialCacheKey: number;
-    _nodeBuilderState: NodeBuilderState | null;
-    _bindings: BindGroup[] | null;
-    _monitor: NodeMaterialObserver | null;
+    /**
+     * The node builder state.
+     *
+     * @type {?NodeBuilderState}
+     * @private
+     * @default null
+     */
+    private _nodeBuilderState;
+    /**
+     * An array of bindings.
+     *
+     * @type {?Array<BindGroup>}
+     * @private
+     * @default null
+     */
+    private _bindings;
+    /**
+     * Reference to the node material observer.
+     *
+     * @type {?NodeMaterialObserver}
+     * @private
+     * @default null
+     */
+    private _monitor;
+    /**
+     * An event listener which is defined by `RenderObjects`. It performs
+     * clean up tasks when `dispose()` on this render object.
+     *
+     * @method
+     */
     onDispose: (() => void) | null;
-    readonly isRenderObject: true;
+    /**
+     * This flag can be used for type testing.
+     *
+     * @type {boolean}
+     * @readonly
+     * @default true
+     */
+    readonly isRenderObject: boolean;
+    /**
+     * An event listener which is executed when `dispose()` is called on
+     * the material of this render object.
+     *
+     * @method
+     */
     onMaterialDispose: () => void;
-    onGeometryDispose: () => void;
     /**
-     * Constructs a new render object.
+     * An event listener which is executed when `dispose()` is called on
+     * the geometry of this render object.
      *
-     * @param {Nodes} nodes - Renderer component for managing nodes related logic.
-     * @param {Geometries} geometries - Renderer component for managing geometries.
-     * @param {Renderer} renderer - The renderer.
-     * @param {Object3D} object - The 3D object.
-     * @param {Material} material - The 3D object's material.
-     * @param {Scene} scene - The scene the 3D object belongs to.
-     * @param {Camera} camera - The camera the object should be rendered with.
-     * @param {LightsNode} lightsNode - The lights node.
-     * @param {RenderContext} renderContext - The render context.
-     * @param {ClippingContext} clippingContext - The clipping context.
+     * @method
      */
-    constructor(
-        nodes: Nodes,
-        geometries: Geometries,
-        renderer: Renderer,
-        object: Object3D,
-        material: Material,
-        scene: Scene,
-        camera: Camera,
-        lightsNode: LightsNode,
-        renderContext: RenderContext,
-        clippingContext: ClippingContext | null,
-    );
+    onGeometryDispose: () => void;
     /**
      * Updates the clipping context.
      *
@@ -150,7 +330,7 @@ declare class RenderObject {
      * @param {string} name - The name of the binding group.
      * @return {?BindGroup} The bindings.
      */
-    getBindingGroup(name: string): BindGroup | undefined;
+    getBindingGroup(name: string): BindGroup | null;
     /**
      * Returns the index of the render object's geometry.
      *
@@ -162,7 +342,7 @@ declare class RenderObject {
      *
      * @return {?BufferAttribute} The indirect attribute. `null` if no indirect drawing is used.
      */
-    getIndirect(): import("./IndirectStorageBufferAttribute.js").default | null;
+    getIndirect(): BufferAttribute | null;
     /**
      * Returns the byte offset into the indirect attribute buffer.
      *
@@ -174,12 +354,7 @@ declare class RenderObject {
      *
      * @return {Array<Object>} An array with object references.
      */
-    getChainArray(): readonly [
-        Object3D<import("../../core/Object3D.js").Object3DEventMap>,
-        Material,
-        RenderContext,
-        LightsNode,
-    ];
+    getChainArray(): unknown[];
     /**
      * This method is used when the geometry of a 3D object has been exchanged and the
      * respective render object now requires an update.
@@ -193,13 +368,13 @@ declare class RenderObject {
      *
      * @return {Array<BufferAttribute>} An array with buffer attributes.
      */
-    getAttributes(): (BufferAttribute | InterleavedBufferAttribute)[];
+    getAttributes(): BufferAttribute[];
     /**
      * Returns the vertex buffers of the render object.
      *
      * @return {Array<BufferAttribute|InterleavedBuffer>} An array with buffer attribute or interleaved buffers.
      */
-    getVertexBuffers(): (BufferAttribute | InterleavedBuffer)[] | null;
+    getVertexBuffers(): Array<BufferAttribute | InterleavedBuffer>;
     /**
      * Returns the draw parameters for the render object.
      *
@@ -269,4 +444,5 @@ declare class RenderObject {
      */
     dispose(): void;
 }
+
 export default RenderObject;

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

@@ -0,0 +1,33 @@
+import Pipeline from "./Pipeline.js";
+import ProgrammableStage from "./ProgrammableStage.js";
+
+/**
+ * Class for representing render pipelines.
+ *
+ * @private
+ * @augments Pipeline
+ */
+declare class RenderObjectPipeline extends Pipeline {
+    /**
+     * Constructs a new render object pipeline.
+     *
+     * @param {string} cacheKey - The pipeline's cache key.
+     * @param {ProgrammableStage} vertexProgram - The pipeline's vertex shader.
+     * @param {ProgrammableStage} fragmentProgram - The pipeline's fragment shader.
+     */
+    constructor(cacheKey: string, vertexProgram: ProgrammableStage, fragmentProgram: ProgrammableStage);
+    /**
+     * The pipeline's vertex shader.
+     *
+     * @type {ProgrammableStage}
+     */
+    vertexProgram: ProgrammableStage;
+    /**
+     * The pipeline's fragment shader.
+     *
+     * @type {ProgrammableStage}
+     */
+    fragmentProgram: ProgrammableStage;
+}
+
+export default RenderObjectPipeline;

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

@@ -8,26 +8,18 @@ import ChainMap from "./ChainMap.js";
 import ClippingContext from "./ClippingContext.js";
 import Geometries from "./Geometries.js";
 import Info from "./Info.js";
-import Nodes from "./nodes/Nodes.js";
+import NodeManager from "./nodes/NodeManager.js";
 import Pipelines from "./Pipelines.js";
 import RenderContext from "./RenderContext.js";
 import Renderer from "./Renderer.js";
 import RenderObject from "./RenderObject.js";
+
 /**
  * This module manages the render objects of the renderer.
  *
  * @private
  */
 declare class RenderObjects {
-    renderer: Renderer;
-    nodes: Nodes;
-    geometries: Geometries;
-    pipelines: Pipelines;
-    bindings: Bindings;
-    info: Info;
-    chainMaps: {
-        [passId: string]: ChainMap<readonly [Object3D, Material, RenderContext, LightsNode], RenderObject>;
-    };
     /**
      * Constructs a new render object management component.
      *
@@ -40,12 +32,57 @@ declare class RenderObjects {
      */
     constructor(
         renderer: Renderer,
-        nodes: Nodes,
+        nodes: NodeManager,
         geometries: Geometries,
         pipelines: Pipelines,
         bindings: Bindings,
         info: Info,
     );
+    /**
+     * The renderer.
+     *
+     * @type {Renderer}
+     */
+    renderer: Renderer;
+    /**
+     * Renderer component for managing nodes related logic.
+     *
+     * @type {Nodes}
+     */
+    nodes: NodeManager;
+    /**
+     * Renderer component for managing geometries.
+     *
+     * @type {Geometries}
+     */
+    geometries: Geometries;
+    /**
+     * Renderer component for managing pipelines.
+     *
+     * @type {Pipelines}
+     */
+    pipelines: Pipelines;
+    /**
+     * Renderer component for managing bindings.
+     *
+     * @type {Bindings}
+     */
+    bindings: Bindings;
+    /**
+     * Renderer component for managing metrics and monitoring data.
+     *
+     * @type {Info}
+     */
+    info: Info;
+    /**
+     * A dictionary that manages render contexts in chain maps
+     * for each pass ID.
+     *
+     * @type {Object<string,ChainMap>}
+     */
+    chainMaps: {
+        [x: string]: ChainMap;
+    };
     /**
      * Returns a render object for the given object and state data.
      *
@@ -66,8 +103,8 @@ declare class RenderObjects {
         camera: Camera,
         lightsNode: LightsNode,
         renderContext: RenderContext,
-        clippingContext: ClippingContext | null,
-        passId?: string | undefined,
+        clippingContext: ClippingContext,
+        passId?: string,
     ): RenderObject;
     /**
      * Returns a chain map for the given pass ID.
@@ -75,12 +112,7 @@ declare class RenderObjects {
      * @param {string} [passId='default'] - The pass ID.
      * @return {ChainMap} The chain map.
      */
-    getChainMap(
-        passId?: string,
-    ): ChainMap<
-        readonly [Object3D<import("../../core/Object3D.js").Object3DEventMap>, Material, RenderContext, LightsNode],
-        RenderObject
-    >;
+    getChainMap(passId?: string): ChainMap;
     /**
      * Frees internal resources.
      */
@@ -102,7 +134,7 @@ declare class RenderObjects {
      * @return {RenderObject} The render object.
      */
     createRenderObject(
-        nodes: Nodes,
+        nodes: NodeManager,
         geometries: Geometries,
         renderer: Renderer,
         object: Object3D,
@@ -111,8 +143,9 @@ declare class RenderObjects {
         camera: Camera,
         lightsNode: LightsNode,
         renderContext: RenderContext,
-        clippingContext: ClippingContext | null,
-        passId: string | undefined,
+        clippingContext: ClippingContext,
+        passId?: string,
     ): RenderObject;
 }
+
 export default RenderObjects;

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

@@ -1,21 +1,24 @@
-import Pipeline from "./Pipeline.js";
-import ProgrammableStage from "./ProgrammableStage.js";
-/**
- * Class for representing render pipelines.
- *
- * @private
- * @augments Pipeline
- */
-declare class RenderPipeline extends Pipeline {
-    vertexProgram: ProgrammableStage;
-    fragmentProgram: ProgrammableStage;
+import { Node } from "../../nodes/Nodes.js";
+import Renderer from "./Renderer.js";
+
+declare class RenderPipeline {
+    renderer: Renderer;
+    outputNode: Node;
+
+    outputColorTransform: boolean;
+
+    needsUpdate: boolean;
+
+    constructor(renderer: Renderer, outputNode?: Node);
+
+    render(): void;
+
+    dispose(): void;
+
     /**
-     * Constructs a new render pipeline.
-     *
-     * @param {string} cacheKey - The pipeline's cache key.
-     * @param {ProgrammableStage} vertexProgram - The pipeline's vertex shader.
-     * @param {ProgrammableStage} fragmentProgram - The pipeline's fragment shader.
+     * @deprecated "renderAsync()" has been deprecated. Use "render()" and "await renderer.init();" when creating the renderer.
      */
-    constructor(cacheKey: string, vertexProgram: ProgrammableStage, fragmentProgram: ProgrammableStage);
+    renderAsync(): Promise<void>;
 }
+
 export default RenderPipeline;