threepipe
Version:
A modern 3D viewer framework built on top of three.js, written in TypeScript, designed to make creating high-quality, modular, and extensible 3D experiences on the web simple and enjoyable.
166 lines • 7.08 kB
TypeScript
import { EventDispatcher, EventListener, LoadingManager } from 'three';
import { IAssetImporter, ImportAssetOptions, ImportFilesOptions, ImportResult, ProcessRawOptions } from './IAssetImporter';
import { IAsset, IFile } from './IAsset';
import { IImporter, ILoader } from './IImporter';
import { AssetManagerOptions } from './AssetManager';
import { IGeometry, LineMaterial2, UnlitLineMaterial, UnlitMaterial } from '../core';
export interface IAssetImporterEventMap {
loaderCreate: {
type: 'loaderCreate';
loader: ILoader;
};
importFile: {
type: 'importFile';
path: string;
state: 'downloading' | 'done' | 'error' | 'adding';
progress?: number;
loadedBytes?: number;
totalBytes?: number;
error?: any;
};
importFiles: {
type: 'importFiles';
files: Map<string, IFile>;
state: 'start' | 'end';
};
processRaw: {
type: 'processRaw';
data: ImportResult;
options: ProcessRawOptions;
path?: string;
};
processRawStart: {
type: 'processRawStart';
data: ImportResult;
options: ProcessRawOptions;
path?: string;
};
/**
* @deprecated use the {@link importFile} event instead
*/
onLoad: {
type: 'onLoad';
};
/**
* @deprecated use the {@link importFile} event instead
*/
onProgress: {
type: 'onProgress';
url: string;
loaded: number;
total: number;
};
/**
* @deprecated use the {@link importFile} event instead
*/
onError: {
type: 'onError';
url: string;
};
/**
* @deprecated use the {@link importFile} event instead
*/
onStart: {
type: 'onStart';
url: string;
loaded: number;
total: number;
};
}
/**
* Asset Importer
*
* Utility class to import assets from local files, blobs, urls, etc.
* Used in {@link AssetManager} to import assets.
* Acts as a wrapper over three.js LoadingManager and adds support for dynamically loading loaders, caching assets, better event dispatching and file tracking.
* @category Asset Manager
*/
export declare class AssetImporter extends EventDispatcher<IAssetImporterEventMap> implements IAssetImporter {
private _loadingManager;
private _storage?;
get storage(): Storage | Cache | undefined;
private _logger;
protected _rootContext?: {
path: string;
rootUrl: string;
};
private _loaderCache;
private _fileDatabase;
private _cachedAssets;
/**
* If true, imported assets are cached in memory(as js/three.js objects) and can be reused later. They will be cleared when dispose event is fired on the object or {@link clearCache} is called.
*/
cacheImportedAssets: boolean;
static DummyMaterial: UnlitMaterial<import('../core').IMaterialEventMap>;
static DummyLineBasicMaterial: UnlitLineMaterial<import('../core').IMaterialEventMap>;
static DummyLineMaterial: LineMaterial2<import('../core').IMaterialEventMap>;
static DummyGeometry: IGeometry;
readonly importers: IImporter[];
constructor(logging?: boolean, { simpleCache, storage }?: AssetManagerOptions);
get loadingManager(): LoadingManager;
get cachedAssets(): IAsset[];
addImporter(...importers: IImporter[]): void;
removeImporter(...importers: IImporter[]): void;
import<T extends ImportResult | undefined = ImportResult>(assetOrPath?: string | IAsset | IAsset[] | File | File[], options?: ImportAssetOptions, onDownloadProgress?: (e: ProgressEvent) => void, isInternal?: boolean): Promise<(T | undefined)[]>;
importSingle<T extends ImportResult | undefined = ImportResult>(asset?: string | IAsset | File, options?: ImportAssetOptions, onDownloadProgress?: (e: ProgressEvent) => void, isInternal?: boolean): Promise<T | undefined>;
importPath<T extends ImportResult | undefined = ImportResult | undefined>(path: string, options?: ImportAssetOptions, onDownloadProgress?: (e: ProgressEvent) => void): Promise<T[]>;
private _serializeOptions;
importAsset<T extends ImportResult | undefined = ImportResult | undefined>(asset?: IAsset, options?: ImportAssetOptions, onDownloadProgress?: (e: ProgressEvent) => void, isInternal?: boolean): Promise<T[]>;
importFile<T extends ImportResult | undefined = ImportResult | undefined>(file?: File, options?: ImportAssetOptions, onDownloadProgress?: (e: ProgressEvent) => void): Promise<T[]>;
/**
* Import multiple local files/blobs from a map of files, like when a local folder is loaded, or when multiple files are dropped.
* @param files
* @param options
*/
importFiles<T extends ImportResult | undefined = ImportResult | undefined>(files: Map<string, IFile>, options?: ImportFilesOptions): Promise<Map<string, T[]>>;
private _loadFile;
/**
* Register a file in the database and return a loader for it. If the loader does not exist, it will be created.
* @param path
* @param file
* @param extension
* @param loader
*/
registerFile(path: string, file?: IFile, extension?: string, loader?: ILoader): ILoader | undefined;
/**
* Remove a file from the database and revoke the object url if it exists.
* @param path
*/
unregisterFile(path: string): void;
/**
* Automatically set name of the asset if not set already, based on the file name.
*/
autoSetName: boolean;
processRaw<T extends (ImportResult | undefined) = ImportResult>(res: T | T[], options: ProcessRawOptions, path?: string): Promise<T[]>;
processRawSingle<T extends (ImportResult | undefined) = ImportResult>(res: T, options: ProcessRawOptions, path?: string): Promise<T>;
dispose(): void;
/**
* Clear memory asset and loader cache. Browser cache and custom cache storage is not cleared with this.
*/
clearCache(): void;
unregisterAllFiles(): void;
clearLoaderCache(): void;
resolveURL(url: string): string;
protected _urlModifiers: ((url: string) => string)[];
addURLModifier(modifier: (url: string) => string): void;
removeURLModifier(modifier: (url: string) => string): void;
protected _urlModifier(url: string): string;
private _isRootFile;
private _getImporter;
private _getLoader;
private _createLoader;
private _cacheStoreInitPromise?;
private _initCacheStorage;
addEventListener<T extends keyof IAssetImporterEventMap>(type: T, listener: EventListener<IAssetImporterEventMap[T], T, this>): void;
protected _onLoad(): void;
protected _onProgress(url: string, loaded: number, total: number): void;
protected _onError(url: string): void;
protected _onStart(url: string, loaded: number, total: number): void;
/**
* @deprecated use {@link processRaw} instead
* @param res
* @param options
*/
processImported(res: any, options: ProcessRawOptions, path?: string): Promise<any[]>;
}
//# sourceMappingURL=../src/assetmanager/AssetImporter.d.ts.map