@needle-tools/three 0.169.12 → 0.169.14

package/types/examples/jsm/loaders/HDRCubeTextureLoader.d.ts

@@ -0,0 +1,18 @@
+import { CubeTexture, Loader, LoadingManager, TextureDataType } from "three";
+
+import { RGBELoader } from "./RGBELoader.js";
+
+export class HDRCubeTextureLoader extends Loader<CubeTexture, readonly string[]> {
+    constructor(manager?: LoadingManager);
+    hdrLoader: RGBELoader;
+    type: TextureDataType;
+
+    load(
+        url: readonly string[],
+        onLoad?: (data: CubeTexture) => void,
+        onProgress?: (event: ProgressEvent) => void,
+        onError?: (err: unknown) => void,
+    ): CubeTexture;
+
+    setDataType(type: TextureDataType): this;
+}

package/types/examples/jsm/loaders/IESLoader.d.ts

@@ -0,0 +1,5 @@
+import { DataTexture, Loader } from "three";
+
+export class IESLoader extends Loader<DataTexture> {
+    parse(text: string): DataTexture;
+}

package/types/examples/jsm/loaders/KMZLoader.d.ts

@@ -0,0 +1,9 @@
+import { Loader, LoadingManager } from "three";
+
+import { Collada } from "./ColladaLoader.js";
+
+export class KMZLoader extends Loader<Collada> {
+    constructor(manager?: LoadingManager);
+
+    parse(data: ArrayBuffer): Collada;
+}

package/types/examples/jsm/loaders/KTX2Loader.d.ts

@@ -0,0 +1,54 @@
+import { CompressedTexture, Loader, LoadingManager, WebGLRenderer } from "three";
+import { Renderer, WebGPURenderer } from "three/webgpu";
+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;
+
+    constructor(manager?: LoadingManager);
+
+    /**
+     * 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;
+
+    init(): Promise<void>;
+
+    parse(buffer: ArrayBuffer, onLoad?: (texture: CompressedTexture) => void, onError?: (err: unknown) => void): void;
+
+    /**
+     * Disposes the loader object, de-allocating any Web Workers created.
+     */
+    dispose(): this;
+}

package/types/examples/jsm/loaders/KTXLoader.d.ts

@@ -0,0 +1,22 @@
+import {
+    CompressedPixelFormat,
+    CompressedTextureLoader,
+    CompressedTextureMipmap,
+    LoadingManager,
+    PixelFormat,
+} from "three";
+
+export interface KTX {
+    mipmaps: CompressedTextureMipmap[];
+    width: number;
+    height: number;
+    format: PixelFormat | CompressedPixelFormat;
+    mipmapCount: number;
+    isCubemap: boolean;
+}
+
+export class KTXLoader extends CompressedTextureLoader {
+    constructor(manager?: LoadingManager);
+
+    parse(buffer: ArrayBuffer, loadMipmaps: boolean): KTX;
+}

package/types/examples/jsm/loaders/LDrawLoader.d.ts

@@ -0,0 +1,19 @@
+import { Group, Loader, LoadingManager, Material } from "three";
+
+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, onError?: (error: unknown) => void): void;
+
+    addMaterial(material: Material): void;
+    getMaterial(colourCode: string): Material | null;
+}

package/types/examples/jsm/loaders/LUT3dlLoader.d.ts

@@ -0,0 +1,39 @@
+import { Data3DTexture, FloatType, Loader, LoadingManager, UnsignedByteType } from "three";
+
+export interface LUT3dlResult {
+    size: number;
+    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);
+
+    /**
+     * 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;
+}

package/types/examples/jsm/loaders/LUTCubeLoader.d.ts

@@ -0,0 +1,42 @@
+import { Data3DTexture, FloatType, Loader, LoadingManager, UnsignedByteType, Vector3 } from "three";
+
+export interface LUTCubeResult {
+    title: string;
+    size: number;
+    domainMin: Vector3;
+    domainMax: Vector3;
+    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);
+
+    /**
+     * 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;
+}

package/types/examples/jsm/loaders/LUTImageLoader.d.ts

@@ -0,0 +1,18 @@
+import { Data3DTexture, Loader, Texture } from "three";
+
+export interface LUTImageResult {
+    size: number;
+    texture3D: Data3DTexture;
+}
+
+export class LUTImageLoader extends Loader<LUTImageResult> {
+    flip: boolean;
+
+    constructor(flipVertical?: boolean);
+
+    getImageData(texture: Texture): ImageData;
+
+    horz2Vert(texture: Texture): ImageData;
+
+    parse(dataArray: Uint8ClampedArray, size: number): LUTImageResult;
+}

package/types/examples/jsm/loaders/LWOLoader.d.ts

@@ -0,0 +1,19 @@
+import { Loader, LoadingManager, Material, Object3D } from "three";
+
+export interface LWO {
+    materials: Material[];
+    meshes: Object3D[];
+}
+
+export interface LWOLoaderParameters {
+    /**
+     * Base content delivery folder path, use when it differs from Lightwave default structure
+     */
+    resourcePath?: string;
+}
+
+export class LWOLoader extends Loader<LWO> {
+    constructor(manager?: LoadingManager, parameters?: LWOLoaderParameters);
+
+    parse(data: ArrayBuffer, path: string, modelName: string): LWO;
+}

package/types/examples/jsm/loaders/LottieLoader.d.ts

@@ -0,0 +1,14 @@
+import { CanvasTexture, Loader, LoadingManager } from "three";
+
+export class LottieLoader extends Loader<CanvasTexture> {
+    constructor(manager?: LoadingManager);
+
+    load(
+        url: string,
+        onLoad?: (data: CanvasTexture) => void,
+        onProgress?: (event: ProgressEvent) => void,
+        onError?: (err: unknown) => void,
+    ): CanvasTexture;
+
+    setQuality(value: number): void;
+}

package/types/examples/jsm/loaders/MD2Loader.d.ts

@@ -0,0 +1,7 @@
+import { BufferGeometry, Loader, LoadingManager } from "three";
+
+export class MD2Loader extends Loader<BufferGeometry> {
+    constructor(manager?: LoadingManager);
+
+    parse(data: ArrayBuffer): BufferGeometry;
+}

package/types/examples/jsm/loaders/MDDLoader.d.ts

@@ -0,0 +1,12 @@
+import { AnimationClip, BufferAttribute, Loader, LoadingManager } from "three";
+
+export interface MDD {
+    morphTargets: BufferAttribute[];
+    clip: AnimationClip;
+}
+
+export class MDDLoader extends Loader<MDD> {
+    constructor(manager?: LoadingManager);
+
+    parse(data: ArrayBuffer): MDD;
+}

package/types/examples/jsm/loaders/MMDLoader.d.ts

@@ -0,0 +1,56 @@
+import { AnimationClip, Camera, FileLoader, Loader, LoadingManager, SkinnedMesh } from "three";
+
+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;
+}

package/types/examples/jsm/loaders/MTLLoader.d.ts

@@ -0,0 +1,94 @@
+import { BufferGeometry, Loader, LoadingManager, Mapping, Material, Side, Texture, Vector2, Wrapping } from "three";
+
+export interface MaterialCreatorOptions {
+    /**
+     * side: Which side to apply the material
+     * THREE.FrontSide (default), THREE.BackSide, THREE.DoubleSide
+     */
+    side?: Side | undefined;
+    /*
+     * wrap: What type of wrapping to apply for textures
+     * THREE.RepeatWrapping (default), THREE.ClampToEdgeWrapping, THREE.MirroredRepeatWrapping
+     */
+    wrap?: Wrapping | undefined;
+    /*
+     * normalizeRGB: RGBs need to be normalized to 0-1 from 0-255
+     * Default: false, assumed to be already normalized
+     */
+    normalizeRGB?: boolean | undefined;
+    /*
+     * ignoreZeroRGBs: Ignore values of RGBs (Ka,Kd,Ks) that are all 0's
+     * Default: false
+     */
+    ignoreZeroRGBs?: boolean | undefined;
+    /*
+     * invertTrProperty: Use values 1 of Tr field for fully opaque. This option is useful for obj
+     * exported from 3ds MAX, vcglib or meshlab.
+     * Default: false
+     */
+    invertTrProperty?: boolean | undefined;
+}
+
+export class MTLLoader extends Loader<MTLLoader.MaterialCreator> {
+    constructor(manager?: LoadingManager);
+    materialOptions: MaterialCreatorOptions;
+
+    parse(text: string, path: string): MTLLoader.MaterialCreator;
+    setMaterialOptions(value: MaterialCreatorOptions): void;
+}
+
+export interface MaterialInfo {
+    ks?: number[] | undefined;
+    kd?: number[] | undefined;
+    ke?: number[] | undefined;
+    map_kd?: string | undefined;
+    map_ks?: string | undefined;
+    map_ke?: string | undefined;
+    norm?: string | undefined;
+    map_bump?: string | undefined;
+    bump?: string | undefined;
+    map_d?: string | undefined;
+    ns?: number | undefined;
+    d?: number | undefined;
+    tr?: number | undefined;
+}
+
+export interface TexParams {
+    scale: Vector2;
+    offset: Vector2;
+    url: string;
+}
+
+export namespace MTLLoader {
+    class MaterialCreator {
+        constructor(baseUrl?: string, options?: MaterialCreatorOptions);
+
+        baseUrl: string;
+        options: MaterialCreatorOptions;
+        materialsInfo: { [key: string]: MaterialInfo };
+        materials: { [key: string]: Material };
+        private materialsArray: Material[];
+        nameLookup: { [key: string]: number };
+        side: Side;
+        wrap: Wrapping;
+        crossOrigin: string;
+
+        setCrossOrigin(value: string): this;
+        setManager(value: LoadingManager): void;
+        setMaterials(materialsInfo: { [key: string]: MaterialInfo }): void;
+        convert(materialsInfo: { [key: string]: MaterialInfo }): { [key: string]: MaterialInfo };
+        preload(): void;
+        getIndex(materialName: string): number;
+        getAsArray(): Material[];
+        create(materialName: string): Material;
+        createMaterial_(materialName: string): Material;
+        getTextureParams(value: string, matParams: any): TexParams;
+        loadTexture(
+            url: string,
+            mapping?: Mapping,
+            onLoad?: (bufferGeometry: BufferGeometry) => void,
+            onProgress?: (event: ProgressEvent) => void,
+            onError?: (event: ErrorEvent) => void,
+        ): Texture;
+    }
+}

package/types/examples/jsm/loaders/MaterialXLoader.d.ts

@@ -0,0 +1,5 @@
+import { Loader, LoadingManager, MeshPhysicalNodeMaterial } from "three/webgpu";
+
+export class MaterialXLoader extends Loader<{ materials: Record<string, MeshPhysicalNodeMaterial> }> {
+    constructor(manager?: LoadingManager);
+}

package/types/examples/jsm/loaders/NRRDLoader.d.ts

@@ -0,0 +1,15 @@
+import { Loader, LoadingManager } from "three";
+
+import { Volume } from "../misc/Volume.js";
+
+export class NRRDLoader extends Loader<Volume> {
+    constructor(manager?: LoadingManager);
+    manager: LoadingManager;
+    path: string;
+
+    fieldFunctions: object;
+
+    parse(data: string): Volume;
+    parseChars(array: number[], start?: number, end?: number): string;
+    setPath(value: string): this;
+}

package/types/examples/jsm/loaders/OBJLoader.d.ts

@@ -0,0 +1,10 @@
+import { Group, Loader, LoadingManager } from "three";
+import { MTLLoader } from "./MTLLoader.js";
+
+export class OBJLoader extends Loader<Group> {
+    constructor(manager?: LoadingManager);
+    materials: MTLLoader.MaterialCreator;
+
+    parse(data: string): Group;
+    setMaterials(materials: MTLLoader.MaterialCreator): this;
+}

package/types/examples/jsm/loaders/PCDLoader.d.ts

@@ -0,0 +1,8 @@
+import { BufferGeometry, Loader, LoadingManager, Points, PointsMaterial } from "three";
+
+export class PCDLoader extends Loader<Points<BufferGeometry, PointsMaterial>> {
+    constructor(manager?: LoadingManager);
+    littleEndian: boolean;
+
+    parse(data: ArrayBuffer | string): Points<BufferGeometry, PointsMaterial>;
+}

package/types/examples/jsm/loaders/PDBLoader.d.ts

@@ -0,0 +1,15 @@
+import { BufferGeometry, Loader, LoadingManager } from "three";
+
+export interface PDB {
+    geometryAtoms: BufferGeometry;
+    geometryBonds: BufferGeometry;
+    json: {
+        atoms: any[][];
+    };
+}
+
+export class PDBLoader extends Loader<PDB> {
+    constructor(manager?: LoadingManager);
+
+    parse(text: string): PDB;
+}

package/types/examples/jsm/loaders/PLYLoader.d.ts

@@ -0,0 +1,11 @@
+import { BufferGeometry, Loader, LoadingManager } from "three";
+
+export class PLYLoader extends Loader<BufferGeometry> {
+    constructor(manager?: LoadingManager);
+    propertyNameMapping: object;
+    customPropertyMapping: Record<string, any>;
+
+    setPropertyNameMapping(mapping: object): void;
+    setCustomPropertyNameMapping(mapping: Record<string, any>): void;
+    parse(data: ArrayBuffer | string): BufferGeometry;
+}

package/types/examples/jsm/loaders/PVRLoader.d.ts

@@ -0,0 +1,16 @@
+import { CompressedPixelFormat, CompressedTextureLoader, CompressedTextureMipmap, LoadingManager } from "three";
+
+export interface PVR {
+    mipmaps: CompressedTextureMipmap[];
+    width: number;
+    height: number;
+    format: CompressedPixelFormat;
+    mipmapCount: number;
+    isCubemap: boolean;
+}
+
+export class PVRLoader extends CompressedTextureLoader {
+    constructor(manager?: LoadingManager);
+
+    parse(buffer: ArrayBuffer, loadMipmaps: boolean): PVR;
+}

package/types/examples/jsm/loaders/RGBELoader.d.ts

@@ -0,0 +1,19 @@
+import { DataTextureLoader, LoadingManager, PixelFormat, TextureDataType } from "three";
+
+export interface RGBE {
+    width: number;
+    height: number;
+    data: Float32Array | Uint8Array;
+    header: string;
+    gamma: number;
+    exposure: number;
+    type: TextureDataType;
+}
+
+export class RGBELoader extends DataTextureLoader {
+    constructor(manager?: LoadingManager);
+    type: TextureDataType;
+
+    parse(buffer: ArrayBuffer): RGBE;
+    setDataType(type: TextureDataType): this;
+}

package/types/examples/jsm/loaders/RGBMLoader.d.ts

@@ -0,0 +1,37 @@
+import { CubeTexture, DataTextureLoader, LoadingManager, PixelFormat, TextureDataType } from "three";
+
+export interface RGBM {
+    width: number;
+    height: number;
+    data: Uint16Array | Float32Array;
+    header: string;
+    format: PixelFormat;
+    type: TextureDataType;
+    flipY: boolean;
+}
+
+export class RGBMLoader extends DataTextureLoader {
+    type: TextureDataType;
+
+    maxRange: number;
+
+    constructor(manager?: LoadingManager);
+
+    loadCubemap(
+        urls: string[],
+        onLoad?: (texture: CubeTexture) => void,
+        onProgress?: (event: ProgressEvent) => void,
+        onError?: (event: ErrorEvent) => void,
+    ): CubeTexture;
+
+    loadCubemapAsync(
+        urls: string[],
+        onProgress?: (event: ProgressEvent) => void,
+    ): Promise<CubeTexture>;
+
+    parse(buffer: ArrayBuffer): RGBM;
+
+    setDataType(dataType: TextureDataType): this;
+
+    setMaxRange(value: number): this;
+}

package/types/examples/jsm/loaders/STLLoader.d.ts

@@ -0,0 +1,7 @@
+import { BufferGeometry, Loader, LoadingManager } from "three";
+
+export class STLLoader extends Loader<BufferGeometry> {
+    constructor(manager?: LoadingManager);
+
+    parse(data: ArrayBuffer | string): BufferGeometry;
+}

package/types/examples/jsm/loaders/SVGLoader.d.ts

@@ -0,0 +1,64 @@
+import { BufferGeometry, Loader, LoadingManager, Shape, ShapePath, Vector2, Vector3 } from "three";
+
+export interface SVGResultPaths extends ShapePath {
+    userData?: Record<string, any> | undefined;
+}
+
+export interface SVGResult {
+    paths: SVGResultPaths[];
+    xml: XMLDocument;
+}
+
+export interface StrokeStyle {
+    strokeColor: string;
+    strokeWidth: number;
+    strokeLineJoin: string;
+    strokeLineCap: string;
+    strokeMiterLimit: number;
+}
+
+export class SVGLoader extends Loader<SVGResult> {
+    constructor(manager?: LoadingManager);
+
+    defaultDPI: number;
+    defaultUnit: string;
+
+    parse(text: string): SVGResult;
+
+    static getStrokeStyle(
+        width?: number,
+        color?: string,
+        lineJoin?: string,
+        lineCap?: string,
+        miterLimit?: number,
+    ): StrokeStyle;
+
+    /**
+     * Generates a stroke with some witdh around the given path.
+     * @remarks The path can be open or closed (last point equals to first point)
+     * @param points  Array of Vector2D (the path). Minimum 2 points.
+     * @param style  Object with SVG properties as returned by SVGLoader.getStrokeStyle(), or SVGLoader.parse() in the path.userData.style object
+     * @param arcDivisions Arc divisions for round joins and endcaps. (Optional)
+     * @param minDistance Points closer to this distance will be merged. (Optional)
+     * @returns BufferGeometry with stroke triangles (In plane z = 0). UV coordinates are generated ('u' along path. 'v' across it, from left to right)
+     */
+    static pointsToStroke(
+        points: Vector2[],
+        style: StrokeStyle,
+        arcDivisions?: number,
+        minDistance?: number,
+    ): BufferGeometry;
+
+    static pointsToStrokeWithBuffers(
+        points: Vector2[],
+        style: StrokeStyle,
+        arcDivisions?: number,
+        minDistance?: number,
+        vertices?: number[],
+        normals?: number[],
+        uvs?: number[],
+        vertexOffset?: number,
+    ): number;
+
+    static createShapes(shapePath: ShapePath): Shape[];
+}