@xviewer.js/core 1.0.5-alhpa.9 → 1.0.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xviewer.js/core",
-  "version": "1.0.5-alhpa.9",
+  "version": "1.0.5",
   "license": "MIT",
   "type": "module",
   "sideEffects": false,

package/types/ComponentManager.d.ts

@@ -9,6 +9,9 @@ interface ComponentInfo {
     components?: ComponentConstructor[];
     single?: boolean;
 }
+export interface ComponentManagerOptions {
+    manual?: boolean;
+}
 export declare enum DependentMode {
     /** Check only, throw error if dependent components do not exist. */
     CheckOnly = 0,
@@ -23,32 +26,39 @@ export declare class ComponentManager {
     private _scheduler;
     private _componentScheduler;
     private _componentsMap;
+    private _started;
+    private _manual;
+    get started(): boolean;
+    get manual(): boolean;
     get viewer(): Viewer;
     get scheduler(): Scheduler;
     get componentScheduler(): ComponentScheduler;
-    constructor(viewer: Viewer);
-    destroy(): void;
+    constructor(viewer: Viewer, { manual, }?: ComponentManagerOptions);
+    destroy(node?: Object3D): void;
     tick(dt: number): void;
     update(dt: number): void;
     render(dt: number): void;
     resize(width: number, height: 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: {
+    start(): this;
+    pause(): this;
+    resume(): this;
+    stop(): this;
+    active(node: Object3D): void;
+    add<T extends Component>(node: Object3D | Component, instance: T): T;
+    add<T extends Component>(node: Object3D | Component, constructor: {
         new (): T;
     }): T;
-    removeComponent(node: Object3D, component: Component): this;
-    getComponent<T extends Component>(node: Object3D, constructor: {
+    remove(node: Object3D, component: Component): this;
+    get<T extends Component>(node: Object3D, constructor: {
         new (...args: any[]): T;
     }): T;
-    getComponentInChildren<T extends Component>(node: Object3D, constructor: {
+    getInChildren<T extends Component>(node: Object3D, constructor: {
         new (): T;
-    }): Component<Object3D<import("three").Object3DEventMap>>;
-    getComponentsInChidren<T extends Component>(node: Object3D, constructor: {
+    }): T;
+    getAllInChildren<T extends Component>(node: Object3D, constructor: {
         new (): T;
     }, out?: T[]): T[];
-    traverseComponents(callback: (comp: Component) => void): void;
+    traverse(callback: (comp: Component) => void): void;
     private _addDendencies;
     private _findComponent;
     protected _activeComponent(comp: Component, active: boolean): void;

package/types/TaskManager.d.ts

@@ -1,15 +1,28 @@
 import { Task } from "./Task";
-export declare class TaskManager {
+export interface TaskManagerOptions {
+    manual?: boolean;
     onComplete?: () => void;
     onProgress?: (task: Task, loaded: number, total: number) => void;
     onError?: (task: Task) => void;
+}
+export declare class TaskManager {
     private _tasks;
     private _taskIndex;
     private _onStartCalled;
+    private _started;
+    private _manual;
     get isComplete(): boolean;
+    get started(): boolean;
+    get manual(): boolean;
     onStart?: () => void;
-    constructor(onComplete?: () => void, onProgress?: (task: Task, loaded: number, total: number) => void, onError?: (task: Task) => void);
+    onComplete?: () => void;
+    onProgress?: (task: Task, loaded: number, total: number) => void;
+    onError?: (task: Task) => void;
+    constructor({ manual, onComplete, onProgress, onError, }?: TaskManagerOptions);
     destroy(): void;
-    add(task: Task): void;
+    start(): this;
+    pause(): this;
+    resume(): this;
+    add(task: Task | (() => void), name?: string): Task;
     update(): void;
 }

package/types/TextureSettings.d.ts

@@ -1,7 +1,7 @@
-import { ColorSpace, Mapping, PixelFormat, TextureDataType, TextureFilter, Vector2, Wrapping } from "three";
+import { AnyMapping, ColorSpace, PixelFormat, TextureDataType, TextureFilter, Vector2, Wrapping } from "three";
 export interface TextureSettings {
     flipY?: boolean;
-    mapping?: Mapping;
+    mapping?: AnyMapping;
     wrapS?: Wrapping;
     wrapT?: Wrapping;
     magFilter?: TextureFilter;

package/types/Utils.d.ts

@@ -7,10 +7,3 @@ export declare function applyProps<T, K extends __C<T>>(target: T & {
 };
 export declare function find<T extends THREE.Object3D>(node: T, path: string): T;
 export declare function getChildren<T extends THREE.Object3D>(node: T, filter: (value: T) => any, group?: boolean): any;
-export declare function getChildByName<T extends THREE.Object3D>(node: T, name: string): T;
-export declare function queryValues<T extends Object & {
-    name: string;
-}>(object: any): T[];
-export declare function queryValues<T extends Object & {
-    name: string;
-}>(object: any, name: string): T;

package/types/Viewer.d.ts

@@ -1,13 +1,15 @@
 import { BufferGeometry, Camera, Color, ColorRepresentation, ColorSpace, DataTexture, LoadingManager, Material, Mesh, Object3D, OrthographicCamera, PerspectiveCamera, Scene, ShaderMaterial, ShadowMapType, Texture, TextureDataType, ToneMapping, TypedArray, Vector3, WebGLCubeRenderTarget, WebGLRenderer, WebGLRendererParameters, WebGLRenderTarget } from "three";
 import { EventEmitter } from "./base";
 import { ComponentManager } from "./ComponentManager";
+import { TaskManager } from "./TaskManager";
 import { DeviceInput, InputOption } from "./DeviceInput";
 import { Orientation, ResizeMode } from "./enums";
-import { AssetProperties, LoaderConstructor } from "./asset/ResourceManager";
+import { LoaderConstructor, ResourceManager } from "./asset/ResourceManager";
 import { __C, __P, __Properties } from "./types";
 import { Component } from "./Component";
 import { Task } from "./Task";
 type SizeFunction = () => number[];
+export declare const DefaultLoaders: LoaderConstructor[];
 export declare class Viewer extends EventEmitter {
     static instanceCount: number;
     static target: Vector3;
@@ -17,15 +19,12 @@ export declare class Viewer extends EventEmitter {
     private _root;
     private _canvas;
     private _gl;
-    private _RENDER_TARGET_FLOAT_TYPE;
-    private _DATA_FLOAT_TYPE;
     private _mount;
     private _input;
     private _dpr;
     private _width;
     private _height;
     private _viewport;
-    private _resourceOptions;
     private _scene;
     private _camera;
     private _renderer;
@@ -40,17 +39,14 @@ export declare class Viewer extends EventEmitter {
     private _windowSize;
     private _orientation;
     private _freeze;
-    private _taskManager;
-    private _resourceManager;
-    private _componentManager;
-    private _loadingManager;
-    private _decodeURL;
+    private _loading;
+    private _resources;
+    private _tasks;
+    private _components;
     get root(): HTMLElement;
     get time(): number;
     get canvas(): HTMLCanvasElement;
-    get gl(): WebGL2RenderingContext | WebGLRenderingContext;
-    get RENDER_TARGET_FLOAT_TYPE(): TextureDataType;
-    get DATA_FLOAT_TYPE(): TextureDataType;
+    get gl(): WebGLRenderingContext | WebGL2RenderingContext;
     get dpr(): number;
     get width(): number;
     get height(): number;
@@ -61,16 +57,20 @@ export declare class Viewer extends EventEmitter {
     };
     get rootRotated(): boolean;
     get input(): DeviceInput;
+    get mount(): Object3D<import("three").Object3DEventMap>;
     get targetFrameRate(): number;
     set targetFrameRate(v: number);
     get instanceId(): number;
-    get componentManager(): ComponentManager;
+    get loading(): LoadingManager;
+    get resources(): ResourceManager;
+    get tasks(): TaskManager;
+    get components(): ComponentManager;
     get scene(): Scene<import("three").Object3DEventMap>;
     get camera(): Camera;
     get renderer(): WebGLRenderer;
     get freeze(): boolean;
     set freeze(v: boolean);
-    constructor({ root, canvas, input, shadows, sortObjects, resize, orthographic, camera, targetFrameRate, fixedFrameTime, colorSpace, toneMapping, toneMappingExposure, maxDPR, path, resourcePath, dracoPath, transcoderPath, orientation, decodeURL, loader, tasker, ...webglOpts }?: {
+    constructor({ root, canvas, input, shadows, sortObjects, resize, orthographic, camera, targetFrameRate, fixedFrameTime, colorSpace, toneMapping, toneMappingExposure, maxDPR, path, resourcePath, dracoPath, basisPath, orientation, URL, manual, resources, tasks, components, ...webglOpts }?: {
         /** 根节点，用于屏幕旋转 */
         root?: HTMLElement;
         /** 渲染用的 canvas 元素，如果不提供，默认获取 id 为 "canvas" 的元素 */
@@ -102,26 +102,35 @@ export declare class Viewer extends EventEmitter {
         /** Draco 压缩解码器路径，默认 Google CDN 地址 */
         dracoPath?: string;
         /** The WASM transcoder and JS wrapper are available from the examples/jsm/libs/basis directory. */
-        transcoderPath?: string;
+        basisPath?: string;
         /** 页面方向，AUTO: 自动，LANDSCAPE: 横屏，PORTRAIT: 竖屏 */
         orientation?: Orientation;
         /** Creates an orthographic camera */
         orthographic?: boolean;
         /** A `THREE.Camera` instance or props that go into the default camera */
         camera?: (Camera | __Properties<PerspectiveCamera & OrthographicCamera>);
-        decodeURL?: (url: string) => string;
-        /** 加载管理器 */
-        loader?: {
+        URL?: (url: string) => string;
+        /** 是否手动控制资源、任务和组件的启动 */
+        manual?: boolean;
+        /** 资源管理器 */
+        resources?: {
+            manual?: boolean;
+            loaders?: LoaderConstructor[];
             onComplete?: () => void;
             onProgress?: (url: string, loaded: number, total: number) => void;
             onError?: (url: string) => void;
         };
         /** 任务管理器 */
-        tasker?: {
+        tasks?: {
+            manual?: boolean;
             onComplete?: () => void;
             onProgress?: (task: Task, loaded: number, total: number) => void;
             onError?: (task: Task) => void;
         };
+        /** 组件管理器 */
+        components?: {
+            manual?: boolean;
+        };
     } & WebGLRendererParameters);
     destroy(): void;
     animate(): void;
@@ -129,16 +138,6 @@ export declare class Viewer extends EventEmitter {
     stop(): this;
     rotate(): void;
     resize(width?: number, height?: number): void;
-    setURLModifier(callback?: (url: string) => string): LoadingManager;
-    loadAsset<URL extends string, Asset = any>({ url, ...props }: AssetProperties<URL>): Promise<Asset>;
-    getAsset<URL extends string, Asset = any>(url: URL): Asset;
-    getLoader(ext: string): import(".").Loader;
-    addLoader(Loader: LoaderConstructor): import(".").Loader;
-    getComponent<T extends Component>(constructor: {
-        new (...args: any[]): T;
-    }, node?: Object3D): T;
-    task<T extends Object3D | Scene | Material | Texture | Function>(target?: T): T;
-    task<T extends Material[]>(target?: Material[]): T;
     use<T extends Scene | Camera | null, K extends __C<T>>(object: T | K & __C<T>, props?: __P<T, K>): T;
     add<T extends Object3D | Component, K extends __C<T>>(object: T | K & __C<T>, props?: __P<T, K>): T;
     remove<T extends Object3D | Component>(ins: T): T;

package/types/WebGL.d.ts

@@ -5,7 +5,7 @@ export declare function checkWebGL(canvas: HTMLCanvasElement, props: WebGLRender
     DATA_FLOAT_TYPE: 1015;
 } | {
     gl: WebGLRenderingContext;
-    RENDER_TARGET_FLOAT_TYPE: 1016 | 1015;
+    RENDER_TARGET_FLOAT_TYPE: 1015 | 1016;
     DATA_FLOAT_TYPE: 1015;
 } | {
     gl: WebGLRenderingContext;

package/types/asset/Loader.d.ts

@@ -1,24 +1,18 @@
-import { LoadingManager, Object3D } from "three";
 import { TextureSettings } from "../TextureSettings";
-import type { Viewer } from "../Viewer";
+import { type ResourceManager } from "./ResourceManager";
 export interface LoadProperties {
     url: string;
     buffer?: string | ArrayBuffer;
     texSettings?: TextureSettings;
     path?: string;
     resourcePath?: string;
-    dracoPath?: string;
-    transcoderPath?: string;
-    manager?: LoadingManager;
     onLoad: (asset: any) => void;
     onProgress?: (event: ProgressEvent) => void;
     onError?: (event: ErrorEvent) => void;
 }
 export declare abstract class Loader {
-    viewer: Viewer;
-    static _texKeys: string[];
-    static _setUserData(node: Object3D): Object3D<import("three").Object3DEventMap>;
-    constructor(viewer: Viewer);
+    manager: ResourceManager;
+    constructor(manager: ResourceManager);
     abstract extension: string[];
     abstract load(props: LoadProperties): void;
 }

package/types/asset/ResourceManager.d.ts

@@ -1,16 +1,25 @@
-import { LoadingManager } from "three";
+import { LoadingManager, WebGLRenderer } from "three";
 import { TextureSettings } from "../TextureSettings";
 import { Loader } from "./Loader";
-import type { Viewer } from "../Viewer";
-export type LoaderConstructor = new (viewer: Viewer) => Loader;
+import { DRACOLoader } from "three/examples/jsm/loaders/DRACOLoader.js";
+import { KTX2Loader } from "three/examples/jsm/loaders/KTX2Loader.js";
+export type LoaderConstructor = new (manager: ResourceManager) => Loader;
+export interface ResourceManagerOptions {
+    manual?: boolean;
+    loadingManager?: LoadingManager;
+    dracoPath?: string;
+    basisPath?: string;
+    renderer?: WebGLRenderer;
+    path?: string;
+    resourcePath?: string;
+    URL?: (url: string) => string;
+}
 export interface AssetProperties<URL extends string = string> extends TextureSettings {
     url?: URL;
     ext?: string;
     buffer?: string | ArrayBuffer;
     path?: string;
     resourcePath?: string;
-    dracoPath?: string;
-    transcoderPath?: string;
     manager?: LoadingManager;
     onProgress?: (event: ProgressEvent) => void;
 }
@@ -22,16 +31,35 @@ export declare class ResourceManager {
     static _splitTextureSettings(props: TextureSettings & {
         [k: string]: any;
     }): {};
-    private _viewer;
     private _loaders;
     private _resources;
+    private _pendingAssets;
+    private _readyWaiters;
     private _loaded;
     private _totalCount;
-    constructor(viewer: Viewer);
+    private _started;
+    private _manual;
+    private _resourceOptions;
+    private _URL;
+    private _ktx2Loader;
+    private _dracoLoader;
+    private _loadingManager;
+    constructor({ dracoPath, basisPath, loadingManager, renderer, path, resourcePath, URL, manual, }: ResourceManagerOptions);
     get isComplete(): boolean;
+    get started(): boolean;
+    get manual(): boolean;
+    get loadingManager(): LoadingManager;
+    get ktx2Loader(): KTX2Loader;
+    get dracoLoader(): DRACOLoader;
     destroy(): void;
+    start(): this;
+    pause(): this;
+    ready(): Promise<void>;
     getLoader(ext: string): Loader;
     addLoader(Loader: LoaderConstructor): Loader;
-    loadAsset<Asset = unknown>({ url, ext, onProgress, ...props }: AssetProperties): Promise<Asset>;
-    getAsset<Asset = unknown>(url: string): Asset;
+    load<Asset = unknown>({ url, ext, onProgress, ...props }: AssetProperties): Promise<Asset>;
+    get<Asset = unknown>(url: string): Asset;
+    private _flushPendingAssets;
+    private _load;
+    private _checkReadyWaiters;
 }

package/types/bmfont/BMFontAtlas.d.ts

@@ -22,6 +22,9 @@ export declare class BMFontAtlas {
         u_shadowColor: {
             value: Color;
         };
+        u_shadowOpacity: {
+            value: number;
+        };
         u_shadowBlur: {
             value: number;
         };

package/types/bmfont/index.d.ts

@@ -1,3 +1,3 @@
 export { BMFontAtlas } from "./BMFontAtlas";
 export { BMFontTextGeometry } from "./BMFontTextGeometry";
-export { BMFontTextLayout } from "./BMFontTextLayout";
+export { BMFontTextLayout, type BMFontInfo } from "./BMFontTextLayout";

package/types/components/DropFile.d.ts

@@ -7,6 +7,17 @@ declare enum Mode {
 }
 export declare class DropFile extends Component {
     static readonly Mode: typeof Mode;
+    static readonly defaultExtension: {
+        fbx: Mode;
+        gltf: Mode;
+        glb: Mode;
+        buf: Mode;
+        exr: Mode;
+        hdr: Mode;
+        png: Mode;
+        jpg: Mode;
+        webp: Mode;
+    };
     private _onLoad;
     private _onError;
     private _extension;

package/types/components/FreelookVirtualCamera.d.ts

@@ -9,7 +9,6 @@ export declare class FreelookVirtualCamera extends Component<Object3D & {
     static preCenter: Vector2;
     static panDelta: Vector2;
     static rotateDelta: Vector2;
-    static posDelta: Vector3;
     static lookAtOffset: Vector3;
     static xAxis: Vector3;
     static yAxis: Vector3;

package/types/index.d.ts

@@ -8,13 +8,15 @@ export * from "./materials";
 export * from "./Utils";
 export * from "./enums";
 export * from "./bmfont";
-export { Viewer } from "./Viewer";
+export { Viewer, DefaultLoaders } from "./Viewer";
 export { Task } from "./Task";
+export { TaskManager, type TaskManagerOptions } from "./TaskManager";
 export { Component } from "./Component";
+export { ComponentManager, type ComponentManagerOptions } from "./ComponentManager";
 export { SystemInfo } from "./SystemInfo";
 export { ObjectInstance } from "./ObjectInstance";
 export { property, PropertyManager } from "./PropertyManager";
 export { dependencies, DependentMode, single } from "./ComponentManager";
 export { DeviceInput } from "./DeviceInput";
 export { Loader, type LoadProperties } from "./asset/Loader";
-export { ResourceManager, type AssetProperties } from "./asset/ResourceManager";
+export { ResourceManager, type AssetProperties, type LoaderConstructor, type ResourceManagerOptions } from "./asset/ResourceManager";

package/types/loaders/EXRLoader.d.ts

@@ -1,6 +1,6 @@
 import { LoadProperties, Loader } from "../asset/Loader";
 export declare class EXRLoader extends Loader {
     extension: string[];
-    load({ url, path, resourcePath, manager, texSettings, onLoad, onProgress, onError, }: LoadProperties): void;
+    load({ url, path, resourcePath, texSettings, onLoad, onProgress, onError, }: LoadProperties): void;
     private _loader;
 }

package/types/loaders/FBXLoader.d.ts

@@ -1,6 +1,6 @@
 import { LoadProperties, Loader } from "../asset/Loader";
 export declare class FBXLoader extends Loader {
     extension: string[];
-    load({ url, buffer, path, resourcePath, manager, onLoad, onProgress, onError }: LoadProperties): void;
+    load({ url, buffer, path, resourcePath, onLoad, onProgress, onError }: LoadProperties): void;
     private _loader;
 }

package/types/loaders/GLTFLoader.d.ts

@@ -1,7 +1,7 @@
 import { LoadProperties, Loader } from "../asset/Loader";
 import { GLTF } from "three/examples/jsm/loaders/GLTFLoader.js";
 import { BufferGeometry, Material, Mesh } from "three";
-export interface GLTFAsset<V = Mesh<BufferGeometry, Material>, M = Material> extends GLTF {
+export interface GLTFAsset<M extends Material | Material[] = Material, V extends Mesh<BufferGeometry, M> = Mesh<BufferGeometry, M>> extends GLTF {
     mesh: V;
     material: M;
     meshes: Map<string, V>;
@@ -9,7 +9,6 @@ export interface GLTFAsset<V = Mesh<BufferGeometry, Material>, M = Material> ext
 }
 export declare class GLTFLoader extends Loader {
     extension: string[];
-    load({ url, buffer, path, resourcePath, dracoPath, manager, onLoad, onProgress, onError }: LoadProperties): void;
+    load({ url, buffer, path, resourcePath, onLoad, onProgress, onError }: LoadProperties): void;
     private _loader;
-    private _dracoLoader;
 }

package/types/loaders/HDRLoader.d.ts

@@ -1,6 +1,6 @@
 import { LoadProperties, Loader } from "../asset/Loader";
 export declare class HDRLoader extends Loader {
     extension: string[];
-    load({ url, path, resourcePath, manager, texSettings, onLoad, onProgress, onError, }: LoadProperties): void;
+    load({ url, path, resourcePath, texSettings, onLoad, onProgress, onError, }: LoadProperties): void;
     private _loader;
 }

package/types/loaders/JSONLoader.d.ts

@@ -1,6 +1,6 @@
 import { LoadProperties, Loader } from "../asset/Loader";
 export declare class JSONLoader extends Loader {
     extension: string[];
-    load({ url, path, resourcePath, manager, onLoad, onProgress, onError }: LoadProperties): void;
+    load({ url, path, resourcePath, onLoad, onProgress, onError }: LoadProperties): void;
     private _loader;
 }

package/types/loaders/KTX2Loader.d.ts

@@ -1,6 +1,5 @@
 import { Loader, LoadProperties } from "../asset/Loader";
 export declare class KTX2Loader extends Loader {
     extension: string[];
-    load({ url, path, resourcePath, transcoderPath, manager, texSettings, onLoad, onProgress, onError }: LoadProperties): void;
-    private _loader;
+    load({ url, path, resourcePath, texSettings, onLoad, onProgress, onError }: LoadProperties): void;
 }

package/types/loaders/STLLoader.d.ts

@@ -0,0 +1,6 @@
+import { LoadProperties, Loader } from "../asset/Loader";
+export declare class STLLoader extends Loader {
+    extension: string[];
+    load({ url, buffer, path, resourcePath, onLoad, onProgress, onError, }: LoadProperties): void;
+    private _loader;
+}

package/types/loaders/SVGLoader.d.ts

@@ -2,7 +2,7 @@ import { Loader, LoadProperties } from "../asset/Loader";
 import { SVGLoader as SVGLoaderPrimitive } from "three/examples/jsm/loaders/SVGLoader.js";
 export declare class SVGLoader extends Loader {
     extension: string[];
-    load({ url, path, resourcePath, manager, onLoad, onProgress, onError, }: LoadProperties): void;
+    load({ url, path, resourcePath, onLoad, onProgress, onError, }: LoadProperties): void;
     private _loader;
     static Primitive: typeof SVGLoaderPrimitive;
 }

package/types/loaders/TextureLoader.d.ts

@@ -1,6 +1,6 @@
 import { LoadProperties, Loader } from "../asset/Loader";
 export declare class TextureLoader extends Loader {
     extension: string[];
-    load({ url, path, resourcePath, manager, texSettings, onLoad, onProgress, onError }: LoadProperties): void;
+    load({ url, path, resourcePath, texSettings, onLoad, onProgress, onError }: LoadProperties): void;
     private _loader;
 }

package/types/loaders/index.d.ts

@@ -4,6 +4,5 @@ export { GLTFLoader, type GLTFAsset } from "./GLTFLoader";
 export { HDRLoader } from "./HDRLoader";
 export { JSONLoader } from "./JSONLoader";
 export { TextureLoader } from "./TextureLoader";
-export { BINLoader } from "./BINLoader";
 export { SVGLoader } from "./SVGLoader";
 export { KTX2Loader } from "./KTX2Loader";