@realsee/five 6.4.2 → 6.5.0-alpha.0

package/five/index.d.ts

@@ -1,3 +1,4 @@
+import { IUniform as IUniform_2 } from 'three';
 import * as THREE_2 from 'three';
 
 export declare interface AddableObject extends THREE_2.Object3D {
@@ -73,6 +74,24 @@ export declare interface BaseEvent {
     defaultPrevented: boolean;
 }
 
+declare class BaseRenderer {
+    screenBuffers: (THREE_2.WebGLRenderTarget | null)[];
+    enableLayeringRendering: boolean;
+    enableFragDepth: boolean;
+    renderer: THREE_2.WebGLRenderer;
+    camera: Camera;
+    scene: THREE_2.Scene;
+    modelScene: ModelScene;
+    type: 'default' | 'edl' | 'hq';
+    protected modelRenderTarget: THREE_2.WebGLRenderTarget;
+    protected copyPass: CopyPass;
+    protected depthCopyPass: DepthCopyPass;
+    constructor(args: RendererInitArgs);
+    render(modelSceneNeedsRender: boolean): void;
+    setSize(width: number, height: number): void;
+    dispose(): void;
+}
+
 export declare interface BoundingVolume {
     type: 'box' | 'sphere' | 'regin';
     applyMatrix4(matrix: THREE_2.Matrix4): this;
@@ -130,11 +149,11 @@ export declare class Camera extends THREE_2.Camera {
     pose: CameraPose;
     private perspectiveCamera;
     private orthographicCamera;
-    time: number;
     autoNearFar: boolean;
     needsRender: boolean;
     refineModel: boolean;
-    environment: THREE_2.Texture | null;
+    time: number;
+    controllerMode: Mode | null;
     private lastValues;
     constructor(fov: number, aspect?: number, near?: number, far?: number, perspToOrtho?: THREE_2.Vector2, resolution?: THREE_2.Vector2, pixelRatio?: number);
     get orthoDistance(): number;
@@ -172,11 +191,6 @@ export declare interface CameraPose {
     offset: THREE_2.Vector3;
 }
 
-export declare interface ClipperParameter {
-    clippingBoxMatrix: THREE_2.Matrix4;
-    floorIndex?: number;
-}
-
 export declare type ControllerCustomInitTypes = {
     Floorplan: FloorplanControllerCustomInitArgs;
     Topview: TopviewControllerCustomInitArgs;
@@ -265,6 +279,10 @@ export declare const controllersDefaultInitArgs: {
     XRPanorama: Required<XRPanoramaControllerCustomInitArgs>;
 };
 
+declare class CopyPass extends Pass {
+    constructor(renderer: THREE_2.WebGLRenderer);
+}
+
 export declare class CullingVolume {
     static get MASK_OUTSIDE(): number;
     static get MASK_INSIDE(): number;
@@ -280,33 +298,6 @@ export declare class CullingVolume {
     computeVisibilityWithPlaneMask(boundingVolume: BoundingVolume, parentPlaneMask: number): number;
 }
 
-export declare class CustomShader {
-    uniforms: {
-        [key: string]: THREE_2.Uniform;
-    };
-    defines: {
-        [key: string]: any;
-    };
-    type: CustomShaderInitArgs['type'];
-    vertex: VertexShaderChunks;
-    fragment: FragmentShaderChunks;
-    constructor(initArgs: CustomShaderInitArgs);
-    getHash(): string;
-    onBeforeCompile(shader: THREE_2.Shader, renderer: THREE_2.WebGLRenderer): void;
-}
-
-export declare interface CustomShaderInitArgs {
-    type: Array<'none' | 'basic' | 'phong' | 'standard' | 'pointcloud'>;
-    vertex?: Partial<VertexShaderChunks>;
-    fragment?: Partial<FragmentShaderChunks>;
-    uniforms?: {
-        [key: string]: any;
-    };
-    defines?: {
-        [key: string]: any;
-    };
-}
-
 /**
  * URL 地址的转换
  * @param source - url 原地址
@@ -315,7 +306,19 @@ export declare interface CustomShaderInitArgs {
  */
 export declare function defaultImageURLTransform(source: string, options: ImageURLOptions): string;
 
-export declare const defaultPbmParameters: PBMParameters;
+declare class DefaultRenderer extends BaseRenderer {
+    constructor(args: RendererInitArgs);
+    render(modelSceneNeedsRender: boolean): void;
+    setSize(width: number, height: number): void;
+}
+
+declare class DepthCopyPass {
+    renderer: THREE_2.WebGLRenderer;
+    material: THREE_2.ShaderMaterial;
+    constructor(renderer: THREE_2.WebGLRenderer);
+    render(depthTexture: THREE_2.DepthTexture, outputBuffer?: THREE_2.WebGLRenderTarget): void;
+    dispose(): void;
+}
 
 export declare class Draco {
     decoderPath: string;
@@ -344,6 +347,70 @@ export declare class Draco {
 
 export declare const draco: Draco;
 
+declare class EDLEffect extends Effect {
+    sharedV2: THREE_2.Vector2;
+    material: EDLMaterial;
+    constructor(renderer: THREE_2.WebGLRenderer, scene: THREE_2.Scene, camera: Camera, modelScene: ModelScene);
+    render(screenBuffers: (THREE_2.WebGLRenderTarget | null)[]): void;
+    dispose(): void;
+}
+
+declare class EDLMaterial extends THREE_2.RawShaderMaterial {
+    uniforms: EDLUniforms & Record<string, IUniform<any>>;
+    screenWidth: number;
+    screenHeight: number;
+    edlStrength: number;
+    uNear: number;
+    uFar: number;
+    radius: number;
+    neighbours: Float32Array;
+    depthMap: THREE_2.Texture;
+    uEDLColor: THREE_2.Texture;
+    uEDLDepth: THREE_2.Texture;
+    uProj: Array<number>;
+    neighbourCount: number;
+    constructor();
+    getUniform<K extends keyof EDLUniforms>(name: K): EDLUniforms[K]["value"];
+    setUniform<K extends keyof EDLUniforms>(name: K, value: EDLUniforms[K]["value"]): void;
+    getDefines(): string;
+    updateShaderSource(): void;
+}
+
+declare class EDLRenderer extends BaseRenderer {
+    edlEffect: EDLEffect;
+    constructor(args: RendererInitArgs);
+    render(modelSceneNeedsRender: boolean): void;
+    setSize(width: number, height: number): void;
+    dispose(): void;
+}
+
+declare interface EDLUniforms {
+    screenWidth: IUniform<number>;
+    screenHeight: IUniform<number>;
+    edlStrength: IUniform<number>;
+    uNear: IUniform<number>;
+    uFar: IUniform<number>;
+    radius: IUniform<number>;
+    neighbours: IUniform<Float32Array>;
+    depthMap: IUniform<THREE_2.Texture>;
+    uEDLColor: IUniform<THREE_2.Texture>;
+    uEDLDepth: IUniform<THREE_2.Texture>;
+    opacity: IUniform<number>;
+    uProj: IUniform<Float32Array>;
+}
+
+declare class Effect {
+    enable: boolean;
+    protected renderer: THREE_2.WebGLRenderer;
+    protected copyPass: CopyPass;
+    protected camera: Camera;
+    protected modelScene: ModelScene;
+    protected scene: THREE_2.Scene;
+    constructor(renderer: THREE_2.WebGLRenderer, scene: THREE_2.Scene, camera: Camera, modelScene: ModelScene);
+    render(buffers: (THREE_2.WebGLRenderTarget | null)[], payload?: any): void;
+    dispose(): void;
+}
+
 /**
  * Five 事件列表
  * @description
@@ -385,9 +452,9 @@ export declare type EventTypes = Pick<ControllerEventTypes, typeof PROXY_CONTROL
     /** 当模型修改楼层 */
     "model.changeShownFloor"(event: ModelEvent): void;
     /** 模型加载完成 */
-    "models.load"(event: ModelsEvent): void;
+    "models.load"(event: ModelSceneEvent): void;
     /** 模型细化完成 */
-    "models.refined"(event: ModelsEvent): void;
+    "models.refined"(event: ModelSceneEvent): void;
     /** 渲染前 */
     "render.prepare"(event: RenderEvent): void;
     /** 渲染后 */
@@ -445,7 +512,15 @@ export declare class Five extends Subscribe<EventTypes> {
      * XRPanorama VR硬件模式
      * ```
      */
-    static Mode: Mirror<Mode>;
+    static Mode: {
+        readonly Panorama: "Panorama";
+        readonly Model: "Model";
+        readonly Floorplan: "Floorplan";
+        readonly Topview: "Topview";
+        readonly Mapview: "Mapview";
+        readonly VRPanorama: "VRPanorama";
+        readonly XRPanorama: "XRPanorama";
+    };
     /**
      * @deprecated
      * 请使用 `import { Line } from "@realsee/five/line"` 代替;
@@ -464,7 +539,7 @@ export declare class Five extends Subscribe<EventTypes> {
     /** 非模型部分使用的 `THREE.Scene` */
     scene: Scene;
     /** 内部模型部分使用的 `THREE.Scene` */
-    modelScene: Scene;
+    modelScene: ModelScene;
     /** 供外部放置需要在xr场景下产生遮挡的物体们*/
     xrCustomObjectsScene: THREE_2.Scene;
     /** 内部使用的 `Camera` */
@@ -488,10 +563,6 @@ export declare class Five extends Subscribe<EventTypes> {
      * 否则会通过 `preserveDrawingBuffer` `backgroundColor` `backgroundAlpha` `antialias` 创建一个 `THREE.WebGLRenderer`
      */
     renderer?: THREE_2.WebGLRenderer;
-    /** 当前加载的模型 */
-    models: Models;
-    private lastModels;
-    private lastWorks?;
     /**
      * 是否需要渲染
      * @description
@@ -563,13 +634,10 @@ export declare class Five extends Subscribe<EventTypes> {
         [key: string]: FivePluginInstance<any>;
     };
     ident: string;
-    /** 模型渲染缓冲*/
-    modelRenderTarget: THREE_2.WebGLRenderTarget;
     /** 包围盒子 */
     private boundingMesh;
     private stopAnimationLoop?;
     private fps;
-    private modelGroup;
     private helperGroup;
     private modeChangeDuration;
     private enableWheel;
@@ -583,15 +651,11 @@ export declare class Five extends Subscribe<EventTypes> {
     private getPixelsRenderTarget;
     private readyCallbacks;
     private syncingState;
-    private lastLoadWorkTask;
+    private loadWorkTask;
     private requestProxy;
     private networkSubscribe;
     private analysis?;
     private renderSwitch01;
-    /**
-     * gpu_picking
-     */
-    private gpuPickingRenderTarget;
     private meshReplaceMaterialMap;
     private meshOriginMaterialMap;
     /**
@@ -604,19 +668,10 @@ export declare class Five extends Subscribe<EventTypes> {
     private _enableEDL;
     private _enableHQ;
     enableLayeringRendering: boolean;
+    private _buildInRenderer;
+    buildInRendererType: 'default' | 'edl' | 'hq' | 'luminance';
     constructor(initArgs?: FiveInitArgs);
     get panoIndex(): number;
-    /**
-     * GPU Picking 获取选中的 mesh
-     * @param x - 屏幕坐标 x
-     * @param y - 屏幕坐标 y
-     * @param colorMap - 需要选取的 mesh 的颜色与 uuid 的映射
-     * @param color - 指定的模型颜色
-     * @returns 选中 mesh 的 uuid
-     */
-    getGPUPicking(x: number, y: number, colorMap: {
-        [key: string]: THREE_2.Color;
-    }, pixelRatio?: number, color?: THREE_2.Vector3): string | false;
     /**
      * 析构 five 对象。
      * @description
@@ -648,10 +703,6 @@ export declare class Five extends Subscribe<EventTypes> {
      */
     get enableIOSEDR(): boolean;
     set enableIOSEDR(enable: boolean);
-    /**
-     * 后处理类型
-     */
-    get postProcessingType(): PostProcessingType;
     /**
      * 是否开启EDL模式
      */
@@ -664,6 +715,7 @@ export declare class Five extends Subscribe<EventTypes> {
      */
     get enablePostProcessing(): boolean;
     set enablePostProcessing(enable: boolean);
+    get buildInRenderer(): FiveBuildInRenderer;
     updateConfiguration(args: Pick<FiveInitArgs, "panorama" | "model" | "floorplan" | "topview" | "mapview" | "vrPanorama" | "imageOptions" | "textureOptions">, refresh?: boolean): void;
     /**
      * 将显示区域加载到页面 DOM 中
@@ -699,6 +751,7 @@ export declare class Five extends Subscribe<EventTypes> {
      */
     removeExtraElement(element: HTMLElement): void;
     /**
+     * @deprecated
      * 获取当前相机姿态, 可以使用 getCurrentState 代替
      */
     getPose(): Pose;
@@ -752,6 +805,7 @@ export declare class Five extends Subscribe<EventTypes> {
     /** 当前加载的 work 数据 */
     get works(): Works;
     get work(): Work | undefined;
+    get models(): Models;
     get model(): Model;
     /**
      * 加载 Work 数据
@@ -907,20 +961,17 @@ export declare class Five extends Subscribe<EventTypes> {
      */
     exitFullscreen(): void;
     private throwError;
-    private loadModel;
+    private loadModels;
     private commonParams;
     private applyController;
     /** 移除事件绑定 */
     private removeEventListeners;
-    /** 暂时通过这个函数获取所有 work 中的数据 */
-    getWorkResources(work: Work): Promise<{
-        url: string;
-        type: string;
-    }[]>;
     get internalLightsEnabled(): boolean;
     set internalLightsEnabled(value: boolean);
 }
 
+declare type FiveBuildInRenderer = DefaultRenderer | EDLRenderer | HQRenderer | LuminanceRenderer;
+
 /** Five 初始化参数 */
 export declare interface FiveInitArgs {
     /**
@@ -1166,13 +1217,6 @@ export declare interface FloorplanControllerCustomInitArgs {
     intersectMeshCreator?: () => IntersectMeshInterface;
 }
 
-export declare interface FragmentShaderChunks {
-    mainBefore: string;
-    mainStart: string;
-    mainModelColor: string;
-    mainEnd: string;
-}
-
 export declare interface GestureEvent extends StateEvent {
     target: EventTarget | null;
     pointerType: 'touch' | 'pen' | 'mouse' | 'kinect';
@@ -1206,6 +1250,36 @@ export declare type GestureTypes = "pan" | "tap" | "dbltap" | "pinch" | "press"
 
 export declare function getViewportScale(): number;
 
+declare class HQEffect extends Effect {
+    sharedV2: THREE_2.Vector2;
+    material: HQMaterial;
+    constructor(renderer: THREE_2.WebGLRenderer, scene: THREE_2.Scene, camera: Camera, modelScene: ModelScene);
+    render(screenBuffers: (THREE_2.WebGLRenderTarget | null)[]): void;
+    dispose(): void;
+}
+
+declare class HQMaterial extends THREE_2.RawShaderMaterial {
+    uniforms: HQUniform & Record<string, IUniform<any>>;
+    uDepthMap: number;
+    uWeightMap: number;
+    constructor();
+    getUniform<K extends keyof HQUniform>(name: K): HQUniform[K]["value"];
+    setUniform<K extends keyof HQUniform>(name: K, value: HQUniform[K]["value"]): void;
+}
+
+declare class HQRenderer extends BaseRenderer {
+    hqEffect: HQEffect;
+    constructor(args: RendererInitArgs);
+    render(modelSceneNeedsRender: boolean): void;
+    setSize(width: number, height: number): void;
+    dispose(): void;
+}
+
+declare interface HQUniform {
+    uDepthMap: IUniform<THREE_2.Texture | null>;
+    uWeightMap: IUniform<THREE_2.Texture | null>;
+}
+
 /**
  * 图片参数
  */
@@ -1288,7 +1362,7 @@ export declare interface Intersection extends THREE_2.Intersection {
     /** 楼层 */
     floor: number;
     model?: Model;
-    viewLayer?: ModelViewLayer;
+    viewLayer?: Tile3DModel;
 }
 
 export declare class IntersectMesh extends THREE_2.Object3D implements IntersectMeshInterface {
@@ -1306,6 +1380,11 @@ export declare interface IntersectMeshInterface extends THREE_2.Object3D {
 
 export declare function isPanoId(id: any): id is PanoId;
 
+declare interface IUniform<T> extends IUniform_2 {
+    type: string;
+    value: T;
+}
+
 export declare class KTX2 {
     transcoderPath: string;
     private workerPool;
@@ -1746,51 +1825,58 @@ export declare type LegacyEventType = {
 };
 
 export declare function loadAt3d(url: string, options?: {
+    upAxis?: 'Y' | 'Z';
     light?: boolean;
     textureOptions?: TextureOptions;
     textureBaseUri?: string;
     textureArray?: string[];
     fetcher?: Fetcher;
-}): Promise<ParsedResultType>;
+}): Promise<LoadResultType>;
 
 export declare function loadB3dm(url: string, options?: {
+    modelUpAxis?: 'Y' | 'Z';
     upAxis?: 'Y' | 'Z';
     light?: boolean;
     fetcher?: Fetcher;
-}): Promise<ParsedResultType>;
+}): Promise<LoadResultType>;
 
 export declare function loadDome(url: string, options?: {
+    upAxis?: 'Y' | 'Z';
     light?: boolean;
     textureOptions?: TextureOptions;
     textureBaseUri?: string;
     fetcher?: Fetcher;
-}): Promise<ParsedResultType>;
+}): Promise<LoadResultType>;
 
 export declare function loadDomez(url: string, options?: {
+    upAxis?: 'Y' | 'Z';
     light?: boolean;
     textureOptions?: TextureOptions;
     textureBaseUri?: string;
     fetcher?: Fetcher;
-}): Promise<ParsedResultType>;
+}): Promise<LoadResultType>;
 
 export declare function loadFbx(url: string, options?: {
+    upAxis?: 'Y' | 'Z';
     light?: boolean;
     fetcher?: Fetcher;
-}): Promise<ParsedResultType>;
+}): Promise<LoadResultType>;
 
 export declare function loadGltf(url: string, options?: {
+    modelUpAxis?: 'Y' | 'Z';
     upAxis?: 'Y' | 'Z';
     light?: boolean;
     fetcher?: Fetcher;
-}): Promise<ParsedResultType>;
+}): Promise<LoadResultType>;
 
 export declare function loadPbm(url: string, options?: {
+    upAxis?: 'Y' | 'Z';
     light?: boolean;
     textureOptions?: TextureOptions;
     textureBaseUri?: string;
     textureArray?: string[];
     fetcher?: Fetcher;
-}): Promise<ParsedResultType>;
+}): Promise<LoadResultType>;
 
 export declare function loadPly<Type extends 'geometry' | 'line' | 'pbmMesh' | 'pbmPointCloud', ResultType = {
     'geometry': THREE_2.BufferGeometry;
@@ -1798,6 +1884,7 @@ export declare function loadPly<Type extends 'geometry' | 'line' | 'pbmMesh' | '
     'pbmMesh': PBMMesh;
     'pbmPointCloud': PBMPointCloud;
 }[Type]>(url: string, options?: {
+    modelUpAxis?: 'Y' | 'Z';
     upAxis?: 'Y' | 'Z';
     light?: boolean;
     propertyNameMapping?: Record<string, string>;
@@ -1808,18 +1895,34 @@ export declare function loadPly<Type extends 'geometry' | 'line' | 'pbmMesh' | '
     }>;
     type?: Type;
     fetcher?: Fetcher;
-}): Promise<ParsedResultType<ResultType>>;
+}): Promise<LoadResultType<ResultType>>;
 
 export declare function loadPnts(url: string, options?: {
+    upAxis?: 'Y' | 'Z';
     fetcher?: Fetcher;
     computeBoundingBox?: boolean;
-}): Promise<ParsedResultType>;
+}): Promise<LoadResultType>;
+
+export declare type LoadResultType<Scene = THREE_2.Object3D> = {
+    type: 'unknown' | 'b3dm' | 'pnts' | 'at3d' | 'pbm' | 'dome' | 'domez' | 'gltf' | 'ply' | 'obj' | 'fbx' | 'x3p';
+    modelUpAxis: 'Y' | 'Z';
+    upAxis: 'Y' | 'Z';
+    byteLength: number;
+    memoryUsage: number;
+    uri: string;
+    scene: Scene;
+    textures: THREE_2.Texture[];
+    animations: THREE_2.AnimationClip[];
+    rtcCenter?: THREE_2.Vector3;
+    dispose: () => void;
+};
 
 export declare function loadX3p(url: string, options?: {
+    upAxis?: 'Y' | 'Z';
     color?: THREE_2.Color;
     light?: boolean;
     fetcher?: Fetcher;
-}): Promise<ParsedResultType>;
+}): Promise<LoadResultType>;
 
 export declare interface LoosePanoWork {
     code?: string;
@@ -1905,14 +2008,6 @@ export declare type LooseWorkPanorama = {
     front: string;
     back: string;
     video?: LooseWorkVideo;
-    luminance?: {
-        up: string;
-        down: string;
-        right: string;
-        left: string;
-        front: string;
-        back: string;
-    };
     tiles?: number[];
     size_list?: number[];
 };
@@ -1928,6 +2023,27 @@ export declare type LooseWorkWithExtrinsics = ParseWorkOptions & {
     work: LooseWork;
 };
 
+declare class LuminanceAdaptiveEffect extends Effect {
+    private luminanceTargetBuffer?;
+    private luminancePrevBuffer?;
+    private luminanceNextBuffer?;
+    private valuePass;
+    private luminancePass;
+    private nextStepPass;
+    private luminanceAdaptivePass;
+    private enableTime;
+    constructor(renderer: THREE_2.WebGLRenderer, scene: THREE_2.Scene, camera: Camera, modelScene: ModelScene);
+    render(screenBuffers: (THREE_2.WebGLRenderTarget | null)[]): void;
+    dispose(): void;
+}
+
+declare class LuminanceRenderer extends BaseRenderer {
+    luminanceAdaptiveEffect: LuminanceAdaptiveEffect;
+    constructor(args: RendererInitArgs);
+    render(modelSceneNeedsRender: boolean): void;
+    setSize(width: number, height: number): void;
+}
+
 export declare interface MapviewControllerCustomInitArgs {
     /** 默认水平角 */
     defaultLongitude?: number;
@@ -1954,8 +2070,6 @@ export declare interface MapviewControllerCustomInitArgs {
     intersectMeshCreator?: () => IntersectMeshInterface;
 }
 
-export declare type Mirror<T extends string> = Record<T, T>;
-
 /**
  * Five 的显示模式，可以通过 `five.changeMode` `five.setState` 来切换
  * - **Panorama**: 全景图游走模式
@@ -1986,6 +2100,36 @@ export declare interface ModeChangeEvent extends StateEvent {
     mode: Mode;
 }
 
+export declare interface Model {
+    dispatchEvent(event: {
+        type: 'error';
+        error: Error;
+    }): void;
+    dispatchEvent(event: {
+        type: 'load';
+    }): void;
+    dispatchEvent(event: {
+        type: 'shownFloorChange';
+        floorIndex: number | null;
+    }): void;
+    dispatchEvent(event: {
+        type: string;
+        [attachment: string]: any;
+    }): void;
+    addEventListener(type: 'error', listener: (event: THREE_2.Event & {
+        type: 'error';
+        error: Error;
+    }) => void): void;
+    addEventListener(type: 'load', listener: (event: THREE_2.Event & {
+        type: 'load';
+    }) => void): void;
+    addEventListener(type: 'changeShownFloor', listener: (event: THREE_2.Event & {
+        type: 'changeShownFloor';
+        floorIndex: number | null;
+    }) => void): void;
+    addEventListener(type: string, listener: (event: THREE_2.Event) => void): void;
+}
+
 /**
  * Five 模型
  * @description
@@ -1995,51 +2139,62 @@ export declare interface ModeChangeEvent extends StateEvent {
  * 通过 json_xxxxxx(<dataURL>) 方式返回。
  */
 export declare class Model extends THREE_2.Object3D {
+    children: Tile3DModel[];
+    add: (...object: Tile3DModel[]) => this;
+    private disposed;
+    parameter: Parameter;
     /** work */
-    work: Work | null;
-    /** 模型的不同图层 */
-    viewLayers: ModelViewLayer[];
-    onError: (error: Error) => void;
-    onShownFloorChange: (floorIndex: number | null) => void;
-    onLoad: () => void;
-    /** 外接盒子的大小 */
-    bounding: THREE_2.Box3;
-    /** 所有楼层 */
-    floorLength: number;
-    /** 材质贴图参数 */
-    textureOptions: TextureOptions;
+    work: Work;
+    /** 是否过期 */
+    outdated: boolean;
+    /** 是否自动细化 */
     autoRefine: boolean;
+    /** 是否在加载元信息 */
+    metaPending: boolean;
+    /** 模型已经加载 */
+    loaded: boolean;
     /** 模型是否已经细化 */
     refined: boolean;
     /** 模型细化进度 */
     refineProgress: [number, number];
-    /** 模型已经加载 */
-    loaded: boolean;
-    /** 是否更新 */
-    needsRender: boolean;
-    /** 缓存相机 */
-    cacheCameras: (THREE_2.PerspectiveCamera | Camera)[];
-    /** 当前样式参数 */
-    materialVersion: number;
-    private materialParameters;
-    private disposed;
-    constructor(options?: {
-        onError?: (error: Error) => void;
-        onShownFloorChange?: (floorIndex: number | null) => void;
-        onLoad?: () => void;
+    /** 初始化完成 */
+    initReady: Promise<void>;
+    /** 初次加载完成 */
+    loadedReady: Promise<void>;
+    /** 外接盒子的大小 */
+    boundingBox: THREE_2.Box3;
+    /** 所有楼层 */
+    floorLength: number;
+    constructor(work: Work, options?: {
+        light?: boolean;
+        textureOptions?: TextureOptions;
     });
+    /** 析构函数 一旦析构，则不能使用 */
+    dispose(): void;
+    /** 模型内容是否为空 */
     get empty(): boolean;
-    /** 获取材质参数 */
-    getMaterial(): PBMParameters;
-    /** 设置材质参数 */
-    setMaterial(values: Partial<PBMParameters>): void;
-    get brightness(): PBMParameters['brightness'];
-    set brightness(brightness: PBMParameters['brightness']);
+    /** 模型的不同图层 */
+    get viewLayers(): Tile3DModel[];
     /**
-     * 当前显示的楼层
+     * 获取模型边界线
+     * @param sphere - 获取区域
+     * @param threshold - 面片间夹角阈值
+     * @returns 所有模型边界线
+     */
+    getEdgesBySphere(sphere: THREE_2.Sphere, threshold?: number): THREE_2.Line3[];
+    /**
+     * 计算模型射线碰撞检测
+     * @param raycaster - THREE 射线对象
+     * @param filterFloorIndex - 和某一楼层做碰撞检测， 不传为和所有楼层做碰撞检测
+     * @param sortByDistance - 是否对结果进行排序
+     * @returns 返回碰撞
      */
-    get shownFloorIndex(): PBMParameters['shownFloorIndex'];
-    set shownFloorIndex(floorIndex: PBMParameters['shownFloorIndex']);
+    intersectRaycaster(raycaster: THREE_2.Raycaster, filterFloorIndex?: undefined | null | number, sortByDistance?: boolean): Intersection[];
+    update(renderer: THREE_2.WebGLRenderer, camera: Camera, modelScene: ModelScene): boolean;
+    localToEnu(vector: THREE_2.Vector3): THREE_2.Vector3;
+    enuToLocal(vector: THREE_2.Vector3): THREE_2.Vector3;
+    worldToEnu(vector: THREE_2.Vector3): THREE_2.Vector3;
+    enuToWorld(vector: THREE_2.Vector3): THREE_2.Vector3;
     /**
      * 当前显示的楼层
      */
@@ -2055,43 +2210,49 @@ export declare class Model extends THREE_2.Object3D {
      */
     show(floor?: number | null): void;
     /**
-     * 裁切
+     * @deprecated
+     * Use `.boundingBox` instead
      */
-    get clippers(): PBMParameters['clippers'];
-    set clippers(clippers: PBMParameters['clippers']);
-    get customShaders(): PBMParameters['customShaders'];
-    set customShaders(customShaders: PBMParameters['customShaders']);
+    get bounding(): THREE_2.Box3;
     /**
-     * 获取模型边界线
-     * @param sphere - 获取区域
-     * @param threshold - 面片间夹角阈值
-     * @returns 所有模型边界线
+     * @deprecated
+     * Use `.parameter.set` instead
      */
-    getEdgesBySphere(sphere: THREE_2.Sphere, threshold?: number): THREE_2.Line3[];
+    setMaterial(parameter: Partial<ParameterValue>): void;
     /**
-     * 计算模型射线碰撞检测
-     * @param raycaster - THREE 射线对象
-     * @param floor - 和某一楼层做碰撞检测， 不传为和所有楼层做碰撞检测
-     * @returns 返回碰撞
+     * @deprecated
+     * Use `.parameter.get` instead
      */
-    intersectRaycaster(raycaster: THREE_2.Raycaster, floor?: undefined | null | number, sortByDistance?: boolean): Intersection[];
+    getMaterial(): Partial<ParameterValue>;
     /**
-     * 加载模型
-     * @param work - work 的
-     * @param options - 图片参数
+     * @deprecated
+     * Use `.parameter.shownFloorIndex` `.parameter.set('brightness', brightness)` instead
      */
-    load(work: Work, options?: {
-        light?: boolean;
-        textureOptions?: TextureOptions;
-        "3d-tiles"?: Tile3dOptions;
-    }): Promise<void>;
-    update(renderer: THREE_2.WebGLRenderer, camera: Camera, mode: Mode): void;
+    get shownFloorIndex(): ParameterValue['shownFloorIndex'];
+    set shownFloorIndex(floorIndex: ParameterValue['shownFloorIndex']);
     /**
-     * 析构函数
-     * @description
-     * 一旦析构，则不能使用
+     * @deprecated
+     * Use `.parameter.brightness` `.parameter.set('brightness', brightness)` instead
      */
-    dispose(): void;
+    get brightness(): ParameterValue['brightness'];
+    set brightness(brightness: ParameterValue['brightness']);
+    /**
+     * @deprecated
+     * Use `.parameter.clippers` `.parameter.set('clippers', clippers)` instead
+     */
+    get clippers(): ParameterValue['clippers'];
+    set clippers(clippers: ParameterValue['clippers']);
+    /**
+     * @deprecated
+     * Use `.parameter.customShaders` `.parameter.set('customShaders', customShaders)` instead
+     */
+    get customShaders(): ParameterValue['customShaders'];
+    set customShaders(customShaders: ParameterValue['customShaders']);
+    /**
+     * @deprecated
+     * Use `.parameter.reset('brightness')` instead
+     */
+    resetBrightness(): void;
 }
 
 export declare interface ModelControllerCustomInitArgs extends PanoramaLikeControllerCustomInitArgs {
@@ -2103,82 +2264,152 @@ export declare interface ModelEvent extends BaseEvent {
     error: Error | null;
 }
 
-export declare type ModelMaterialValues = Omit<PBMParameters, 'clippers' | 'shownFloorIndex' | 'brightness' | 'customShaders'>;
+export declare interface ModelLike extends THREE_2.Object3D {
+    update?(renderer: THREE_2.WebGLRenderer, camera: Camera, modelScene: ModelScene): boolean;
+    dispose?: () => void;
+}
 
 export declare type Models = Model[] & {
-    needsRender: boolean;
-    /** 包围盒 */
+    /**
+     * @deprecated
+     * use `modelScene.autoRefine` instead
+     */
+    autoUpdate: boolean;
+    /**
+     * @deprecated
+     * use `modelScene.boundingBox` instead
+     */
     bounding: THREE_2.Box3;
-    /** 是否家在完成 */
+    /**
+     * @deprecated
+     * use `modelScene.loaded` instead
+     */
     loaded: boolean;
-    /** 是否细化完成 */
+    /**
+     * @deprecated
+     * use `modelScene.refined` instead
+     */
     refined: boolean;
-    /** 细化成都 */
+    /**
+     * @deprecated
+     * use `modelScene.refineProgress` instead
+     */
     refineProgress: [number, number];
-    materialVersion: number;
-    /** 缓存相机 */
-    cacheCameras: (THREE_2.PerspectiveCamera | Camera)[];
-    /** 是否自动更新模型 */
-    autoUpdate: boolean;
     /**
-     * 计算模型射线碰撞检测
-     * @param raycaster - THREE 射线对象
-     * @returns 返回碰撞
+     * @deprecated
+     * use `modelScene.parameter.cacheCameras` `modelScene.parameter.set('cacheCameras', cacheCameras)` instead
+     */
+    cacheCameras: readonly (THREE_2.PerspectiveCamera | Camera)[];
+    /**
+     * @deprecated
+     * use `modelScene.intersectRaycaster` instead
      */
     intersectRaycaster(raycaster: THREE_2.Raycaster): Intersection[];
-    /** 设置材质参数 */
-    setMaterial(values: Partial<ModelMaterialValues>): void;
-    /** 获取材质参数 */
-    getMaterial(): ModelMaterialValues;
-    /** 突出模型 */
+    /**
+     * @deprecated
+     * Use `.parameter.set` instead
+     */
+    setMaterial(values: Partial<ParameterValue>): void;
+    /**
+     * @deprecated
+     * Use `.parameter.get` instead
+     */
+    getMaterial(): ParameterValue;
+    /**
+     * @deprecated
+     * Use `.parameter.reset('brightness')` instead
+     */
     resetBrightness(): void;
-    /** 更新模型 */
-    update(renderer: THREE_2.WebGLRenderer, camera: Camera, mode: Mode): void;
 };
 
-export declare interface ModelsEvent extends BaseEvent {
-    models: Models;
-}
-
-export declare class ModelViewLayer {
-    readonly scene: Tile3DModel;
-    readonly error: Error | null;
-    constructor(scene: Tile3DModel, error: Error | null);
-    get name(): string;
-    get type(): "point_cloud" | "mesh";
-    get upAxis(): string;
-    get groundHeight(): number;
-    get model(): Model;
+export declare class ModelScene extends THREE_2.Scene {
+    needsRender: boolean;
+    children: ModelLike[];
+    /** 自动细化 */
+    autoRefine: boolean;
+    /** 包围盒 */
+    boundingBox: THREE_2.Box3;
+    /** 加载完成 */
+    loaded: boolean;
+    /** 细化完成 */
+    refined: boolean;
+    /** 细化进度 */
+    refineProgress: [number, number];
+    /** 参数 */
+    parameter: Parameter;
+    /** 模型列表 */
+    readonly models: Models;
+    constructor();
+    add(...objects: ModelLike[]): this;
+    remove(...objects: ModelLike[]): this;
+    /**
+     * 计算模型射线碰撞检测
+     * @param raycaster - THREE 射线对象
+     * @param floor - 和某一楼层做碰撞检测， 不传为和所有楼层做碰撞检测
+     * @param sortByDistance - 根据距离排序
+     * @returns 返回碰撞点
+     */
+    intersectRaycaster(raycaster: THREE_2.Raycaster, floor?: number | null, sortByDistance?: boolean): Intersection[];
+    update(renderer: THREE_2.WebGLRenderer, camera: Camera): boolean;
     /**
      * @deprecated
-     * 使用 modelViewLayer.scene.localToLla(new THREE.Vector()) 替代
+     * Use `.boundingBox` instead
      */
-    get coordinates(): string;
+    get bounding(): THREE_2.Box3;
     /**
      * @deprecated
-     * 使用 modelViewLayer.scene.coordinateTransform 替代
+     * Use `.parameter.set` instead
      */
-    getTransformMatrix4(target?: THREE_2.Matrix4): THREE_2.Matrix4;
+    setMaterial(parameter: Partial<ParameterValue>): void;
     /**
      * @deprecated
-     * 使用 modelViewLayer.scene.llaToWorld 替代
+     * Use `.parameter.get` instead
      */
-    coordinatesToWorldPoint(coordinates: {
-        longitude: number;
-        latitude: number;
-        altitude: number;
-    }): THREE_2.Vector3;
+    getMaterial(): ParameterValue;
     /**
      * @deprecated
-     * 使用 modelViewLayer.scene.llaToWorld 替代
+     * Use `.parameter.reset('brightness')` instead
      */
-    worldPointToCoordinates(point: THREE_2.Vector3): {
-        longitude: number;
-        latitude: number;
-        altitude: number;
-    };
+    resetBrightness(): void;
 }
 
+export declare interface ModelSceneEvent extends BaseEvent {
+    modelScene: ModelScene;
+}
+
+export declare class Motion<K extends string> {
+    config: MotionConfig<K>;
+    value: MotionValue<K>;
+    progress: number;
+    ended: boolean;
+    startTime: number;
+    startVelocity: number;
+    duration: number;
+    keyframes: MotionKeyframe<K>[];
+    private callbacks?;
+    constructor(initalValue: MotionInitalValue<K>);
+    private getProgress;
+    private getValue;
+    getProgressVelocity(time: number): number;
+    update(time: number): boolean;
+    getKeyFrameSegment(time: number): [MotionKeyframe<K>, MotionKeyframe<K>];
+    getTargetKeyframe(): MotionKeyframe<K>;
+    set(value: Partial<MotionValue<K>>, duration: number, startProgressVelocity?: number, time?: number): Promise<void>;
+    setKeyframes(keyframes: MotionKeyframe<K>[], duration: number, startProgressVelocity?: number, time?: number): Promise<void>;
+    dispose(): void;
+}
+
+/** 是否是循环变化，比如 [0, 2 * Math.PI], 前闭后开 */
+export declare type MotionCircle = [number, number];
+
+export declare type MotionConfig<K extends string> = Record<K, {
+    circle: MotionCircle | false;
+}>;
+
+export declare type MotionInitalValue<K extends string> = Record<K, MotionValue<K>[K] | ({
+    value: MotionValue<K>[K];
+} & MotionConfig<K>[K])>;
+
 export declare interface MotionKeyframe<K extends string> {
     progress: number;
     value: MotionValue<K>;
@@ -2474,8 +2705,6 @@ export declare interface PanoramaControllerCustomInitArgs extends PanoramaLikeCo
     panoTapTriggerRadius?: number;
     /** 地面观察点标识自定义创建器 */
     panoCircleMeshCreator?: (pano: Pano) => PanoCircleMeshInterface;
-    /** TiledCubeTextureLevel */
-    tiledCubeTextureLevel?: number;
     /**
      * 全景瓦片登记
      * @param fov - 当前 fov
@@ -2489,6 +2718,8 @@ export declare interface PanoramaControllerCustomInitArgs extends PanoramaLikeCo
     tileMaxRequest?: number;
     /** 是否开启光照自适应效果 */
     luminanceAdaptiveEffectEnable?: boolean;
+    /** 是否使用深度信息干预全景图着色 */
+    flyEffectUseDepthBuffer?: boolean;
 }
 
 export declare interface PanoramaLikeControllerCustomInitArgs {
@@ -2523,16 +2754,134 @@ export declare interface PanoTextureEvent extends BaseEvent {
     error: Error | null;
 }
 
-export declare type ParsedResultType<Scene = THREE_2.Object3D> = {
-    type: 'unknown' | 'b3dm' | 'pnts' | 'at3d' | 'pbm' | 'dome' | 'domez' | 'gltf' | 'ply' | 'obj' | 'fbx' | 'x3p';
-    upAxis: 'Z';
-    byteLength: number;
-    memoryUsage: number;
-    uri: string;
-    scene: Scene;
-    textures: THREE_2.Texture[];
-    dispose: () => void;
-};
+export declare interface Parameter extends Readonly<Partial<ParameterValue>> {
+}
+
+export declare class Parameter {
+    static createDefault(): Required<ParameterValue>;
+    static resolveValue(...values: Partial<ParameterValue>[]): ResolvedParameterValue;
+    private value;
+    id: string;
+    versionNumber: number;
+    constructor(initialValue?: Partial<ParameterValue>);
+    get version(): string;
+    resolveValue(...baseValues: Partial<ParameterValue>[]): ResolvedParameterValue;
+    set<T extends keyof ParameterValue>(name: T, value: ParameterValue[T]): this;
+    set(values: Partial<ParameterValue>): this;
+    reset(...names: (keyof ParameterValue)[]): this;
+    resetAll(): this;
+    copy(value: Partial<ParameterValue>): this;
+}
+
+export declare interface ParameterMaterialValue {
+    /** 自定义材质*/
+    customShaders: readonly PBMCustomShader[];
+    /** 是否生效标注 */
+    vertexMarks: boolean;
+    /** 起始点 */
+    pano0: PBMPanoPicture | null;
+    /** 结束点 */
+    pano1: PBMPanoPicture | null;
+    /** 起始点深度 */
+    pano0Depth: PBMPanoDepth | null;
+    /** 结束点深度 */
+    pano1Depth: PBMPanoDepth | null;
+    /** 细化瓦片的屏幕渲染 */
+    refinedScreen: PBMRefinedScreen | null;
+    /** 模型贴图和全景图的混合程度 [0-1] */
+    modelAlpha: number;
+    /** 全景图混合程度 [0-1] */
+    progress: number;
+    /** 全景图过度混合 */
+    transition: PBMTransition;
+    /** 模型透明度 */
+    opacity: number;
+    /** 楼层样式 */
+    floorStyle: PBMFloorStyle;
+    /** 颜色样式 */
+    colorStyle: PBMColorStyle;
+    /** 模型颜色*/
+    constantColor: THREE_2.Vector3;
+    /** 楼层参数*/
+    shownFloorIndex: number;
+    /** 模型裁切参数（工程侧调用）*/
+    clippers: readonly PBMClipperParameter[];
+    /** 亮度 */
+    brightness: number;
+    /** 是否使用EDL*/
+    useEDL: boolean;
+    /** 是否使用HQ*/
+    useHQWeight: boolean;
+    /** 是否使用HQ_DEPTH_MASK*/
+    useHQDepth: boolean;
+    /** 点云形状*/
+    pointShape: PBMPointShape;
+    /** 点云大小绘制方式*/
+    pointSize: PBMPointSize;
+    /** 点云背面绘制方式*/
+    pointBack: PBMPointBack;
+    /** 点云基础大小*/
+    pointScale: number;
+    /** 点云最小尺寸*/
+    pointMinPixel: number;
+    /** 点云最大尺寸*/
+    pointMaxPixel: number;
+    /** 点云出现动画 */
+    pointAppearAnimation: boolean;
+    /** 饱和度调整值*/
+    colorSaturation: number;
+    /** 亮度调整值*/
+    colorBrightness: number;
+    /** outline增益*/
+    outlineGain: number;
+    /** distance增益*/
+    distanceGain: number;
+    /** 高程着色材质*/
+    gradientTexture: THREE_2.Texture | null;
+    /** 是否产生阴影 */
+    castShadow: boolean;
+    /** 是否接受阴影 */
+    receiveShadow: boolean;
+    /** 半透明叠加渲染*/
+    useAddBlend: boolean;
+}
+
+export declare interface ParameterTilesetValue {
+    tileDebug: TileDebug;
+    /** 模型显示最小细化层级 */
+    minLevelOfDetail: number;
+    /** 模型显示最大细化层级 */
+    maxLevelOfDetail: number;
+    /** 模型显示最小细化误差 */
+    minGeometricError: number;
+    /** 模型显示最大细化误差 */
+    maxGeometricError: number;
+    /** 全景态下模型显示最小细化误差 */
+    panoramaMinGeometricError: number;
+    /** 模型越层级加载 */
+    skipLevelOfDetail: boolean;
+    /** 模型是否最密 */
+    mostDetail: boolean;
+    /** 模型加载不在视野中的兄弟节点 */
+    loadSiblings: boolean;
+    /** 模型加载不在视野中的所有节点 */
+    loadAll: boolean;
+    /** 模型最大内存缓存 */
+    maxMemoryUsage: number;
+    /** 模型网络最大请求并发数 */
+    maxRequests: number;
+    /** 模型网络请求顺序 */
+    requestOrder: TileRequestOrder;
+    /** 模型屏幕空间误差计算最大值 */
+    maxScreenSpaceError: number;
+    memoryAdjustedOverflow: number;
+    memoryAdjustedScreenSpaceError: boolean;
+    /** 缓存相机 */
+    cacheCameras: readonly (Camera | THREE_2.PerspectiveCamera)[];
+}
+
+export declare interface ParameterValue extends ParameterMaterialValue, ParameterTilesetValue {
+}
 
 /**
  * 解析 Work 数据
@@ -2561,20 +2910,83 @@ export declare type ParseWorkOptions = {
     }) => void;
 };
 
-/** PBM 模型组 */
+declare class Pass {
+    renderer: THREE_2.WebGLRenderer;
+    material: THREE_2.ShaderMaterial;
+    constructor(renderer: THREE_2.WebGLRenderer, shader: Shader);
+    render(inputBuffer: THREE_2.WebGLRenderTarget, outputBuffer: THREE_2.WebGLRenderTarget | null): void;
+    dispose(): void;
+}
+
+export declare type PBMAlphaMode = 'OPAQUE' | 'MASK' | 'BLEND';
+
+export declare interface PBMClipperParameter {
+    clippingBoxMatrix: THREE_2.Matrix4;
+    floorIndex?: number;
+}
+
+export declare type PBMColorStyle = 'RGB' | 'ALTITUDE' | 'CONSTANT';
+
+/**
+ * PBM 模型组
+ * @deprecated 弃用, 直接使用 THREE.Group
+ */
 export declare class PBMContainer extends THREE_2.Group {
-    pbmMaterialParametersVersion: number;
-    /** 是否需要更新按需渲染 */
-    needsRender: boolean;
-    /** 当前样式参数 */
-    materialParameters: PBMParameters;
     constructor();
-    /** 获取材质参数 */
-    getMaterial(): PBMParameters;
-    /** 设置材质参数 */
-    setMaterial(parameters: Partial<PBMParameters>): void;
 }
 
+declare class PBMCustomShader {
+    id: string;
+    version: number;
+    uniforms: {
+        [key: string]: THREE_2.Uniform;
+    };
+    defines: {
+        [key: string]: any;
+    };
+    type: PBMCustomShaderInitArgs['type'];
+    vertex: PBMCustomShaderSlots['vertex'];
+    fragment: PBMCustomShaderSlots['fragment'];
+    constructor(initArgs: PBMCustomShaderInitArgs);
+    get needsUpdate(): boolean;
+    set needsUpdate(value: boolean);
+    onBeforeCompile(shader: THREE_2.Shader, renderer: THREE_2.WebGLRenderer): void;
+}
+export { PBMCustomShader as CustomShader }
+export { PBMCustomShader }
+
+declare interface PBMCustomShaderInitArgs {
+    type: Array<'none' | 'basic' | 'phong' | 'standard' | 'pointcloud'>;
+    vertex?: Partial<PBMCustomShaderSlots['vertex']>;
+    fragment?: Partial<PBMCustomShaderSlots['fragment']>;
+    uniforms?: {
+        [key: string]: THREE_2.Uniform;
+    };
+    defines?: {
+        [key: string]: any;
+    };
+}
+export { PBMCustomShaderInitArgs as CustomShaderInitArgs }
+export { PBMCustomShaderInitArgs }
+
+declare interface PBMCustomShaderSlots {
+    vertex: {
+        mainBefore: string;
+        mainStart: string;
+        mainEnd: string;
+    };
+    fragment: {
+        mainBefore: string;
+        mainStart: string;
+        mainModelColor: string;
+        mainEnd: string;
+    };
+}
+export { PBMCustomShaderSlots as CustomShaderChunks }
+export { PBMCustomShaderSlots }
+
+export declare type PBMFloorStyle = 'VISIBILITY' | 'OPACITY';
+
 /**
  * PBM 模型组
  * @deprecated 弃用, 直接使用 THREE.Group
@@ -2582,21 +2994,22 @@ export declare class PBMContainer extends THREE_2.Group {
 export declare class PBMGroup extends THREE_2.Group {
 }
 
-/** PBM 对象 */
+export declare class PBMMaterial extends THREE_2.Material {
+}
+
 export declare class PBMMesh extends THREE_2.Mesh<THREE_2.BufferGeometry, PBMMeshMaterial[]> {
     constructor(geometry: THREE_2.BufferGeometry, materials: PBMMeshMaterial[]);
-    update(renderer: THREE_2.WebGLRenderer, camera: Camera, model: Model, tile?: Tile): void;
 }
 
-/** PBM 材质 */
-export declare class PBMMeshMaterial extends THREE_2.ShaderMaterial implements PBMParameters {
-    shaderType: 'none' | 'basic' | 'phong' | 'standard';
-    /** 更新版本 */
-    syncModelVersion?: string;
+export declare class PBMMeshMaterial extends PBMMaterial implements THREE_2.MeshBasicMaterial, THREE_2.MeshPhongMaterial, THREE_2.MeshStandardMaterial {
+    readonly isPBMMeshMaterial: true;
+    readonly isShaderMaterial: true;
+    readonly isMeshBasicMaterial: boolean;
+    readonly isMeshPhongMaterial: boolean;
+    readonly isMeshStandardMaterial: boolean;
+    shaderType: PBMMeshShaderType;
     vertexTangents: boolean;
-    /** 内置参数 */
     color: THREE_2.Color;
-    colorAlpha: number;
     map: THREE_2.Texture | null;
     lightMap: THREE_2.Texture | null;
     lightMapIntensity: number;
@@ -2604,13 +3017,13 @@ export declare class PBMMeshMaterial extends THREE_2.ShaderMaterial implements P
     aoMapIntensity: number;
     specularMap: THREE_2.Texture | null;
     specular: THREE_2.Color;
+    shininess: number;
     roughnessMap: THREE_2.Texture | null;
     roughness: number;
     metalnessMap: THREE_2.Texture | null;
     metalness: number;
     alphaMap: THREE_2.Texture | null;
-    alphaMode: 'OPAQUE' | 'MASK' | 'BLEND';
-    combine: THREE_2.Combine | null;
+    combine: THREE_2.Combine;
     envMap: THREE_2.Texture | THREE_2.CubeTexture | null;
     envMapIntensity: number;
     reflectivity: number;
@@ -2626,235 +3039,210 @@ export declare class PBMMeshMaterial extends THREE_2.ShaderMaterial implements P
     displacementMap: THREE_2.Texture | null;
     displacementScale: number;
     displacementBias: number;
-    shininess: number;
-    /** 自定义材质*/
-    customShaders: CustomShader[];
-    /** 上一次的customShader*/
-    customShaderHash: string;
-    /** 上一次的customShaderUniforms*/
-    customShaderUniforms: Record<string, THREE_2.Uniform | undefined>;
-    /** 上一次的customShaderDefines*/
-    customShaderDefines: Record<string, any>;
-    /** 起始点 */
-    pano0: PBMParameters['pano0'];
-    /** 结束点 */
-    pano1: PBMParameters['pano1'];
-    /** 模型贴图和全景图的混合程度 [0-1] */
-    modelAlpha: PBMParameters['modelAlpha'];
-    /** 全景图混合程度 [0-1] */
-    progress: PBMParameters['progress'];
-    /** 全景图过度混合 */
-    transition: PBMParameters['transition'];
-    /** 模型透明度 */
-    opacity: PBMParameters['opacity'];
-    /** 点云着色方式*/
-    colorStyle: PBMParameters['colorStyle'];
-    /** 模型颜色*/
-    constantColor: PBMParameters['constantColor'];
-    /** 楼层样式*/
-    floorStyle: PBMParameters['floorStyle'];
-    /** 楼层参数*/
-    shownFloorIndex: PBMParameters['shownFloorIndex'];
-    /** 亮度 */
-    brightness: PBMParameters['brightness'];
-    /** 对外模型裁切参数*/
-    clippers: PBMParameters['clippers'];
-    /** edl*/
-    useEDL: PBMParameters['useEDL'];
-    /** hq*/
-    useHQWeight: PBMParameters['useHQWeight'];
-    /** HQDepthMask*/
-    useHQDepth: PBMParameters['useHQDepth'];
-    /** 点云大小绘制方式*/
-    pointSize: PBMParameters['pointSize'];
-    /** 点云形状*/
-    pointShape: PBMParameters['pointShape'];
-    /** 点云基础大小*/
-    pointScale: PBMParameters['pointScale'];
-    /** 点云背面绘制方式*/
-    pointBack: PBMParameters['pointBack'];
-    /** 点云像素最小值*/
-    pointMinPixel: PBMParameters['pointMinPixel'];
-    /** 点云像素最大值*/
-    pointMaxPixel: PBMParameters['pointMaxPixel'];
-    /** 高程彩色图*/
-    gradientTexture: PBMParameters['gradientTexture'];
-    /** HSV饱和度调整值*/
+    wireframe: boolean;
+    wireframeLinewidth: number;
+    wireframeLinecap: string;
+    wireframeLinejoin: string;
+    skinning: boolean;
+    morphTargets: boolean;
+    morphNormals: boolean;
+    metal: boolean;
+    vertexMarks: boolean;
+    alphaMode: PBMAlphaMode;
+    colorAlpha: number;
+    pano0: PBMPanoPicture | null;
+    pano1: PBMPanoPicture | null;
+    pano0Depth: PBMPanoDepth | null;
+    pano1Depth: PBMPanoDepth | null;
+    refinedScreen: PBMRefinedScreen | null;
+    modelAlpha: number;
+    progress: number;
+    transition: PBMTransition;
+    colorStyle: PBMColorStyle;
+    constantColor: THREE_2.Vector3;
+    floorIndex: number;
+    shownFloorIndex: number;
+    floorStyle: PBMFloorStyle;
+    gradientTexture: THREE_2.Texture | null;
+    brightness: number;
     colorSaturation: number;
-    /** HSV亮度调整值*/
     colorBrightness: number;
-    /** outline增益*/
     outlineGain: number;
-    /** distance增益 */
     distanceGain: number;
-    /** 半透明叠加渲染*/
-    useAddBlend: boolean;
-    /** 所属楼层*/
-    floorIndex: number;
-    constructor(shaderType?: 'none' | 'basic' | 'phong' | 'standard', parameters?: Partial<PBMParameters>);
-    onBeforeCompile(shader: THREE_2.Shader, renderer: THREE_2.WebGLRenderer): void;
-    refreshUniforms(renderer?: THREE_2.WebGLRenderer): void;
-    update(renderer: THREE_2.WebGLRenderer, camera: Camera, model: Model): void;
+    useEDL: boolean;
+    useHQWeight: boolean;
+    useHQDepth: boolean;
+    modelBoundingMin: THREE_2.Vector3;
+    modelBoundingMax: THREE_2.Vector3;
+    clippers: readonly PBMClipperParameter[];
+    customShaders: readonly PBMCustomShader[];
+    onBeforeRender?: (renderer: THREE_2.WebGLRenderer, scene: THREE_2.Scene, camera: THREE_2.Camera, geometry: THREE_2.BufferGeometry | THREE_2.Geometry, object: THREE_2.Object3D, group: THREE_2.Group) => void;
+    constructor(parameters?: PBMMeshMaterialParameters | PBMMeshShaderType);
     copy(source: PBMMeshMaterial): this;
-    clone(): any;
+    clone(): this;
+    /**
+     * @deprecated
+     * 已经不需要再被调用了
+     */
+    refreshUniforms(): void;
+}
+
+export declare interface PBMMeshMaterialParameters extends THREE_2.MaterialParameters, THREE_2.MaterialParameters, THREE_2.MeshBasicMaterialParameters, THREE_2.MeshPhongMaterialParameters, THREE_2.MeshStandardMaterialParameters {
+    shaderType?: PBMMeshShaderType;
+    vertexMarks?: boolean;
+    colorAlpha?: number;
+    alphaMode?: PBMAlphaMode;
+    pano0?: PBMPanoPicture | null;
+    pano1?: PBMPanoPicture | null;
+    refinedScreen?: PBMRefinedScreen | null;
+    modelAlpha?: number;
+    progress?: number;
+    transition?: PBMTransition;
+    colorStyle?: PBMColorStyle;
+    constantColor?: THREE_2.Vector3;
+    floorIndex?: number;
+    shownFloorIndex?: number;
+    floorStyle?: PBMFloorStyle;
+    gradientTexture?: THREE_2.Texture | null;
+    brightness?: number;
+    colorSaturation?: number;
+    colorBrightness?: number;
+    outlineGain?: number;
+    distanceGain?: number;
+    useEDL?: boolean;
+    useHQWeight?: boolean;
+    useHQDepth?: boolean;
+    modelBoundingMin?: THREE_2.Vector3;
+    modelBoundingMax?: THREE_2.Vector3;
+    clippers?: PBMClipperParameter[];
+    customShaders?: PBMCustomShader[];
+}
+
+export declare type PBMMeshShaderType = 'none' | 'basic' | 'phong' | 'standard';
+
+export declare interface PBMPanoDepth {
+    /** 点位 Id */
+    panoId: PanoId;
+    /** 深度图 */
+    map: THREE_2.CubeTexture;
+    /** 图片尺寸 */
+    mapSize: number;
+    /** 图片最大深度 */
+    maxDepth: number;
 }
 
 export declare interface PBMPanoPicture {
-    /** 起始点位全景图 */
-    map: THREE_2.CubeTexture | TileCubeTextureTarget;
-    /** 亮度增益 */
-    luminanceMap: null | THREE_2.CubeTexture | TileCubeTextureTarget;
-    /** 起始点全景图变换矩阵 4x4 */
+    /** 点位 Id */
+    panoId: PanoId;
+    /** 全景图 */
+    map: THREE_2.CubeTexture;
+    /** 图片尺寸 */
+    mapSize: number;
+    /** 全景图变换矩阵 4x4 */
     matrix: THREE_2.Matrix4;
     /** 缩放 */
     zoom: number;
 }
 
-/** PBM 材质参数 */
-export declare interface PBMParameters {
-    /** 自定义材质*/
-    customShaders: CustomShader[];
-    /** 起始点 */
-    pano0: PBMPanoPicture | null;
-    /** 结束点 */
-    pano1: PBMPanoPicture | null;
-    /** 模型贴图和全景图的混合程度 [0-1] */
-    modelAlpha: number;
-    /** 全景图混合程度 [0-1] */
-    progress: number;
-    /** 全景图过度混合 */
-    transition: 'BLACK' | 'SPREAD' | 'FADE';
-    /** 模型透明度 */
-    opacity: number;
-    /** 楼层样式 */
-    floorStyle: 'VISIBILITY' | 'OPACITY';
-    /** 颜色样式 */
-    colorStyle: 'RGB' | 'ALTITUDE' | 'CONSTANT';
-    /** 模型颜色*/
-    constantColor: THREE_2.Vector3;
-    /** 楼层参数*/
-    shownFloorIndex: number;
-    /** 模型裁切参数（工程侧调用）*/
-    clippers: ClipperParameter[] | null;
-    /** 亮度 */
-    brightness: number;
-    /** 是否使用EDL*/
-    useEDL: boolean;
-    /** 是否使用HQ*/
-    useHQWeight: boolean;
-    /** 是否使用HQ_DEPTH_MASK*/
-    useHQDepth: boolean;
-    /** 点云形状*/
-    pointShape: 'SQUARE' | 'CIRCLE';
-    /** 点云大小绘制方式*/
-    pointSize: 'FIXED' | 'ATTENUATION' | 'GEOMETRIC';
-    /** 点云背面绘制方式*/
-    pointBack: 'VISIBLE' | 'HIDDEN' | 'DARK';
-    /** 点云基础大小*/
-    pointScale: number;
-    /** 点云最小尺寸*/
-    pointMinPixel: number;
-    /** 点云最大尺寸*/
-    pointMaxPixel: number;
-    /** 饱和度调整值*/
-    colorSaturation: number;
-    /** 亮度调整值*/
-    colorBrightness: number;
-    /** 半透明叠加渲染*/
-    useAddBlend: boolean;
-    /** outline增益*/
-    outlineGain: number;
-    /** distance增益*/
-    distanceGain: number;
-    /** 高程着色材质*/
-    gradientTexture: THREE_2.Texture | null;
-}
+export declare type PBMPointBack = 'VISIBLE' | 'HIDDEN' | 'DARK';
 
 /** PBM 对象 */
 export declare class PBMPointCloud extends THREE_2.Points<THREE_2.BufferGeometry, PBMPointCloudMaterial> {
-    private appearMotion;
     constructor(geometry: THREE_2.BufferGeometry, materials: PBMPointCloudMaterial);
-    update(renderer: THREE_2.WebGLRenderer, camera: Camera, model: Model, tile?: Tile): void;
 }
 
-export declare class PBMPointCloudMaterial extends THREE_2.ShaderMaterial implements PBMParameters {
-    /** 自定义材质*/
-    customShaders: CustomShader[];
-    /** 上一次的customShader*/
-    customShaderHash: string;
-    /** 上一次的customShaderUniforms*/
-    customShaderUniforms: Record<string, THREE_2.Uniform | undefined>;
-    /** 上一次的customShaderDefines*/
-    customShaderDefines: Record<string, any>;
-    /** 更新版本 */
-    syncModelVersion?: string;
-    /** 起始点 */
-    pano0: PBMParameters['pano0'];
-    /** 结束点 */
-    pano1: PBMParameters['pano1'];
-    /** 全景图混合程度 [0-1] */
-    progress: PBMParameters['progress'];
-    /** 全景图过度混合 */
-    transition: PBMParameters['transition'];
-    /** 楼层样式 */
-    floorStyle: PBMParameters['floorStyle'];
-    /** 楼层参数*/
-    shownFloorIndex: PBMParameters['shownFloorIndex'];
-    /** 亮度 */
-    brightness: PBMParameters['brightness'];
-    /** 对外模型裁切参数*/
-    clippers: PBMParameters['clippers'];
-    /** 着色样式*/
-    colorStyle: PBMParameters['colorStyle'];
-    /** 模型颜色*/
-    constantColor: PBMParameters['constantColor'];
-    /** 全景和点云/模型的混合程度*/
-    modelAlpha: PBMParameters['modelAlpha'];
-    /** 是否使用EDL*/
-    useEDL: PBMParameters['useEDL'];
-    /** 是否使用HQ*/
-    useHQWeight: PBMParameters['useHQWeight'];
-    /** 是否使用HQ_DEPTH_MASK*/
-    useHQDepth: PBMParameters['useHQDepth'];
-    /** 点云大小绘制方式*/
-    pointSize: PBMParameters['pointSize'];
-    /** 点云形状*/
-    pointShape: PBMParameters['pointShape'];
-    /** 点云基础缩放*/
-    pointScale: PBMParameters['pointScale'];
-    /** 点云背面绘制方式*/
-    pointBack: PBMParameters['pointBack'];
-    /** 点云像素最小值*/
-    pointMinPixel: PBMParameters['pointMinPixel'];
-    /** 点云像素最大值*/
-    pointMaxPixel: PBMParameters['pointMaxPixel'];
-    /** 高程彩色图*/
-    gradientTexture: PBMParameters['gradientTexture'];
-    /** 所属楼层*/
+export declare class PBMPointCloudMaterial extends PBMMaterial {
+    readonly isPBMPointCloudMaterial: true;
+    readonly isShaderMaterial: true;
+    readonly shaderType: PBMPointCloudShaderType;
+    vertexMarks: boolean;
+    pointScale: number;
+    pointMinPixel: number;
+    pointMaxPixel: number;
+    pointSize: PBMPointSize;
+    pointShape: PBMPointShape;
+    pointBack: PBMPointBack;
+    modelAlpha: number;
+    colorStyle: PBMColorStyle;
+    constantColor: THREE_2.Vector3;
     floorIndex: number;
-    /** 饱HSV和度调整值*/
+    shownFloorIndex: number;
+    floorStyle: PBMFloorStyle;
+    gradientTexture: THREE_2.Texture | null;
+    brightness: number;
     colorSaturation: number;
-    /** HSV亮度调整值*/
     colorBrightness: number;
-    /** outline增益*/
     outlineGain: number;
-    /** distance增益*/
     distanceGain: number;
-    /** 半透明叠加渲染*/
-    useAddBlend: boolean;
-    constructor(parameters?: Partial<PBMParameters>);
-    onBeforeCompile(shader: THREE_2.Shader, renderer: THREE_2.WebGLRenderer): void;
-    update(renderer: THREE_2.WebGLRenderer, camera: Camera, model: Model): void;
+    useEDL: boolean;
+    useHQWeight: boolean;
+    useHQDepth: boolean;
+    modelBoundingMin: THREE_2.Vector3;
+    modelBoundingMax: THREE_2.Vector3;
+    clippers: readonly PBMClipperParameter[];
+    customShaders: readonly PBMCustomShader[];
+    onBeforeRender?: (renderer: THREE_2.WebGLRenderer, scene: THREE_2.Scene, camera: THREE_2.Camera, geometry: THREE_2.BufferGeometry | THREE_2.Geometry, object: THREE_2.Object3D, group: THREE_2.Group) => void;
+    constructor(parameters?: PBMPointCloudMaterialParameters);
     copy(source: PBMPointCloudMaterial): this;
+    clone(): this;
+    /**
+     * @deprecated
+     * 已经不需要再被调用了
+     */
+    refreshUniforms(): void;
+}
+
+export declare interface PBMPointCloudMaterialParameters extends THREE_2.MaterialParameters {
+    vertexMarks?: boolean;
+    pointScale?: number;
+    pointMinPixel?: number;
+    pointMaxPixel?: number;
+    pointSize?: PBMPointSize;
+    pointShape?: PBMPointShape;
+    pointBack?: PBMPointBack;
+    modelAlpha?: number;
+    colorStyle?: PBMColorStyle;
+    constantColor?: THREE_2.Vector3;
+    floorIndex?: number;
+    shownFloorIndex?: number;
+    floorStyle?: PBMFloorStyle;
+    gradientTexture?: THREE_2.Texture | null;
+    brightness?: number;
+    colorSaturation?: number;
+    colorBrightness?: number;
+    outlineGain?: number;
+    distanceGain?: number;
+    useEDL?: boolean;
+    useHQWeight?: boolean;
+    useHQDepth?: boolean;
+    modelBoundingMin?: THREE_2.Vector3;
+    modelBoundingMax?: THREE_2.Vector3;
+    clippers?: PBMClipperParameter[];
+    customShaders?: PBMCustomShader[];
+}
+
+export declare type PBMPointCloudShaderType = 'pointcloud';
+
+export declare type PBMPointShape = 'SQUARE' | 'CIRCLE';
+
+export declare type PBMPointSize = 'FIXED' | 'ATTENUATION';
+
+export declare interface PBMRefinedScreen {
+    projectionMatrix: THREE_2.Matrix4;
+    matrixInverse: THREE_2.Matrix4;
+    map: THREE_2.Texture | null;
+    pano: number;
+    opacity: number;
 }
 
 export declare class PBMSkinnedMesh extends THREE_2.SkinnedMesh<THREE_2.BufferGeometry, PBMMeshMaterial[]> {
     geometry: THREE_2.BufferGeometry;
     material: PBMMeshMaterial[];
     constructor(geometry: THREE_2.BufferGeometry, materials: PBMMeshMaterial[], useVertexTexture?: boolean);
-    update(renderer: THREE_2.WebGLRenderer, camera: Camera, model: Model, tile?: Tile): void;
 }
 
+export declare type PBMTransition = 'BLACK' | 'SPREAD' | 'FADE';
+
 /**
  * 相机位姿
  * @document ../../../guides/coordinate.md
@@ -2904,6 +3292,14 @@ export declare type RegionBoundingVolumeJson = {
     region: number[];
 };
 
+declare interface RendererInitArgs {
+    renderer: THREE_2.WebGLRenderer;
+    camera: Camera;
+    scene: THREE_2.Scene;
+    modelScene: ModelScene;
+    enableLayeringRendering: boolean;
+}
+
 export declare interface RenderEvent extends BaseEvent {
     needsRender: boolean;
     info: null | {
@@ -2921,10 +3317,16 @@ export declare interface RenderEvent extends BaseEvent {
     };
 }
 
+export declare interface ResolvedParameterValue extends ParameterValue {
+    versions: string[];
+}
+
 /** Five 场景*/
 export declare class Scene extends THREE_2.Scene {
+    needsRender: boolean;
     add(...objects: AddableObject[]): this;
     remove(...objects: AddableObject[]): this;
+    update(renderer: THREE_2.WebGLRenderer, camera: THREE_2.Camera): boolean;
 }
 
 /**
@@ -2945,6 +3347,17 @@ export declare interface Scissor {
     height: number;
 }
 
+declare type Shader = {
+    uniforms?: {
+        [name: string]: THREE_2.IUniform;
+    };
+    defines?: {
+        [name: string]: boolean;
+    };
+    vertex?: string;
+    fragment: string;
+};
+
 export declare class SphereBoundingVolume implements BoundingVolume {
     type: "sphere";
     center: THREE_2.Vector3;
@@ -3115,22 +3528,6 @@ export declare class TextureLoader {
         timeout?: number;
         fetcher: Fetcher;
     }, onLoad: (response: NetworkResponse<THREE_2.CubeTexture, NetWorkMeta[]>) => void, onError: (error: Error) => void, onProgress: (percent: number) => void, renderer: THREE_2.WebGLRenderer): Promise<NetworkResponse<THREE_2.CubeTexture, NetWorkMeta[]>>;
-    loadTiledCubeTexture(sources: WorkCubeImage, tileSources: WorkTile[], options: {
-        tileMaxLevel?: number;
-        imageURL?: {
-            transform?: (source: string, options: ImageURLOptions) => string;
-            options?: ImageURLOptions;
-        };
-        format?: THREE_2.PixelFormat;
-        minFilter?: THREE_2.TextureFilter;
-        magFilter?: THREE_2.TextureFilter;
-        generateMipmaps?: boolean;
-        wrapS?: THREE_2.Wrapping;
-        wrapT?: THREE_2.Wrapping;
-        viaAjax?: boolean;
-        timeout?: number;
-        fetcher: Fetcher;
-    }, onLoad: (response: NetworkResponse<TileCubeTextureTarget, NetWorkMeta[]>) => void, onError: (error: Error) => void, onProgress: (percent: number) => void, renderer: THREE_2.WebGLRenderer): Promise<NetworkResponse<TileCubeTextureTarget, NetWorkMeta[]>>;
 }
 
 /**
@@ -3168,7 +3565,6 @@ export declare class Tile {
     content: {
         uri: string;
         group?: number;
-        boundingVolume?: BoundingVolume;
         data?: TileContentData;
         loadState: 'LOADING' | 'UNLOADED' | 'READY' | 'FAILED';
         loadStateUpdateTime: number;
@@ -3221,89 +3617,32 @@ export declare class Tile {
     get contentByteLength(): number;
     get contentMemoryUsage(): number;
     getScreenSpaceError(frameState: TilesetFrameState, distanceToCamera: number, useParentGeometricError: boolean): number;
-    getPriority(): number;
-}
-
-export declare interface Tile3dLayerOptions {
-    /** 调试模式 */
-    debug?: 'root-bounding-volume' | 'selected-bounding-volume' | 'none';
-    /** 显示图层 */
-    showLayers?: boolean | string[];
-    /** 可观测区域, 相对于 local 系 */
-    viewerRequestVolume?: BoundingVolume | BoundingVolumeJson;
-    /** 模型显示最小细化层级 */
-    minLevelOfDetail?: number;
-    /** 模型显示最大细化层级 */
-    maxLevelOfDetail?: number;
-    /** 模型显示最小细化误差 */
-    minGeometricError?: number;
-    /** 模型显示最大细化误差 */
-    maxGeometricError?: number;
-    /** 模型越层级加载 */
-    skipLevelOfDetail?: boolean;
-    /** 模型是否最密 */
-    mostDetail?: boolean;
-    /** 模型加载不在视野中的兄弟节点 */
-    loadSiblings?: boolean;
-    /** 模型加载不在视野中的所有节点 */
-    loadAll?: boolean;
-    /** 模型最大内存缓存 */
-    maxMemoryUsage?: number;
-    /** 模型网络最大请求并发数 */
-    maxRequests?: number;
-    /** 模型网络请求顺序 */
-    requestOrder?: 'SCREEN_SPACE_ERROR' | 'SCREEN_LEVEL_VERTICAL' | 'SCREEN_VERTICAL';
-    /** 模型屏幕空间误差计算最大值 */
-    maxScreenSpaceError?: number;
+    getPriority(frameState: TilesetFrameState): number;
 }
 
 export declare class Tile3DModel extends THREE_2.Object3D {
-    static DEFAULT_PANORAMA_MIN_GEOMETRIC_ERROR: number;
-    static DEFAULT_MIN_LEVEL_OF_DETAIL: number;
-    static DEFAULT_MAX_LEVEL_OF_DETAIL: number;
-    static DEFAULT_MIN_GEOMETRIC_ERROR: number;
-    static DEFAULT_MAX_GEOMETRIC_ERROR: number;
-    static DEFAULT_MAX_MEMORY_USAGE: number;
-    static DEFAULT_MAX_SCREEN_SPACE_ERROR: number;
-    static DEFAULT_SKIP_LEVEL_OF_DETAIL: boolean;
-    static DEFAULT_MOST_DETAIL: boolean;
-    static DEFAULT_LOAD_SIBLINGS: boolean;
-    static DEFAULT_LOAD_ALL: boolean;
-    static DEFAULT_MAX_REQUESTS: number;
-    static DEFAULT_REQUEST_ORDER: TileRequestOrder;
-    modelIndex: number;
-    modelsLoaded: any;
-    debug: 'root-bounding-volume' | 'selected-bounding-volume' | 'none';
     type: 'point_cloud' | 'mesh';
+    parent: Model | null;
+    /** meta 信息加载错误 */
+    error?: Error | null;
+    /** meta 信息加载错误 */
+    onError?: (error: Error) => void;
+    /** 更新帧次数 */
+    frameNumber: number;
+    parameter: Parameter;
     light: boolean;
     upAxis: string;
-    model: Model;
-    viewLayer?: ModelViewLayer;
     fetcher: Fetcher;
     search: string;
     groundHeight: number | null;
-    coordinateTransform: {
-        localToEnuMatrix: THREE_2.Matrix4;
-        enuToLocalMatrix: THREE_2.Matrix4;
-        enuToEcefMatrix: THREE_2.Matrix4;
-        ecefToEnuMatrix: THREE_2.Matrix4;
-        localToEcefMatrix: THREE_2.Matrix4;
-        ecefToLocalMatrix: THREE_2.Matrix4;
-    };
+    enuToEcefMatrix: THREE_2.Matrix4;
+    ecefToEnuMatrix: THREE_2.Matrix4;
     tileset: Tileset;
-    minLevelOfDetail: number;
-    maxLevelOfDetail: number;
-    maxGeometricError: number;
-    minGeometricError: number;
-    panoramaMinGeometricError: number;
     boundingBox: THREE_2.Box3;
-    needsRefined: boolean;
+    autoRefine: boolean;
     refined: boolean;
     refineProgress: [number, number];
     loaded: boolean;
-    needsRender: boolean;
-    lastRenderHash: string;
-    cacheCameras: (THREE_2.PerspectiveCamera | Camera)[];
     private clearStencilObject;
     private disposed;
     private renderer?;
@@ -3311,7 +3650,9 @@ export declare class Tile3DModel extends THREE_2.Object3D {
     private backfaceObjects;
     private debugObjects;
     private tileObjects;
-    constructor(model: Model, tilesetHeader: TilesetHeader, options: Tile3DModelLoaderOptions);
+    constructor(tilesetHeader: TilesetHeader, options: Tile3DModelLoaderOptions);
+    get tiles(): Tile[];
+    get trajectories(): Trajectory[];
     getRecommendProps(options?: {
         powerPreference?: 'high' | 'default';
     }): {
@@ -3320,27 +3661,34 @@ export declare class Tile3DModel extends THREE_2.Object3D {
         maxScreenSpaceError: number;
         maxMemoryUsage: number;
     };
-    getRenderHash(): string;
-    get maxMemoryUsage(): number;
-    set maxMemoryUsage(value: number);
-    get maxRequests(): number;
-    set maxRequests(value: number);
-    get requestOrder(): TileRequestOrder;
-    set requestOrder(value: TileRequestOrder);
-    get skipLevelOfDetail(): boolean;
-    set skipLevelOfDetail(value: boolean);
-    get mostDetail(): boolean;
-    set mostDetail(value: boolean);
-    get loadSiblings(): boolean;
-    set loadSiblings(value: boolean);
-    get loadAll(): boolean;
-    set loadAll(value: boolean);
-    get maxScreenSpaceError(): number;
-    set maxScreenSpaceError(value: number);
-    get currentMaxScreenSpaceError(): number;
-    get trajectories(): Trajectory[];
+    loadContent(tile: Tile): Promise<void>;
+    unloadContent(tile: Tile): Promise<void>;
+    loadAllTilesets(): Promise<void>;
+    loadTrajectory(trajectory: Trajectory): Promise<void>;
+    unloadTrajectory(trajectory: Trajectory): Promise<void>;
+    intersectRaycaster(raycaster: THREE_2.Raycaster, filterFloorIndex?: undefined | null | number, sortByDistance?: boolean, target?: Intersection[]): Intersection[];
+    private cloneSkipBackfaceObject;
+    update(renderer: THREE_2.WebGLRenderer, camera: Camera, modelScene: ModelScene, model: Model): boolean;
+    dispose(): void;
+    /**
+     * @deprecated
+     * use this.parent instead.
+     */
+    get model(): Model;
+    /**
+     * @deprecated
+     * it's self
+     */
+    get scene(): this;
+    /**
+     * @deprecated
+     * it's self
+     */
+    get viewLayer(): this;
     localToEnu(vector: THREE_2.Vector3): THREE_2.Vector3;
     enuToLocal(vector: THREE_2.Vector3): THREE_2.Vector3;
+    enuToEcef(vector: THREE_2.Vector3): THREE_2.Vector3;
+    ecefToEnu(vector: THREE_2.Vector3): THREE_2.Vector3;
     localToEcef(vector: THREE_2.Vector3): THREE_2.Vector3;
     ecefToLocal(vector: THREE_2.Vector3): THREE_2.Vector3;
     localToLla(vector: THREE_2.Vector3): THREE_2.Vector3;
@@ -3351,15 +3699,123 @@ export declare class Tile3DModel extends THREE_2.Object3D {
     ecefToWorld(vector: THREE_2.Vector3): THREE_2.Vector3;
     worldToLla(vector: THREE_2.Vector3): THREE_2.Vector3;
     llaToWorld(vector: THREE_2.Vector3): THREE_2.Vector3;
-    loadContent(tile: Tile): Promise<void>;
-    unloadContent(tile: Tile): Promise<void>;
-    loadAllTilesets(): Promise<void>;
-    loadTrajectory(trajectory: Trajectory): Promise<void>;
-    unloadTrajectory(trajectory: Trajectory): Promise<void>;
-    intersectRaycaster(raycaster: THREE_2.Raycaster, sortByDistance?: boolean, target?: Intersection[]): Intersection[];
-    private cloneSkipBackfaceObject;
-    update(renderer: THREE_2.WebGLRenderer, camera: Camera, mode: Mode): void;
-    dispose(): void;
+    /**
+     * @deprecated
+     * 使用 localToLla(new THREE.Vector()) 替代
+     */
+    get coordinates(): string;
+    /**
+     * @deprecated
+     * 使用 coordinateTransform 替代
+     */
+    getTransformMatrix4(target?: THREE_2.Matrix4): THREE_2.Matrix4;
+    /**
+     * @deprecated
+     * 使用 llaToWorld 替代
+     */
+    coordinatesToWorldPoint(coordinates: {
+        longitude: number;
+        latitude: number;
+        altitude: number;
+    }): THREE_2.Vector3;
+    /**
+     * @deprecated
+     * 使用 llaToWorld 替代
+     */
+    worldPointToCoordinates(point: THREE_2.Vector3): {
+        longitude: number;
+        latitude: number;
+        altitude: number;
+    };
+    /**
+     * @deprecated
+     * Use `.parameter.reset('brightness')` instead
+     */
+    resetBrightness(): void;
+    /**
+     * @deprecated
+     * use `.parameter.tileDebug` `.parameter.set('tileDebug', tileDebug)` instend
+     */
+    get debug(): TileDebug;
+    set debug(value: TileDebug);
+    /**
+     * @deprecated
+     * use `.parameter.minLevelOfDetail` `.parameter.set('minLevelOfDetail', minLevelOfDetail)` instend
+     */
+    get minLevelOfDetail(): number;
+    set minLevelOfDetail(value: number);
+    /**
+     * @deprecated
+     * use `.parameter.maxLevelOfDetail` `.parameter.set('maxLevelOfDetail', maxLevelOfDetail)` instend
+     */
+    get maxLevelOfDetail(): number;
+    set maxLevelOfDetail(value: number);
+    /**
+     * @deprecated
+     * use `.parameter.minGeometricError` `.parameter.set('minGeometricError', minGeometricError)` instend
+     */
+    get minGeometricError(): number;
+    set minGeometricError(value: number);
+    /**
+     * @deprecated
+     * use `.parameter.maxGeometricError` `.parameter.set('maxGeometricError', maxGeometricError)` instend
+     */
+    get maxGeometricError(): number;
+    set maxGeometricError(value: number);
+    /**
+     * @deprecated
+     * use `.parameter.panoramaMinGeometricError` `.parameter.set('panoramaMinGeometricError', panoramaMinGeometricError)` instend
+     */
+    get panoramaMinGeometricError(): number;
+    set panoramaMinGeometricError(value: number);
+    /**
+     * @deprecated
+     * use `.parameter.skipLevelOfDetail` `.parameter.set('skipLevelOfDetail', skipLevelOfDetail)` instend
+     */
+    get skipLevelOfDetail(): boolean;
+    set skipLevelOfDetail(value: boolean);
+    /**
+     * @deprecated
+     * use `.parameter.mostDetail` `.parameter.set('mostDetail', mostDetail)` instend
+     */
+    get mostDetail(): boolean;
+    set mostDetail(value: boolean);
+    /**
+     * @deprecated
+     * use `.parameter.loadSiblings` `.parameter.set('loadSiblings', loadSiblings)` instend
+     */
+    get loadSiblings(): boolean;
+    set loadSiblings(value: boolean);
+    /**
+     * @deprecated
+     * use `.parameter.loadAll` `.parameter.set('loadAll', loadAll)` instend
+     */
+    get loadAll(): boolean;
+    set loadAll(value: boolean);
+    /**
+     * @deprecated
+     * use `.parameter.maxMemoryUsage` `.parameter.set('maxMemoryUsage', maxMemoryUsage)` instend
+     */
+    get maxMemoryUsage(): number;
+    set maxMemoryUsage(value: number);
+    /**
+     * @deprecated
+     * use `.parameter.maxRequests` `.parameter.set('maxRequests', maxRequests)` instend
+     */
+    get maxRequests(): number;
+    set maxRequests(value: number);
+    /**
+     * @deprecated
+     * use `.parameter.requestOrder` `.parameter.set('requestOrder', requestOrder)` instend
+     */
+    get requestOrder(): TileRequestOrder;
+    set requestOrder(value: TileRequestOrder);
+    /**
+     * @deprecated
+     * use `.parameter.maxScreenSpaceError` `.parameter.set('maxScreenSpaceError', maxScreenSpaceError)` instend
+     */
+    get maxScreenSpaceError(): number;
+    set maxScreenSpaceError(value: number);
 }
 
 /** Advanced loader options */
@@ -3368,23 +3824,20 @@ export declare interface Tile3DModelLoaderOptions {
     light: boolean;
     type: 'point_cloud' | 'mesh';
     upAxis: string;
-    url: string;
     referer: string;
     fetcher: Fetcher;
-    groundHeight: number | null;
-    coordinateTransform: {
-        localToEnuMatrix: THREE_2.Matrix4;
-        enuToLocalMatrix: THREE_2.Matrix4;
-        enuToEcefMatrix: THREE_2.Matrix4;
-        ecefToEnuMatrix: THREE_2.Matrix4;
-        localToEcefMatrix: THREE_2.Matrix4;
-        ecefToLocalMatrix: THREE_2.Matrix4;
-    };
     search?: string;
-    onError?: (error: Error) => void;
+    groundHeight: number | null;
+    enuToEcefMatrix: THREE_2.Matrix4;
+    ecefToEnuMatrix: THREE_2.Matrix4;
+    error?: Error | null;
 }
 
-export declare type Tile3dOptions = Tile3dLayerOptions | ((layer: WorkModelLayer) => Tile3dLayerOptions);
+export declare type Tile3dOptions = (Partial<ParameterTilesetValue> & {
+    showLayers?: boolean | string[];
+}) | ((viewLayer: Tile3DModel, model: Model) => void | (Partial<ParameterTilesetValue> & {
+    showLayers?: boolean | string[];
+}));
 
 export declare class TileCache {
     private options;
@@ -3406,7 +3859,7 @@ export declare type TileCacheOptions = {
 };
 
 export declare type TileContentData = {
-    type: ParsedResultType['type'];
+    type: LoadResultType['type'];
     byteLength: number;
     memoryUsage: number;
     uri: string;
@@ -3423,52 +3876,12 @@ export declare interface TileCubeNode {
     children: TileCubeNode[];
 }
 
-export declare class TileCubeTextureTarget {
-    private tileTree;
-    private tileSources;
-    private options;
-    private renderer;
-    static DEFAULT_MAX_REQUEST: number;
-    name: string;
-    needsRender: boolean;
-    baseLevel: number;
-    maxRequest: number;
-    private disposed;
-    private loadedCubeNodes;
-    private loadingCubeNodes;
-    private drawedCubeNodes;
-    private baseCubeTexture;
-    private _cubeRenderTarget;
-    private prepareToRender;
-    constructor(baseCubeTexture: THREE_2.CubeTexture, tileTree: TileCubeTree, tileSources: WorkTile[], options: {
-        textureSize: number;
-        textureLoader: TextureLoader;
-        imageURL?: {
-            transform?: (source: string, options: ImageURLOptions) => string;
-            options?: ImageURLOptions;
-        };
-        format?: THREE_2.PixelFormat;
-        minFilter?: THREE_2.TextureFilter;
-        magFilter?: THREE_2.TextureFilter;
-        generateMipmaps?: boolean;
-        wrapS?: THREE_2.Wrapping;
-        wrapT?: THREE_2.Wrapping;
-        timeout?: number;
-        fetcher: Fetcher;
-    }, renderer: THREE_2.WebGLRenderer);
-    get cubeRenderTarget(): THREE_2.WebGLCubeRenderTarget | null;
-    set cubeRenderTarget(cubeRenderTarget: THREE_2.WebGLCubeRenderTarget | null);
-    private requestTile;
-    update(frustum: THREE_2.Frustum, level: number): void;
-    get tilePending(): number;
-    get texture(): THREE_2.Texture;
-    dispose(): void;
-}
-
 export declare interface TileCubeTree {
     children: TileCubeNode[];
 }
 
+export declare type TileDebug = 'root-bounding-volume' | 'selected-bounding-volume' | 'none';
+
 export declare interface TileHeader {
     content?: {
         uri?: string;
@@ -3486,14 +3899,15 @@ export declare interface TileHeader {
 }
 
 export declare class TileNode extends THREE_2.Object3D {
-    private contentObject;
-    private disposers;
     materials: THREE_2.Material[];
     pbmObjects: (PBMMesh | PBMSkinnedMesh | PBMPointCloud)[];
+    private contentObject;
+    private appearMotion;
+    private disposers;
     constructor(name: string, contentObject: THREE_2.Object3D, disposer?: () => void);
     generateBvhTree(): Promise<this>;
-    intersectRaycaster(raycaster: THREE_2.Raycaster, sortByDistance?: boolean, target?: Intersection[]): Intersection[];
-    update(renderer: THREE_2.WebGLRenderer, camera: Camera, model: Model, tile: Tile): void;
+    intersectRaycaster(raycaster: THREE_2.Raycaster, filterFloorIndex?: undefined | null | number, sortByDistance?: boolean, target?: Intersection[]): Intersection[];
+    update(renderer: THREE_2.WebGLRenderer, camera: Camera, modelScene: ModelScene, tile: Tile, parameterValue: ResolvedParameterValue): boolean;
     dispose(): void;
     clone(): this;
 }
@@ -3517,16 +3931,6 @@ export declare type TileRequestSchedulerOptions = {
 };
 
 export declare class Tileset {
-    static DEFAULT_MAX_MEMORY_USAGE: number;
-    static DEFAULT_MEMORY_OVERFLOW: number;
-    static DEFAULT_MEMORY_ADJUSTED_SCREEN_SPACE_ERROR: boolean;
-    static DEFAULT_MAX_SCREEN_SPACE_ERROR: number;
-    static DEFAULT_SKIP_LEVEL_OF_DETAIL: boolean;
-    static DEFAULT_MOST_DETAIL: boolean;
-    static DEFAULT_LOAD_SIBLINGS: boolean;
-    static DEFAULT_LOAD_ALL: boolean;
-    static DEFAULT_MAX_REQUESTS: number;
-    static DEFAULT_REQUEST_ORDER: TileRequestOrder;
     asset: {
         version: string;
         tilesetVersion: string;
@@ -3541,20 +3945,13 @@ export declare class Tileset {
         [key: string]: any;
     };
     id: string;
-    url: string;
-    referer: string;
-    hasMixedContent: boolean;
     frameNumber: number;
-    minLevelOfDetail: number;
-    maxLevelOfDetail: number;
-    minGeometricError: number;
-    maxGeometricError: number;
-    properties: Record<string, any>;
+    hasMixedContent: boolean;
+    properties: NonNullable<TilesetHeader['properties']>;
     options: TilesetOptions;
     root: Tile;
     rootMeta: NonNullable<TilesetHeader['rootMeta']>;
     transform: THREE_2.Matrix4;
-    transformIsIdentity: boolean;
     geometricError: number;
     cache: TileCache;
     currentMaxScreenSpaceError: number;
@@ -3563,16 +3960,6 @@ export declare class Tileset {
     private normalTraverser;
     private skipTraverser;
     private mostDetailTraverser;
-    maxMemoryUsage: number;
-    memoryOverflow: number;
-    memoryAdjustedScreenSpaceError: boolean;
-    maxScreenSpaceError: number;
-    skipLevelOfDetail: boolean;
-    mostDetail: boolean;
-    loadSiblings: boolean;
-    loadAll: boolean;
-    maxRequests: number;
-    tileRequestOrder: TileRequestOrder;
     loadedTiles: Set<Tile>;
     needsRefinedTiles: Set<Tile>;
     requestedTiles: Tile[];
@@ -3582,23 +3969,24 @@ export declare class Tileset {
     selectedTrajectories: Trajectory[];
     pointLength: number;
     floorLength: number;
-    constructor(id: string, header: TilesetHeader, options: TilesetOptions);
+    constructor(header: TilesetHeader, options: TilesetOptions);
     private adjustScreenSpaceError;
-    private get traverser();
+    private getTraverser;
     /** Release resources */
     reset(): void;
     update(frameState: TilesetFrameState, cacheFrameStates?: TilesetFrameState[]): void;
 }
 
 export declare type TilesetFrameState = {
+    debug: TileDebug;
     frameNumber: number;
     time: number;
     camera: {
         type: "PerspectiveCamera" | "OrthographicCamera";
-        position: THREE.Vector3;
-        direction: THREE.Vector3;
-        up: THREE.Vector3;
-        projectionMatrix: THREE.Matrix4;
+        position: THREE_2.Vector3;
+        direction: THREE_2.Vector3;
+        up: THREE_2.Vector3;
+        projectionMatrix: THREE_2.Matrix4;
         visible: boolean;
         refine: boolean;
     };
@@ -3610,9 +3998,20 @@ export declare type TilesetFrameState = {
     maxLevelOfDetail: number;
     minGeometricError: number;
     maxGeometricError: number;
+    skipLevelOfDetail: boolean;
+    mostDetail: boolean;
+    loadSiblings: boolean;
+    loadAll: boolean;
+    maxRequests: number;
+    requestOrder: TileRequestOrder;
+    maxScreenSpaceError: number;
+    memoryAdjustedOverflow: number;
+    memoryAdjustedScreenSpaceError: boolean;
+    maxMemoryUsage: number;
 };
 
 export declare interface TilesetHeader {
+    tilesetUrl: string;
     asset: {
         version: string;
         tilesetVersion?: string;
@@ -3635,7 +4034,12 @@ export declare interface TilesetHeader {
      * @deprecated
      * 老数据，记录层高。现在记录在 tile 的 extra 中
      */
-    properties?: Record<string, any>;
+    properties?: {
+        floorInfo?: {
+            ground: number;
+            height: number;
+        }[];
+    };
     geometricError: number;
     root: TileHeader;
     rootMeta?: {
@@ -3691,7 +4095,7 @@ export declare interface TopviewControllerCustomInitArgs extends Omit<FloorplanC
 }
 
 export declare class Trajectory {
-    index: number;
+    id: string;
     name: string;
     tileset: Tileset;
     transform: THREE_2.Matrix4;
@@ -3705,7 +4109,7 @@ export declare class Trajectory {
         byteLength: number;
         memoryUsage: number;
     };
-    constructor(index: number, header: TrajectoryHeader, tileset: Tileset);
+    constructor(id: string, header: TrajectoryHeader, tileset: Tileset);
 }
 
 export declare type TrajectoryContentData = {
@@ -3729,17 +4133,11 @@ export declare class TrajectoryNode extends THREE_2.Object3D {
     contentObject: THREE_2.Object3D;
     private disposers;
     constructor(name: string, contentObject: THREE_2.Object3D, disposer?: () => void);
-    update(renderer: THREE_2.WebGLRenderer, camera: Camera, model: Model): void;
+    update(renderer: THREE_2.WebGLRenderer, camera: Camera, modelScene: ModelScene, trajectory: Trajectory, parameterValue: ParameterValue): boolean;
     dispose(): void;
     clone(): this;
 }
 
-export declare interface VertexShaderChunks {
-    mainBefore: string;
-    mainStart: string;
-    mainEnd: string;
-}
-
 export declare enum VolumePlaneIntersect {
     Outside = -1,
     Intersecting = 0,
@@ -3791,6 +4189,8 @@ export declare class Work {
     model?: WorkModel;
     /** 全景点位信息 */
     observers: WorkObserver[];
+    /** 全景点位包围盒 */
+    observerBox: THREE_2.Box3;
     /** 数据签发人 */
     issuer: string;
     /** 位姿修正 */
@@ -3835,16 +4235,12 @@ export declare interface WorkCubeImage {
     front: string;
     /** 全景图 back */
     back: string;
-    /** 分辨率表 */
-    sizeList?: number[];
 }
 
 /** 全景图 */
 export declare interface WorkImage extends WorkCubeImage {
-    /** 光照强度图 */
-    luminance?: WorkCubeImage & {
-        tiles?: WorkTile[];
-    };
+    /** 分辨率表 */
+    sizeList?: number[];
     /** 瓦片信息 */
     tiles?: WorkTile[];
 }
@@ -3929,14 +4325,25 @@ export declare interface WorkObserver {
     position: THREE_2.Vector3;
     /** 点位和模型的旋转对齐关系四元数 */
     quaternion: THREE_2.Quaternion;
+    /** 点位和模型的旋转对齐关系矩阵 */
+    matrix: THREE_2.Matrix4;
+    /** 点位和模型的地面坐标 */
+    getResolvedStandingPosition(target: THREE_2.Vector3): typeof target;
+    /** 点位和模型的观察点坐标 */
+    getResolvedPosition(target: THREE_2.Vector3): typeof target;
+    /** 点位和模型的旋转对齐关系四元数 */
+    getResolvedQuaternion(target: THREE_2.Quaternion): typeof target;
+    /** 点位和模型的旋转对齐关系矩阵 */
+    getResolvedMatrix(target: THREE_2.Matrix4): typeof target;
 }
 
-export declare interface WorkResolvedObserver extends WorkObserver {
+export declare interface WorkResolvedObserver extends Omit<WorkObserver, 'getResolvedStandingPosition' | 'getResolvedPosition' | 'getResolvedQuaternion' | 'getResolvedMatrix'> {
     isResolved: true;
 }
 
 export declare type Works = ReadonlyArray<Work> & {
     resolvedObservers: WorkResolvedObserver[];
+    resolvedObserverBox: THREE_2.Box3;
     initial: WorkInitial;
     getWork(workCode: string): Work | undefined;
     getResolvedObserver(pano: PanoId | Pano | number): WorkResolvedObserver | undefined;
@@ -3950,16 +4357,13 @@ export declare interface WorksEvent extends BaseEvent {
     userAction: boolean;
 }
 
-export declare interface WorkTile {
+export declare interface WorkTile extends WorkCubeImage {
+    /** 层级 */
     level: number;
+    /** 尺寸 */
     size: number;
+    /** 缩放比例 */
     scale: number;
-    up: string;
-    down: string;
-    right: string;
-    left: string;
-    front: string;
-    back: string;
 }
 
 /** 全景视频贴片 */