@types/three 0.181.0 → 0.183.0

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

@@ -1,4 +1,6 @@
+import { TypedArray } from "../../core/BufferAttribute.js";
 import Binding from "./Binding.js";
+
 /**
  * Represents a buffer binding type.
  *
@@ -7,16 +9,61 @@ import Binding from "./Binding.js";
  * @augments Binding
  */
 declare class Buffer extends Binding {
-    readonly isBuffer: true;
-    bytesPerElement: number;
-    _buffer: Float32Array | null;
     /**
      * Constructs a new buffer.
      *
      * @param {string} name - The buffer's name.
      * @param {TypedArray} [buffer=null] - The buffer.
      */
-    constructor(name?: string, buffer?: Float32Array | null);
+    constructor(name: string, buffer?: TypedArray);
+    /**
+     * This flag can be used for type testing.
+     *
+     * @type {boolean}
+     * @readonly
+     * @default true
+     */
+    readonly isBuffer: boolean;
+    /**
+     * The bytes per element.
+     *
+     * @type {number}
+     */
+    bytesPerElement: number;
+    /**
+     * A reference to the internal buffer.
+     *
+     * @private
+     * @type {TypedArray}
+     */
+    private _buffer;
+    /**
+     * An array of update ranges.
+     *
+     * @private
+     * @type {Array<{start: number, count: number}>}
+     */
+    private _updateRanges;
+    /**
+     * The array of update ranges.
+     *
+     * @type {Array<{start: number, count: number}>}
+     */
+    get updateRanges(): Array<{
+        start: number;
+        count: number;
+    }>;
+    /**
+     * Adds an update range.
+     *
+     * @param {number} start - The start index.
+     * @param {number} count - The number of elements.
+     */
+    addUpdateRange(start: number, count: number): void;
+    /**
+     * Clears all update ranges.
+     */
+    clearUpdateRanges(): void;
     /**
      * The buffer's byte length.
      *
@@ -30,7 +77,7 @@ declare class Buffer extends Binding {
      * @type {Float32Array}
      * @readonly
      */
-    get buffer(): Float32Array | null;
+    get buffer(): TypedArray;
     /**
      * Updates the binding.
      *
@@ -39,4 +86,5 @@ declare class Buffer extends Binding {
      */
     update(): boolean;
 }
+
 export default Buffer;

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

@@ -6,7 +6,7 @@
  * @param {number} floatLength - The buffer length.
  * @return {number} The padded length.
  */
-declare function getFloatLength(floatLength: number): number;
+export function getFloatLength(floatLength: number): number;
 /**
  * Given the count of vectors and their vector length, this function computes
  * a total length in bytes with buffer alignment according to STD140 layout.
@@ -16,7 +16,7 @@ declare function getFloatLength(floatLength: number): number;
  * @param {number} [vectorLength=4] - The vector length.
  * @return {number} The padded length.
  */
-declare function getVectorLength(count: number, vectorLength?: number): number;
+export function getVectorLength(count: number, vectorLength?: number): number;
 /**
  * This function is called with a vector length and ensure the computed length
  * matches a predefined stride (in this case `4`).
@@ -25,5 +25,4 @@ declare function getVectorLength(count: number, vectorLength?: number): number;
  * @param {number} vectorLength - The vector length.
  * @return {number} The padded length.
  */
-declare function getStrideLength(vectorLength: number): number;
-export { getFloatLength, getStrideLength, getVectorLength };
+export function getStrideLength(vectorLength: number): number;

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,19 +6,29 @@ type RecursiveWeakMap<K extends readonly object[], V> = WeakMap<K[number], V | R
  *
  * @private
  */
-declare class ChainMap<K extends readonly object[], V> {
-    weakMap: RecursiveWeakMap<K, V>;
+declare class ChainMap {
     /**
-     * Constructs a new Chain Map.
+     * A map of Weak Maps by their key length.
+     *
+     * @type {Object<number, WeakMap>}
+     */
+    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.
      */
-    constructor();
+    _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.
      *
@@ -27,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;