soonspacejs 2.3.20 → 2.4.2

package/types/Loader/DatLoader/parse-chunk/index.d.ts

@@ -0,0 +1,11 @@
+import { noCompressWorker } from './noCompress';
+import { gzipCompressWorker } from './gzipCompress';
+export { noCompressWorker, gzipCompressWorker, };
+declare global {
+    interface Window {
+        parseChunkWorker: any;
+        noCompressWorker: any;
+        gzipCompressWorker: any;
+    }
+}
+export declare const parseChunkWorker: () => void;

package/types/Loader/DatLoader/parse-chunk/noCompress.d.ts

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

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,42 @@
+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;
+    /**
+     * 设置 draco path
+     * @param path
+     */
     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 +45,12 @@ declare class ModelManage extends DefaultManage {
      * 清空本地模型缓存数据
      */
     clearIdb(): Promise<void>;
-    _loadItem(modelInfo: ModelInfo, parent?: BaseObject3D | null): Promise<Model>;
+    dispose(): void;
     /**
      * 远程请求 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,17 +21,17 @@ 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;
+    dispose(): void;
 }
 export { ManagerStore, };
 export default Manager;

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,18 @@ 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 * from './network';
 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/network.d.ts

@@ -0,0 +1 @@
+export declare const fetchFile: (url: string) => Promise<Response>;

package/types/Shared/path.d.ts

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

package/types/Viewport/EffectManager.d.ts

@@ -0,0 +1,44 @@
+import { Camera, Scene, WebGLRenderer } from 'three';
+import { EffectComposer, Pass, Effect } from 'postprocessing';
+export interface EffectState<T = Effect> {
+    enabled: boolean;
+    effect: T;
+}
+declare class EffectManager {
+    readonly renderer: WebGLRenderer;
+    readonly scene: Scene;
+    readonly camera: Camera;
+    static CONSTANTS: {
+        renderPass: string;
+        normalPass: string;
+        depthDownsamplingPass: string;
+        effectPass: string;
+        smaaEffect: string;
+        ssaoEffect: string;
+        outlineEffect: string;
+    };
+    effectComposer: EffectComposer;
+    passesMap: Map<string, Pass>;
+    effectsMap: Map<string, EffectState>;
+    constructor(renderer: WebGLRenderer, scene: Scene, camera: Camera);
+    /**
+     * 更新 Effect pass
+     */
+    updateEffectPass(): void;
+    /**
+     * 更新 camera
+     * @param camera
+     */
+    updateCamera(camera: Camera): void;
+    private _initEffectComposer;
+    private _initPasses;
+    private _initRenderPass;
+    private _initNormalPass;
+    private _initDownSamplingPass;
+    private _initEffectPass;
+    private _initEffects;
+    private _initSMAAEffect;
+    private _initSSAOEffect;
+    private _initOutlineEffect;
+}
+export default EffectManager;

package/types/Viewport/RendererManager.d.ts

@@ -1,35 +1,16 @@
-import { Scene, WebGLRenderer, Camera, Vector2 } from 'three';
-import { EffectComposer } from 'three/examples/jsm/postprocessing/EffectComposer.js';
-import { Pass } from 'three/examples/jsm/postprocessing/Pass.js';
-import { RenderPass } from 'three/examples/jsm/postprocessing/RenderPass.js';
-import { OutlinePass } from 'three/examples/jsm/postprocessing/OutlinePass.js';
-import { UnrealBloomPass } from 'three/examples/jsm/postprocessing/UnrealBloomPass.js';
-import { ShaderPass } from 'three/examples/jsm/postprocessing/ShaderPass.js';
+import { WebGLRenderer, Vector2 } from 'three';
 import { CSS2DRenderer, CSS2DHalfRenderer, CSS3DRenderer } from '../Renderer';
 import { InternalOptions, ViewportOptions } from '../Interface';
-export interface PassObj {
-    renderPass: RenderPass;
-    outlinePass: OutlinePass;
-    unrealBloomPass: UnrealBloomPass;
-    sobelPass: ShaderPass;
-    gammaCorrectionPass: ShaderPass;
-}
 declare class RendererManager {
-    scene: Scene;
     options: ViewportOptions;
     internalOptions: InternalOptions;
-    effectComposer: EffectComposer | null;
     renderer: WebGLRenderer;
     container: HTMLElement;
     interactiveContainer: HTMLElement;
     rendererCSS2D: CSS2DRenderer;
     rendererCSS3D: CSS3DRenderer;
     rendererCSS2DHalf: CSS2DHalfRenderer;
-    constructor(scene: Scene, options: ViewportOptions);
-    initEffectComposer(): EffectComposer;
-    initAllPass(camera: Camera): PassObj;
-    addPass(effectPass: Pass): void;
-    isIncludesPass(effectPass: Pass): boolean;
+    constructor(options: ViewportOptions);
     setInternalState(name: keyof InternalOptions, state: boolean): void;
     getWidth(): number;
     getHeight(): number;
@@ -41,10 +22,5 @@ declare class RendererManager {
     _initRenderCSS3D(): CSS3DRenderer;
     _initRenderCSS2DHalf(): CSS2DHalfRenderer;
     _initInteractiveContainer(): HTMLElement;
-    _initRenderPass(camera: Camera): RenderPass;
-    _initOutlinePass(camera: Camera): OutlinePass;
-    _initUnrealBloomPass(): UnrealBloomPass;
-    _initSobelPass(): ShaderPass;
-    _initGammaCorrectionPass(): ShaderPass;
 }
 export default RendererManager;

package/types/Viewport/index.d.ts

@@ -1,18 +1,22 @@
-import { Scene, PerspectiveCamera, WebGLRenderer, PMREMGenerator, Vector3, AnimationMixer, Intersection, Object3D, AnimationAction, AnimationClip } from 'three';
-import { EffectComposer } from 'three/examples/jsm/postprocessing/EffectComposer.js';
+import { Clock, Scene, PerspectiveCamera, WebGLRenderer, PMREMGenerator, Vector3, AnimationMixer, Intersection, Object3D, AnimationAction, AnimationClip } from 'three';
+import { EffectComposer } from 'postprocessing';
 import Stats from 'three/examples/jsm/libs/stats.module.js';
 import { Sky } from 'three/examples/jsm/objects/Sky.js';
 import Scener from './Scener';
 import { CSS2DRenderer, CSS2DHalfRenderer, CSS3DRenderer } from '../Renderer';
-import RendererManager, { PassObj } from './RendererManager';
+import RendererManager from './RendererManager';
 import CameraManager from './CameraManager';
+import EffectManager from './EffectManager';
 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, ToneMappingOptions, SSAOOptions } 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;
@@ -32,8 +36,8 @@ declare class Viewport {
     cameraManager: CameraManager;
     camera: PerspectiveCamera;
     controls: FullFreeControls;
+    effectManager: EffectManager;
     effectComposer: EffectComposer;
-    passObj: PassObj;
     mixer: AnimationMixer;
     /**
      * render 前回调
@@ -51,12 +55,17 @@ declare class Viewport {
     _initInfo(): void;
     _initStats(): void;
     _initViewHelper(): void;
-    setSobel(options?: SobelOptions): void;
+    /**
+     ***************************** post-processing ***************************
+     */
+    setSobel(): void;
+    setBloom(): void;
+    setSSAO(options: SSAOOptions): void;
     /**
      ***************************** renderer ***************************
      */
-    setBloom(options?: BloomOptions): void;
     setColorSpace(colorSpace: ColorSpace): void;
+    setToneMapping(options?: ToneMappingOptions): void;
     /**
      ***************************** background ***************************
      */
@@ -80,6 +89,9 @@ declare class Viewport {
      */
     render(fn?: () => void): Promise<void>;
     trigerRender(count?: number): void;
+    /**
+     * effect passes
+     */
     _passesObserver(): void;
     /**
      * 每帧都会被执行
@@ -106,6 +118,5 @@ declare class Viewport {
      * @param {MouseEvent | TouchEvent} event     鼠标事件对象 或 触摸事件对象
      */
     _triggerSceneEventInAllObject(eventType: SceneEventType, event: MouseEvent | TouchEvent): void;
-    _getManagerScene(type: string): Object3D | undefined;
 }
 export default Viewport;