@types/three 0.182.0 → 0.183.1

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

@@ -1,4 +1,5 @@
 import { Group } from "../../objects/Group.js";
+
 /**
  * A specialized group which enables applications access to the
  * Render Bundle API of WebGPU. The group with all its descendant nodes
@@ -12,14 +13,22 @@ import { Group } from "../../objects/Group.js";
  * @augments Group
  */
 declare class BundleGroup extends Group {
-    readonly isBundleGroup: true;
-    readonly type: string;
-    static: boolean;
-    version: number;
     /**
-     * Constructs a new bundle group.
+     * This flag can be used for type testing.
+     *
+     * @type {boolean}
+     * @readonly
+     * @default true
+     */
+    readonly isBundleGroup: boolean;
+    /**
+     * The bundle group's version.
+     *
+     * @type {number}
+     * @readonly
+     * @default 0
      */
-    constructor();
+    readonly version: number;
     /**
      * Set this property to `true` when the bundle group has changed.
      *
@@ -29,4 +38,5 @@ declare class BundleGroup extends Group {
      */
     set needsUpdate(value: boolean);
 }
+
 export default BundleGroup;

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

@@ -3,31 +3,87 @@ import { Vector2 } from "../../math/Vector2.js";
 import { Vector4 } from "../../math/Vector4.js";
 import { DepthTexture } from "../../textures/DepthTexture.js";
 import { FramebufferTexture } from "../../textures/FramebufferTexture.js";
+
 export interface CanvasTargetEventMap {
     resize: {};
     dispose: {};
 }
+
 /**
  * CanvasTarget is a class that represents the final output destination of the renderer.
  *
  * @augments EventDispatcher
  */
 declare class CanvasTarget extends EventDispatcher<CanvasTargetEventMap> {
-    domElement: HTMLCanvasElement;
-    _pixelRatio: number;
-    _width: number;
-    _height: number;
-    _viewport: Vector4;
-    _scissor: Vector4;
-    _scissorTest: boolean;
-    colorTexture: FramebufferTexture;
-    depthTexture: DepthTexture;
     /**
      * Constructs a new CanvasTarget.
      *
      * @param {HTMLCanvasElement|OffscreenCanvas} domElement - The canvas element to render to.
      */
-    constructor(domElement: HTMLCanvasElement);
+    constructor(domElement: HTMLCanvasElement | OffscreenCanvas);
+    /**
+     * A reference to the canvas element the renderer is drawing to.
+     * This value of this property will automatically be created by
+     * the renderer.
+     *
+     * @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.
+     *
+     * @type {FramebufferTexture}
+     */
+    colorTexture: FramebufferTexture;
+    /**
+     * The depth texture of the default framebuffer.
+     *
+     * @type {DepthTexture}
+     */
+    depthTexture: DepthTexture;
     /**
      * Returns the pixel ratio.
      *
@@ -83,6 +139,10 @@ declare class CanvasTarget extends EventDispatcher<CanvasTargetEventMap> {
      * @return {Vector4} The scissor rectangle.
      */
     getScissor(target: Vector4): Vector4;
+    /**
+     * Defines the scissor rectangle.
+     */
+    setScissor(x: Vector4): void;
     /**
      * Defines the scissor rectangle.
      *
@@ -92,7 +152,6 @@ declare class CanvasTarget extends EventDispatcher<CanvasTargetEventMap> {
      * @param {number} width - The width of the scissor box in logical pixel unit.
      * @param {number} height - The height of the scissor box in logical pixel unit.
      */
-    setScissor(x: Vector4): void;
     setScissor(x: number, y: number, width: number, height: number): void;
     /**
      * Returns the scissor test value.
@@ -113,6 +172,10 @@ declare class CanvasTarget extends EventDispatcher<CanvasTargetEventMap> {
      * @return {Vector4} The viewport definition.
      */
     getViewport(target: Vector4): Vector4;
+    /**
+     * Defines the viewport.
+     */
+    setViewport(x: Vector4): void;
     /**
      * Defines the viewport.
      *
@@ -123,14 +186,13 @@ declare class CanvasTarget extends EventDispatcher<CanvasTargetEventMap> {
      * @param {number} minDepth - The minimum depth value of the viewport. WebGPU only.
      * @param {number} maxDepth - The maximum depth value of the viewport. WebGPU only.
      */
-    setViewport(x: Vector4): void;
     setViewport(x: number, y: number, width: number, height: number, minDepth?: number, maxDepth?: number): void;
     /**
      * Dispatches the resize event.
      *
      * @private
      */
-    _dispatchResize(): void;
+    private _dispatchResize;
     /**
      * Frees the GPU-related resources allocated by this instance. Call this
      * method whenever this instance is no longer used in your app.
@@ -139,4 +201,5 @@ declare class CanvasTarget extends EventDispatcher<CanvasTargetEventMap> {
      */
     dispose(): void;
 }
+
 export default CanvasTarget;

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

@@ -1,4 +1,3 @@
-type RecursiveWeakMap<K extends readonly object[], V> = WeakMap<K[number], V | RecursiveWeakMap<K, V>>;
 /**
  * Data structure for the renderer. It allows defining values
  * with chained, hierarchical keys. Keys are meant to be
@@ -7,26 +6,29 @@ type RecursiveWeakMap<K extends readonly object[], V> = WeakMap<K[number], V | R
  *
  * @private
  */
-declare class ChainMap<K extends readonly object[], V> {
-    weakMaps: Record<number, RecursiveWeakMap<K, V>>;
+declare class ChainMap {
     /**
-     * Constructs a new Chain Map.
+     * A map of Weak Maps by their key length.
+     *
+     * @type {Object<number, WeakMap>}
      */
-    constructor();
+    weakMaps: {
+        [x: number]: WeakMap<object, unknown>;
+    };
     /**
      * Returns the Weak Map for the given keys.
      *
      * @param {Array<Object>} keys - List of keys.
      * @return {WeakMap} The weak map.
      */
-    _getWeakMap(keys: K): RecursiveWeakMap<K, V>;
+    _getWeakMap(keys: object[]): WeakMap<object, unknown>;
     /**
      * Returns the value for the given array of keys.
      *
      * @param {Array<Object>} keys - List of keys.
      * @return {any} The value. Returns `undefined` if no value was found.
      */
-    get(keys: K): V | undefined;
+    get(keys: object[]): unknown;
     /**
      * Sets the value for the given keys.
      *
@@ -34,13 +36,14 @@ declare class ChainMap<K extends readonly object[], V> {
      * @param {any} value - The value to set.
      * @return {ChainMap} A reference to this Chain Map.
      */
-    set(keys: K, value: V): this;
+    set(keys: object[], value: unknown): ChainMap;
     /**
      * Deletes a value for the given keys.
      *
      * @param {Array<Object>} keys - The keys.
      * @return {boolean} Returns `true` if the value has been removed successfully and `false` if the value has not be found.
      */
-    delete(keys: K): boolean;
+    delete(keys: object[]): boolean;
 }
+
 export default ChainMap;

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

@@ -5,6 +5,7 @@ import { Plane } from "../../math/Plane.js";
 import { Vector4 } from "../../math/Vector4.js";
 import { ClippingGroup } from "../../objects/ClippingGroup.js";
 import { Scene } from "../../scenes/Scene.js";
+
 /**
  * Represents the state that is used to perform clipping via clipping planes.
  * There is a default clipping context for each render context. When the
@@ -14,22 +15,71 @@ import { Scene } from "../../scenes/Scene.js";
  * @private
  */
 declare class ClippingContext {
-    version: number;
+    /**
+     * Constructs a new clipping context.
+     *
+     * @param {?ClippingContext} [parentContext=null] - A reference to the parent clipping context.
+     */
+    constructor(parentContext?: ClippingContext | null);
+    /**
+     * The clipping context's version.
+     *
+     * @type {number}
+     * @readonly
+     */
+    readonly version: number;
+    /**
+     * Whether the intersection of the clipping planes is used to clip objects, rather than their union.
+     *
+     * @type {?boolean}
+     * @default null
+     */
     clipIntersection: boolean | null;
+    /**
+     * The clipping context's cache key.
+     *
+     * @type {string}
+     */
     cacheKey: string;
-    intersectionPlanes?: Plane[];
-    unionPlanes?: Plane[];
+    /**
+     * Whether the shadow pass is active or not.
+     *
+     * @type {boolean}
+     * @default false
+     */
+    shadowPass: boolean;
+    /**
+     * The view normal matrix.
+     *
+     * @type {Matrix3}
+     */
     viewNormalMatrix: Matrix3;
+    /**
+     * Internal cache for maintaining clipping contexts.
+     *
+     * @type {WeakMap<ClippingGroup,ClippingContext>}
+     */
     clippingGroupContexts: WeakMap<ClippingGroup, ClippingContext>;
-    shadowPass: boolean;
-    viewMatrix?: Matrix4;
-    parentVersion: number | null;
     /**
-     * Constructs a new clipping context.
+     * The intersection planes.
      *
-     * @param {?ClippingContext} [parentContext=null] - A reference to the parent clipping context.
+     * @type {Array<Vector4>}
      */
-    constructor(parentContext?: ClippingContext | null);
+    intersectionPlanes: Vector4[];
+    /**
+     * The intersection planes.
+     *
+     * @type {Array<Vector4>}
+     */
+    unionPlanes: Vector4[];
+    /**
+     * The version of the clipping context's parent context.
+     *
+     * @type {?number}
+     * @readonly
+     */
+    readonly parentVersion: number | null;
+    viewMatrix?: Matrix4;
     /**
      * Projects the given source clipping planes and writes the result into the
      * destination array.
@@ -38,7 +88,7 @@ declare class ClippingContext {
      * @param {Array<Vector4>} destination - The destination.
      * @param {number} offset - The offset.
      */
-    projectPlanes(source: readonly Plane[], destination: readonly Vector4[], offset: number): void;
+    projectPlanes(source: Plane[], destination: Vector4[], offset: number): void;
     /**
      * Updates the root clipping context of a scene.
      *
@@ -68,4 +118,5 @@ declare class ClippingContext {
      */
     get unionClippingCount(): number;
 }
+
 export default ClippingContext;

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

@@ -1,4 +1,5 @@
 import { Color, ColorRepresentation } from "../../math/Color.js";
+
 /**
  * A four-component version of {@link Color} which is internally
  * used by the renderer to represents clear color with alpha as
@@ -8,19 +9,22 @@ import { Color, ColorRepresentation } from "../../math/Color.js";
  * @augments Color
  */
 declare class Color4 extends Color {
-    a: number;
     /**
      * Constructs a new four-component color.
-     * You can also pass a single THREE.Color, hex or
+     * You can pass a single THREE.Color, hex or
      * string argument to this constructor.
+     */
+    constructor(color?: ColorRepresentation);
+    /**
+     * Constructs a new four-component color.
      *
-     * @param {number|string} [r=1] - The red value.
+     * @param {number} [r=1] - The red value.
      * @param {number} [g=1] - The green value.
      * @param {number} [b=1] - The blue value.
      * @param {number} [a=1] - The alpha value.
      */
-    constructor(color?: ColorRepresentation);
     constructor(r: number, g: number, b: number, a?: number);
+    a: number;
     /**
      * Overwrites the default to honor alpha.
      * You can also pass a single THREE.Color, hex or
@@ -39,7 +43,7 @@ declare class Color4 extends Color {
      * @param {Color4} color - The color to copy.
      * @return {Color4} A reference to this object.
      */
-    copy(color: Color): this;
+    copy(color: Color4): this;
     /**
      * Overwrites the default to honor alpha.
      *
@@ -47,4 +51,5 @@ declare class Color4 extends Color {
      */
     clone(): this;
 }
+
 export default Color4;

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

@@ -1,5 +1,6 @@
 import Pipeline from "./Pipeline.js";
 import ProgrammableStage from "./ProgrammableStage.js";
+
 /**
  * Class for representing compute pipelines.
  *
@@ -7,8 +8,6 @@ import ProgrammableStage from "./ProgrammableStage.js";
  * @augments Pipeline
  */
 declare class ComputePipeline extends Pipeline {
-    computeProgram: ProgrammableStage;
-    readonly isComputePipeline: true;
     /**
      * Constructs a new render pipeline.
      *
@@ -16,5 +15,20 @@ declare class ComputePipeline extends Pipeline {
      * @param {ProgrammableStage} computeProgram - The pipeline's compute shader.
      */
     constructor(cacheKey: string, computeProgram: ProgrammableStage);
+    /**
+     * The pipeline's compute shader.
+     *
+     * @type {ProgrammableStage}
+     */
+    computeProgram: ProgrammableStage;
+    /**
+     * This flag can be used for type testing.
+     *
+     * @type {boolean}
+     * @readonly
+     * @default true
+     */
+    readonly isComputePipeline: boolean;
 }
+
 export default ComputePipeline;

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

@@ -5,6 +5,8 @@ export declare const AttributeType: {
     readonly INDIRECT: 4;
 };
 export type AttributeType = (typeof AttributeType)[keyof typeof AttributeType];
-export declare const GPU_CHUNK_BYTES = 16;
-export declare const BlendColorFactor = 211;
-export declare const OneMinusBlendColorFactor = 212;
+
+export const GPU_CHUNK_BYTES: 16;
+
+export const BlendColorFactor: 211;
+export const OneMinusBlendColorFactor: 212;

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

@@ -1,15 +1,14 @@
-import { RenderTargetOptions } from "../../core/RenderTarget.js";
-import { WebGLCubeRenderTarget } from "../../renderers/WebGLCubeRenderTarget.js";
+import { RenderTarget, RenderTargetOptions } from "../../core/RenderTarget.js";
 import { Texture } from "../../textures/Texture.js";
-import { WebGLRenderer } from "../WebGLRenderer.js";
+import Renderer from "./Renderer.js";
+
 /**
  * This class represents a cube render target. It is a special version
  * of `WebGLCubeRenderTarget` which is compatible with `WebGPURenderer`.
  *
- * @augments WebGLCubeRenderTarget
+ * @augments RenderTarget
  */
-declare class CubeRenderTarget extends WebGLCubeRenderTarget {
-    readonly isCubeRenderTarget: true;
+declare class CubeRenderTarget extends RenderTarget {
     /**
      * Constructs a new cube render target.
      *
@@ -17,6 +16,14 @@ declare class CubeRenderTarget extends WebGLCubeRenderTarget {
      * @param {RenderTarget~Options} [options] - The configuration object.
      */
     constructor(size?: number, options?: RenderTargetOptions);
+    /**
+     * This flag can be used for type testing.
+     *
+     * @type {boolean}
+     * @readonly
+     * @default true
+     */
+    readonly isCubeRenderTarget: boolean;
     /**
      * Converts the given equirectangular texture to a cube map.
      *
@@ -24,6 +31,16 @@ declare class CubeRenderTarget extends WebGLCubeRenderTarget {
      * @param {Texture} texture - The equirectangular texture.
      * @return {CubeRenderTarget} A reference to this cube render target.
      */
-    fromEquirectangularTexture(renderer: WebGLRenderer, texture: Texture): this;
+    fromEquirectangularTexture(renderer: Renderer, texture: Texture): this;
+    /**
+     * Clears this cube render target.
+     *
+     * @param {Renderer} renderer - The renderer.
+     * @param {boolean} [color=true] - Whether the color buffer should be cleared or not.
+     * @param {boolean} [depth=true] - Whether the depth buffer should be cleared or not.
+     * @param {boolean} [stencil=true] - Whether the stencil buffer should be cleared or not.
+     */
+    clear(renderer: Renderer, color?: boolean, depth?: boolean, stencil?: boolean): void;
 }
+
 export default CubeRenderTarget;

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

@@ -4,47 +4,39 @@
  *
  * @private
  */
-declare class DataMap<
-    M extends {
-        [key: string]: {
-            key: object;
-            value: unknown;
-        };
-    },
-> {
-    data: WeakMap<M[keyof M]["key"], M[keyof M]["value"]>;
+declare class DataMap {
     /**
-     * Constructs a new data map.
+     * `DataMap` internally uses a weak map
+     * to manage its data.
+     *
+     * @type {WeakMap<Object, Object>}
      */
-    constructor();
+    data: WeakMap<object, unknown>;
     /**
      * Returns the dictionary for the given object.
      *
      * @param {Object} object - The object.
      * @return {Object} The dictionary.
      */
-    get<K extends M[keyof M]["key"]>(object: K): Extract<M[keyof M], {
-        key: K;
-    }>["value"];
+    get(object: object): unknown;
     /**
      * Deletes the dictionary for the given object.
      *
      * @param {Object} object - The object.
      * @return {?Object} The deleted dictionary.
      */
-    delete<K extends M[keyof M]["key"]>(object: K): Extract<M[keyof M], {
-        key: K;
-    }>["value"];
+    delete(object: object): unknown | null;
     /**
      * Returns `true` if the given object has a dictionary defined.
      *
      * @param {Object} object - The object to test.
      * @return {boolean} Whether a dictionary is defined or not.
      */
-    has(object: M[keyof M]["key"]): boolean;
+    has(object: object): boolean;
     /**
      * Frees internal resources.
      */
     dispose(): void;
 }
+
 export default DataMap;

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,21 +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 | number[];
+    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.
@@ -87,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;