soonspacejs 2.3.20 → 2.4.0

package/package.json

@@ -1,6 +1,7 @@
 {
   "name": "soonspacejs",
-  "version": "2.3.20",
+  "version": "2.4.0",
+  "homepage": "http://www.xwbuilders.com:8800/",
   "description": "soonspacejs 2.x",
   "main": "dist/index.js",
   "module": "dist/index.esm.js",
@@ -21,5 +22,5 @@
     "localforage": "1.9.0",
     "three": "0.139.0"
   },
-  "gitHead": "e1703d68f492f42e428f921e5436aa425346d20e"
+  "gitHead": "33f17a26b09ee1ff70726ef24baacba701a8a573"
 }

package/types/Interface/animation.d.ts

@@ -1,10 +1,10 @@
-declare type AnimationMode = 'Linear.None' | 'Quadratic.In' | 'Quadratic.Out' | 'Quadratic.InOut' | 'Cubic.In' | 'Cubic.Out' | 'Cubic.InOut' | 'Quartic.In' | 'Quartic.Out' | 'Quartic.InOut' | 'Quintic.In' | 'Quintic.Out' | 'Quintic.InOut' | 'Sinusoidal.In' | 'Sinusoidal.Out' | 'Sinusoidal.InOut' | 'Exponential.In' | 'Exponential.Out' | 'Exponential.InOut' | 'Circular.In' | 'Circular.Out' | 'Circular.InOut' | 'Elastic.In' | 'Elastic.Out' | 'Elastic.InOut' | 'Back.In' | 'Back.Out' | 'Back.InOut' | 'Bounce.In' | 'Bounce.Out' | 'Bounce.InOut';
-declare type AnimationModeEnum = Record<AnimationMode, (amount: number) => number>;
+declare type AnimationModeType = 'Linear.None' | 'Quadratic.In' | 'Quadratic.Out' | 'Quadratic.InOut' | 'Cubic.In' | 'Cubic.Out' | 'Cubic.InOut' | 'Quartic.In' | 'Quartic.Out' | 'Quartic.InOut' | 'Quintic.In' | 'Quintic.Out' | 'Quintic.InOut' | 'Sinusoidal.In' | 'Sinusoidal.Out' | 'Sinusoidal.InOut' | 'Exponential.In' | 'Exponential.Out' | 'Exponential.InOut' | 'Circular.In' | 'Circular.Out' | 'Circular.InOut' | 'Elastic.In' | 'Elastic.Out' | 'Elastic.InOut' | 'Back.In' | 'Back.Out' | 'Back.InOut' | 'Bounce.In' | 'Bounce.Out' | 'Bounce.InOut';
+declare type AnimationModeValueType = (amount: number) => number;
 interface AnimationOptions {
     duration?: number;
     delay?: number;
     repeat?: number | boolean;
-    mode?: AnimationMode;
+    mode?: AnimationModeType;
     yoyo?: boolean;
 }
-export { AnimationMode, AnimationModeEnum, AnimationOptions, };
+export { AnimationModeType, AnimationModeValueType, AnimationOptions, };

package/types/Interface/base.d.ts

@@ -1,3 +1,4 @@
+import { Color } from 'three';
 interface IVector2 {
     x: number;
     y: number;
@@ -15,7 +16,7 @@ interface IVector3 extends IVector2 {
 declare type Position = IVector3;
 declare type Rotation = IVector3;
 declare type Scale = IVector3;
-declare type IColor = string | number;
+declare type IColor = string | number | Color;
 interface Level {
     max: number | null;
     min: number | null;

package/types/Interface/manager.d.ts

@@ -89,7 +89,7 @@ interface ShortestPathByMultipleEndPoints extends BaseObject3DInfo, TopologyEffe
     end: Position[];
 }
 interface TopologyNodeGraph {
-    targetNodeId: string;
+    targetNodeId: string | number;
     linkInfo: {
         id: string;
         name: string;

package/types/Interface/viewport.d.ts

@@ -80,6 +80,7 @@ interface ViewportOptions {
     fog?: boolean | FogOptions;
     controls?: ControlsOptions;
     hoverEnabled?: boolean;
+    levelEnabled?: boolean;
     closeInfoLog?: boolean;
     closeWarnLog?: boolean;
     useIndexedDB?: boolean;
@@ -98,4 +99,8 @@ export interface BloomOptions {
 export interface SobelOptions {
     enable?: boolean;
 }
+export interface ToneMappingOptions {
+    type?: 'None' | 'Linear' | 'Reinhard' | 'Cineon' | 'ACESFilmic';
+    exposure?: number;
+}
 export { CameraViewpointData, FlyToObjOptions, SurroundOptions, LabelOptions, InternalOptions, SelectModelOptions, EdgeSelectOptions, StrokeSelectOptions, OpacitySelectOptions, HighlightSelectOptions, EmissiveSelectOptions, FogOptions, SkyOptions, ViewportOptions, ViewportState, };

package/types/Library/BaseObject3D.d.ts

@@ -1,4 +1,4 @@
-import { Object3D, Vector3, Euler, BaseEvent, Event } from 'three';
+import { Object3D, Vector3, Euler, BaseEvent, Event, Box3 } from 'three';
 import { Tween } from '@tweenjs/tween.js';
 import { Position, Rotation, Scale, Level, AnimationOptions, Interpolate } from '../Interface';
 interface BaseObject3DInfo {
@@ -25,6 +25,7 @@ declare class BaseObject3D<E extends BaseEvent = Event> extends Object3D<E> {
     setScale(scale: Scale | Vector3, options?: AnimationOptions, onUpdate?: (source: Scale, tween: Tween<Scale>) => void, onStart?: (tween: Tween<Scale>) => void): Promise<void>;
     sClone<T extends BaseObject3D>(recursive?: boolean): T;
     sCopy<T extends BaseObject3D>(source: BaseObject3D, recursive?: boolean): T;
+    getBoundingBox(): Box3;
     getSpaceAttribute(isFromWorld?: boolean): {
         position: Vector3;
         rotation: Euler;

package/types/Library/Model.d.ts

@@ -1,4 +1,3 @@
-import { Box3 } from 'three';
 import { BaseObject3D, BaseObject3DInfo } from './BaseObject3D';
 import { ObjectEvents, ObjectEventsListener } from '../Interface';
 interface ModelInfo extends BaseObject3DInfo, ObjectEvents<Model> {
@@ -15,7 +14,6 @@ declare class Model extends BaseObject3D<ObjectEventsListener> implements Object
     onDblClick: ((object: Model) => void) | null;
     onRightClick: ((object: Model) => void) | null;
     constructor(param: ModelInnerInfo);
-    getBoundingBox(): Box3;
     eventPropagation(): void;
     setEnvMap(dirPath: string, fileNames?: string[], options?: {
         reflectivity?: number;

package/types/Library/Sbm.d.ts

@@ -1,4 +1,3 @@
-import { Box3 } from 'three';
 import { BaseObject3D, BaseObject3DInfo } from './BaseObject3D';
 import { ObjectEvents, ObjectEventsListener } from '../Interface';
 interface SbmInfo extends BaseObject3DInfo, ObjectEvents<Sbm> {
@@ -12,7 +11,6 @@ declare class Sbm extends BaseObject3D<ObjectEventsListener> implements ObjectEv
     onDblClick: ((object: Sbm) => void) | null;
     onRightClick: ((object: Sbm) => void) | null;
     constructor(param: SbmInfo);
-    getBoundingBox(): Box3;
     eventPropagation(): void;
     setEnvMap(dirPath: string, fileNames?: string[], options?: {
         reflectivity?: number;

package/types/Loader/DatLoader.d.ts

@@ -0,0 +1,68 @@
+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;
+    }[];
+};

package/types/Loader/SbmLoader/SbkLoader.d.ts

@@ -6,22 +6,13 @@ declare class SbkLoader {
     materials: Map<string, any>;
     sbmInfo: SbmInfo | null;
     constructor();
-    /**
-     * 加载模型
-     * @param sbmInfo 模型信息
-     * @param onProgress 模型加载进度回填函数
-     */
-    load(sbmInfo: SbmInfo, onProgress?: ModelLoadingProgressCallback): Promise<Sbm | {
-        sbm: Sbm;
-        caches: SbmCache;
-    }>;
     /**
      * 解析模型
      * @param buffer 模型二进制原数据
      * @param sbmInfo 模型信息
      * @param onProgress 模型加载进度回填函数
      */
-    parseBuffer(buffer: ArrayBuffer, sbmInfo: SbmInfo, onProgress?: ModelLoadingProgressCallback): Promise<Sbm | {
+    parseBuffer(buffer: ArrayBuffer, sbmInfo: SbmInfo, onProgress?: ModelLoadingProgressCallback): Promise<{
         sbm: Sbm;
         caches: SbmCache;
     }>;

package/types/Loader/SbmLoader/SbmLoader.d.ts

@@ -1,35 +1,39 @@
 import { Sbm, SbmInfo } from '../../Library';
 import { ModelLoadingProgress, ModelLoadingProgressCallback } from '../../Interface';
+import { SbmCache } from '../../Interface/sbmCache';
 declare class SbmLoader {
     materials: Map<string, any>;
     sbmInfo: SbmInfo | null;
     isLE: boolean;
     constructor();
-    /**
-     * 加载模型
-     * @param sbmInfo 模型信息
-     * @param onProgress 模型加载进度回填函数
-     */
-    load(sbmInfo: SbmInfo, onProgress?: ModelLoadingProgressCallback): Promise<Sbm>;
     /**
      * 解析模型
      * @param buffer 模型二进制原数据
      * @param sbmInfo 模型信息
      * @param onProgress 模型加载进度回填函数
      */
-    parseBuffer(buffer: ArrayBuffer, sbmInfo: SbmInfo, onProgress?: ModelLoadingProgressCallback): Promise<Sbm>;
+    parseBuffer(buffer: ArrayBuffer, sbmInfo: SbmInfo, onProgress?: ModelLoadingProgressCallback): Promise<{
+        sbm: Sbm;
+        caches: SbmCache;
+    }>;
     /**
      * @param dataView
      * @param offset
      * @param onProgress
      */
-    _parseV2(dataView: DataView, offset: number, onProgress?: ModelLoadingProgressCallback): Promise<Sbm>;
+    _parseV2(dataView: DataView, offset: number, onProgress?: ModelLoadingProgressCallback): Promise<{
+        sbm: Sbm;
+        caches: SbmCache;
+    }>;
     /**
      * @param dataView
      * @param offset
      * @param onProgress
      */
-    _parseV3(dataView: DataView, offset: number, onProgress?: ModelLoadingProgressCallback): Promise<Sbm>;
+    _parseV3(dataView: DataView, offset: number, onProgress?: ModelLoadingProgressCallback): Promise<{
+        sbm: Sbm;
+        caches: SbmCache;
+    }>;
     /**
      * 获取材质贴图路径
      * @param modelUrl 模型资源路径

package/types/Loader/{utils → SbmLoader/utils}/generateSbm.d.ts

@@ -1,4 +1,4 @@
-import { Texture, MeshPhongMaterial } from 'three';
+import { Texture, MeshStandardMaterial } from 'three';
 /**
  * 生成 sbm 纹理
  * @param url
@@ -10,4 +10,4 @@ export declare const generateSbmTexture: (textureUrl: string) => Texture;
  * @param arr
  * @param texture
  */
-export declare const generateSbmMaterial: (materialId: string, arr: number[], texture: Texture | null) => MeshPhongMaterial;
+export declare const generateSbmMaterial: (materialId: string, arr: number[], texture: Texture | null) => MeshStandardMaterial;

package/types/Manager/Canvas3DManage.d.ts

@@ -1,8 +1,8 @@
 import DefaultManage from './DefaultManage';
 import Viewport from '../Viewport';
-import { Group, GroupInfo, Canvas3D, Canvas3DInfo } from '../Library';
+import { Group, GroupInfo, Canvas3D, Canvas3DInfo, SceneManage } from '../Library';
 declare class Canvas3DManage extends DefaultManage {
-    constructor(viewport: Viewport);
+    constructor(viewport: Viewport, scene: SceneManage);
     create(info: Canvas3DInfo): Canvas3D;
     createToGroup(groupInfo: GroupInfo, poiInfo: Canvas3DInfo[]): Group;
     addForGroup(groupId: GroupInfo['id'], poiInfo: Canvas3DInfo[]): Group | null;

package/types/Manager/DefaultManage.d.ts

@@ -1,22 +1,31 @@
+import { Object3D } from 'three';
 import Viewport from '../Viewport';
-import { SceneManage, BaseObject3D, Group, GroupInfo } from '../Library';
+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;
-    constructor(type: string, viewport: Viewport);
-    update(): void;
-    getById<T>(id: BaseObject3D['sid'], type?: string): T | null;
-    getByName<T>(name: string, type?: string): T[];
-    getByUserDataProperty<T = BaseObject3D>(propNameOrFindFunc: string | UserDataPropertyFindFunc, propValue?: any): T[];
+    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;
-    createGroup(groupInfo: GroupInfo): Group;
-    getGroupById<T = Group>(id: string | number): T | null;
-    getGroupByName<T = Group>(name: string): T[];
-    getAllGroup(): Group[];
-    removeGroupById(id: BaseObject3D['sid']): boolean;
     clear(): void;
     getAll<T = BaseObject3D>(): T[];
     hideAll(): void;

package/types/Manager/GroupManage.d.ts

@@ -0,0 +1,7 @@
+import { SceneManage } from '../Library';
+import Viewport from '../Viewport';
+import DefaultManage from './DefaultManage';
+declare class GroupManage extends DefaultManage {
+    constructor(viewport: Viewport, scene: SceneManage);
+}
+export default GroupManage;

package/types/Manager/HelperManage.d.ts

@@ -3,9 +3,9 @@ import DefaultManage from './DefaultManage';
 import { GridHelper, AxesHelper, Box3Helper, DirectionalLightHelper, HemisphereLightHelper, SpotLightHelper, PointLightHelper } from 'three';
 import { RectAreaLightHelper } from 'three/examples/jsm/helpers/RectAreaLightHelper.js';
 import { GridHelperOptions, AxesHelperOptions, BoxHelperOptions, PlaneHelperOptions, GroundHelperOptions, DirectionalLightHelperOptions, HemisphereLightHelperOptions, SpotLightHelperOptions, PointLightHelperOptions, RectAreaLightHelperOptions } from '../Interface';
-import { BaseMesh, Ground } from '../Library';
+import { BaseMesh, Ground, SceneManage } from '../Library';
 declare class HelperManage extends DefaultManage {
-    constructor(viewport: Viewport);
+    constructor(viewport: Viewport, scene: SceneManage);
     addGridHelper(options: GridHelperOptions): GridHelper;
     addAxesHelper(options: AxesHelperOptions): AxesHelper;
     addBoxHelper(options: BoxHelperOptions): Box3Helper;

package/types/Manager/LightManage.d.ts

@@ -2,8 +2,9 @@ import { AmbientLight, DirectionalLight, HemisphereLight, SpotLight, PointLight,
 import DefaultManage from './DefaultManage';
 import Viewport from '../Viewport';
 import { AmbientLightOptions, DirectionalLightOptions, HemisphereLightOptions, SpotLightOptions, PointLightOptions, RectAreaLightOptions } from '../Interface';
+import { SceneManage } from '../Library';
 declare class LightManage extends DefaultManage {
-    constructor(viewport: Viewport);
+    constructor(viewport: Viewport, scene: SceneManage);
     createAmbientLight(options: AmbientLightOptions): AmbientLight;
     setAmbientLight(options: AmbientLightOptions): boolean;
     createDirectionalLight(options: DirectionalLightOptions): DirectionalLight;

package/types/Manager/ModelManage.d.ts

@@ -1,20 +1,38 @@
+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 { DatLoader } from '../Loader/DatLoader';
 import DefaultManage from './DefaultManage';
-import { BaseObject3D, Group, GroupInfo, Model, ModelInfo } from '../Library';
+import { BaseObject3D, Group, GroupInfo, Model, ModelInfo, SceneManage } from '../Library';
 import { CloneModelInfo } from '../Interface';
 import Viewport from '../Viewport';
 declare class ModelManage extends DefaultManage {
     readonly viewport: Viewport;
     modelMaps: Map<string, Model>;
     store: typeof localforage;
+    loadingManager: LoadingManager;
+    datLoader: DatLoader;
+    gltfLoader: GLTFLoader;
+    fbxLoader: FBXLoader;
     dracoDecoderPath: string | null;
-    gltfLoader: GLTFLoader | null;
-    fbxLoader: FBXLoader | null;
-    constructor(viewport: Viewport);
+    constructor(viewport: Viewport, scene: SceneManage);
+    private _initLoadingManager;
+    private _setModelMpas;
+    private _parseSbmx;
+    private _parseDat;
+    private _parseGltf;
+    private _parseFbx;
     setDracoDecoderPath(path: string): void;
     load(modelInfo: ModelInfo): Promise<Model>;
+    _loadItem(modelInfo: ModelInfo, parent?: BaseObject3D | null): Promise<Model>;
+    /**
+     * model 解析
+     * @param format
+     * @param buffer
+     * @param modelInfo
+     * @returns
+     */
     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>;
@@ -23,13 +41,11 @@ declare class ModelManage extends DefaultManage {
      * 清空本地模型缓存数据
      */
     clearIdb(): Promise<void>;
-    _loadItem(modelInfo: ModelInfo, parent?: BaseObject3D | null): Promise<Model>;
     /**
      * 远程请求 model
      * @param modelInfo
      * @returns
      */
     _fetchBuffer(modelInfo: ModelInfo): Promise<ArrayBuffer>;
-    private _copyMaterial;
 }
 export default ModelManage;

package/types/Manager/PluginObjectManage.d.ts

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

package/types/Manager/PoiManage.d.ts

@@ -1,11 +1,11 @@
 import DefaultManage from './DefaultManage';
 import { SpriteMaterial } from 'three';
-import { Poi, PoiInfo, Group, GroupInfo, BaseObject3D } from '../Library';
+import { Poi, PoiInfo, Group, GroupInfo, BaseObject3D, SceneManage } from '../Library';
 import { ClonePoiInfo } from '../Interface';
 import Viewport from '../Viewport';
 declare class PoiManage extends DefaultManage {
     materials: Map<string, SpriteMaterial>;
-    constructor(viewport: Viewport);
+    constructor(viewport: Viewport, scene: SceneManage);
     create(info: PoiInfo): Poi;
     clone(poi: Poi, poiInfo: ClonePoiInfo, parent?: BaseObject3D | null): Poi | void;
     createToGroup(groupInfo: GroupInfo, poiInfo: PoiInfo[]): Group;

package/types/Manager/PoiNodeManage.d.ts

@@ -1,8 +1,8 @@
 import DefaultManage from './DefaultManage';
 import Viewport from '../Viewport';
-import { PoiNode, PoiNodeInfo, Group, GroupInfo } from '../Library';
+import { PoiNode, PoiNodeInfo, Group, GroupInfo, SceneManage } from '../Library';
 declare class PoiNodeManage extends DefaultManage {
-    constructor(viewport: Viewport);
+    constructor(viewport: Viewport, scene: SceneManage);
     create(info: PoiNodeInfo): PoiNode;
     createToGroup(groupInfo: GroupInfo, poiNodeInfo: PoiNodeInfo[]): Group;
     addForGroup(groupId: GroupInfo['id'], poiNodeInfo: PoiNodeInfo[]): Group | null;

package/types/Manager/SbmManage.d.ts

@@ -1,14 +1,14 @@
 import * as localforage from 'localforage';
 import DefaultManage from './DefaultManage';
 import Viewport from '../Viewport';
-import { BaseObject3D, Group, GroupInfo, Sbm, SbmInfo } from '../Library';
+import { BaseObject3D, Group, GroupInfo, Sbm, SbmInfo, SceneManage } from '../Library';
 import { CloneSbmInfo, ModelLoadingProgressCallback, GroupProgressCallback } from '../Interface';
 import { SbmCache } from '../Interface/sbmCache';
 declare class SbmManage extends DefaultManage {
     readonly viewport: Viewport;
     modelMaps: Map<string, Sbm>;
     store: typeof localforage;
-    constructor(viewport: Viewport);
+    constructor(viewport: Viewport, scene: SceneManage);
     load(sbmInfo: SbmInfo, onProgress?: ModelLoadingProgressCallback): Promise<Sbm>;
     parse(data: ArrayBuffer | SbmCache, sbmInfo: SbmInfo, onProgress?: ModelLoadingProgressCallback): Promise<Sbm>;
     clone(model: Sbm, sbmInfo: CloneSbmInfo, parent?: BaseObject3D | null): Promise<Sbm>;

package/types/Manager/TopologyManage.d.ts

@@ -1,11 +1,11 @@
 import DefaultManage from './DefaultManage';
-import { Group, GroupInfo, Topology, TopologyInfo } from '../Library';
+import { Group, GroupInfo, SceneManage, Topology, TopologyInfo } from '../Library';
 import { TopologyInfoForGml, ShortestPathInfo, ShortestPathByMultipleStartPoints, ShortestPathByMultipleEndPoints, TopologyNodeInfo } from '../Interface';
 import Viewport from '../Viewport';
 import { Dijkstras } from '../Math/dijkstra';
 declare class TopologyManage extends DefaultManage {
     dijkstra: Dijkstras;
-    constructor(viewport: Viewport);
+    constructor(viewport: Viewport, scene: SceneManage);
     createFromGml(topologyInfoForGml: TopologyInfoForGml): Promise<Topology>;
     create(topologyInfo: TopologyInfo): Topology;
     resetNodes(topology: Topology, nodes: TopologyNodeInfo[]): Topology;

package/types/Manager/index.d.ts

@@ -1,5 +1,5 @@
 import Viewport from '../Viewport';
-import DefaultManage from './DefaultManage';
+import { SceneManage } from '../Library';
 import LightManage from './LightManage';
 import SbmManage from './SbmManage';
 import ModelManage from './ModelManage';
@@ -9,8 +9,10 @@ import Canvas3DManage from './Canvas3DManage';
 import TopologyManage from './TopologyManage';
 import HelperManage from './HelperManage';
 import PluginObjectManage from './PluginObjectManage';
+import GroupManage from './GroupManage';
 interface ManagerStore {
-    LightManager: LightManage;
+    groupManager: GroupManage;
+    lightManager: LightManage;
     sbmManager: SbmManage;
     modelManager: ModelManage;
     poiManager: PoiManage;
@@ -19,14 +21,13 @@ interface ManagerStore {
     topologyManager: TopologyManage;
     helperManager: HelperManage;
     pluginObjectManager: PluginObjectManage;
-    [x: string]: DefaultManage;
 }
 declare class Manager {
     readonly viewport: Viewport;
-    needUpdate: boolean;
+    readonly scene: SceneManage;
     readonly store: ManagerStore;
-    readonly postUpdate: Map<string, () => void>;
     constructor(viewport: Viewport);
+    levelUpdate(): void;
     update(): void;
     clearObject(): void;
     clear(): void;

package/types/Shared/cloneDeep.d.ts

@@ -0,0 +1,2 @@
+declare function cloneDeep<T = any>(val: T): T;
+export { cloneDeep, };

package/types/Shared/index.d.ts

@@ -9,15 +9,17 @@ declare const isArray: (arg: any) => arg is any[];
 declare const isObject: <T = Record<any, any>>(val: unknown) => val is T;
 declare const isFunction: (val: unknown) => val is () => void;
 declare const isPromise: <T = any>(val: unknown) => val is Promise<T>;
-declare const typeJudge: (val: any) => string;
+declare const getValueType: (val: any) => string;
 declare const sleep: (time: number) => Promise<void>;
 declare const getAsciiString: (buf: ArrayBufferLike, offset: number, len: number) => string;
 export * from './log';
 export * from './viewport';
 export * from './MinHeap';
 export * from './map';
-export * from './sbmx';
+export * from './path';
+export * from './cloneDeep';
+export * from './material';
 export { hasOwn, };
 export { isString, isBoolean, isNumber, isNull, isSymbol, };
 export { isDate, isArray, isObject, isFunction, isPromise, };
-export { typeJudge, sleep, getAsciiString, };
+export { getValueType, sleep, getAsciiString, };

package/types/Shared/material.d.ts

@@ -0,0 +1,2 @@
+import { Mesh } from 'three';
+export declare const cloneMaterials: (mesh: Mesh) => import("three").Material | import("three").Material[];

package/types/Shared/path.d.ts

@@ -0,0 +1 @@
+export declare const parseFilePath: (url: string) => string;

package/types/Viewport/RendererManager.d.ts

@@ -13,12 +13,13 @@ export interface PassObj {
     unrealBloomPass: UnrealBloomPass;
     sobelPass: ShaderPass;
     gammaCorrectionPass: ShaderPass;
+    fxaaPass: ShaderPass;
 }
 declare class RendererManager {
     scene: Scene;
     options: ViewportOptions;
     internalOptions: InternalOptions;
-    effectComposer: EffectComposer | null;
+    effectComposer: EffectComposer;
     renderer: WebGLRenderer;
     container: HTMLElement;
     interactiveContainer: HTMLElement;
@@ -26,7 +27,7 @@ declare class RendererManager {
     rendererCSS3D: CSS3DRenderer;
     rendererCSS2DHalf: CSS2DHalfRenderer;
     constructor(scene: Scene, options: ViewportOptions);
-    initEffectComposer(): EffectComposer;
+    _initEffectComposer(): EffectComposer;
     initAllPass(camera: Camera): PassObj;
     addPass(effectPass: Pass): void;
     isIncludesPass(effectPass: Pass): boolean;
@@ -46,5 +47,6 @@ declare class RendererManager {
     _initUnrealBloomPass(): UnrealBloomPass;
     _initSobelPass(): ShaderPass;
     _initGammaCorrectionPass(): ShaderPass;
+    _initFXAAPass(): ShaderPass;
 }
 export default RendererManager;

package/types/Viewport/index.d.ts

@@ -1,4 +1,4 @@
-import { Scene, PerspectiveCamera, WebGLRenderer, PMREMGenerator, Vector3, AnimationMixer, Intersection, Object3D, AnimationAction, AnimationClip } from 'three';
+import { Clock, Scene, PerspectiveCamera, WebGLRenderer, PMREMGenerator, Vector3, AnimationMixer, Intersection, Object3D, AnimationAction, AnimationClip } from 'three';
 import { EffectComposer } from 'three/examples/jsm/postprocessing/EffectComposer.js';
 import Stats from 'three/examples/jsm/libs/stats.module.js';
 import { Sky } from 'three/examples/jsm/objects/Sky.js';
@@ -8,11 +8,14 @@ import RendererManager, { PassObj } from './RendererManager';
 import CameraManager from './CameraManager';
 import { FullFreeControls } from '../Controls';
 import { Model } from '../Library';
-import { ColorSpace, SkyOptions, IColor, OffsetPoint, SceneEventType, Position, ViewportOptions, ViewportState, ModelAnimationFindFunc, SignalsState, BloomOptions, SobelOptions } from '../Interface';
+import { ColorSpace, SkyOptions, IColor, OffsetPoint, SceneEventType, Position, ViewportOptions, ViewportState, ModelAnimationFindFunc, SignalsState, BloomOptions, SobelOptions, ToneMappingOptions } from '../Interface';
 import Info from './Info';
 import { ViewHelper } from './ViewHelper';
-export declare const innerRenderState: Record<string, boolean>;
+export declare const innerRenderState: {
+    needsUpdate: boolean;
+};
 declare class Viewport {
+    clock: Clock;
     options: ViewportOptions;
     state: ViewportState;
     signals: SignalsState;
@@ -51,12 +54,13 @@ declare class Viewport {
     _initInfo(): void;
     _initStats(): void;
     _initViewHelper(): void;
-    setSobel(options?: SobelOptions): void;
     /**
      ***************************** renderer ***************************
      */
+    setSobel(options?: SobelOptions): void;
     setBloom(options?: BloomOptions): void;
     setColorSpace(colorSpace: ColorSpace): void;
+    setToneMapping(options?: ToneMappingOptions): void;
     /**
      ***************************** background ***************************
      */
@@ -106,6 +110,5 @@ declare class Viewport {
      * @param {MouseEvent | TouchEvent} event     鼠标事件对象 或 触摸事件对象
      */
     _triggerSceneEventInAllObject(eventType: SceneEventType, event: MouseEvent | TouchEvent): void;
-    _getManagerScene(type: string): Object3D | undefined;
 }
 export default Viewport;