@xviewer.js/debug 1.0.0-alpha.5 → 1.0.0-alpha.7

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@xviewer.js/debug",
-    "version": "1.0.0-alpha.5",
+    "version": "1.0.0-alpha.7",
     "publishConfig": {
         "access": "public",
         "registry": "https://registry.npmjs.org"
@@ -18,6 +18,6 @@
         "types/**/*"
     ],
     "dependencies": {
-        "@xviewer.js/core": "1.0.0-alpha.5"
+        "@xviewer.js/core": "1.0.0-alpha.7"
     }
 }

package/types/Component.d.ts

@@ -0,0 +1,34 @@
+import { Object3D } from "three";
+import { Viewer } from "./Viewer";
+import { ComponentManager } from "./ComponentManager";
+import { ObjectInstance } from "./ObjectInstance";
+export declare class Component<T extends Object3D = Object3D> extends ObjectInstance {
+    get enabled(): boolean;
+    set enabled(v: boolean);
+    private _enabled;
+    node: T;
+    viewer: Viewer;
+    manager: ComponentManager;
+    type: string;
+    onLoad?(): void;
+    onEnable?(): void;
+    onDisable?(): void;
+    onDestroy?(): void;
+    start?(): void;
+    update?(dt: number): void;
+    lastUpdate?(dt: number): void;
+    flags: {
+        Destroyed?: boolean;
+        OnLoadCalled?: boolean;
+        OnEnableCalled?: boolean;
+        StartCalled?: boolean;
+        Deactivating?: boolean;
+        IsStartCalled?: boolean;
+    };
+    protected _onPreDestroy(): void;
+    schedule(callback: Function, interval: number, repeat?: number): void;
+    unshedule(callback: Function): void;
+    unscheduleAll(): void;
+    destroy(): boolean;
+    destroyImmediate(): void;
+}

package/types/ComponentManager.d.ts

@@ -0,0 +1,48 @@
+import { Object3D } from "three";
+import { Scheduler } from "./Scheduler";
+import { Component } from "./Component";
+import { ComponentScheduler } from "./ComponentScheduler";
+import { Viewer } from "./Viewer";
+type ComponentConstructor = new () => Component;
+interface DependentInfo {
+    mode: DependentMode;
+    components: ComponentConstructor[];
+}
+export declare enum DependentMode {
+    /** Check only, throw error if dependent components do not exist. */
+    CheckOnly = 0,
+    /** Auto add if dependent components do not exist. */
+    AutoAdd = 1
+}
+export declare function dependencies(componentOrComponents: ComponentConstructor | ComponentConstructor[], mode?: DependentMode): <T extends ComponentConstructor>(target: T) => void;
+export declare class ComponentManager {
+    static _dependenciesMap: Map<ComponentConstructor, DependentInfo>;
+    private _viewer;
+    private _scheduler;
+    private _componentScheduler;
+    private _componentsMap;
+    get viewer(): Viewer;
+    get scheduler(): Scheduler;
+    get componentScheduler(): ComponentScheduler;
+    constructor(viewer: Viewer);
+    destroy(): void;
+    update(dt: number): void;
+    destroyComponents(node: Object3D): void;
+    activeComponents(node: Object3D): void;
+    addComponent<T extends Component>(node: Object3D | Component, instance: T): T;
+    addComponent<T extends Component>(node: Object3D | Component, constructor: {
+        new (): T;
+    }): T;
+    removeComponent(node: Object3D, component: Component): this;
+    getComponent<T extends Component>(node: Object3D, constructor: {
+        new (): T;
+    }, autoAdd?: boolean): T;
+    getComponentsInChidren<T extends Component>(node: Object3D, constructor: {
+        new (): T;
+    }, out?: T[]): T[];
+    traverseComponents(callback: (comp: Component) => void): void;
+    private _addDendencies;
+    private _findComponent;
+    protected _activeComponent(comp: Component, active: boolean): void;
+}
+export {};

package/types/ComponentScheduler.d.ts

@@ -0,0 +1,19 @@
+import { Component } from "./Component";
+declare class Invoker<T> {
+    protected _targets: T[];
+    protected _callback: (target: T, dt: number) => any;
+    constructor(callback: (target: T, dt: number) => any);
+    add(target: any): void;
+    remove(target: any): void;
+    invoke(dt: number): void;
+}
+export declare class ComponentScheduler {
+    startInvoker: Invoker<Component>;
+    updateInvoker: Invoker<Component>;
+    lastUpdateInvoker: Invoker<Component>;
+    start(): void;
+    update(dt: number): void;
+    lastUpdate(dt: number): void;
+    enableComponent(comp: Component, enable: boolean): void;
+}
+export {};

package/types/DebugManager.d.ts

@@ -0,0 +1,2 @@
+export declare class DebugManager {
+}

package/types/DetectUA.d.ts

@@ -0,0 +1,79 @@
+export interface IDeviceResult {
+    version: string;
+}
+export interface IBrowserResult {
+    name: string;
+    version: string;
+}
+export declare class DetectUA {
+    userAgent: string;
+    private isAndroidDevice;
+    private iOSDevice;
+    /**
+     * Detect a users browser, browser version and whether it is a mobile-, tablet- or desktop device
+     *
+     * @param forceUserAgent Force a user agent string (useful for testing)
+     */
+    constructor(forceUserAgent?: string);
+    /**
+     * Match entry based on position found in the user-agent string
+     *
+     * @param pattern regular expression pattern
+     */
+    private match;
+    /**
+     * Returns if the device is a mobile device
+     */
+    get isMobile(): boolean;
+    /**
+     * Returns if the device is a tablet device
+     */
+    get isTablet(): boolean;
+    /**
+     * Returns if the device is a desktop device
+     */
+    get isDesktop(): boolean;
+    /**
+     * Returns if the device is running MacOS (and if so which version)
+     *
+     * '5' => Leopard'
+     * '6' => Snow Leopard'
+     * '7' => Lion'
+     * '8' => Mountain Lion'
+     * '9' => Mavericks'
+     * '10' => Yosemite'
+     * '11' => El Capitan'
+     * '12' => Sierra'
+     * '13' => High Sierra'
+     * '14' => Mojave'
+     * '15' => Catalina'
+     */
+    get isMacOS(): IDeviceResult | boolean;
+    /**
+     * Returns if the device is running Windows (and if so which version)
+     *
+     * 'NT' => 'NT'
+     * 'XP' => 'XP'
+     * 'NT 5.0' => '2000'
+     * 'NT 5.1' => 'XP'
+     * 'NT 5.2' => '2003'
+     * 'NT 6.0' => 'Vista'
+     * 'NT 6.1' => '7'
+     * 'NT 6.2' => '8'
+     * 'NT 6.3' => '8.1'
+     * 'NT 10.0' => '10'
+     */
+    get isWindows(): IDeviceResult | boolean;
+    /**
+     * Returns if the device is an iOS device (and if so which version)
+     */
+    get isiOS(): IDeviceResult | boolean;
+    /**
+     * Returns if the device is an Android device (and if so which version)
+     */
+    get isAndroid(): IDeviceResult | boolean;
+    /**
+     * Returns the browser name and version
+     */
+    get browser(): IBrowserResult | boolean;
+}

package/types/DeviceInput.d.ts

@@ -0,0 +1,60 @@
+import { Vector2 } from "three";
+import { ConnTarget } from "./Pressability";
+import { Viewer } from "./Viewer";
+export declare class DeviceInput {
+    viewer: Viewer;
+    static readonly CLICK = "click";
+    static readonly MOUSE_WHEEL = "mousewheel";
+    static readonly TOUCH_START = "touchstart";
+    static readonly TOUCH_END = "touchend";
+    static readonly TOUCH_MOVE = "touchmove";
+    static readonly POINTER_DOWN = "pointerdown";
+    static readonly POINTER_UP = "pointerup";
+    static readonly POINTER_MOVE = "pointermove";
+    static readonly POINTER_OVER = "pointerover";
+    static readonly POINTER_OUT = "pointerout";
+    static readonly KEYDOWN = "keydown";
+    static readonly KEYPRESS = "keypress";
+    static readonly KEYUP = "keyup";
+    static readonly RESIZE = "resize";
+    private _listeners;
+    private _mouseWheel;
+    private _touches;
+    private _touchCount;
+    private _pointerButton;
+    private _pointerPosition;
+    private _pointer;
+    private _keys;
+    private _pressability;
+    get pointerButton(): number;
+    get pointer(): Vector2;
+    get pointerPosition(): Vector2;
+    get mouseWheel(): number;
+    get touchCount(): number;
+    get touches(): {
+        id: number;
+        position: Vector2;
+    }[];
+    get keys(): {
+        [k: string]: boolean;
+    };
+    constructor(viewer: Viewer);
+    addEventListeners(): void;
+    removeAllListeners(): void;
+    connect(target: ConnTarget, event: string): void;
+    disconnect(target: ConnTarget): void;
+    private _addEventListener;
+    private _remapPointer;
+    private _remapTouch;
+    private _computePointer;
+    private _onPointerDown;
+    private _onPointerUp;
+    private _onPointerMove;
+    private _onMouseWheel;
+    private _onTouchStart;
+    private _onTouchEnd;
+    private _onTouchMove;
+    private _onKeyDown;
+    private _onKeyPress;
+    private _onKeyUp;
+}

package/types/ObjectInstance.d.ts

@@ -0,0 +1,7 @@
+export declare class ObjectInstance {
+    static _instanceCount: number;
+    instanceId: number;
+    uuid: string;
+    name: string;
+    type: string;
+}

package/types/Plugin.d.ts

@@ -0,0 +1,10 @@
+import { ObjectInstance } from "./ObjectInstance";
+import { Viewer } from "./Viewer";
+export declare class Plugin extends ObjectInstance {
+    viewer: Viewer;
+    type: string;
+    install?(): void;
+    uninstall?(): void;
+    onUpdate?(dt: number): void;
+    onRender?(dt: number): void;
+}

package/types/PluginManager.d.ts

@@ -0,0 +1,17 @@
+import { Plugin } from "./Plugin";
+import { Viewer } from "./Viewer";
+import { __C } from "./types";
+export declare class PluginManager {
+    private _viewer;
+    private _plugins;
+    private _pluginsMap;
+    get viewer(): Viewer;
+    constructor(viewer: Viewer);
+    destroy(): void;
+    update(dt: number): void;
+    render(dt: number): void;
+    traversePlugins(callback: (plugin: Plugin) => void): void;
+    getPlugin<T extends Plugin>(plugin: new (...args: any[]) => T, autoAdd?: boolean): T;
+    addPlugin<T extends Plugin, K extends __C<T>>(plugin: T | K & __C<T>): T;
+    removePlugin<T extends Plugin, K extends __C<T>>(plugin: T | K & __C<T>): void;
+}

package/types/Pressability.d.ts

@@ -0,0 +1,17 @@
+import { Camera, Intersection, Object3D, Vector2 } from "three";
+export interface ConnTarget {
+    node: Object3D;
+    emit(name: string, e: {
+        intersects: Intersection[];
+    }): void;
+    has(name: string): boolean;
+}
+export declare class Pressability {
+    private _raycaster;
+    private _connectors;
+    connect(target: ConnTarget): void;
+    disconnect(target: ConnTarget): void;
+    pointerDown(pointer: Vector2, camera: Camera): void;
+    pointerUp(pointer: Vector2, camera: Camera): void;
+    pointerMove(pointer: Vector2, camera: Camera): void;
+}

package/types/PropertyManager.d.ts

@@ -0,0 +1,19 @@
+export declare class PropertyManager {
+    static _propertiesMap: Map<Object, Object>;
+    static _getProperties(target: object): Object;
+    static _hasProperties(target: object): boolean;
+    static _getMergedProperties(target: Object): any;
+}
+export interface IPropertyOptions {
+    dir?: string;
+    parent?: string;
+    max?: number;
+    min?: number;
+    step?: number;
+    value?: any;
+    name?: string;
+}
+type PropertyDecorator = (target: Object, propertyKey: string) => void;
+export declare function property(options?: IPropertyOptions): PropertyDecorator;
+export declare function property(...args: Parameters<PropertyDecorator>): void;
+export {};

package/types/Scheduler.d.ts

@@ -0,0 +1,13 @@
+export interface ICallTarget {
+    uuid: string;
+}
+export declare class Scheduler {
+    private _callers;
+    private _callersArray;
+    pause(target: ICallTarget): void;
+    resume(target: ICallTarget): void;
+    schedule(target: ICallTarget, callback: Function, interval: number, repeat: number): void;
+    unshedule(target: ICallTarget, callback: Function): void;
+    unscheduleAll(target: ICallTarget): void;
+    update(dt: number): void;
+}

package/types/SystemInfo.d.ts

@@ -0,0 +1,24 @@
+export declare class SystemInfo {
+    static isMobile: boolean;
+    static isDesktop: boolean;
+    static device: string;
+    static isAndroid: boolean;
+    static isIOS: boolean;
+    static isMacOS: boolean;
+    static isWindows: boolean;
+    static isLinux: boolean;
+    static ua: string;
+    static isEdge: boolean;
+    static isIE: boolean;
+    static isFirefox: boolean;
+    static isChrome: boolean;
+    static isOpera: boolean;
+    static isSafari: boolean;
+    static isSupportMSAA: boolean;
+    static isSupportOgg: boolean;
+    static isRetina: boolean;
+    static devicePixelRatio: number;
+    static cpuCoreCount: number;
+    static baseUrl: string;
+    static isIFrame: boolean;
+}

package/types/Task.d.ts

@@ -0,0 +1,5 @@
+export declare class Task {
+    excute: () => void;
+    name: string;
+    constructor(excute: () => void, name?: string);
+}

package/types/TaskManager.d.ts

@@ -0,0 +1,15 @@
+import { Task } from "./Task";
+import { EventEmitter } from "./base";
+export declare class TaskManager extends EventEmitter {
+    onComplete?: () => void;
+    onProgress?: (task: Task, loaded: number, total: number) => void;
+    onError?: (task: Task) => void;
+    private _tasks;
+    private _taskIndex;
+    private _percent;
+    get percent(): number;
+    constructor(onComplete?: () => void, onProgress?: (task: Task, loaded: number, total: number) => void, onError?: (task: Task) => void);
+    destroy(): void;
+    add(task: Task): void;
+    update(): void;
+}

package/types/TextureSettings.d.ts

@@ -0,0 +1,13 @@
+import { Mapping, PixelFormat, TextureDataType, TextureFilter, Vector2, Wrapping } from "three";
+export interface TextureSettings {
+    flipY?: boolean;
+    mapping?: Mapping;
+    wrapS?: Wrapping;
+    wrapT?: Wrapping;
+    magFilter?: TextureFilter;
+    minFilter?: TextureFilter;
+    format?: PixelFormat;
+    dataType?: TextureDataType;
+    anisotropy?: number;
+    repeat?: Vector2;
+}

package/types/Utils.d.ts

@@ -0,0 +1,6 @@
+import { __C, __P } from "./types";
+export declare function applyProps<T, K extends __C<T>>(target: T & {
+    copy?: Function;
+}, props: __P<T, K>): T & {
+    copy?: Function;
+};

package/types/Viewer.d.ts

@@ -0,0 +1,143 @@
+import { BufferGeometry, Camera, ColorSpace, DataTexture, DirectionalLightShadow, Euler, Material, Mesh, Object3D, OrthographicCamera, PerspectiveCamera, Scene, ShaderMaterial, ShadowMapType, Texture, TextureDataType, ToneMapping, Vector3, WebGLCubeRenderTarget, WebGLRenderer, WebGLRendererParameters, WebGLRenderTarget } from "three";
+import { EventEmitter } from "./base";
+import { ComponentManager } from "./ComponentManager";
+import { AssetProperties, LoaderConstructor } from "./asset/ResourceManager";
+import { __C, __P } from "./types";
+import { Component } from "./Component";
+import { TextureSettings } from "./TextureSettings";
+import { Plugin } from "./Plugin";
+export declare class Viewer extends EventEmitter {
+    static __target: Vector3;
+    static __worldPos: Vector3;
+    static _getClassInstance(constructor: any, args?: any[]): any;
+    static _shadowCameraKeys: string[];
+    static _setDirectLightShadow(shadow: DirectionalLightShadow, props: number[]): DirectionalLightShadow;
+    static CompileMaterial(renderer: WebGLRenderer, scene: Scene, camera: Camera, target: Material | Material[]): void;
+    static CompileObject3D(renderer: WebGLRenderer, scene: Scene, camera: Camera, target: Object3D): void;
+    static CompileTexture(renderer: WebGLRenderer, target: Texture | Texture[]): void;
+    static Blit(renderer: WebGLRenderer, renderTarget: WebGLRenderTarget, material: ShaderMaterial, lod?: number, face?: number): void;
+    static GetFullscreenTriangle(): BufferGeometry<import("three").NormalBufferAttributes>;
+    static fullscreenMesh: Mesh;
+    static fullscreenCamera: OrthographicCamera;
+    private _root;
+    private _canvas;
+    private _gl;
+    private _RENDER_TARGET_FLOAT_TYPE;
+    private _DATA_FLOAT_TYPE;
+    private _scene;
+    private _camera;
+    private _renderer;
+    private _input;
+    private _dpr;
+    private _width;
+    private _height;
+    private _viewport;
+    private _orientation;
+    private _running;
+    private _rootRotated;
+    private _time;
+    private _lastTime;
+    private _targetFrameRate;
+    private _autoResize;
+    private _taskManager;
+    private _resourceManager;
+    private _componentManager;
+    private _pluginManager;
+    private _tweenManager;
+    get root(): HTMLElement;
+    get time(): number;
+    get scene(): Scene;
+    get camera(): PerspectiveCamera;
+    get renderer(): WebGLRenderer;
+    get canvas(): HTMLCanvasElement;
+    get gl(): WebGL2RenderingContext | WebGLRenderingContext;
+    get RENDER_TARGET_FLOAT_TYPE(): TextureDataType;
+    get DATA_FLOAT_TYPE(): TextureDataType;
+    get dpr(): number;
+    get width(): number;
+    get height(): number;
+    get viewport(): {
+        width: number;
+        height: number;
+        factor: number;
+    };
+    get rootRotated(): boolean;
+    constructor({ root, canvas, autoStart, autoResize, shadows, camera, targetFrameRate, colorSpace, toneMapping, toneMappingExposure, maxDPR, path, resourcePath, dracoPath, loader, tasker, ...webglOpts }?: {
+        root?: HTMLElement;
+        canvas?: HTMLCanvasElement;
+        targetFrameRate?: number;
+        autoStart?: boolean;
+        autoResize?: boolean;
+        shadows?: boolean | ShadowMapType;
+        colorSpace?: ColorSpace;
+        toneMapping?: ToneMapping;
+        toneMappingExposure?: number;
+        maxDPR?: number;
+        path?: string;
+        resourcePath?: string;
+        dracoPath?: string;
+        camera?: {
+            fov?: number;
+            aspect?: number;
+            near?: number;
+            far?: number;
+            position?: Vector3;
+            rotation?: Euler;
+        };
+        loader?: {
+            onLoad?: () => void;
+            onProgress?: (url: string, loaded: number, total: number) => void;
+            onError?: (url: string) => void;
+        };
+        tasker?: {
+            onComplete?: () => void;
+            onProgress?: (target: Object, loaded: number, total: number) => void;
+            onError?: (target: Object) => void;
+        };
+    } & WebGLRendererParameters);
+    destroy(): void;
+    private _addDefaultLoaders;
+    private _frame;
+    loop(dt: number): void;
+    update(dt: number): void;
+    render(dt: number): void;
+    _onRender(dt: number): void;
+    _onResize(width: number, height: number): void;
+    start(): this;
+    stop(): this;
+    resize(width?: number, height?: number): void;
+    loadAsset(props: AssetProperties & TextureSettings): Promise<any>;
+    addLoader(Loader: LoaderConstructor): void;
+    load({ url, ext, onProgress, castShadow, receiveShadow, ...props }: AssetProperties & __P<Object3D, typeof Object3D>): Promise<any>;
+    tween(target: Object): import("./tween").Tween<Object>;
+    timeline(target: Object): import("./tween").TweenChain;
+    killTweensOf(target: Object): void;
+    traverseMaterials(callback: (mat: Material) => void): void;
+    traversePlugins(callback: (plugin: Plugin) => void): void;
+    getPlugin<T extends Plugin>(plugin: new (...args: any[]) => T, autoAdd?: boolean): T;
+    addPlugin<T extends Plugin, K extends __C<T>>(plugin: T | K & __C<T>, props?: __P<T, K>): T;
+    removePlugin<T extends Plugin, K extends __C<T>>(plugin: T | K & __C<T>): void;
+    getComponent<T extends Component>(node: Object3D, constructor: {
+        new (): T;
+    }, autoAdd?: boolean): T;
+    traverseComponents(callback: (comp: Component) => void): void;
+    addComponent<T extends Component>(node: Object3D | Component, instance: T): T;
+    addComponent<T extends Component>(node: Object3D | Component, constructor: {
+        new (): T;
+    }): T;
+    removeComponent(node: Object3D, component: Component): ComponentManager;
+    addNode<T, K extends __C<T>>(object: T | K & __C<T>, props?: __P<T, K>): T;
+    removeNode(node: Object3D): void;
+    activeNode(node: Object3D, active: boolean): Object3D<import("three").Object3DEventMap>;
+    createRenderTarget(width: number, height: number, nearest?: boolean, floatType?: boolean | TextureDataType, msaa?: number, mipmap?: boolean): WebGLRenderTarget<Texture>;
+    createCubeRenderTarget(size: number, nearest?: boolean, floatType?: boolean | TextureDataType, msaa?: number, mipmap?: boolean): WebGLCubeRenderTarget;
+    createDataTexture(data: BufferSource, width: number, height: number, floatType?: boolean, nearest?: boolean): DataTexture;
+    /**
+     * 传送门，得到一个全新的场景
+     * @param callback 禁止使用异步函数，会导致状态错误
+     * @returns
+     */
+    portal<T = any>(callback: () => T): T;
+    compile(target?: Object3D | Scene | Material | Texture): void;
+    compile(target?: Material[]): void;
+}

package/types/WebGL.d.ts

@@ -0,0 +1,14 @@
+import { WebGLRendererParameters } from "three";
+export declare function parepareWebGL(canvas: HTMLCanvasElement, props: WebGLRendererParameters): {
+    gl: WebGL2RenderingContext;
+    RENDER_TARGET_FLOAT_TYPE: 1016;
+    DATA_FLOAT_TYPE: 1015;
+} | {
+    gl: WebGLRenderingContext;
+    RENDER_TARGET_FLOAT_TYPE: 1016 | 1015;
+    DATA_FLOAT_TYPE: 1015;
+} | {
+    gl: WebGLRenderingContext;
+    RENDER_TARGET_FLOAT_TYPE: 1009;
+    DATA_FLOAT_TYPE: 1009;
+};

package/types/asset/ResourceManager.d.ts

@@ -0,0 +1,42 @@
+import { LoadingManager } from "three";
+import { TextureSettings } from "../TextureSettings";
+import { aLoader } from "./aLoader";
+export interface AssetProperties {
+    ext?: string;
+    url?: string | File | {
+        mainFile: File;
+        additionalFiles: File[];
+    };
+    onProgress?: (event: ProgressEvent) => void;
+}
+export type LoaderConstructor = new (manager: ResourceManager) => aLoader;
+export declare class ResourceManager {
+    static extension(path: string): string;
+    static dirname(path: string): string;
+    static basename(path: string, ext?: string): string;
+    static _parseURL(uri: any): {
+        url: string;
+        file: any;
+        ext: string;
+    };
+    static _getTextureKey(url: string, settings: TextureSettings): string;
+    static _texSettingKeys: string[];
+    static _splitTextureSettings(props: TextureSettings & {
+        [k: string]: any;
+    }): {};
+    path: string;
+    resourcePath: string;
+    dracoPath: string;
+    loadingManager: LoadingManager;
+    private _caches;
+    private _loaders;
+    constructor(props: {
+        path: string;
+        resourcePath: string;
+        dracoPath: string;
+        loadingManager: LoadingManager;
+    });
+    destroy(): void;
+    addLoader(Loader: LoaderConstructor): void;
+    loadAsset<T = any>({ url, ext, onProgress, ...props }: AssetProperties & TextureSettings): Promise<T>;
+}

package/types/asset/aLoader.d.ts

@@ -0,0 +1,17 @@
+import { Object3D } from "three";
+import { ResourceManager } from "./ResourceManager";
+import { TextureSettings } from "../TextureSettings";
+export interface LoadProperties {
+    url: string;
+    texSettings?: TextureSettings;
+    onLoad: (asset: any) => void;
+    onProgress?: (event: ProgressEvent) => void;
+    onError?: (event: ErrorEvent) => void;
+}
+export declare abstract class aLoader {
+    manager: ResourceManager;
+    static _setMeshData(node: Object3D): Object3D<import("three").Object3DEventMap>;
+    constructor(manager: ResourceManager);
+    abstract extension: string[];
+    abstract load(props: LoadProperties): void;
+}