@types/three 0.159.0 → 0.161.0

three/README.md

@@ -8,7 +8,7 @@ This package contains type definitions for three (https://threejs.org/).
 Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/three.
 
 ### Additional Details
- * Last updated: Thu, 30 Nov 2023 20:07:36 GMT
+ * Last updated: Wed, 31 Jan 2024 17:07:12 GMT
  * Dependencies: [@types/stats.js](https://npmjs.com/package/@types/stats.js), [@types/webxr](https://npmjs.com/package/@types/webxr), [fflate](https://npmjs.com/package/fflate), [meshoptimizer](https://npmjs.com/package/meshoptimizer)
 
 # Credits

three/examples/jsm/Addons.d.ts

@@ -25,6 +25,7 @@ export * from './csm/CSMShader.js';
 export * as Curves from './curves/CurveExtras.js';
 export * from './curves/NURBSCurve.js';
 export * from './curves/NURBSSurface.js';
+export * from './curves/NURBSVolume.js';
 export * as NURBSUtils from './curves/NURBSUtils.js';
 
 export * from './effects/AnaglyphEffect.js';
@@ -151,6 +152,7 @@ export * from './misc/MorphAnimMesh.js';
 export * from './misc/MorphBlendMesh.js';
 export * from './misc/ProgressiveLightMap.js';
 export * from './misc/RollerCoaster.js';
+export * from './misc/Timer.js';
 export * from './misc/TubePainter.js';
 export * from './misc/Volume.js';
 export * from './misc/VolumeSlice.js';
@@ -160,7 +162,7 @@ export * from './modifiers/EdgeSplitModifier.js';
 export * from './modifiers/SimplifyModifier.js';
 export * from './modifiers/TessellateModifier.js';
 
-export * from './objects/GroundProjectedSkybox.js';
+export * from './objects/GroundedSkybox.js';
 export * from './objects/Lensflare.js';
 export * from './objects/MarchingCubes.js';
 export * from './objects/Reflector.js';
@@ -183,6 +185,7 @@ export * from './postprocessing/DotScreenPass.js';
 export * from './postprocessing/EffectComposer.js';
 export * from './postprocessing/FilmPass.js';
 export * from './postprocessing/GlitchPass.js';
+export * from './postprocessing/GTAOPass.js';
 export * from './postprocessing/HalftonePass.js';
 export * from './postprocessing/LUTPass.js';
 export * from './postprocessing/MaskPass.js';
@@ -230,6 +233,7 @@ export * from './shaders/FocusShader.js';
 export * from './shaders/FreiChenShader.js';
 export * from './shaders/GammaCorrectionShader.js';
 export * from './shaders/GodRaysShader.js';
+export * from './shaders/GTAOShader.js';
 export * from './shaders/HalftoneShader.js';
 export * from './shaders/HorizontalBlurShader.js';
 export * from './shaders/HorizontalTiltShiftShader.js';

three/examples/jsm/capabilities/WebGPU.d.ts

@@ -1,5 +1,7 @@
 // tslint:disable-next-line:no-unnecessary-class
+
 export default class WebGPU {
     static isAvailable(): boolean;
+    static getStaticAdapter(): unknown;
     static getErrorMessage(): HTMLElement;
 }

three/examples/jsm/curves/NURBSUtils.d.ts

@@ -1,20 +1,146 @@
 import { Vector3, Vector4 } from '../../../src/Three.js';
 
-export function findSpan(p: number, u: number, U: number[]): number;
-export function calcBasisFunctions(span: number, u: number, p: number, U: number[]): number[];
-export function calcBSplinePoint(p: number, U: number[], P: Vector4[], u: number): Vector4;
-export function calcBasisFunctionDerivatives(span: number, u: number, p: number, n: number, U: number[]): number[][];
-export function calcBSplineDerivatives(p: number, U: number[], P: Vector4[], u: number, nd: number): Vector4[];
+/**
+ * Finds knot vector span.
+ * @param p degree
+ * @param u parametric value
+ * @param U knot vector
+ * @returns the span
+ */
+export function findSpan(p: number, u: number, U: readonly number[]): number;
+
+/**
+ * Calculate basis functions. See The NURBS Book, page 70, algorithm A2.2
+ * @param span span in which u lies
+ * @param u parametric point
+ * @param p degrees
+ * @param U knot vector
+ * @returns array[p+1] with basis function values
+ */
+export function calcBasisFunctions(span: number, u: number, p: number, U: readonly number[]): number[];
+
+/**
+ * Calculate B-Spline curve points. See The NURBS Book, page 82, algorithm A3.1.
+ * @param p degree of B-Spline
+ * @param U knot vector
+ * @param P control points (x, y, z, w)
+ * @param u parametric point
+ * @returns point for given u
+ */
+export function calcBSplinePoint(p: number, U: readonly number[], P: readonly Vector4[], u: number): Vector4;
+
+/**
+ * Calculate basis functions derivatives. See The NURBS Book, page 72, algorithm A2.3.
+ * @param span span in which u lies
+ * @param u parametric point
+ * @param p degree
+ * @param n number of derivatives to calculate
+ * @param U knot vector
+ * @returns array[n+1][p+1] with basis functions derivatives
+ */
+export function calcBasisFunctionDerivatives(
+    span: number,
+    u: number,
+    p: number,
+    n: number,
+    U: readonly number[],
+): number[][];
+
+/**
+ * Calculate derivatives of a B-Spline. See The NURBS Book, page 93, algorithm A3.2.
+ * @param p degree
+ * @param U knot vector
+ * @param P control points
+ * @param u Parametric points
+ * @param nd number of derivatives
+ * @returns array[d+1] with derivatives
+ */
+export function calcBSplineDerivatives(
+    p: number,
+    U: readonly number[],
+    P: readonly Vector4[],
+    u: number,
+    nd: number,
+): Vector4[];
+
+/**
+ * Calculate "K over I"
+ * @returns k!/(i!(k-i)!
+ */
 export function calcKoverI(k: number, i: number): number;
-export function calcRationalCurveDerivatives(Pders: Vector4[]): Vector3[];
-export function calcNURBSDerivatives(p: number, U: number[], P: Vector4[], u: number, nd: number): Vector3[];
+
+/**
+ * Calculate derivatives (0-nd) of rational curve. See The NURBS Book, page 127, algorithm A4.2.
+ * @param Pders result of function calcBSplineDerivatives
+ * @returns array with derivatives for rational curve.
+ */
+export function calcRationalCurveDerivatives(Pders: readonly Vector4[]): Vector3[];
+
+/**
+ * Calculate NURBS curve derivatives. See The NURBS Book, page 127, algorithm A4.2.
+ * @param p degree
+ * @param U knot vector
+ * @param P control points in homogeneous space
+ * @param u parametric points
+ * @param nd number of derivatives
+ * @returns array with derivatives
+ */
+export function calcNURBSDerivatives(
+    p: number,
+    U: readonly number[],
+    P: readonly Vector4[],
+    u: number,
+    nd: number,
+): Vector3[];
+
+/**
+ * Calculate rational B-Spline surface point. See The NURBS Book, page 134, algorithm A4.3.
+ * @param p degree of B-Spline surface
+ * @param q degree of B-Spline surface
+ * @param U knot vector
+ * @param V knot vector
+ * @param P control points (x, y, z, w)
+ * @param u parametric value
+ * @param v parametric value
+ * @param target
+ * @returns point for given (u, v)
+ */
 export function calcSurfacePoint(
     p: number,
     q: number,
-    U: number[],
-    V: number[],
-    P: Vector4[],
+    U: readonly number[],
+    V: readonly number[],
+    P: readonly (readonly Vector4[])[],
+    u: number,
+    v: number,
+    target: Vector3,
+): Vector3;
+
+/**
+ * Calculate rational B-Spline volume point. See The NURBS Book, page 134, algorithm A4.3.
+ * @param p degree of B-Spline volume
+ * @param q degree of B-Spline volume
+ * @param r degree of B-Spline volume
+ * @param U knot vector
+ * @param V knot vector
+ * @param W knot vector
+ * @param P control points (x, y, z, w)
+ * @param u parametric value
+ * @param v parametric value
+ * @param w parametric value
+ * @param target
+ * @returns point for given (u, v, w)
+ */
+export function calcVolumePoint(
+    p: number,
+    q: number,
+    r: number,
+    U: readonly number[],
+    V: readonly number[],
+    W: readonly number[],
+    P: readonly (readonly (readonly Vector4[])[])[],
     u: number,
     v: number,
+    w: number,
     target: Vector3,
 ): Vector3;

three/examples/jsm/curves/NURBSVolume.d.ts

@@ -0,0 +1,23 @@
+import { Vector3, Vector4 } from '../../../src/Three.js';
+
+export class NURBSVolume {
+    degree1: number;
+    degree2: number;
+    degree3: number;
+    knots1: readonly number[];
+    knots2: readonly number[];
+    knots3: readonly number[];
+    controlPoints: Vector4[][][];
+
+    constructor(
+        degree1: number,
+        degree2: number,
+        degree3: number,
+        knots1: readonly number[],
+        knots2: readonly number[],
+        knots3: readonly number[],
+        controlPoints: Vector4[][][],
+    );
+
+    getPoint(t1: number, t2: number, t3: number, target: Vector3): void;
+}

three/examples/jsm/exporters/USDZExporter.d.ts

@@ -2,6 +2,7 @@ import { Object3D } from '../../../src/Three.js';
 
 export interface USDZExporterOptions {
     quickLookCompatible?: boolean;
+    maxTextureSize?: number;
 }
 
 export class USDZExporter {

three/examples/jsm/loaders/GLTFLoader.d.ts

@@ -131,6 +131,7 @@ export class GLTFParser {
 }
 
 export interface GLTFLoaderPlugin {
+    readonly name: string;
     beforeRoot?: (() => Promise<void> | null) | undefined;
     afterRoot?: ((result: GLTF) => Promise<void> | null) | undefined;
     loadNode?: ((nodeIndex: number) => Promise<Object3D> | null) | undefined;

three/examples/jsm/loaders/KTX2Loader.d.ts

@@ -1,17 +1,51 @@
-import { LoadingManager, CompressedTextureLoader, CompressedTexture, WebGLRenderer } from '../../../src/Three.js';
+import { LoadingManager, Loader, CompressedTexture, WebGLRenderer } from '../../../src/Three.js';
 import WebGPURenderer from '../renderers/webgpu/WebGPURenderer.js';
+import Renderer from '../renderers/common/Renderer.js';
+import { WorkerPool } from '../utils/WorkerPool.js';
+
+export interface KTX2LoaderWorkerConfig {
+    astcSupported: boolean;
+    etc1Supported: boolean;
+    etc2Supported: boolean;
+    dxtSupported: boolean;
+    bptcSupported: boolean;
+    pvrtcSupported: boolean;
+}
+
+export class KTX2Loader extends Loader<CompressedTexture> {
+    transcoderPath: string;
+    transcoderBinary: ArrayBuffer | null;
+    transcoderPending: Promise<void> | null;
+
+    workerPool: WorkerPool;
+    workerSourceURL: string;
+    workerConfig: KTX2LoaderWorkerConfig;
 
-export class KTX2Loader extends CompressedTextureLoader {
     constructor(manager?: LoadingManager);
 
-    setTranscoderPath(path: string): KTX2Loader;
-    setWorkerLimit(limit: number): KTX2Loader;
-    detectSupport(renderer: WebGLRenderer | WebGPURenderer): KTX2Loader;
-    dispose(): KTX2Loader;
+    /**
+     * The WASM transcoder and JS wrapper are available from the examples/jsm/libs/basis directory.
+     * @param path Path to folder containing the WASM transcoder and JS wrapper.
+     */
+    setTranscoderPath(path: string): this;
+
+    /**
+     * Sets the maximum number of web workers to be allocated by this instance.
+     * @param limit Maximum number of workers. Default is '4'.
+     */
+    setWorkerLimit(limit: number): this;
+
+    detectSupportAsync(renderer: Renderer): Promise<this>;
+
+    /**
+     * Detects hardware support for available compressed texture formats, to determine the output format for the
+     * transcoder. Must be called before loading a texture.
+     * @param renderer A renderer instance.
+     */
+    detectSupport(renderer: WebGLRenderer | WebGPURenderer): this;
 
-    parse(
-        buffer: ArrayBuffer,
-        onLoad: (texture: CompressedTexture) => void,
-        onError?: (event: ErrorEvent) => void,
-    ): KTX2Loader;
+    /**
+     * Disposes the loader object, de-allocating any Web Workers created.
+     */
+    dispose(): this;
 }

three/examples/jsm/loaders/LUT3dlLoader.d.ts

@@ -1,4 +1,4 @@
-import { Loader, LoadingManager, DataTexture, Data3DTexture } from '../../../src/Three.js';
+import { Loader, LoadingManager, DataTexture, Data3DTexture, UnsignedByteType, FloatType } from '../../../src/Three.js';
 
 export interface LUT3dlResult {
     size: number;
@@ -6,8 +6,35 @@ export interface LUT3dlResult {
     texture3D: Data3DTexture;
 }
 
+/**
+ * A 3D LUT loader that supports the .3dl file format.
+ *
+ * Based on the following references:
+ *
+ * http://download.autodesk.com/us/systemdocs/help/2011/lustre/index.html?url=./files/WSc4e151a45a3b785a24c3d9a411df9298473-7ffd.htm,topicNumber=d0e9492
+ * https://community.foundry.com/discuss/topic/103636/format-spec-for-3dl?mode=Post&postID=895258
+ */
 export class LUT3dlLoader extends Loader<LUT3dlResult> {
+    type: typeof UnsignedByteType | typeof FloatType;
+
+    /**
+     * Creates a new {@link LUT3dlLoader}.
+     * @param manager The LoadingManager to use. Defaults to {@link DefaultLoadingManager}
+     */
     constructor(manager?: LoadingManager);
 
-    parse(data: string): LUT3dlResult;
+    /**
+     * Sets the desired texture type. Only {@link THREE.UnsignedByteType} and {@link THREE.FloatType} are supported. The
+     * default is {@link THREE.UnsignedByteType}.
+     * @param type The texture type. See the Textures texture constants page for details.
+     */
+    setType(type: typeof UnsignedByteType | typeof FloatType): this;
+
+    /**
+     * Parse a 3dl data string and fire {@link onLoad} callback when complete. The argument to {@link onLoad} will be an
+     * object containing the following LUT data: {@link LUT3dlResult.size}, {@link LUT3dlResult.texture} and
+     * {@link LUT3dlResult.texture3D}.
+     * @param input The 3dl data string.
+     */
+    parse(input: string): LUT3dlResult;
 }

three/examples/jsm/loaders/LUTCubeLoader.d.ts

@@ -1,4 +1,12 @@
-import { Loader, LoadingManager, Vector3, DataTexture, Data3DTexture } from '../../../src/Three.js';
+import {
+    Loader,
+    LoadingManager,
+    Vector3,
+    DataTexture,
+    Data3DTexture,
+    UnsignedByteType,
+    FloatType,
+} from '../../../src/Three.js';
 
 export interface LUTCubeResult {
     title: string;
@@ -9,8 +17,35 @@ export interface LUTCubeResult {
     texture3D: Data3DTexture;
 }
 
+/**
+ * A 3D LUT loader that supports the .cube file format.
+ *
+ * Based on the following reference:
+ *
+ * https://wwwimages2.adobe.com/content/dam/acom/en/products/speedgrade/cc/pdfs/cube-lut-specification-1.0.pdf
+ */
 export class LUTCubeLoader extends Loader<LUTCubeResult> {
+    type: typeof UnsignedByteType | typeof FloatType;
+
+    /**
+     * Creates a new {@link LUTCubeLoader}.
+     * @param manager The LoadingManager to use. Defaults to {@link DefaultLoadingManager}
+     */
     constructor(manager?: LoadingManager);
 
-    parse(data: string): LUTCubeResult;
+    /**
+     * Sets the desired texture type. Only {@link THREE.UnsignedByteType} and {@link THREE.FloatType} are supported. The
+     * default is {@link THREE.UnsignedByteType}.
+     * @param type The texture type. See the Textures texture constants page for details.
+     */
+    setType(type: typeof UnsignedByteType | typeof FloatType): this;
+
+    /**
+     * Parse a cube data string and fire {@link onLoad} callback when complete. The argument to {@link onLoad} will be
+     * an object containing the following LUT data: {@link LUTCubeResult.title}, {@link LUTCubeResult.size},
+     * {@link LUTCubeResult.domainMin}, {@link LUTCubeResult.domainMax}, {@link LUTCubeResult.texture} and
+     * {@link LUTCubeResult.texture3D}.
+     * @param input The cube data string.
+     */
+    parse(input: string): LUTCubeResult;
 }

three/examples/jsm/loaders/MaterialXLoader.d.ts

@@ -0,0 +1,6 @@
+import { Loader, LoadingManager } from '../../../src/Three.js';
+import { MeshPhysicalNodeMaterial } from '../nodes/Nodes.js';
+
+export class MaterialXLoader extends Loader<{ materials: Record<string, MeshPhysicalNodeMaterial> }> {
+    constructor(manager?: LoadingManager);
+}

three/examples/jsm/materials/MeshPostProcessingMaterial.d.ts

@@ -0,0 +1,13 @@
+import { MeshPhysicalMaterial, MeshPhysicalMaterialParameters, Texture } from '../../../src/Three.js';
+
+export interface MeshPostProcessingMaterialParameters extends MeshPhysicalMaterialParameters {
+    aoPassMap?: Texture | null | undefined;
+    aoPassMapScale?: number | undefined;
+}
+
+export class MeshPostProcessingMaterial extends MeshPhysicalMaterial {
+    constructor(parameters: MeshPostProcessingMaterialParameters);
+
+    get aoPassMap(): Texture | null | undefined;
+    set aoPassMap(aoPassMap: Texture | null | undefined);
+}

three/examples/jsm/misc/Timer.d.ts

@@ -0,0 +1,80 @@
+/**
+ * This class is an alternative to {@link THREE.Clock} with a different API design and behavior
+ * The goal is to avoid the conceptual flaws that became apparent in {@link THREE.Clock} over time.
+ *
+ * - {@link Timer} has an {@link .update()} method that updates its internal state. That makes it possible to call
+ *   {@link .getDelta()} and {@link .getElapsed()} multiple times per simulation step without getting different values.
+ * - The class uses the Page Visibility API to avoid large time delta values when the app is inactive (e.g. tab switched
+ *   or browser hidden).
+ * - It's possible to configure a fixed time delta and a time scale value (similar to Unity's Time interface).
+ *
+ * @example
+ * const timer = new Timer();
+ *
+ * function animate() {
+ *   requestAnimationFrame(animate);
+ *   timer.update();
+ *   const delta = timer.getDelta();
+ *   // do something with delta
+ *   renderer.render(scene, camera);
+ * }
+ *
+ * @see https://threejs.org/examples/#webgl_morphtargets_sphere
+ */
+export class Timer {
+    constructor();
+
+    /**
+     * Disables the usage of a fixed delta time.
+     */
+    disableFixedDelta(): this;
+
+    /**
+     * Can be used to free all internal resources. Usually called when the timer instance isn't required anymore.
+     */
+    dispose(): this;
+
+    /**
+     * Enables the usage of a fixed delta time.
+     */
+    enableFixedDelta(): this;
+
+    /**
+     * Returns the time delta in seconds.
+     */
+    getDelta(): number;
+
+    /**
+     * Returns the elapsed time in seconds.
+     */
+    getElapsed(): number;
+
+    /**
+     * Returns the fixed time delta that has been previously configured via {@link .setFixedDelta()}.
+     */
+    getFixedDelta(): number;
+
+    getTimescale(): number;
+
+    /**
+     * Resets the time computation for the current simulation step.
+     */
+    reset(): this;
+
+    /**
+     * Defines a fixed time delta value which is used to update the timer per simulation step.
+     */
+    setFixedDelta(fixedDelta: number): this;
+
+    /**
+     * Sets a time scale that scales the time delta in {@link .update()}.
+     * @param timescale
+     */
+    setTimescale(timescale: number): this;
+
+    /**
+     * Updates the internal state of the timer. This method should be called once per simulation step and before you
+     * perform queries against the timer (e.g. via {@link .getDelta()}).
+     */
+    update(): this;
+}