@types/three 0.181.0 → 0.182.0

three/src/nodes/math/UnpackFloatNode.d.ts

@@ -0,0 +1,18 @@
+import Node from "../core/Node.js";
+import TempNode from "../core/TempNode.js";
+import { PackFloatNodeEncoding } from "./PackFloatNode.js";
+
+declare class PackFloatNode extends TempNode {
+    uintNode: Node;
+    encoding: PackFloatNodeEncoding;
+
+    readonly isPackFloatNode: true;
+
+    constructor(encoding: PackFloatNodeEncoding, uintNode: Node);
+}
+
+export default PackFloatNode;
+
+export const unpackSnorm2x16: (value: Node) => PackFloatNode;
+export const unpackUnorm2x16: (value: Node) => PackFloatNode;
+export const unpackHalf2x16: (value: Node) => PackFloatNode;

three/src/nodes/tsl/TSLCore.d.ts

@@ -483,38 +483,38 @@ declare module "../Nodes.js" {
         toVec2: () => Node;
         toVec2Assign: () => this;
 
-        toIvec2: () => Node;
-        toIvec2Assign: () => this;
+        toIVec2: () => Node;
+        toIVec2Assign: () => this;
 
-        toUvec2: () => Node;
-        toUvec2Assign: () => this;
+        toUVec2: () => Node;
+        toUVec2Assign: () => this;
 
-        toBvec2: () => Node;
-        toBvec2Assign: () => this;
+        toBVec2: () => Node;
+        toBVec2Assign: () => this;
 
         toVec3: () => Node;
         toVec3Assign: () => this;
 
-        toIvec3: () => Node;
-        toIvec3Assign: () => this;
+        toIVec3: () => Node;
+        toIVec3Assign: () => this;
 
-        toUvec3: () => Node;
-        toUvec3Assign: () => this;
+        toUVec3: () => Node;
+        toUVec3Assign: () => this;
 
-        toBvec3: () => Node;
-        ttoBvec3Assign: () => this;
+        toBVec3: () => Node;
+        toBVec3Assign: () => this;
 
         toVec4: () => Node;
         toVec4Assign: () => this;
 
-        toIvec4: () => Node;
-        toIvec4Assign: () => this;
+        toIVec4: () => Node;
+        toIVec4Assign: () => this;
 
-        toUvec4: () => Node;
-        toUvec4Assign: () => this;
+        toUVec4: () => Node;
+        toUVec4Assign: () => this;
 
-        toBvec4: () => Node;
-        toBvec4Assign: () => this;
+        toBVec4: () => Node;
+        toBVec4Assign: () => this;
 
         toMat2: () => Node;
         toMat2Assign: () => this;

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

@@ -2,3 +2,4 @@ import Node from "../core/Node.js";
 
 export const directionToColor: (node: Node) => Node;
 export const colorToDirection: (node: Node) => Node;
+export const unpackNormal: (xy: Node) => Node;

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

@@ -44,3 +44,5 @@ export const getNormalFromDepth: (
 ) => Node;
 
 export const interleavedGradientNoise: (position: Node) => Node;
+
+export const vogelDiskSample: (sampleIndex: Node, samplesCount: Node, phi: Node) => Node;

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

@@ -1,6 +1,9 @@
+import ContextNode from "../core/ContextNode.js";
 import Node from "../core/Node.js";
 import OperatorNode from "../math/OperatorNode.js";
 
+export function replaceDefaultUV(callback: (node: Node) => Node, node?: Node | null): ContextNode;
+
 export const rotateUV: (
     uv: Node,
     rotation: Node,

three/src/objects/LOD.d.ts

@@ -57,7 +57,7 @@ export class LOD<TEventMap extends Object3DEventMap = Object3DEventMap> extends
     /**
      * An array of level objects
      */
-    levels: Array<{
+    readonly levels: Array<{
         /** The Object3D to display at this level. */
         object: Object3D;
         /** The distance at which to display this level of detail. Expects a `Float`. */

three/src/objects/Skeleton.d.ts

@@ -61,12 +61,14 @@ export class Skeleton {
     /**
      * The array buffer holding the bone data when using a vertex texture.
      */
-    boneMatrices: Float32Array;
+    boneMatrices: Float32Array | null;
+
+    previousBoneMatrices: Float32Array | null;
 
     /**
      * The {@link THREE.DataTexture | DataTexture} holding the bone data when using a vertex texture.
      */
-    boneTexture: null | DataTexture;
+    boneTexture: DataTexture | null;
 
     frame: number;
 

three/src/renderers/WebGLRenderer.d.ts

@@ -1,5 +1,5 @@
 import { Camera } from "../cameras/Camera.js";
-import { CullFace, ShadowMapType, ToneMapping, WebGLCoordinateSystem } from "../constants.js";
+import { CullFace, ShadowMapType, TextureDataType, ToneMapping, WebGLCoordinateSystem } from "../constants.js";
 import { TypedArray } from "../core/BufferAttribute.js";
 import { BufferGeometry } from "../core/BufferGeometry.js";
 import { Object3D } from "../core/Object3D.js";
@@ -76,6 +76,11 @@ export interface WebGLRendererParameters extends WebGLCapabilitiesParameters {
      * default is false.
      */
     failIfMajorPerformanceCaveat?: boolean | undefined;
+
+    /**
+     * @default UnsignedByteType
+     */
+    outputBufferType?: TextureDataType | undefined;
 }
 
 export interface WebGLDebug {
@@ -100,6 +105,17 @@ export interface WebGLDebug {
         | null;
 }
 
+export interface Effect {
+    setSize(width: number, height: number): void;
+    render(
+        renderer: WebGLRenderer,
+        writeBuffer: WebGLRenderTarget,
+        readBuffer: WebGLRenderTarget,
+        deltaTime: number,
+        maskActive: boolean,
+    ): void;
+}
+
 /**
  * The WebGL renderer displays your beautifully crafted scenes using WebGL, if your device supports it.
  * This renderer has way better performance than CanvasRenderer.
@@ -228,9 +244,6 @@ export class WebGLRenderer {
     getPixelRatio(): number;
     setPixelRatio(value: number): void;
 
-    getDrawingBufferSize(target: Vector2): Vector2;
-    setDrawingBufferSize(width: number, height: number, pixelRatio: number): void;
-
     getSize(target: Vector2): Vector2;
 
     /**
@@ -238,6 +251,11 @@ export class WebGLRenderer {
      */
     setSize(width: number, height: number, updateStyle?: boolean): void;
 
+    getDrawingBufferSize(target: Vector2): Vector2;
+    setDrawingBufferSize(width: number, height: number, pixelRatio: number): void;
+
+    setEffects(effects: Effect[] | null): void;
+
     getCurrentViewport(target: Vector4): Vector4;
 
     /**

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

@@ -22,6 +22,12 @@ declare class Binding {
      * @param {number} visibility - The shader stage.
      */
     setVisibility(visibility: number): void;
+    /**
+     * The shader stages in which the binding's resource is visible.
+     *
+     * @return {number} The visibility bitmask.
+     */
+    getVisibility(): number;
     /**
      * Clones the binding.
      *

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

@@ -10,6 +10,10 @@ declare class Buffer extends Binding {
     readonly isBuffer: true;
     bytesPerElement: number;
     _buffer: Float32Array | null;
+    _updateRanges: {
+        start: number;
+        count: number;
+    }[];
     /**
      * Constructs a new buffer.
      *
@@ -17,6 +21,26 @@ declare class Buffer extends Binding {
      * @param {TypedArray} [buffer=null] - The buffer.
      */
     constructor(name?: string, buffer?: Float32Array | null);
+    /**
+     * The array of update ranges.
+     *
+     * @type {Array<{start: number, count: number}>}
+     */
+    get updateRanges(): {
+        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.
      *

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

@@ -8,11 +8,18 @@ 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>;
+    weakMaps: Record<number, RecursiveWeakMap<K, V>>;
     /**
      * Constructs a new Chain Map.
      */
     constructor();
+    /**
+     * 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>;
     /**
      * Returns the value for the given array of keys.
      *

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

@@ -72,6 +72,13 @@ declare class Geometries extends DataMap<{
      * @return {?BufferAttribute} The indirect attribute. `null` if no indirect drawing is used.
      */
     getIndirect(renderObject: RenderObject): import("./IndirectStorageBufferAttribute.js").default | 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[];
     /**
      * Returns the index of the given render object's geometry. This is implemented
      * in a method to return a wireframe index if necessary.

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

@@ -1,5 +1,6 @@
 import { Camera } from "../../cameras/Camera.js";
 import { RenderTarget } from "../../core/RenderTarget.js";
+import MRTNode from "../../nodes/core/MRTNode.js";
 import { Scene } from "../../scenes/Scene.js";
 import ChainMap from "./ChainMap.js";
 import RenderContext from "./RenderContext.js";
@@ -22,9 +23,10 @@ declare class RenderContexts {
      * @param {Scene} scene - The scene.
      * @param {Camera} camera - The camera that is used to render the scene.
      * @param {?RenderTarget} [renderTarget=null] - The active render target.
+     * @param {?MRT} [mrt=null] - The active multiple render target.
      * @return {RenderContext} The render context.
      */
-    get(scene: Scene, camera: Camera, renderTarget?: RenderTarget | null): RenderContext;
+    get(scene: Scene, camera: Camera, renderTarget?: RenderTarget | null, mrt?: MRTNode | null): RenderContext;
     /**
      * Returns a render context intended for clear operations.
      *

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

@@ -163,6 +163,12 @@ declare class RenderObject {
      * @return {?BufferAttribute} The indirect attribute. `null` if no indirect drawing is used.
      */
     getIndirect(): import("./IndirectStorageBufferAttribute.js").default | null;
+    /**
+     * Returns the byte offset into the indirect attribute buffer.
+     *
+     * @return {number|Array<number>} The byte offset into the indirect attribute buffer.
+     */
+    getIndirectOffset(): number | number[];
     /**
      * Returns an array that acts as a key for identifying the render object in a chain map.
      *

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

@@ -64,7 +64,7 @@ export interface RendererParameters {
     antialias?: boolean | undefined;
     samples?: number | undefined;
     getFallback?: ((error: unknown) => Backend) | null | undefined;
-    colorBufferType?: TextureDataType | undefined;
+    outputBufferType?: TextureDataType | undefined;
     multiview?: boolean | undefined;
 }
 /**
@@ -156,7 +156,7 @@ declare class Renderer {
     ) => void;
     _isDeviceLost: boolean;
     onDeviceLost: (info: DeviceLostInfo) => void;
-    _colorBufferType: TextureDataType;
+    _outputBufferType: TextureDataType;
     _initialized: boolean;
     _initPromise: Promise<this> | null;
     _compilationPromises: Promise<void>[] | null;
@@ -195,7 +195,7 @@ declare class Renderer {
      * @property {number} [samples=0] - When `antialias` is `true`, `4` samples are used by default. This parameter can set to any other integer value than 0
      * to overwrite the default.
      * @property {?Function} [getFallback=null] - This callback function can be used to provide a fallback backend, if the primary backend can't be targeted.
-     * @property {number} [colorBufferType=HalfFloatType] - Defines the type of color buffers. The default `HalfFloatType` is recommend for best
+     * @property {number} [outputBufferType=HalfFloatType] - Defines the type of output buffers. The default `HalfFloatType` is recommend for best
      * quality. To save memory and bandwidth, `UnsignedByteType` might be used. This will reduce rendering quality though.
      * @property {boolean} [multiview=false] - If set to `true`, the renderer will use multiview during WebXR rendering if supported.
      */
@@ -243,7 +243,7 @@ declare class Renderer {
      * @param {Object3D} scene - The scene or 3D object to precompile.
      * @param {Camera} camera - The camera that is used to render the scene.
      * @param {?Scene} targetScene - If the first argument is a 3D object, this parameter must represent the scene the 3D object is going to be added.
-     * @return {Promise<Array|undefined>} A Promise that resolves when the compile has been finished.
+     * @return {Promise} A Promise that resolves when the compile has been finished.
      */
     compileAsync(scene: Object3D, camera: Camera, targetScene?: Scene | null): Promise<void>;
     /**
@@ -265,12 +265,12 @@ declare class Renderer {
      * @return {Promise} A Promise that resolves when synchronization has been finished.
      */
     waitForGPU(): Promise<void>;
+    set inspector(value: InspectorBase);
     /**
-     * Sets the inspector instance. The inspector can be any class that extends from `InspectorBase`.
+     * The inspector instance. The inspector can be any class that extends from `InspectorBase`.
      *
-     * @param {InspectorBase} value - The new inspector.
+     * @type {InspectorBase}
      */
-    set inspector(value: InspectorBase);
     get inspector(): InspectorBase;
     /**
      * Enables or disables high precision for model-view and normal-view matrices.
@@ -303,9 +303,16 @@ declare class Renderer {
      */
     getMRT(): MRTNode | null;
     /**
-     * Returns the color buffer type.
+     * Returns the output buffer type.
+     *
+     * @return {number} The output buffer type.
+     */
+    getOutputBufferType(): TextureDataType;
+    /**
+     * Returns the output buffer type.
      *
-     * @return {number} The color buffer type.
+     * @deprecated since r182. Use `.getOutputBufferType()` instead.
+     * @return {number} The output buffer type.
      */
     getColorBufferType(): TextureDataType;
     /**
@@ -495,9 +502,9 @@ declare class Renderer {
     /**
      * Defines the scissor rectangle.
      *
-     * @param {number | Vector4} x - The horizontal coordinate for the lower left corner of the box in logical pixel unit.
+     * @param {number | Vector4} x - The horizontal coordinate for the upper left corner of the box in logical pixel unit.
      * Instead of passing four arguments, the method also works with a single four-dimensional vector.
-     * @param {number} y - The vertical coordinate for the lower left corner of the box in logical pixel unit.
+     * @param {number} y - The vertical coordinate for the upper left corner of the box in logical pixel unit.
      * @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.
      */
@@ -525,8 +532,8 @@ declare class Renderer {
     /**
      * Defines the viewport.
      *
-     * @param {number | Vector4} x - The horizontal coordinate for the lower left corner of the viewport origin in logical pixel unit.
-     * @param {number} y - The vertical coordinate for the lower left corner of the viewport origin  in logical pixel unit.
+     * @param {number | Vector4} x - The horizontal coordinate for the upper left corner of the viewport origin in logical pixel unit.
+     * @param {number} y - The vertical coordinate for the upper left corner of the viewport origin  in logical pixel unit.
      * @param {number} width - The width of the viewport in logical pixel unit.
      * @param {number} height - The height of the viewport in logical pixel unit.
      * @param {number} minDepth - The minimum depth value of the viewport. WebGPU only.
@@ -738,6 +745,8 @@ declare class Renderer {
     getCanvasTarget(): CanvasTarget;
     /**
      * Resets the renderer to the initial state before WebXR started.
+     *
+     * @private
      */
     _resetXRState(): void;
     /**
@@ -920,6 +929,7 @@ declare class Renderer {
      * Analyzes the given 3D object's hierarchy and builds render lists from the
      * processed hierarchy.
      *
+     * @private
      * @param {Object3D} object - The 3D object to process (usually a scene).
      * @param {Camera} camera - The camera the object is rendered with.
      * @param {number} groupOrder - The group order is derived from the `renderOrder` of groups and is used to group 3D objects within groups.
@@ -980,6 +990,7 @@ declare class Renderer {
      * Retrieves shadow nodes for the given material. This is used to setup shadow passes.
      * The result is cached per material and updated when the material's version changes.
      *
+     * @private
      * @param {Material} material
      * @returns {Object} - The shadow nodes for the material.
      */

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

@@ -128,6 +128,7 @@ declare class UniformsGroup extends UniformBuffer {
     /**
      * Returns a typed array that matches the given data type.
      *
+     * @private
      * @param {string} type - The data type.
      * @return {TypedArray} The typed array.
      */

three/src/renderers/shaders/ShaderLib.d.ts

@@ -21,7 +21,7 @@ declare const ShaderLib: {
     background: ShaderLibShader;
     cube: ShaderLibShader;
     equirect: ShaderLibShader;
-    distanceRGBA: ShaderLibShader;
+    distance: ShaderLibShader;
     shadow: ShaderLibShader;
     physical: ShaderLibShader;
 };

three/src/renderers/webgl/WebGLCapabilities.d.ts

@@ -42,7 +42,7 @@ export class WebGLCapabilities {
     maxVaryings: number;
     maxFragmentUniforms: number;
 
-    vertexTextures: boolean;
-
     maxSamples: number;
+
+    samples: number;
 }

three/src/renderers/webgl/WebGLPrograms.d.ts

@@ -36,7 +36,6 @@ export interface WebGLProgramParameters {
     instancingColor: boolean;
     instancingMorph: boolean;
 
-    supportsVertexTextures: boolean;
     outputColorSpace: string;
     alphaToCoverage: boolean;
 

three/src/textures/CubeDepthTexture.d.ts

@@ -0,0 +1,41 @@
+import {
+    DepthTexturePixelFormat,
+    MagnificationTextureFilter,
+    Mapping,
+    MinificationTextureFilter,
+    TextureDataType,
+    Wrapping,
+} from "../constants.js";
+import { DepthTextureImageData } from "./DepthTexture.js";
+import { Texture } from "./Texture.js";
+
+declare class CubeDepthTexture extends Texture<CubeDepthTextureImageData> {
+    readonly isCubeDepthTexture: true;
+    readonly isCubeTexture: true;
+
+    constructor(
+        size: number,
+        type?: TextureDataType,
+        mapping?: Mapping,
+        wrapS?: Wrapping,
+        wrapT?: Wrapping,
+        magFilter?: MagnificationTextureFilter,
+        minFilter?: MinificationTextureFilter,
+        anisotropy?: number,
+        format?: DepthTexturePixelFormat,
+    );
+
+    get images(): CubeDepthTextureImageData;
+    set images(value: CubeDepthTextureImageData);
+}
+
+export { CubeDepthTexture };
+
+export type CubeDepthTextureImageData = [
+    DepthTextureImageData,
+    DepthTextureImageData,
+    DepthTextureImageData,
+    DepthTextureImageData,
+    DepthTextureImageData,
+    DepthTextureImageData,
+];

three/src/textures/CubeTexture.d.ts

@@ -27,7 +27,7 @@ import { Texture } from "./Texture.js";
  * @see {@link https://threejs.org/docs/index.html#api/en/textures/CubeTexture | Official Documentation}
  * @see {@link https://github.com/mrdoob/three.js/blob/master/src/textures/CubeTexture.js | Source}
  */
-export class CubeTexture extends Texture<HTMLImageElement[]> {
+export class CubeTexture<TImage = unknown> extends Texture<TImage[]> {
     /**
      * This creates a new {@link THREE.CubeTexture | CubeTexture} object.
      * @param images
@@ -42,7 +42,7 @@ export class CubeTexture extends Texture<HTMLImageElement[]> {
      * @param colorSpace See {@link Texture.colorSpace | .colorSpace}. Default {@link NoColorSpace}
      */
     constructor(
-        images?: HTMLImageElement[],
+        images?: TImage[],
         mapping?: CubeTextureMapping,
         wrapS?: Wrapping,
         wrapT?: Wrapping,
@@ -65,8 +65,8 @@ export class CubeTexture extends Texture<HTMLImageElement[]> {
      * An image object, typically created using the {@link THREE.CubeTextureLoader.load | CubeTextureLoader.load()} method.
      * @see {@link Texture.image}
      */
-    get images(): HTMLImageElement[];
-    set images(value: HTMLImageElement[]);
+    get images(): TImage[];
+    set images(value: TImage[]);
 
     /**
      * @inheritDoc

three/src/utils.d.ts

@@ -1,3 +1,5 @@
+declare function isTypedArray(object: unknown): boolean;
+
 declare function createCanvasElement(): HTMLCanvasElement;
 
 declare function setConsoleFunction(
@@ -16,4 +18,14 @@ declare function warnOnce(...params: unknown[]): void;
 
 declare function probeAsync(gl: WebGLRenderingContext, sync: WebGLSync, interval: number): Promise<void>;
 
-export { createCanvasElement, error, getConsoleFunction, log, probeAsync, setConsoleFunction, warn, warnOnce };
+export {
+    createCanvasElement,
+    error,
+    getConsoleFunction,
+    isTypedArray,
+    log,
+    probeAsync,
+    setConsoleFunction,
+    warn,
+    warnOnce,
+};

three/src/nodes/functions/BSDF/DFGApprox.d.ts

@@ -1,10 +0,0 @@
-import Node from "../../core/Node.js";
-import OperatorNode from "../../math/OperatorNode.js";
-
-// Analytical approximation of the DFG LUT, one half of the
-// split-sum approximation used in indirect specular lighting.
-// via 'environmentBRDF' from "Physically Based Shading on Mobile"
-// https://www.unrealengine.com/blog/physically-based-shading-on-mobile
-declare const DFGApprox: (args: { roughness: Node; dotNV: Node }) => OperatorNode;
-
-export default DFGApprox;