soonspacejs 2.4.2 → 2.4.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "soonspacejs",
-  "version": "2.4.2",
+  "version": "2.4.5",
   "homepage": "http://www.xwbuilders.com:8800/",
   "description": "soonspacejs 2.x",
   "module": "./dist/index.esm.js",
@@ -22,12 +22,8 @@
   "author": "xuek",
   "license": "UNLICENSED",
   "dependencies": {
-    "@robotlegsjs/signals": "1.1.0",
-    "@soonspacejs/xml2json": "0.0.2",
-    "@tweenjs/tween.js": "18.6.4",
-    "@types/three": "0.139.0",
-    "localforage": "1.9.0",
-    "three": "0.139.0"
+    "@tweenjs/tween.js": "^18.6.4",
+    "@types/three": "0.141.0"
   },
-  "gitHead": "230b233208bee55f866a7835dc0a3a73a5b398cb"
+  "gitHead": "b3d9d2cdea1ab611395f847861d58db5843cd38c"
 }

package/types/Controls/FullFreeControls.d.ts

@@ -6,6 +6,7 @@ declare class FullFreeControls implements ControlsOptions {
     camera: PerspectiveCamera;
     domElement: HTMLElement;
     interactivePosition: Vector3 | null;
+    fallbackInteractivePosition: Vector3 | null;
     state: number;
     [x: string]: any;
     constructor(viewport: Viewport, camera: PerspectiveCamera);

package/types/Interface/controls.d.ts

@@ -1,6 +1,8 @@
+import { Vector3 } from 'three';
 interface ControlsOptions {
     enabled?: boolean;
     enabledMousePointInteractive?: boolean;
+    fallbackInteractivePosition?: Vector3 | null;
     enableZoom?: boolean;
     zoomSpeed?: number;
     zoomMinDistance?: number;

package/types/Interface/events.d.ts

@@ -9,28 +9,33 @@ interface SceneModelIntersect {
     model: Sbm | Model;
     sourceData: Intersection;
 }
-interface ModelEventParam {
+interface ModelEventParams {
     target: Sbm | Model;
     currentTarget: Mesh;
     intersects: SceneModelIntersect[];
+    event: MouseEvent | TouchEvent;
+}
+interface PoiEventParams {
+    target: Poi;
+    event: MouseEvent | TouchEvent;
 }
 interface SceneClickParam {
     type: SceneEventType;
     event: MouseEvent | TouchEvent;
 }
 interface SceneGlobalEvents {
-    modelHover?: (param: ModelEventParam) => void;
+    modelHover?: (param: ModelEventParams) => void;
     modelUnHover?: (model: Sbm | Model) => void;
-    modelClick?: (param: ModelEventParam) => void;
-    modelRightClick?: (param: ModelEventParam) => void;
-    modelDblClick?: (param: ModelEventParam) => void;
-    poiHover?: (poi: Poi) => void;
+    modelClick?: (param: ModelEventParams) => void;
+    modelRightClick?: (param: ModelEventParams) => void;
+    modelDblClick?: (param: ModelEventParams) => void;
+    poiHover?: (poi: PoiEventParams) => void;
     poiUnHover?: (poi: Poi) => void;
-    poiClick?: (poi: Poi) => void;
-    poiRightClick?: (poi: Poi) => void;
-    poiDblClick?: (poi: Poi) => void;
+    poiClick?: (poi: PoiEventParams) => void;
+    poiRightClick?: (poi: PoiEventParams) => void;
+    poiDblClick?: (poi: PoiEventParams) => void;
     selectPosition?: (position: Position) => void;
     sceneClick?: (param: SceneClickParam) => void;
     resize?: () => void;
 }
-export { ScenePoiIntersect, SceneModelIntersect, ModelEventParam, SceneClickParam, SceneGlobalEvents, };
+export { ScenePoiIntersect, SceneModelIntersect, ModelEventParams, SceneClickParam, SceneGlobalEvents, };

package/types/Interface/viewport.d.ts

@@ -88,6 +88,10 @@ interface ViewportOptions {
 interface ViewportState {
     useFreq: number;
     animationTotal: number;
+    /**
+     * 场景是否被销毁
+     */
+    isDisposed: boolean;
 }
 export interface BloomOptions {
     enabled?: boolean;

package/types/Loader/DatLoader/index.d.ts

@@ -1,5 +1,6 @@
 import * as THREE from 'three';
 import { Material } from 'three';
+import localforage from 'localforage';
 export interface SubMesh {
     start: number;
     count: number;
@@ -34,21 +35,23 @@ export interface MaterialsMapValue {
     materialIndex: number;
 }
 declare class DatLoader extends THREE.Loader {
-    loadedTextures: Set<string>;
+    readonly store: typeof localforage;
+    loadedTextures: Map<string, Promise<any>>;
     loadedMaterialsMap: Map<string, MaterialsMapValue>;
     loadedMaterials: THREE.Material[];
     dracoDecoderPath: string | null;
     workerPool: any;
     workerSourceURL: string;
-    constructor();
+    constructor(store: typeof localforage);
     /**
      *
      * @param buffer
-     * @param path
+     * @param url
      */
-    parseAsync(buffer: ArrayBuffer, path: string): Promise<THREE.Mesh<THREE.BufferGeometry, THREE.Material[]> | undefined>;
+    parseAsync(buffer: ArrayBuffer, url: string): Promise<THREE.Mesh<THREE.BufferGeometry, THREE.Material[]> | undefined>;
+    private _decodeBuffer;
     private _initWorkerCreator;
-    private _createMeshByStream;
+    private _createMesh;
     /**
      * 创建 material
      * @param path

package/types/Manager/Canvas3DManage.d.ts

@@ -5,6 +5,6 @@ declare class Canvas3DManage extends DefaultManage {
     constructor(viewport: Viewport, scene: SceneManage);
     create(info: Canvas3DInfo): Canvas3D;
     createToGroup(groupInfo: GroupInfo, poiInfo: Canvas3DInfo[]): Group;
-    addForGroup(groupId: GroupInfo['id'], poiInfo: Canvas3DInfo[]): Group | null;
+    addForGroup(group: Group | null, poiInfo: Canvas3DInfo[]): Group | null;
 }
 export default Canvas3DManage;

package/types/Manager/DefaultManage.d.ts

@@ -1,35 +1,18 @@
 import { Object3D } from 'three';
 import Viewport from '../Viewport';
 import { Group, GroupInfo, SceneManage, BaseObject3D } from '../Library';
-import { UserDataPropertyFindFunc } from '../Interface';
-declare type findPropKey = 'name' | 'sid';
-declare type ManageCache = {
-    objects: Map<BaseObject3D['sid'], Object3D>;
-};
 declare class DefaultManage {
     readonly type: string;
     readonly scene: SceneManage;
     readonly viewport: Viewport;
-    readonly cache: ManageCache;
     constructor(type: string, viewport: Viewport, scene: SceneManage);
-    /**
-     * cache
-     */
-    getObjectsCache<T extends Object3D>(sid: BaseObject3D['sid']): T;
-    setObjectsCache<T extends Object3D>(objects: T): void;
-    removeObjectsCache(sid: BaseObject3D['sid']): void;
     /***
      * group
      */
     createGroup(groupInfo: GroupInfo, parent?: Object3D | null): Group;
-    getById<T extends Object3D>(id: BaseObject3D['sid'], type?: string): T | null;
-    getByName<T extends BaseObject3D>(name: string, type?: string): T[];
-    getByUserDataProperty<T extends Object3D = BaseObject3D>(propNameOrFindFunc: string | UserDataPropertyFindFunc, propValue?: any): T[];
-    removeById(id: BaseObject3D['sid']): boolean;
     clear(): void;
     getAll<T = BaseObject3D>(): T[];
     hideAll(): void;
     showAll(): void;
-    _getChildByTypeAndProp<T = BaseObject3D>(type: string, propKey: findPropKey, propVal: any): T[];
 }
 export default DefaultManage;

package/types/Manager/LightManage.d.ts

@@ -6,17 +6,17 @@ import { SceneManage } from '../Library';
 declare class LightManage extends DefaultManage {
     constructor(viewport: Viewport, scene: SceneManage);
     createAmbientLight(options: AmbientLightOptions): AmbientLight;
-    setAmbientLight(options: AmbientLightOptions): boolean;
+    setAmbientLight(light: AmbientLight | null, options: AmbientLightOptions): boolean;
     createDirectionalLight(options: DirectionalLightOptions): DirectionalLight;
-    setDirectionalLight(options: DirectionalLightOptions): boolean;
+    setDirectionalLight(light: DirectionalLight | null, options: DirectionalLightOptions): boolean;
     createHemisphereLight(options: HemisphereLightOptions): HemisphereLight;
-    setHemisphereLight(options: HemisphereLightOptions): boolean;
+    setHemisphereLight(light: HemisphereLight | null, options: HemisphereLightOptions): boolean;
     createSpotLight(options: SpotLightOptions): SpotLight;
-    setSpotLight(options: SpotLightOptions): boolean;
+    setSpotLight(light: SpotLight | null, options: SpotLightOptions): boolean;
     createPointLight(options: PointLightOptions): PointLight;
-    setPointLight(options: PointLightOptions): boolean;
+    setPointLight(light: PointLight | null, options: PointLightOptions): boolean;
     createRectAreaLight(options: RectAreaLightOptions): RectAreaLight;
-    setRectAreaLight(options: RectAreaLightOptions): boolean;
+    setRectAreaLight(light: RectAreaLight | null, options: RectAreaLightOptions): boolean;
     updateAllShadow(): void;
 }
 export default LightManage;

package/types/Manager/ModelManage.d.ts

@@ -1,7 +1,7 @@
 import { LoadingManager } from 'three';
 import { FBXLoader } from 'three/examples/jsm/loaders/FBXLoader.js';
 import { GLTFLoader } from 'three/examples/jsm/loaders/GLTFLoader.js';
-import * as localforage from 'localforage';
+import localforage from 'localforage';
 import { DatLoader } from '../Loader/DatLoader';
 import DefaultManage from './DefaultManage';
 import { BaseObject3D, Group, GroupInfo, Model, ModelInfo, SceneManage } from '../Library';
@@ -10,6 +10,9 @@ import Viewport from '../Viewport';
 declare class ModelManage extends DefaultManage {
     readonly viewport: Viewport;
     modelMaps: Map<string, Model>;
+    /**
+     * workaround for types
+     */
     store: typeof localforage;
     loadingManager: LoadingManager;
     datLoader: DatLoader;
@@ -40,7 +43,7 @@ declare class ModelManage extends DefaultManage {
     parse(format: string, buffer: ArrayBuffer, modelInfo: ModelInfo): Promise<Model>;
     clone(model: Model, info: CloneModelInfo, parent?: BaseObject3D | null): Promise<Model>;
     loadToGroup(groupInfo: GroupInfo, modelInfo: ModelInfo[]): Promise<Group>;
-    addForGroup(groupId: GroupInfo['id'], modelInfo: ModelInfo[]): Promise<Group | null>;
+    addForGroup(group: Group | null, modelInfo: ModelInfo[]): Promise<Group | null>;
     /**
      * 清空本地模型缓存数据
      */

package/types/Manager/PluginObjectManage.d.ts

@@ -5,6 +5,6 @@ import Viewport from '../Viewport';
 declare class PluginManage extends DefaultManage {
     constructor(viewport: Viewport, scene: SceneManage);
     createObject(info: PluginObjectInfo, object?: Object3D): PluginObject;
-    addToObject(id: PluginObjectInfo['id'], object: Object3D): PluginObject | null;
+    addToObject(pluginObject: PluginObject | null, object: Object3D): PluginObject | null;
 }
 export default PluginManage;

package/types/Manager/PoiManage.d.ts

@@ -9,7 +9,7 @@ declare class PoiManage extends DefaultManage {
     create(info: PoiInfo): Poi;
     clone(poi: Poi, poiInfo: ClonePoiInfo, parent?: BaseObject3D | null): Poi | void;
     createToGroup(groupInfo: GroupInfo, poiInfo: PoiInfo[]): Group;
-    addForGroup(groupId: GroupInfo['id'], poiInfo: PoiInfo[]): Group | null;
+    addForGroup(group: Group | null, poiInfo: PoiInfo[]): Group | null;
     _createMaterial(url: PoiInfo['url']): SpriteMaterial;
     private _copyMaterial;
 }

package/types/Manager/PoiNodeManage.d.ts

@@ -5,7 +5,7 @@ declare class PoiNodeManage extends DefaultManage {
     constructor(viewport: Viewport, scene: SceneManage);
     create(info: PoiNodeInfo): PoiNode;
     createToGroup(groupInfo: GroupInfo, poiNodeInfo: PoiNodeInfo[]): Group;
-    addForGroup(groupId: GroupInfo['id'], poiNodeInfo: PoiNodeInfo[]): Group | null;
+    addForGroup(group: Group | null, poiNodeInfo: PoiNodeInfo[]): Group | null;
     _openEnableRenderCss(info: PoiNodeInfo): void;
 }
 export default PoiNodeManage;

package/types/Manager/SbmManage.d.ts

@@ -13,7 +13,7 @@ declare class SbmManage extends DefaultManage {
     parse(data: ArrayBuffer | SbmCache, sbmInfo: SbmInfo, onProgress?: ModelLoadingProgressCallback): Promise<Sbm>;
     clone(model: Sbm, sbmInfo: CloneSbmInfo, parent?: BaseObject3D | null): Promise<Sbm>;
     loadToGroup(groupInfo: GroupInfo, sbmInfoList: SbmInfo[], onProgress?: GroupProgressCallback): Promise<Group>;
-    addForGroup(groupId: GroupInfo['id'], sbmInfoList: SbmInfo[], onProgress?: GroupProgressCallback): Promise<Group | null>;
+    addForGroup(group: Group | null, sbmInfoList: SbmInfo[], onProgress?: GroupProgressCallback): Promise<Group | null>;
     createGroupFromXml(groupInfo: GroupInfo, url: string): Promise<Group>;
     /**
      * 清空本地模型缓存数据

package/types/Manager/TopologyManage.d.ts

@@ -10,7 +10,7 @@ declare class TopologyManage extends DefaultManage {
     create(topologyInfo: TopologyInfo): Topology;
     resetNodes(topology: Topology, nodes: TopologyNodeInfo[]): Topology;
     createToGroup(groupInfo: GroupInfo, topologyInfos: TopologyInfo[]): Group;
-    addForGroup(groupId: GroupInfo['id'], topologyInfos: TopologyInfo[]): Group | null;
+    addForGroup(group: Group | null, topologyInfos: TopologyInfo[]): Group | null;
     getShortestPath(topology: Topology, info: ShortestPathInfo): Topology | null;
     getShortestPathByMultipleStartPoints(topology: Topology, info: ShortestPathByMultipleStartPoints): Topology | null;
     getShortestPathByMultipleEndPoints(topology: Topology, info: ShortestPathByMultipleEndPoints): Topology | null;

package/types/Manager/index.d.ts

@@ -1,5 +1,6 @@
+import { Object3D } from 'three';
 import Viewport from '../Viewport';
-import { SceneManage } from '../Library';
+import { BaseObject3D, SceneManage } from '../Library';
 import LightManage from './LightManage';
 import SbmManage from './SbmManage';
 import ModelManage from './ModelManage';
@@ -10,6 +11,7 @@ import TopologyManage from './TopologyManage';
 import HelperManage from './HelperManage';
 import PluginObjectManage from './PluginObjectManage';
 import GroupManage from './GroupManage';
+import { UserDataPropertyFindFunc } from '../Interface';
 interface ManagerStore {
     groupManager: GroupManage;
     lightManager: LightManage;
@@ -22,13 +24,49 @@ interface ManagerStore {
     helperManager: HelperManage;
     pluginObjectManager: PluginObjectManage;
 }
+declare type ManageCache = {
+    objects: Map<BaseObject3D['sid'], Object3D>;
+};
 declare class Manager {
     readonly viewport: Viewport;
-    readonly scene: SceneManage;
     readonly store: ManagerStore;
+    readonly cache: ManageCache;
+    readonly scene: SceneManage;
     constructor(viewport: Viewport);
+    /**
+     * level update
+     * @returns
+     */
     levelUpdate(): void;
+    /**
+     *
+     * frame update
+     *
+     */
     update(): void;
+    /**
+     *
+     * objects
+     *
+     */
+    getObjectById<T extends Object3D>(id: BaseObject3D['sid']): T | null;
+    getObjectByName<T extends Object3D>(name: string): T[];
+    getObjectByUserDataProperty<T extends Object3D>(propNameOrFindFunc: string | UserDataPropertyFindFunc, propValue?: any): T[];
+    removeObjectById(id: BaseObject3D['sid']): boolean;
+    _getObjectByProps<T extends Object3D>(key: 'sid' | 'name', value: any): T[];
+    /**
+     *
+     * cache
+     *
+     */
+    getObjectCache<T extends Object3D>(sid: BaseObject3D['sid']): T | undefined;
+    setObjectCache<T extends Object3D>(object?: T): void;
+    deleteObjectCache<T extends Object3D>(object?: T): void;
+    /**
+     *
+     * clear object
+     *
+     */
     clearObject(): void;
     clear(): void;
     dispose(): void;

package/types/Shared/index.d.ts

@@ -3,6 +3,7 @@ declare const isString: (val: unknown) => val is string;
 declare const isBoolean: (val: unknown) => val is boolean;
 declare const isNumber: (val: unknown) => val is number;
 declare const isNull: (val: unknown) => val is null;
+declare const isUndefined: (val: unknown) => val is null;
 declare const isSymbol: (val: unknown) => val is symbol;
 declare const isDate: (val: unknown) => val is Date;
 declare const isArray: (arg: any) => arg is any[];
@@ -20,7 +21,8 @@ export * from './path';
 export * from './cloneDeep';
 export * from './material';
 export * from './network';
+export * from './task';
 export { hasOwn, };
-export { isString, isBoolean, isNumber, isNull, isSymbol, };
+export { isString, isBoolean, isNumber, isNull, isUndefined, isSymbol, };
 export { isDate, isArray, isObject, isFunction, isPromise, };
 export { getValueType, sleep, getAsciiString, };

package/types/Shared/task.d.ts

@@ -0,0 +1 @@
+export declare const idleTask: (callback: () => void) => void;

package/types/Viewport/CameraManager.d.ts

@@ -2,7 +2,7 @@ import { Box3, PerspectiveCamera, Vector3, Euler, Object3D } from 'three';
 import { Rotation, Position, AnimationOptions, FlyToViewpoint, CameraViewpointData, FlyToObjOptions, SurroundOptions, LabelOptions } from '../Interface';
 import { BaseObject3D, BaseMesh } from '../Library';
 import Viewport from '.';
-declare class cameraManager {
+declare class CameraManager {
     viewport: Viewport;
     mainCamera: PerspectiveCamera;
     currentCamera: PerspectiveCamera;
@@ -26,4 +26,4 @@ declare class cameraManager {
     getMovePosByBBox(bbox: Box3): Vector3;
     getObjectLabelPos(bbox: Box3 | BaseObject3D, rotation?: FlyToViewpoint | Rotation | Euler, options?: LabelOptions): Position;
 }
-export default cameraManager;
+export default CameraManager;

package/types/Viewport/index.d.ts

@@ -39,6 +39,7 @@ declare class Viewport {
     effectManager: EffectManager;
     effectComposer: EffectComposer;
     mixer: AnimationMixer;
+    viewHelper: ViewHelper;
     /**
      * render 前回调
      */
@@ -50,7 +51,6 @@ declare class Viewport {
     private selectModel;
     private selectPoi;
     private _loop;
-    viewHelper: ViewHelper;
     constructor(options: ViewportOptions);
     _initInfo(): void;
     _initStats(): void;
@@ -60,7 +60,7 @@ declare class Viewport {
      */
     setSobel(): void;
     setBloom(): void;
-    setSSAO(options: SSAOOptions): void;
+    setSSAO(options?: SSAOOptions): void;
     /**
      ***************************** renderer ***************************
      */

package/types/index.d.ts

@@ -32,6 +32,85 @@ declare global {
 }
 export default class SoonSpace {
     static readonly THREE: typeof THREE;
+    static readonly TWEEN: {
+        Easing: {
+            Linear: {
+                None: (amount: number) => number;
+            };
+            Quadratic: {
+                In: (amount: number) => number;
+                Out: (amount: number) => number;
+                InOut: (amount: number) => number;
+            };
+            Cubic: {
+                In: (amount: number) => number;
+                Out: (amount: number) => number;
+                InOut: (amount: number) => number;
+            };
+            Quartic: {
+                In: (amount: number) => number;
+                Out: (amount: number) => number;
+                InOut: (amount: number) => number;
+            };
+            Quintic: {
+                In: (amount: number) => number;
+                Out: (amount: number) => number;
+                InOut: (amount: number) => number;
+            };
+            Sinusoidal: {
+                In: (amount: number) => number;
+                Out: (amount: number) => number;
+                InOut: (amount: number) => number;
+            };
+            Exponential: {
+                In: (amount: number) => number;
+                Out: (amount: number) => number;
+                InOut: (amount: number) => number;
+            };
+            Circular: {
+                In: (amount: number) => number;
+                Out: (amount: number) => number;
+                InOut: (amount: number) => number;
+            };
+            Elastic: {
+                In: (amount: number) => number;
+                Out: (amount: number) => number;
+                InOut: (amount: number) => number;
+            };
+            Back: {
+                In: (amount: number) => number;
+                Out: (amount: number) => number;
+                InOut: (amount: number) => number;
+            };
+            Bounce: {
+                In: (amount: number) => number;
+                Out: (amount: number) => number;
+                InOut: (amount: number) => number;
+            };
+        };
+        Group: typeof import("@tweenjs/tween.js").Group;
+        Interpolation: {
+            Linear: (v: number[], k: number) => number;
+            Bezier: (v: number[], k: number) => number;
+            CatmullRom: (v: number[], k: number) => number;
+            Utils: {
+                Linear: (p0: number, p1: number, t: number) => number;
+                Bernstein: (n: number, i: number) => number;
+                Factorial: (n: number) => number;
+                CatmullRom: (p0: number, p1: number, p2: number, p3: number, t: number) => number;
+            };
+        };
+        now: () => number;
+        Sequence: typeof import("@tweenjs/tween.js").Sequence;
+        nextId: typeof import("@tweenjs/tween.js").Sequence.nextId;
+        Tween: typeof import("@tweenjs/tween.js").Tween;
+        VERSION: string;
+        getAll: () => import("@tweenjs/tween.js").Tween<Record<string, any>>[];
+        removeAll: () => void;
+        add: (tween: import("@tweenjs/tween.js").Tween<Record<string, any>>) => void;
+        remove: (tween: import("@tweenjs/tween.js").Tween<Record<string, any>>) => void;
+        update: (time?: number | undefined, preserve?: boolean | undefined) => boolean;
+    };
     readonly THREE: typeof THREE;
     readonly THREE_PLUGINS: {
         TransformControls: typeof TransformControls;
@@ -118,7 +197,7 @@ export default class SoonSpace {
      * @param bloom
      */
     setBloom(): void;
-    setSSAO(options: SSAOOptions): void;
+    setSSAO(options?: SSAOOptions): void;
     /**
      * 设置场景的颜色空间
      * @param colorSpace
@@ -457,6 +536,15 @@ export default class SoonSpace {
     updateAllShadow(): void;
     /******/
     /******/
+    /******* Object methods */
+    /******/
+    /******/
+    getObjectById<T extends Object3D = BaseObject3D>(id: BaseObject3DInfo['id']): T | null;
+    getObjectByName<T extends Object3D = BaseObject3D>(name: string): T[];
+    getObjectByUserDataProperty<T extends Object3D = BaseObject3D>(property: string | UserDataPropertyFindFunc, value: any): T[];
+    removeObjectById(id: BaseObject3DInfo['id']): boolean;
+    /******/
+    /******/
     /******* Group methods */
     /******/
     /******/

package/types/Loader/DatLoader/DatLoader_DEPRECATED.d.ts

@@ -1,68 +0,0 @@
-import * as THREE from 'three';
-import { Material } from 'three';
-export interface TexturesIndexes {
-    name: string;
-    base_map: string;
-    nor_map: string;
-    color: {
-        r: number;
-        g: number;
-        b: number;
-        a: number;
-    };
-    metallic: number;
-    roughness: number;
-    alphamode: number;
-    use_list: string[];
-}
-export interface MaterialsMapValue {
-    material: Material;
-    materialIndex: number;
-}
-declare class DatLoader extends THREE.Loader {
-    loadedTextures: Set<string>;
-    loadedMaterialsMap: Map<string, MaterialsMapValue>;
-    loadedMaterials: THREE.Material[];
-    constructor();
-    /**
-     *
-     * @param buffer
-     * @param path
-     */
-    parseAsync(buffer: ArrayBuffer, path: string): Promise<THREE.Mesh<THREE.BufferGeometry, THREE.Material[]>>;
-    private _createMeshByStream;
-    /**
-     * 创建 material
-     * @param path
-     * @returns
-     */
-    private _createMaterial;
-}
-export { DatLoader, };
-export interface SubMesh {
-    start: number;
-    count: number;
-    uuid: string;
-    alphaMode: number;
-}
-export interface ChunkInfo {
-    position: Float32Array;
-    normal: Int8Array;
-    color: Uint8Array;
-    texcoord: Float32Array;
-    indice: Uint32Array;
-    sub_mesh: SubMesh[];
-}
-export declare const parseChunk: (arraybuffer: ArrayBuffer) => {
-    position: Float32Array;
-    normal: Int8Array;
-    color: Uint8Array;
-    texcoord: Float32Array;
-    indice: Uint32Array;
-    sub_mesh: {
-        start: number;
-        count: number;
-        uuid: string;
-        alphaMode: number;
-    }[];
-};