@threepipe/plugins-extra-importers/dist/index.d.ts

Extra Threepipe plugins for importing several file types.

import { AnyOptions, BaseImporterPlugin, BufferGeometry, Group, Importer, Mesh, Object3D, Points, Scene } from 'threepipe';
import { TDSLoader } from 'three/examples/jsm/loaders/TDSLoader.js';
import { ThreeMFLoader } from 'three/examples/jsm/loaders/3MFLoader.js';
import { Collada } from 'three/examples/jsm/loaders/ColladaLoader.js';
import { AMFLoader } from 'three/examples/jsm/loaders/AMFLoader.js';
import { GCodeLoader } from 'three/examples/jsm/loaders/GCodeLoader.js';
import { BVH } from 'three/examples/jsm/loaders/BVHLoader.js';
import { Chunk } from 'three/examples/jsm/loaders/VOXLoader.js';
import { MDD } from 'three/examples/jsm/loaders/MDDLoader.js';
import { TiltLoader } from 'three/examples/jsm/loaders/TiltLoader.js';
import { VRMLLoader } from 'three/examples/jsm/loaders/VRMLLoader.js';
/**
 * Adds support for loading Autodesk 3ds `.3ds`, `application/x-3ds` files and data uris
 */
export declare class TDSLoadPlugin extends BaseImporterPlugin {
    static readonly PluginType = "TDSLoadPlugin";
    protected _importer: Importer<TDSLoader>;
}
/**
 * Adds support for loading `.3mf`, `model/3mf` files and data uris
 */
export declare class ThreeMFLoadPlugin extends BaseImporterPlugin {
    static readonly PluginType = "ThreeMFLoadPlugin";
    protected _importer: Importer<ThreeMFLoader>;
}
/**
 * Adds support for loading Collada `.dae`, `model/vnd.collada+xml` files and data uris
 */
export declare class ColladaLoadPlugin extends BaseImporterPlugin {
    static readonly PluginType = "ColladaLoadPlugin";
    protected _importer: Importer<{
        transform(res: Collada, _: AnyOptions): Scene;
        parse(text: string, path: string): Collada;
        crossOrigin: string;
        withCredentials: boolean;
        path: string;
        resourcePath: string;
        manager: import('threepipe').LoadingManager;
        requestHeader: {
            [header: string]: string;
        };
        load(url: string, onLoad: (data: Collada) => void, onProgress?: (event: ProgressEvent) => void, onError?: (err: unknown) => void): void;
        loadAsync(url: string, onProgress?: (event: ProgressEvent) => void): Promise<Collada>;
        setCrossOrigin(crossOrigin: string): /*elided*/ any;
        setWithCredentials(value: boolean): /*elided*/ any;
        setPath(path: string): /*elided*/ any;
        setResourcePath(resourcePath: string): /*elided*/ any;
        setRequestHeader(requestHeader: {
            [header: string]: string;
        }): /*elided*/ any;
    }>;
}
/**
 * Adds support for loading Additive Manufacturing files `.amf`, `application/amf` files and data uris
 */
export declare class AMFLoadPlugin extends BaseImporterPlugin {
    static readonly PluginType = "AMFLoadPlugin";
    protected _importer: Importer<AMFLoader>;
}
/**
 * Adds support for loading `.gcode`, `application/gcode` files and data uris
 */
export declare class GCodeLoadPlugin extends BaseImporterPlugin {
    static readonly PluginType = "GCodeLoadPlugin";
    protected _importer: Importer<GCodeLoader>;
}
/**
 * Adds support for loading `.bvh`, `application/bvh` files and data uris
 */
export declare class BVHLoadPlugin extends BaseImporterPlugin {
    static readonly PluginType = "BVHLoadPlugin";
    protected _importer: Importer<{
        transform(res: BVH, _: AnyOptions): Object3D;
        animateBonePositions: boolean;
        animateBoneRotations: boolean;
        parse(text: string): BVH;
        crossOrigin: string;
        withCredentials: boolean;
        path: string;
        resourcePath: string;
        manager: import('threepipe').LoadingManager;
        requestHeader: {
            [header: string]: string;
        };
        load(url: string, onLoad: (data: BVH) => void, onProgress?: (event: ProgressEvent) => void, onError?: (err: unknown) => void): void;
        loadAsync(url: string, onProgress?: (event: ProgressEvent) => void): Promise<BVH>;
        setCrossOrigin(crossOrigin: string): /*elided*/ any;
        setWithCredentials(value: boolean): /*elided*/ any;
        setPath(path: string): /*elided*/ any;
        setResourcePath(resourcePath: string): /*elided*/ any;
        setRequestHeader(requestHeader: {
            [header: string]: string;
        }): /*elided*/ any;
    }>;
}
/**
 * Adds support for loading Magica Voxel `.vox` files and data uris
 */
export declare class VOXLoadPlugin extends BaseImporterPlugin {
    static readonly PluginType = "VOXLoadPlugin";
    protected _importer: Importer<{
        transform(chunks: Chunk[], _: AnyOptions): Object3D;
        parse(data: ArrayBuffer): object[];
        crossOrigin: string;
        withCredentials: boolean;
        path: string;
        resourcePath: string;
        manager: import('threepipe').LoadingManager;
        requestHeader: {
            [header: string]: string;
        };
        load(url: string, onLoad: (data: Chunk[]) => void, onProgress?: (event: ProgressEvent) => void, onError?: (err: unknown) => void): void;
        loadAsync(url: string, onProgress?: (event: ProgressEvent) => void): Promise<Chunk[]>;
        setCrossOrigin(crossOrigin: string): /*elided*/ any;
        setWithCredentials(value: boolean): /*elided*/ any;
        setPath(path: string): /*elided*/ any;
        setResourcePath(resourcePath: string): /*elided*/ any;
        setRequestHeader(requestHeader: {
            [header: string]: string;
        }): /*elided*/ any;
    }>;
}
/**
 * Adds support for loading animation `.mdd`, `application/mdd` files and data uris
 */
export declare class MDDLoadPlugin extends BaseImporterPlugin {
    static readonly PluginType = "MDDLoadPlugin";
    protected _importer: Importer<{
        transform(res: MDD, _: AnyOptions): Object3D;
        parse(data: ArrayBuffer): MDD;
        crossOrigin: string;
        withCredentials: boolean;
        path: string;
        resourcePath: string;
        manager: import('threepipe').LoadingManager;
        requestHeader: {
            [header: string]: string;
        };
        load(url: string, onLoad: (data: MDD) => void, onProgress?: (event: ProgressEvent) => void, onError?: (err: unknown) => void): void;
        loadAsync(url: string, onProgress?: (event: ProgressEvent) => void): Promise<MDD>;
        setCrossOrigin(crossOrigin: string): /*elided*/ any;
        setWithCredentials(value: boolean): /*elided*/ any;
        setPath(path: string): /*elided*/ any;
        setResourcePath(resourcePath: string): /*elided*/ any;
        setRequestHeader(requestHeader: {
            [header: string]: string;
        }): /*elided*/ any;
    }>;
}
/**
 * Adds support for loading Point cloud data `.pcd`, `application/pcd` files and data uris
 */
export declare class PCDLoadPlugin extends BaseImporterPlugin {
    static readonly PluginType = "PCDLoadPlugin";
    protected _importer: Importer<{
        transform(points: Points, options: AnyOptions): any;
        littleEndian: boolean;
        parse(data: ArrayBuffer | string): Points;
        crossOrigin: string;
        withCredentials: boolean;
        path: string;
        resourcePath: string;
        manager: import('threepipe').LoadingManager;
        requestHeader: {
            [header: string]: string;
        };
        load(url: string, onLoad: (data: Points<BufferGeometry<import('./threepipe').NormalBufferAttributes, import('./threepipe').BufferGeometryEventMap>, import('threepipe').Material<import('./threepipe').MaterialEventMap> | import('threepipe').Material<import('./threepipe').MaterialEventMap>[]>) => void, onProgress?: (event: ProgressEvent) => void, onError?: (err: unknown) => void): void;
        loadAsync(url: string, onProgress?: (event: ProgressEvent) => void): Promise<Points<BufferGeometry<import('./threepipe').NormalBufferAttributes, import('./threepipe').BufferGeometryEventMap>, import('threepipe').Material<import('./threepipe').MaterialEventMap> | import('threepipe').Material<import('./threepipe').MaterialEventMap>[]>>;
        setCrossOrigin(crossOrigin: string): /*elided*/ any;
        setWithCredentials(value: boolean): /*elided*/ any;
        setPath(path: string): /*elided*/ any;
        setResourcePath(resourcePath: string): /*elided*/ any;
        setRequestHeader(requestHeader: {
            [header: string]: string;
        }): /*elided*/ any;
    }>;
}
/**
 * Adds support for loading Tilt brush `.tilt`, `application/tilt` files and data uris
 */
export declare class TiltLoadPlugin extends BaseImporterPlugin {
    static readonly PluginType = "TiltLoadPlugin";
    protected _importer: Importer<TiltLoader>;
}
/**
 * Adds support for loading VRML `.wrl`, `model/vrml` files and data uris
 */
export declare class VRMLLoadPlugin extends BaseImporterPlugin {
    static readonly PluginType = "VRMLLoadPlugin";
    protected _importer: Importer<VRMLLoader>;
}
/**
 * Adds support for loading LDraw `.mpd`, `application/mpd` files and data uris. see https://ldraw.org
 */
export declare class LDrawLoadPlugin extends BaseImporterPlugin {
    static readonly PluginType = "LDrawLoadPlugin";
    protected _importer: Importer<{
        transform(res: Group, _: AnyOptions): any;
        materials: import('threepipe').Material[];
        materialsLibrary: Record<string, import('threepipe').Material>;
        fileMap: Record<string, string>;
        smoothNormals: boolean;
        preloadMaterials(url: string): Promise<void>;
        setFileMap(fileMap: Record<string, string>): void;
        setMaterials(materials: import('threepipe').Material[]): void;
        parse(text: string, path: string, onLoad: (data: Group) => void): void;
        addMaterial(material: import('threepipe').Material): void;
        getMaterial(colourCode: string): import('threepipe').Material | null;
        crossOrigin: string;
        withCredentials: boolean;
        path: string;
        resourcePath: string;
        manager: import('threepipe').LoadingManager;
        requestHeader: {
            [header: string]: string;
        };
        load(url: string, onLoad: (data: Group<import('./threepipe').Object3DEventMap>) => void, onProgress?: (event: ProgressEvent) => void, onError?: (err: unknown) => void): void;
        loadAsync(url: string, onProgress?: (event: ProgressEvent) => void): Promise<Group<import('./threepipe').Object3DEventMap>>;
        setCrossOrigin(crossOrigin: string): /*elided*/ any;
        setWithCredentials(value: boolean): /*elided*/ any;
        setPath(path: string): /*elided*/ any;
        setResourcePath(resourcePath: string): /*elided*/ any;
        setRequestHeader(requestHeader: {
            [header: string]: string;
        }): /*elided*/ any;
    }>;
}
/**
 * Adds support for loading VTK `.vtk`, '.vtp', `application/vtk` files and data uris
**/
export declare class VTKLoadPlugin extends BaseImporterPlugin {
    static readonly PluginType = "VTKLoadPlugin";
    protected _importer: Importer<{
        transform(res: BufferGeometry, _: AnyOptions): Mesh | undefined;
        parse(data: ArrayBuffer | string, path: string): BufferGeometry;
        crossOrigin: string;
        withCredentials: boolean;
        path: string;
        resourcePath: string;
        manager: import('threepipe').LoadingManager;
        requestHeader: {
            [header: string]: string;
        };
        load(url: string, onLoad: (data: BufferGeometry<import('./threepipe').NormalBufferAttributes, import('./threepipe').BufferGeometryEventMap>) => void, onProgress?: (event: ProgressEvent) => void, onError?: (err: unknown) => void): void;
        loadAsync(url: string, onProgress?: (event: ProgressEvent) => void): Promise<BufferGeometry<import('./threepipe').NormalBufferAttributes, import('./threepipe').BufferGeometryEventMap>>;
        setCrossOrigin(crossOrigin: string): /*elided*/ any;
        setWithCredentials(value: boolean): /*elided*/ any;
        setPath(path: string): /*elided*/ any;
        setResourcePath(resourcePath: string): /*elided*/ any;
        setRequestHeader(requestHeader: {
            [header: string]: string;
        }): /*elided*/ any;
    }>;
}
/**
 * Adds support for loading XYZ `.xyz`, `text/plain+xyz` files and data uris
 */
export declare class XYZLoadPlugin extends BaseImporterPlugin {
    static readonly PluginType = "XYZLoadPlugin";
    protected _importer: Importer<{
        transform(res: BufferGeometry, options: AnyOptions): Points | undefined;
        parse(data: string, onLoad: (geometry: BufferGeometry) => void): object;
        crossOrigin: string;
        withCredentials: boolean;
        path: string;
        resourcePath: string;
        manager: import('threepipe').LoadingManager;
        requestHeader: {
            [header: string]: string;
        };
        load(url: string, onLoad: (data: BufferGeometry<import('./threepipe').NormalBufferAttributes, import('./threepipe').BufferGeometryEventMap>) => void, onProgress?: (event: ProgressEvent) => void, onError?: (err: unknown) => void): void;
        loadAsync(url: string, onProgress?: (event: ProgressEvent) => void): Promise<BufferGeometry<import('./threepipe').NormalBufferAttributes, import('./threepipe').BufferGeometryEventMap>>;
        setCrossOrigin(crossOrigin: string): /*elided*/ any;
        setWithCredentials(value: boolean): /*elided*/ any;
        setPath(path: string): /*elided*/ any;
        setResourcePath(resourcePath: string): /*elided*/ any;
        setRequestHeader(requestHeader: {
            [header: string]: string;
        }): /*elided*/ any;
    }>;
}
export declare const extraImportPlugins: readonly [typeof TDSLoadPlugin, typeof ThreeMFLoadPlugin, typeof ColladaLoadPlugin, typeof AMFLoadPlugin, typeof GCodeLoadPlugin, typeof BVHLoadPlugin, typeof VOXLoadPlugin, typeof MDDLoadPlugin, typeof PCDLoadPlugin, typeof TiltLoadPlugin, typeof VRMLLoadPlugin, typeof LDrawLoadPlugin, typeof VTKLoadPlugin, typeof XYZLoadPlugin];
//# sourceMappingURL=index.d.ts.map