@types/three 0.157.1 → 0.158.0

three/examples/jsm/libs/tween.module.d.ts

@@ -0,0 +1,219 @@
+type EasingFunction = (amount: number) => number;
+interface EasingFunctionGroup {
+    In: EasingFunction;
+    Out: EasingFunction;
+    InOut: EasingFunction;
+}
+/**
+ * The Ease class provides a collection of easing functions for use with tween.js.
+ */
+declare const Easing: Readonly<{
+    Linear: Readonly<
+        EasingFunctionGroup & {
+            None: EasingFunction;
+        }
+    >;
+    Quadratic: Readonly<EasingFunctionGroup>;
+    Cubic: Readonly<EasingFunctionGroup>;
+    Quartic: Readonly<EasingFunctionGroup>;
+    Quintic: Readonly<EasingFunctionGroup>;
+    Sinusoidal: Readonly<EasingFunctionGroup>;
+    Exponential: Readonly<EasingFunctionGroup>;
+    Circular: Readonly<EasingFunctionGroup>;
+    Elastic: Readonly<EasingFunctionGroup>;
+    Back: Readonly<EasingFunctionGroup>;
+    Bounce: Readonly<EasingFunctionGroup>;
+    generatePow(power?: number): EasingFunctionGroup;
+}>;
+
+type InterpolationFunction = (v: number[], k: number) => number;
+declare const Interpolation: {
+    Linear: (v: number[], k: number) => number;
+    Bezier: (v: number[], k: number) => number;
+    CatmullRom: (v: number[], k: number) => number;
+    Utils: {
+        Linear: (p0: number, p1: number, t: number) => number;
+        Bernstein: (n: number, i: number) => number;
+        Factorial: (n: number) => number;
+        CatmullRom: (p0: number, p1: number, p2: number, p3: number, t: number) => number;
+    };
+};
+
+/**
+ * Controlling groups of tweens
+ *
+ * Using the TWEEN singleton to manage your tweens can cause issues in large apps with many components.
+ * In these cases, you may want to create your own smaller groups of tween
+ */
+declare class Group {
+    private _tweens;
+    private _tweensAddedDuringUpdate;
+    getAll(): Array<Tween<UnknownProps>>;
+    removeAll(): void;
+    add(tween: Tween<UnknownProps>): void;
+    remove(tween: Tween<UnknownProps>): void;
+    update(time?: number, preserve?: boolean): boolean;
+}
+
+/**
+ * Tween.js - Licensed under the MIT license
+ * https://github.com/tweenjs/tween.js
+ * ----------------------------------------------
+ *
+ * See https://github.com/tweenjs/tween.js/graphs/contributors for the full list of contributors.
+ * Thank you all, you're awesome!
+ */
+
+declare class Tween<T extends UnknownProps> {
+    private _object;
+    private _group;
+    private _isPaused;
+    private _pauseStart;
+    private _valuesStart;
+    private _valuesEnd;
+    private _valuesStartRepeat;
+    private _duration;
+    private _isDynamic;
+    private _initialRepeat;
+    private _repeat;
+    private _repeatDelayTime?;
+    private _yoyo;
+    private _isPlaying;
+    private _reversed;
+    private _delayTime;
+    private _startTime;
+    private _easingFunction;
+    private _interpolationFunction;
+    private _chainedTweens;
+    private _onStartCallback?;
+    private _onStartCallbackFired;
+    private _onEveryStartCallback?;
+    private _onEveryStartCallbackFired;
+    private _onUpdateCallback?;
+    private _onRepeatCallback?;
+    private _onCompleteCallback?;
+    private _onStopCallback?;
+    private _id;
+    private _isChainStopped;
+    private _propertiesAreSetUp;
+    constructor(_object: T, _group?: Group | false);
+    getId(): number;
+    isPlaying(): boolean;
+    isPaused(): boolean;
+    to(target: UnknownProps, duration?: number): this;
+    duration(duration?: number): this;
+    dynamic(dynamic?: boolean): this;
+    start(time?: number, overrideStartingValues?: boolean): this;
+    startFromCurrentValues(time?: number): this;
+    private _setupProperties;
+    stop(): this;
+    end(): this;
+    pause(time?: number): this;
+    resume(time?: number): this;
+    stopChainedTweens(): this;
+    group(group?: Group): this;
+    delay(amount?: number): this;
+    repeat(times?: number): this;
+    repeatDelay(amount?: number): this;
+    yoyo(yoyo?: boolean): this;
+    easing(easingFunction?: EasingFunction): this;
+    interpolation(interpolationFunction?: InterpolationFunction): this;
+    chain(...tweens: Array<Tween<any>>): this;
+    onStart(callback?: (object: T) => void): this;
+    onEveryStart(callback?: (object: T) => void): this;
+    onUpdate(callback?: (object: T, elapsed: number) => void): this;
+    onRepeat(callback?: (object: T) => void): this;
+    onComplete(callback?: (object: T) => void): this;
+    onStop(callback?: (object: T) => void): this;
+    private _goToEnd;
+    /**
+     * @returns true if the tween is still playing after the update, false
+     * otherwise (calling update on a paused tween still returns true because
+     * it is still playing, just paused).
+     */
+    update(time?: number, autoStart?: boolean): boolean;
+    private _updateProperties;
+    private _handleRelativeValue;
+    private _swapEndStartRepeatValues;
+}
+type UnknownProps = Record<string, any>;
+
+declare function now(): number;
+
+/**
+ * Utils
+ */
+// tslint:disable-next-line:no-unnecessary-class
+declare class Sequence {
+    private static _nextId;
+    static nextId(): number;
+}
+
+declare const VERSION = '21.0.0';
+
+declare const nextId: typeof Sequence.nextId;
+declare function getAll(): Array<Tween<UnknownProps>>;
+declare function removeAll(): void;
+declare function add(tween: Tween<UnknownProps>): void;
+declare function remove(tween: Tween<UnknownProps>): void;
+declare function update(time?: number, preserve?: boolean): boolean;
+
+declare const exports: {
+    Easing: Readonly<{
+        Linear: Readonly<
+            EasingFunctionGroup & {
+                None: EasingFunction;
+            }
+        >;
+        Quadratic: Readonly<EasingFunctionGroup>;
+        Cubic: Readonly<EasingFunctionGroup>;
+        Quartic: Readonly<EasingFunctionGroup>;
+        Quintic: Readonly<EasingFunctionGroup>;
+        Sinusoidal: Readonly<EasingFunctionGroup>;
+        Exponential: Readonly<EasingFunctionGroup>;
+        Circular: Readonly<EasingFunctionGroup>;
+        Elastic: Readonly<EasingFunctionGroup>;
+        Back: Readonly<EasingFunctionGroup>;
+        Bounce: Readonly<EasingFunctionGroup>;
+        generatePow(power?: number): EasingFunctionGroup;
+    }>;
+    Group: typeof Group;
+    Interpolation: {
+        Linear: (v: number[], k: number) => number;
+        Bezier: (v: number[], k: number) => number;
+        CatmullRom: (v: number[], k: number) => number;
+        Utils: {
+            Linear: (p0: number, p1: number, t: number) => number;
+            Bernstein: (n: number, i: number) => number;
+            Factorial: (n: number) => number;
+            CatmullRom: (p0: number, p1: number, p2: number, p3: number, t: number) => number;
+        };
+    };
+    now: () => number;
+    Sequence: typeof Sequence;
+    nextId: typeof Sequence.nextId;
+    Tween: typeof Tween;
+    VERSION: string;
+    getAll: () => Array<Tween<UnknownProps>>;
+    removeAll: () => void;
+    add: (tween: Tween<UnknownProps>) => void;
+    remove: (tween: Tween<UnknownProps>) => void;
+    update: (time?: number, preserve?: boolean) => boolean;
+};
+
+export {
+    Easing,
+    Group,
+    Interpolation,
+    Sequence,
+    Tween,
+    VERSION,
+    add,
+    exports as default,
+    getAll,
+    nextId,
+    now,
+    remove,
+    removeAll,
+    update,
+};

three/examples/jsm/lights/RectAreaLightUniformsLib.d.ts

@@ -0,0 +1,3 @@
+export namespace RectAreaLightUniformsLib {
+    function init(): void;
+}

three/examples/jsm/lines/Line2.d.ts

@@ -0,0 +1,11 @@
+import { LineGeometry } from './LineGeometry.js';
+import { LineSegments2 } from './LineSegments2.js';
+import { LineMaterial } from './LineMaterial.js';
+
+export class Line2 extends LineSegments2 {
+    geometry: LineGeometry;
+    material: LineMaterial;
+
+    constructor(geometry?: LineGeometry, material?: LineMaterial);
+    readonly isLine2: true;
+}

three/examples/jsm/lines/LineGeometry.d.ts

@@ -0,0 +1,10 @@
+import { Line } from '../../../src/Three.js';
+
+import { LineSegmentsGeometry } from './LineSegmentsGeometry.js';
+
+export class LineGeometry extends LineSegmentsGeometry {
+    constructor();
+    readonly isLineGeometry: true;
+
+    fromLine(line: Line): this;
+}

three/examples/jsm/lines/LineMaterial.d.ts

@@ -0,0 +1,31 @@
+import { Color, MaterialParameters, ShaderMaterial, Vector2 } from '../../../src/Three.js';
+
+export interface LineMaterialParameters extends MaterialParameters {
+    alphaToCoverage?: boolean | undefined;
+    color?: number | undefined;
+    dashed?: boolean | undefined;
+    dashScale?: number | undefined;
+    dashSize?: number | undefined;
+    dashOffset?: number | undefined;
+    gapSize?: number | undefined;
+    linewidth?: number | undefined;
+    resolution?: Vector2 | undefined;
+    wireframe?: boolean | undefined;
+    worldUnits?: boolean | undefined;
+}
+
+export class LineMaterial extends ShaderMaterial {
+    constructor(parameters?: LineMaterialParameters);
+    color: Color;
+    dashed: boolean;
+    dashScale: number;
+    dashSize: number;
+    dashOffset: number;
+    gapSize: number;
+    opacity: number;
+    readonly isLineMaterial: true;
+    linewidth: number;
+    resolution: Vector2;
+    alphaToCoverage: boolean;
+    worldUnits: boolean;
+}

three/examples/jsm/lines/LineSegments2.d.ts

@@ -0,0 +1,14 @@
+import { Mesh } from '../../../src/Three.js';
+
+import { LineMaterial } from './LineMaterial.js';
+import { LineSegmentsGeometry } from './LineSegmentsGeometry.js';
+
+export class LineSegments2 extends Mesh {
+    geometry: LineSegmentsGeometry;
+    material: LineMaterial;
+
+    constructor(geometry?: LineSegmentsGeometry, material?: LineMaterial);
+    readonly isLineSegments2: true;
+
+    computeLineDistances(): this;
+}

three/examples/jsm/lines/LineSegmentsGeometry.d.ts

@@ -0,0 +1,23 @@
+import {
+    EdgesGeometry,
+    InstancedBufferGeometry,
+    LineSegments,
+    Matrix4,
+    Mesh,
+    WireframeGeometry,
+} from '../../../src/Three.js';
+
+export class LineSegmentsGeometry extends InstancedBufferGeometry {
+    constructor();
+    readonly isLineSegmentsGeometry: true;
+
+    applyMatrix4(matrix: Matrix4): this;
+    computeBoundingBox(): void;
+    computeBoundingSphere(): void;
+    fromEdgesGeometry(geometry: EdgesGeometry): this;
+    fromLineSegments(lineSegments: LineSegments): this;
+    fromMesh(mesh: Mesh): this;
+    fromWireframeGeometry(geometry: WireframeGeometry): this;
+    setColors(array: number[] | Float32Array): this;
+    setPositions(array: number[] | Float32Array): this;
+}

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

@@ -0,0 +1,16 @@
+import { LoadingManager, CompressedTextureLoader, PixelFormat, CompressedPixelFormat } from '../../../src/Three.js';
+
+export interface DDS {
+    mipmaps: object[];
+    width: number;
+    height: number;
+    format: PixelFormat | CompressedPixelFormat;
+    mipmapCount: number;
+    isCubemap: boolean;
+}
+
+export class DDSLoader extends CompressedTextureLoader {
+    constructor(manager?: LoadingManager);
+
+    parse(buffer: ArrayBuffer, loadMipmaps: boolean): DDS;
+}

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

@@ -0,0 +1,19 @@
+import { Loader, LoadingManager, BufferGeometry } from '../../../src/Three.js';
+
+export class DRACOLoader extends Loader<BufferGeometry> {
+    constructor(manager?: LoadingManager);
+
+    setDecoderPath(path: string): DRACOLoader;
+    setDecoderConfig(config: object): DRACOLoader;
+    setWorkerLimit(workerLimit: number): DRACOLoader;
+
+    load(
+        url: string,
+        onLoad?: (data: BufferGeometry) => void,
+        onProgress?: (event: ProgressEvent) => void,
+        onError?: (err: unknown) => void,
+    ): void;
+
+    preload(): DRACOLoader;
+    dispose(): DRACOLoader;
+}

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

@@ -0,0 +1,147 @@
+import {
+    AnimationClip,
+    BufferAttribute,
+    BufferGeometry,
+    Camera,
+    Group,
+    InterleavedBufferAttribute,
+    Loader,
+    LoadingManager,
+    Mesh,
+    MeshStandardMaterial,
+    Object3D,
+    Material,
+    SkinnedMesh,
+    Texture,
+    TextureLoader,
+    FileLoader,
+    ImageBitmapLoader,
+    Skeleton,
+} from '../../../src/Three.js';
+
+import { DRACOLoader } from './DRACOLoader.js';
+import { KTX2Loader } from './KTX2Loader.js';
+
+export interface GLTF {
+    animations: AnimationClip[];
+    scene: Group;
+    scenes: Group[];
+    cameras: Camera[];
+    asset: {
+        copyright?: string | undefined;
+        generator?: string | undefined;
+        version?: string | undefined;
+        minVersion?: string | undefined;
+        extensions?: any;
+        extras?: any;
+    };
+    parser: GLTFParser;
+    userData: any;
+}
+
+export class GLTFLoader extends Loader<GLTF> {
+    constructor(manager?: LoadingManager);
+    dracoLoader: DRACOLoader | null;
+
+    setDRACOLoader(dracoLoader: DRACOLoader): GLTFLoader;
+
+    register(callback: (parser: GLTFParser) => GLTFLoaderPlugin): GLTFLoader;
+    unregister(callback: (parser: GLTFParser) => GLTFLoaderPlugin): GLTFLoader;
+
+    setKTX2Loader(ktx2Loader: KTX2Loader): GLTFLoader;
+    setMeshoptDecoder(meshoptDecoder: /* MeshoptDecoder */ any): GLTFLoader;
+
+    parse(
+        data: ArrayBuffer | string,
+        path: string,
+        onLoad: (gltf: GLTF) => void,
+        onError?: (event: ErrorEvent) => void,
+    ): void;
+
+    parseAsync(data: ArrayBuffer | string, path: string): Promise<GLTF>;
+}
+
+export type GLTFReferenceType = 'materials' | 'nodes' | 'textures' | 'meshes';
+
+export interface GLTFReference {
+    materials?: number;
+    nodes?: number;
+    textures?: number;
+    meshes?: number;
+}
+
+export class GLTFParser {
+    json: any;
+
+    options: {
+        path: string;
+        manager: LoadingManager;
+        ktx2Loader: KTX2Loader;
+        meshoptDecoder: /* MeshoptDecoder */ any;
+        crossOrigin: string;
+        requestHeader: { [header: string]: string };
+    };
+
+    fileLoader: FileLoader;
+    textureLoader: TextureLoader | ImageBitmapLoader;
+    plugins: { [name: string]: GLTFLoaderPlugin };
+    extensions: { [name: string]: any };
+    associations: Map<Object3D | Material | Texture, GLTFReference>;
+
+    setExtensions(extensions: { [name: string]: any }): void;
+    setPlugins(plugins: { [name: string]: GLTFLoaderPlugin }): void;
+
+    parse(onLoad: (gltf: GLTF) => void, onError?: (event: ErrorEvent) => void): void;
+
+    getDependency: (type: string, index: number) => Promise<any>;
+    getDependencies: (type: string) => Promise<any[]>;
+    loadBuffer: (bufferIndex: number) => Promise<ArrayBuffer>;
+    loadBufferView: (bufferViewIndex: number) => Promise<ArrayBuffer>;
+    loadAccessor: (accessorIndex: number) => Promise<BufferAttribute | InterleavedBufferAttribute>;
+    loadTexture: (textureIndex: number) => Promise<Texture>;
+    loadTextureImage: (textureIndex: number, sourceIndex: number, loader: Loader) => Promise<Texture>;
+    loadImageSource: (sourceIndex: number, loader: Loader) => Promise<Texture>;
+    assignTexture: (
+        materialParams: { [key: string]: any },
+        mapName: string,
+        mapDef: {
+            index: number;
+            texCoord?: number | undefined;
+            extensions?: any;
+        },
+    ) => Promise<void>;
+    assignFinalMaterial: (object: Mesh) => void;
+    getMaterialType: () => typeof MeshStandardMaterial;
+    loadMaterial: (materialIndex: number) => Promise<Material>;
+    createUniqueName: (originalName: string) => string;
+    createNodeMesh: (nodeIndex: number) => Promise<Group | Mesh | SkinnedMesh>;
+    loadGeometries: (
+        /**
+         * GLTF.Primitive[]
+         * See: https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/schema/mesh.primitive.schema.json
+         */
+        primitives: Array<{ [key: string]: any }>,
+    ) => Promise<BufferGeometry[]>;
+    loadMesh: (meshIndex: number) => Promise<Group | Mesh | SkinnedMesh>;
+    loadCamera: (cameraIndex: number) => Promise<Camera>;
+    loadSkin: (skinIndex: number) => Promise<Skeleton>;
+    loadAnimation: (animationIndex: number) => Promise<AnimationClip>;
+    loadNode: (nodeIndex: number) => Promise<Object3D>;
+    loadScene: () => Promise<Group>;
+}
+
+export interface GLTFLoaderPlugin {
+    beforeRoot?: (() => Promise<void> | null) | undefined;
+    afterRoot?: ((result: GLTF) => Promise<void> | null) | undefined;
+    loadNode?: ((nodeIndex: number) => Promise<Object3D> | null) | undefined;
+    loadMesh?: ((meshIndex: number) => Promise<Group | Mesh | SkinnedMesh> | null) | undefined;
+    loadBufferView?: ((bufferViewIndex: number) => Promise<ArrayBuffer> | null) | undefined;
+    loadMaterial?: ((materialIndex: number) => Promise<Material> | null) | undefined;
+    loadTexture?: ((textureIndex: number) => Promise<Texture> | null) | undefined;
+    getMaterialType?: ((materialIndex: number) => typeof Material | null) | undefined;
+    extendMaterialParams?:
+        | ((materialIndex: number, materialParams: { [key: string]: any }) => Promise<any> | null)
+        | undefined;
+    createNodeMesh?: ((nodeIndex: number) => Promise<Group | Mesh | SkinnedMesh> | null) | undefined;
+    createNodeAttachment?: ((nodeIndex: number) => Promise<Object3D> | null) | undefined;
+}

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

@@ -0,0 +1,17 @@
+import { LoadingManager, CompressedTextureLoader, CompressedTexture, WebGLRenderer } from '../../../src/Three.js';
+import WebGPURenderer from '../renderers/webgpu/WebGPURenderer.js';
+
+export class KTX2Loader extends CompressedTextureLoader {
+    constructor(manager?: LoadingManager);
+
+    setTranscoderPath(path: string): KTX2Loader;
+    setWorkerLimit(limit: number): KTX2Loader;
+    detectSupport(renderer: WebGLRenderer | WebGPURenderer): KTX2Loader;
+    dispose(): KTX2Loader;
+
+    parse(
+        buffer: ArrayBuffer,
+        onLoad: (texture: CompressedTexture) => void,
+        onError?: (event: ErrorEvent) => void,
+    ): KTX2Loader;
+}

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

@@ -0,0 +1,19 @@
+import { Loader, LoadingManager, Group, Material } from '../../../src/Three.js';
+
+export class LDrawLoader extends Loader<Group> {
+    materials: Material[];
+    materialsLibrary: Record<string, Material>;
+    fileMap: Record<string, string>;
+    smoothNormals: boolean;
+
+    constructor(manager?: LoadingManager);
+
+    preloadMaterials(url: string): Promise<void>;
+    setFileMap(fileMap: Record<string, string>): void;
+    setMaterials(materials: Material[]): void;
+
+    parse(text: string, path: string, onLoad: (data: Group) => void): void;
+
+    addMaterial(material: Material): void;
+    getMaterial(colourCode: string): Material | null;
+}

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

@@ -11,7 +11,7 @@ export interface LogLuv {
 
 export class LogLuvLoader extends DataTextureLoader {
     type: TextureDataType;
-    constructor(manager: LoadingManager);
+    constructor(manager?: LoadingManager);
 
     parse(buffer: Iterable<number>): LogLuv;
 

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

@@ -0,0 +1,56 @@
+import { Camera, AnimationClip, FileLoader, Loader, LoadingManager, SkinnedMesh } from '../../../src/Three.js';
+
+export interface MMDLoaderAnimationObject {
+    animation: AnimationClip;
+    mesh: SkinnedMesh;
+}
+
+export class MMDLoader extends Loader<SkinnedMesh> {
+    constructor(manager?: LoadingManager);
+    animationBuilder: object;
+    animationPath: string;
+    loader: FileLoader;
+    meshBuilder: object;
+    parser: object | null;
+
+    loadAnimation(
+        url: string,
+        object: SkinnedMesh | Camera,
+        onLoad: (object: SkinnedMesh | AnimationClip) => void,
+        onProgress?: (event: ProgressEvent) => void,
+        onError?: (event: ErrorEvent) => void,
+    ): void;
+    loadPMD(
+        url: string,
+        onLoad: (object: object) => void,
+        onProgress?: (event: ProgressEvent) => void,
+        onError?: (event: ErrorEvent) => void,
+    ): void;
+    loadPMX(
+        url: string,
+        onLoad: (object: object) => void,
+        onProgress?: (event: ProgressEvent) => void,
+        onError?: (event: ErrorEvent) => void,
+    ): void;
+    loadVMD(
+        url: string,
+        onLoad: (object: object) => void,
+        onProgress?: (event: ProgressEvent) => void,
+        onError?: (event: ErrorEvent) => void,
+    ): void;
+    loadVPD(
+        url: string,
+        isUnicode: boolean,
+        onLoad: (object: object) => void,
+        onProgress?: (event: ProgressEvent) => void,
+        onError?: (event: ErrorEvent) => void,
+    ): void;
+    loadWithAnimation(
+        url: string,
+        vmdUrl: string | string[],
+        onLoad: (object: MMDLoaderAnimationObject) => void,
+        onProgress?: (event: ProgressEvent) => void,
+        onError?: (event: ErrorEvent) => void,
+    ): void;
+    setAnimationPath(animationPath: string): this;
+}