@realsee/five 5.0.0-alpha.99 → 6.0.0-alpha.1

package/five/index.d.ts

@@ -1,13 +1,18 @@
 import * as THREE_2 from 'three';
 
 export declare interface AddableObject extends THREE_2.Object3D {
+    /** 是否需要渲染一次 */
     needsRender?: boolean;
+    /** 动画 */
     mixer?: THREE_2.AnimationMixer;
+    /** 设置当前分辨率 */
     setResolution?(width: number, height: number): void;
+    /** 设置当前时间 */
+    setTime?(time: number): void;
 }
 
 export declare interface AnimationFrame {
-    callback: (time: number, deltaTime: number) => void;
+    callback: (time: number, deltaTime: number, ...args: any[]) => void;
     once: boolean;
     delay: number;
     order: number;
@@ -17,11 +22,17 @@ export declare class AnimationFrameLoop {
     private frames;
     private time;
     private stoped;
+    private context?;
+    private requestId;
     private static sharedInstance?;
     static get shared(): AnimationFrameLoop;
     static getFrameTime(): number;
     constructor();
     private loop;
+    setContext(context: any): void;
+    getContext(): any;
+    private requestAnimationFrame;
+    private cancelAnimationFrame;
     private remove;
     /**
      * 添加到动画循环
@@ -35,6 +46,48 @@ export declare class AnimationFrameLoop {
     disponse(): void;
 }
 
+export declare interface BoundingVolume {
+    type: 'box' | 'sphere' | 'regin';
+    applyMatrix4(matrix: THREE_2.Matrix4): this;
+    getBoundingBox(target: THREE_2.Box3): THREE_2.Box3;
+    toGeometry(): THREE_2.BufferGeometry;
+    getCenter(result: THREE_2.Vector3): THREE_2.Vector3;
+    distanceSquaredTo(point: THREE_2.Vector3): number;
+    distanceTo(point: THREE_2.Vector3): number;
+    intersectPlane(plane: THREE_2.Plane): VolumePlaneIntersect;
+    intersectRay(ray: THREE_2.Ray): boolean;
+    clone(): BoundingVolume;
+    copy(boundingVolume: this): this;
+    fromJson(json: any): this;
+    toJson(): BoundingVolumeJson;
+}
+
+export declare type BoundingVolumeJson = RegionBoundingVolumeJson | BoxBoundingVolumeJson | SphereBoundingVolumeJson;
+
+export declare class BoxBoundingVolume implements BoundingVolume {
+    type: "box";
+    center: THREE_2.Vector3;
+    halfSize: THREE_2.Vector3;
+    rotation: THREE_2.Matrix3;
+    constructor();
+    fromJson({ box }: BoxBoundingVolumeJson): this;
+    toJson(): BoxBoundingVolumeJson;
+    copy(boxBoundingVolume: BoxBoundingVolume): this;
+    clone(): BoxBoundingVolume;
+    applyMatrix4(matrix: THREE_2.Matrix4): this;
+    getCenter(result: THREE_2.Vector3): THREE_2.Vector3;
+    distanceSquaredTo(point: THREE_2.Vector3): number;
+    distanceTo(point: THREE_2.Vector3): number;
+    getBoundingBox(target: THREE_2.Box3): THREE_2.Box3;
+    toGeometry(): THREE_2.BufferGeometry;
+    intersectPlane(plane: THREE_2.Plane): VolumePlaneIntersect;
+    intersectRay(ray: THREE_2.Ray): boolean;
+}
+
+export declare type BoxBoundingVolumeJson = {
+    box: number[];
+};
+
 export declare class BVH {
     trianglesArray?: Float32Array;
     offsetArray?: Uint32Array;
@@ -49,6 +102,7 @@ export declare class BVH {
      * @return 碰撞焦点数组
      */
     intersectRay(rayOrigin: BVHVector3, rayDirection: BVHVector3, backfaceCulling: boolean): BVHIntersect[];
+    trianglesInSphere(center: BVHVector3, radius: number): Float32Array;
     dispose(): void;
 }
 
@@ -92,16 +146,44 @@ export declare class BVHVector3 {
 }
 
 /** Five 相机 */
-export declare class Camera extends THREE_2.PerspectiveCamera {
+export declare class Camera extends THREE_2.Camera {
+    fov: number;
+    aspect: number;
+    near: number;
+    far: number;
+    perspToOrtho: THREE_2.Vector2;
+    orthoDistance: number;
     /** 相机姿态 */
     pose: CameraPose;
-    constructor(fov: number);
+    private perspectiveCamera;
+    private orthographicCamera;
+    needsRender: boolean;
+    private lastValues;
+    constructor(fov: number, aspect?: number, near?: number, far?: number, perspToOrtho?: THREE_2.Vector2, orthoDistance?: number);
+    get zoom(): number;
+    get top(): number;
+    get bottom(): number;
+    get left(): number;
+    get right(): number;
+    getDirection(target: THREE_2.Vector3): THREE_2.Vector3;
     /** 通过相机参数反算姿态 */
-    computePose(): this;
+    computePose(distance?: number): this;
     /** 设置相机姿态 */
     setFromPose(pose: Partial<CameraPose>): this;
     /** 拷贝相机姿态 */
     copyPose(): CameraPose;
+    private computeProjectionMatrix;
+    setViewOffset(fullWidth: number, fullHeight: number, x: number, y: number, width: number, height: number): void;
+    clearViewOffset(): void;
+    updateProjectionMatrix(): void;
+    get perspectiveProjectionMatrix(): THREE_2.Matrix4;
+    get perspectiveProjectionMatrixInverse(): THREE_2.Matrix4;
+    get orthographicProjectionMatrix(): THREE_2.Matrix4;
+    get orthographicProjectionMatrixInverse(): THREE_2.Matrix4;
+    updateTime(_time: number, _deltaTime: number): void;
+    get isPerspectiveCamera(): boolean;
+    get isOrthographicCamera(): boolean;
+    copy(source: this, recursive?: boolean): this;
 }
 
 export declare interface CameraPose {
@@ -112,6 +194,22 @@ export declare interface CameraPose {
     offset: THREE_2.Vector3;
 }
 
+export declare class Clipper {
+    numPlanes: number;
+    clipperPlanes: Float32Array | null;
+    clipperFloors: number[] | null;
+    private static sharedInstance?;
+    static get shared(): Clipper;
+    constructor();
+    update(clipperParameters: ClipperParameter[], camera: THREE_2.Camera): void;
+    private projectPlanes;
+}
+
+export declare interface ClipperParameter {
+    clippingBoxMatrix: THREE_2.Matrix4;
+    floorIndex?: number;
+}
+
 export declare type ControllerCustomInitTypes = {
     Floorplan: FloorplanControllerCustomInitArgs;
     Topview: TopviewControllerCustomInitArgs;
@@ -119,23 +217,25 @@ export declare type ControllerCustomInitTypes = {
     VRPanorama: VRPanoramaControllerCustomInitArgs;
     Model: ModelControllerCustomInitArgs;
     DepthPanorama: DepthPanoramaControllerCustomInitArgs;
+    Mapview: MapviewControllerCustomInitArgs;
+    XRPanorama: XRPanoramaControllerCustomInitArgs;
 };
 
 export declare type ControllerEventTypes = {
     /**
      * 模态间切换动画开始
-     * @param panoIndex - 当前点位
+     * @param panoId - 当前点位
      * @param pose - 相机姿态
      * @param userAction - 是否用户触发
      */
-    initAnimationWillStart(panoIndex: number, pose: Pose, userAction: boolean): void;
+    initAnimationWillStart(panoId: WorkPanoId, pose: Pose, userAction: boolean): void;
     /**
      * 模态间切换动画结束
-     * @param panoIndex - 当前点位
+     * @param panoId - 当前点位
      * @param pose - 相机姿态
      * @param userAction - 是否用户触发
      */
-    initAnimationEnded(panoIndex: number, pose: Pose, userAction: boolean): void;
+    initAnimationEnded(panoId: WorkPanoId, pose: Pose, userAction: boolean): void;
     /**
      * 意图要变化相机的可视角度 可以通过 `return false` 阻止
      * @deprecated
@@ -170,43 +270,43 @@ export declare type ControllerEventTypes = {
     cameraDirectionUpdate(coordinates: Pick<Pose, "longitude" | "latitude">, userAction: boolean): void;
     /**
      * 观察点位被选择
-     * @param panoIndex - 选择的点位
+     * @param panoId - 选择的点位
      */
-    panoSelected(panoIndex: number | null): void;
+    panoSelected(panoId: WorkPanoId | null): void;
     /**
      * 意图要移动到某个点位 可以通过 `return false` 阻止
-     * @param panoIndex - 图要移动到的点位下标
+     * @param panoId - 图要移动到的点位
      * @param options - 移动参数
      * @param userAction - 是否用户触发
      * @returns 可以通过 `return false` 阻止
      */
-    wantsMoveToPano(panoIndex: number, options: MovePanoOptions, userAction: boolean): void | false;
+    wantsMoveToPano(panoId: WorkPanoId, options: MovePanoOptions, userAction: boolean): void | false;
     /**
      * 开始加载并移动到某个观察点位
      * @description
      * 可 panoWillArrive 相比
      * - moveToPano 在加载全景图资源前触发
      * - panoWillArrive 在加载全景图资源后触发
-     * @param panoIndex - 移动到的点位下标
+     * @param panoId - 移动到的点位
      * @param userAction - 是否用户触发
      */
-    moveToPano(panoIndex: number, userAction: boolean): void;
+    moveToPano(panoId: WorkPanoId, userAction: boolean): void;
     /**
      * 开始加载某个观察点的全景资源
-     * @param panoIndex - 移动到的点位下标
+     * @param panoId - 移动到的点位
      */
-    panoWillLoad(panoIndex: number): void;
+    panoWillLoad(panoId: WorkPanoId): void;
     /**
      * 某个观察点的全景资源加载完成
-     * @param panoIndex - 对应的点位下标
+     * @param panoId - 对应的点位
      */
-    panoLoaded(panoIndex: number): void;
+    panoLoaded(panoId: WorkPanoId): void;
     /**
      * 某个观察点的全景资源加载失败
      * @param error - 错误对象
-     * @param panoIndex - 对应的点位下标
+     * @param panoId - 对应的点位
      */
-    panoLoadError(error: Error, panoIndex: number): void;
+    panoLoadError(error: Error, panoId: WorkPanoId): void;
     /**
      * 移动到某个观察点位被取消
      * @description
@@ -214,34 +314,34 @@ export declare type ControllerEventTypes = {
      * - 移动过程中切换模态
      * - 移动过程中 five 被析构
      * - 移动过程点击切换到另一个点位
-     * @param panoIndex - 对应的点位下标
+     * @param panoId - 对应的点位
      */
-    moveToPanoCanceled(panoIndex: number): void;
+    moveToPanoCanceled(panoId: WorkPanoId): void;
     /**
      * 开始移动到某个观察点位
      * @description
      * 和 moveToPano 相比
      * - moveToPano 在加载全景图资源前触发
      * - panoWillArrive 在加载全景图资源后触发
-     * @param panoIndex - 移动到点位下标
+     * @param panoId - 移动到点位
      * @param pose - 相机姿态
      * @param userAction - 是否用户触发
      */
-    panoWillArrive(panoIndex: number, pose: Pose, userAction: boolean): void;
+    panoWillArrive(panoId: WorkPanoId, pose: Pose, userAction: boolean): void;
     /**
      * 移动到某个观察点位
-     * @param panoIndex - 移动到点位下标
+     * @param panoIndex - 移动到点位
      * @param pose - 相机姿态
      * @param userAction - 是否用户触发
      */
-    panoArrived(panoIndex: number, pose: Pose, userAction: boolean): void;
+    panoArrived(panoId: WorkPanoId, pose: Pose, userAction: boolean): void;
     /**
      * 移动中， 会告知移动状态（耗时百分比）
-     * @param panoIndex - 将要移动到的点位下标
-     * @param prevPanoIndex - 上一个点位下标
+     * @param panoId - 将要移动到的点位下标
+     * @param prevPanoId - 上一个点位下标
      * @param progress - 整个过程经度 [0-1]
      */
-    movingToPano(panoIndex: number, prevPanoIndex: number, progress: number): void;
+    movingToPano(panoId: WorkPanoId, prevPanoId: WorkPanoId, progress: number): void;
     /**
      * 意图要触发手势， 可以通过 `return false` 阻止
      * @param type - 手势类型
@@ -371,50 +471,68 @@ export declare type ControllerEventTypes = {
     vrWantsToExit(): void;
     /**
      * 观察点的全景资源开始加载
-     * @param panoIndex - 加载点位下标
-     * @param observer - 对应的 observer 详情
+     * @param panoId - 加载点位
      */
-    textureStartLoad(panoIndex: number, observer: WorkObserver): void;
+    textureStartLoad(panoId: WorkPanoId): void;
     /**
      * 观察点的全景资源加载中，可获取到进度
      * @param progress - 加载进度 [0-1]
-     * @param panoIndex - 加载点位下标
-     * @param observer - 对应的 observer 详情
+     * @param panoId - 加载点位下标
      */
-    textureLoading(progress: number, panoIndex: number, observer: WorkObserver): void;
+    textureLoading(progress: number, panoId: WorkPanoId): void;
     /**
      * 观察点的全景资源加载被中止
-     * @param panoIndex - 加载点位下标
-     * @param observer - 对应的 observer 详情
+     * @param panoId - 加载点位
      */
-    textureAbort(panoIndex: number, observer: WorkObserver): void;
+    textureAbort(panoId: WorkPanoId): void;
     /**
      * 观察点的全景资源加载失败
      * @param error - 错误对象
-     * @param panoIndex - 加载点位下标
-     * @param observer - 对应的 observer 详情
+     * @param panoId - 加载点位
      */
-    textureError(error: Error, panoIndex: number, observer: WorkObserver): void;
+    textureError(error: Error, panoId: WorkPanoId): void;
     /**
      * 观察点的全景资源加载完成
-     * @param panoIndex - 加载点位下标
-     * @param observer - 对应的 observer 详情
+     * @param panoId - 加载点位
      */
-    textureLoaded(panoIndex: number, observer: WorkObserver, meta: (NetWorkMeta | null)[]): void;
+    textureLoaded(panoId: WorkPanoId, meta: (NetWorkMeta | null)[]): void;
     /**
      * 抛出错误
      * @param error - 抛出错误
      */
     error(error: Error): void;
+    /**
+     * webXR模式开始，webxr session完成坐标系矫正
+     */
+    webXRSessionStart(): void;
+    /**
+     * webXR模式结束,webxr session销毁
+     */
+    webXRSessionEnd(): void;
+    /**
+     * axes代表控制杆，axes数组的0-1元素分别代表左控制器的左（-1）右（1）,左控制器的上（-1）下（1），axes数组的2-3元素同理
+     */
+    webXRControllerEvent(type: WebXRControllerType, key: WebXRControllerKey, params: WebXRControllerParams): void;
 };
 
+export declare class CullingVolume {
+    static get MASK_OUTSIDE(): number;
+    static get MASK_INSIDE(): number;
+    static get MASK_INDETERMINATE(): number;
+    planes: THREE_2.Plane[];
+    constructor(planes?: THREE_2.Plane[]);
+    setFromFrustum(frustum: THREE_2.Frustum): this;
+    computeVisibility(boundingVolume: BoundingVolume): VolumePlaneIntersect;
+    computeVisibilityWithPlaneMask(boundingVolume: BoundingVolume, parentPlaneMask: number): number;
+}
+
 /**
  * URL 地址的转换
- * @param url - url 原地址
+ * @param source - url 原地址
  * @param options - url 转换参数
  * @returns url 转换结果
  */
-export declare function defaultImageURLTransform(url: string, options: ImageURLOptions): string;
+export declare function defaultImageURLTransform(source: string, options: ImageURLOptions): string;
 
 export declare interface DepthPanoramaControllerCustomInitArgs extends PanoramaLikeControllerCustomInitArgs {
     /** 最远可移动观察点距离 */
@@ -427,7 +545,7 @@ export declare interface DepthPanoramaControllerCustomInitArgs extends PanoramaL
      */
     panoTapTriggerRadius?: number;
     /** 地面观察点标识自定义创建器 */
-    panoCircleMeshCreator?: () => PanoCircleMeshInterface;
+    panoCircleMeshCreator?: (panoId: WorkPanoId) => PanoCircleMeshInterface;
 }
 
 /**
@@ -452,62 +570,44 @@ export declare type EventTypes = Pick<ControllerEventTypes, typeof PROXY_CONTROL
     /**
      * 准备加载 Work 数据
      * @param input - 输入的 work
-     * @param work - 归一化的标准 work
+     * @param works - 归一化的标准 work
      * @param state - 加载时的姿态
      */
-    willLoad(input: any, work: Work, state: Omit<State, "offset">): void;
+    willLoad(input: any, works: Works, state: Partial<State>): void;
     /**
      * 开始加载 Work 数据
      * @param input - 输入的 work
-     * @param work - 归一化的标准 work
+     * @param works - 归一化的标准 work
      * @param state - 加载时的姿态
      */
-    load(input: any, work: Work, state: Omit<State, "offset">): void;
+    load(input: any, works: Works, state: Partial<State>): void;
     /**
      * 加载完 Work 数据
      * @param input - 输入的 work
-     * @param work - 归一化的标准 work
+     * @param works - 归一化的标准 work
      */
-    loaded(input: any, work: Work): void;
+    loaded(input: any, works: Works): void;
     /**
      * 模型开始加载
      * @param workModel - 归一化的标准 work 中的 model 值
      */
     modelWillLoad(workModel: WorkModel): void;
-    /**
-     * 模型三角面片结构加载完成
-     * @param model - 加载完的 model 本质是一个 {@link PBMGroup}
-     */
-    modelGeometryLoaded(model: Model): void;
-    /**
-     * 模型材质结构加载完成
-     * @param model - 加载完的 model 本质是一个 {@link PBMGroup}
-     */
-    modelMaterialLoaded(model: Model): void;
-    /**
-     * 模型 bvh树 计算完成
-     * @description
-     * bvh 树用于高效的碰撞检测，可以在 `model.bvh` 属性来设置是否开启。默认开启。
-     * bvh 树计算需要一定事件，可能会暂时影响一些性能。计算完毕后，会对碰撞检测带来质的提升。
-     * @param model - 加载完的 model 本质是一个 {@link PBMGroup}
-     */
-    modelBvhLoaded(model: Model): void;
     /**
      * 模型加载错误
      * @param error - 错误对象
-     * @param model - 加载完的 model 本质是一个 {@link PBMGroup}
+     * @param model - 加载完的 model
      */
     modelLoadError(error: Error, model: Model): void;
     /**
      * 模型加载完成
-     * @param model - 加载完的 model 本质是一个 {@link PBMGroup}
+     * @param models - 加载完的 model
      */
-    modelLoaded(model: Model): void;
+    modelLoaded(models: Models): void;
     /**
      * 模型楼层切换
      * @param shownFloor - 模型楼层
      */
-    modelShownFloorChange(shownFloor: number | null, totalFloorLength: number): void;
+    modelShownFloorChange(shownFloor: number | null): void;
     /**
      * 渲染循环
      * @param rendered - 是否渲染了
@@ -542,21 +642,21 @@ export declare type EventTypes = Pick<ControllerEventTypes, typeof PROXY_CONTROL
     stateSynced(state: State): void;
     /**
      * 意图要移动到某个点时, 可以通过 return false 阻止
-     * @param panoIndex - 意图要移动到点位下标
+     * @param panoId - 意图要移动到点位
      * @param options - 移动参数
      * @param userAction - 是否用户触发
      * @returns 可以通过 return false 阻止
      */
-    wantsMoveToPano(panoIndex: number, options: MovePanoOptions, userAction: boolean): void | false;
+    wantsMoveToPano(panoId: WorkPanoId, options: MovePanoOptions, userAction: boolean): void | false;
     /**
      * 同 wantsMoveToPano
      * @description
-     * @param panoIndex - 意图要移动到点位下标
+     * @param panoId - 意图要移动到点位
      * @param options - 移动参数
      * @param userAction - 是否用户触发
      * @returns 可以通过 return false 阻止
      */
-    wantsToMoveToPano(panoIndex: number, options: MovePanoOptions, userAction: boolean): void;
+    wantsToMoveToPano(panoId: WorkPanoId, options: MovePanoOptions, userAction: boolean): void;
     /**
      * 意图要切换到某个模态， 可以通过 return false 阻止
      * @param mode - 意图要切换到的模态
@@ -570,8 +670,9 @@ export declare type EventTypes = Pick<ControllerEventTypes, typeof PROXY_CONTROL
      * @param prevMode - 上本质是一个模态
      * @param panoIndex - 初始化动画结束后的点位下标
      * @param toPose - 初始化动画结束后的状态
+     * @param userAction - 是否用户触发
      */
-    modeChange(mode: Mode, prevMode: Mode, panoIndex: number, toPose: Pose): void;
+    modeChange(mode: Mode, prevMode: Mode, panoId: WorkPanoId, toPose: Pose, userAction: boolean): void;
     /**
      * 帮助元素显应的变换
      * @param visible - 帮助元素的是否开启
@@ -602,6 +703,9 @@ export declare type EventTypes = Pick<ControllerEventTypes, typeof PROXY_CONTROL
  * ```
  */
 export declare class Five extends Subscribe<EventTypes> {
+    static get version(): string;
+    static get dracoPath(): string;
+    static set dracoPath(path: string);
     /**
      * Five 的显示模式，可以通过 `five.changeMode` `five.setState` 来切换
      * @description
@@ -612,6 +716,7 @@ export declare class Five extends Subscribe<EventTypes> {
      * Topview 户型图模式
      * DepthPanorama 深度图游走模式
      * VRPanorama VR眼镜模式
+     * XRPanorama VR硬件模式
      * ```
      */
     static Mode: Mirror<Mode>;
@@ -627,9 +732,9 @@ export declare class Five extends Subscribe<EventTypes> {
      */
     paused: boolean;
     /** 当前点位序号 */
-    panoIndex?: number;
+    panoId: WorkPanoId;
     /** 当前展示的模式 */
-    currentMode?: Mode;
+    currentMode: Mode;
     /** 内部使用的 `THREE.Scene` */
     scene: Scene;
     /** 内部使用的 `Camera` */
@@ -654,7 +759,7 @@ export declare class Five extends Subscribe<EventTypes> {
      */
     renderer?: THREE_2.WebGLRenderer;
     /** 当前加载的模型 */
-    model: Model;
+    models: Models;
     /**
      * 是否需要渲染
      * @description
@@ -676,6 +781,12 @@ export declare class Five extends Subscribe<EventTypes> {
      * 平衡加载时间和图片质量
      */
     textureOptions: TextureOptions;
+    /**
+     * 模型lod的配置参数
+     * @description
+     * 可以配置加载模型lod的相关参数
+     */
+    modelLodOptions: ModelLodOptions;
     /**
      * 模型贴图的配置参数
      * @description
@@ -707,8 +818,11 @@ export declare class Five extends Subscribe<EventTypes> {
         [key: string]: FivePluginInstance<any>;
     };
     ident: string;
+    /** 包围盒子 */
+    private boundingMesh;
     private stopAnimationLoop?;
     private fps;
+    private modelGroup;
     private helperGroup;
     private modeChangeDuration;
     private onlyRenderIfNeeds;
@@ -717,7 +831,6 @@ export declare class Five extends Subscribe<EventTypes> {
     private destroyed;
     private stateSynced;
     private controllerInits;
-    private panoramaLikeSavedPose;
     private extraElements;
     private getPixelsRenderTarget;
     private readyCallbacks;
@@ -730,11 +843,31 @@ export declare class Five extends Subscribe<EventTypes> {
      */
     private _enableIOSEDR;
     private lastLoadWorkTask;
+    private requestProxy;
     private networkSubscribe;
-    private screenBuffer?;
+    private screenBuffers?;
     private analysis?;
     private renderSwitch01;
+    /**
+     * gpu_picking
+     */
+    private gpuPickingRenderTarget;
+    private meshReplaceMaterialMap;
+    private meshOriginMaterialMap;
+    private copyEffect;
     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
@@ -766,9 +899,17 @@ export declare class Five extends Subscribe<EventTypes> {
      */
     get enableIOSEDR(): boolean;
     set enableIOSEDR(enable: boolean);
+    /**
+     * 是否开启EDL模式
+     */
+    get enableEDL(): boolean;
+    set enableEDL(enable: boolean);
+    /**
+     * 是否开启后处理
+     */
     get enablePostProcessing(): boolean;
     set enablePostProcessing(enable: boolean);
-    updateConfiguration(args: Pick<FiveInitArgs, "panorama" | "model" | "floorplan" | "topview" | "depthPanorama" | "vrPanorama" | "imageOptions">): void;
+    updateConfiguration(args: Pick<FiveInitArgs, "panorama" | "model" | "floorplan" | "topview" | "mapview" | "depthPanorama" | "vrPanorama" | "imageOptions" | "textureOptions">): void;
     /**
      * 将显示区域加载到页面 DOM 中
      * @description
@@ -819,6 +960,17 @@ export declare class Five extends Subscribe<EventTypes> {
      * @returns Promise 是否移动成功
      */
     updateCamera(pose: Partial<Omit<Pose, "offset">>, duration: number, userAction?: boolean): Promise<void>;
+    /**
+     * 通过帧动画移动相机。（不触发点位移动）
+     * @description
+     * 如果动画中途被打断（用户触发行为，或者调用 setState, load, changeMode）的等
+     * 会 Promise.reject。运动完成则 Promise.resolve
+     * @param keyframes - 动画帧
+     * @param duration - 动画触发的时常
+     * @param userAction - 是否用户触发
+     * @returns Promise 是否移动成功
+     */
+    updateCameraWithKeyframes(keyframes: MotionKeyframe<Exclude<keyof Pose, "offset">>[], duration: number, userAction?: boolean): Promise<void>;
     /**
      * 获取当前相机经纬度
      * @deprecated 请使用使用 getPose
@@ -838,28 +990,10 @@ export declare class Five extends Subscribe<EventTypes> {
         phi: number;
         lookAtVector: THREE_2.Vector3;
     };
-    /**
-     * 初始化 initBasisLoader
-     * @description
-     * 同初始化的 initBasisLoader 参数。用于初始化 basisLoader。
-     * basisLoader 只会初始化一次，一旦初始化则不会再修改。
-     *
-     * @param transcoderResourcePath - basis 解析器路径
-     * 如果不设置，使用默认解析器 basis 解析器。
-     * 可以传入解析器的 `resourcePath`, 则使用指定的解析器
-     * @example
-     * ```
-     * // 使用默认解析器
-     * five.initialBasisLoader();
-     *
-     * // 使用指定解析器
-     * // 会调用这个目录下的 basis_transcoder.js basis_transcoder.wasm 文件作为解析器
-     * five.initialBasisLoader("https://vrlab-public.ljcdn.com/release/static/image/release/five/basis/");
-     * ```
-     */
-    initBasisLoader(transcoderResourcePath?: string): void;
     /** 当前加载的 work 数据 */
-    get work(): Work;
+    get works(): Works;
+    get work(): Work | undefined;
+    get model(): Model;
     /**
      * 加载 Work 数据
      * @param inputWork - Work 数据
@@ -869,7 +1003,7 @@ export declare class Five extends Subscribe<EventTypes> {
      *  - State 自定义姿态
      * @param duration - 切换时间
      */
-    load(inputWork: Work | LooseWork | any | Promise<Work | LooseWork | any>, state?: "inherit" | "initial" | Partial<Omit<State, "offset">>, duration?: number, userAction?: boolean): Promise<void>;
+    load(inputWork: string | Work | LooseWork | string[] | Work[] | LooseWork[] | LooseWorkWithExtrinsics[] | Promise<Work | LooseWork | Work[] | LooseWork[] | LooseWorkWithExtrinsics[]>, state?: "inherit" | "initial" | Partial<State>, duration?: number, userAction?: boolean): Promise<void>;
     private load_;
     /**
      * 切换模态
@@ -894,6 +1028,10 @@ export declare class Five extends Subscribe<EventTypes> {
      * 获取显示用的画布（Canvas DOM节点）
      */
     getElement(): HTMLCanvasElement | undefined;
+    /**
+     * 获取观测点
+     */
+    get observers(): WorkObserver[];
     /**
      * 强制渲染
      * @description
@@ -906,9 +1044,9 @@ export declare class Five extends Subscribe<EventTypes> {
      * @param callback - 渲染完成回调
      */
     render(callback?: () => void, updateObjectResolution?: boolean): THREE_2.WebGLRenderTarget;
-    updateTime(time: number, deltaTime: number): void;
+    updateTime(time: number, deltaTime: number, ...args: any[]): void;
     /**
-     * 但停自动播放
+     * 暂停自动播放
      */
     pause(): void;
     play(): void;
@@ -918,13 +1056,15 @@ export declare class Five extends Subscribe<EventTypes> {
      * @param options - 移动点位参数
      * @param userAction - 是否用户触犯
      */
-    moveToPano(panoIndex: number, options?: MovePanoOptions, userAction?: boolean): void;
+    moveToPano(panoId: WorkPanoId, options?: MovePanoOptions, userAction?: boolean): Promise<void>;
+    moveToPano(panoIndex: number, options?: MovePanoOptions, userAction?: boolean): Promise<void>;
     /**
      * 预加载点位图片资源
      * @param panoIndex - 观察点序号
      * @param callback - 加载完成回调, 并传递加载用时。
      * @returns 加载完成的 Promise 参数同 callback
      */
+    preloadPano(panoId: WorkPanoId, callback?: (costs: number) => void): Promise<number>;
     preloadPano(panoIndex: number, callback?: (costs: number) => void): Promise<number>;
     /**
      * 计算三维坐标对应到屏幕的二维坐标
@@ -965,16 +1105,28 @@ export declare class Five extends Subscribe<EventTypes> {
     setState(state: Partial<State>, immediately?: boolean, userAction?: boolean): void;
     aroundScissor(callback: () => void): void;
     private syncState;
-    ready(): Promise<void>;
+    /**
+     * 当前页面静态
+     */
+    ready(args?: {
+        tile?: boolean;
+    }): Promise<void>;
+    /**
+     * 请求全屏
+     */
     requestFullscreen(): void;
+    /**
+     * 退出全屏
+     */
     exitFullscreen(): void;
     private throwError;
     private loadModel;
     private commonParams;
-    private saveControllerPose;
     private applyController;
     /** 移除事件绑定 */
     private removeEventListeners;
+    /** 销毁GPU Picking 所用的材质 */
+    private diposeGPUPickingMaterial;
 }
 
 /** Five 初始化参数 */
@@ -1076,24 +1228,6 @@ export declare interface FiveInitArgs {
      * @default `false`
      */
     maxFps?: number | false;
-    /**
-     * 是否初始化 `basisLoader`。
-     * @description
-     * 当你需要加载 basis 格式图片时请启用。
-     * 如果设置为 `true` 使用默认解析器 basis 解析器。
-     * 如果要自定义，可以传入解析器的 `resourcePath`, 则使用指定的解析器
-     * @default `false`
-     * @example
-     * ```
-     * // 使用默认解析器
-     * initialBasisLoader: true
-     *
-     * // 使用指定解析器
-     * // 会调用这个目录下的 basis_transcoder.js basis_transcoder.wasm 文件作为解析器
-     * initialBasisLoader: "https://vrlab-public.ljcdn.com/release/static/image/release/five/basis/"
-     * ```
-     */
-    initialBasisLoader?: boolean | string;
     /**
      * 外挂视频对象。
      * @description
@@ -1110,15 +1244,19 @@ export declare interface FiveInitArgs {
     floorplan?: ControllerCustomInitTypes["Floorplan"];
     /** 户型图模式下的特定参数 */
     topview?: ControllerCustomInitTypes["Topview"];
+    /** 地图模式下的特定参数 */
+    mapview?: ControllerCustomInitTypes["Mapview"];
     /** 深度图游走模式下的特定参数 */
     depthPanorama?: ControllerCustomInitTypes["DepthPanorama"];
     /** VR眼镜模式下的特定参数 */
     vrPanorama?: ControllerCustomInitTypes["VRPanorama"];
+    /** XR眼镜模式下的特定参数 */
+    xrPanorama?: ControllerCustomInitTypes["XRPanorama"];
     /**
      * 模式间切换时的过度动画时间
      * @description
      * 单位毫秒
-     * @default `1000`
+     * @default `800`
      */
     modeChangeDuration?: number;
     /**
@@ -1131,6 +1269,26 @@ export declare interface FiveInitArgs {
      * 是否展示 powered by 如视
      */
     poweredByRealsee?: boolean;
+    /**
+     * 是否使用webgl2渲染执行环境, 默认值 false
+     */
+    webgl2?: boolean;
+    /**
+     * 是否开启模型裁切
+     */
+    localClippingEnabled?: boolean;
+    /**
+     * 请求代理
+     * @param url - 发起的请求
+     * @returns 返回的请求
+     */
+    requestProxy?(url: string): string | Promise<string>;
+    /**
+     * 模型lod相关的配置，maxDepth为加载的最大深度
+     */
+    modelLod?: {
+        maxDepth?: number;
+    };
 }
 
 /**
@@ -1161,8 +1319,6 @@ parameters: Parameters<T>[1]
 export declare type FivePluginInstance<T extends FivePlugin<any, any>> = ReturnType<T>;
 
 export declare interface FloorplanControllerCustomInitArgs {
-    /** 默认偏航角 */
-    defaultLongitude?: number;
     /** 默认俯仰角 */
     defaultLatitude?: number;
     /** 最大俯仰角 */
@@ -1175,6 +1331,8 @@ export declare interface FloorplanControllerCustomInitArgs {
     maxFov?: number;
     /** 最小相机可视角度 */
     minFov?: number;
+    /** 鼠标焦点环自定义创建器 */
+    intersectMeshCreator?: () => IntersectMeshInterface;
 }
 
 export declare type GestureTypes = "pan" | "tap" | "pinch" | "press" | "mouseWheel";
@@ -1198,34 +1356,61 @@ export declare interface ImageOptions {
     quality?: number;
     /** 图片格式参数 */
     format?: "jpg" | "png" | "heif" | "webp" | "avif";
+    /** 锐化参数 海外不支持 */
+    sharpen?: number;
+    mappings?: ImageURLMappings;
+}
+
+export declare function imageSupport(): Promise<{
+    avif: boolean;
+    webp: boolean;
+}>;
+
+export declare interface ImageURLMappings {
+    [publicDomain: string]: {
+        "type"?: string;
+        "pano": [string, string];
+        "tile": [string, string];
+        "model": [string, string];
+        "texture": [string];
+        "default": [string];
+    };
 }
 
 export declare interface ImageURLOptions {
+    /** 图片类型标识 */
     key: string;
-    basisLoaderInitialized: boolean;
+    /** 图片尺寸参数 尽量使用 2 的幂次 如 256 512 1024 */
     size?: number;
+    /** 图片质量参数(0-100) */
     quality?: number;
+    /** 图片格式参数 */
     format?: "jpg" | "png" | "heif" | "webp" | "avif";
+    /** 图片裁切 */
     cut?: [x: number, y: number, width: number, height: number];
+    /** 锐化参数 海外不支持 */
     sharpen?: number;
+    /** url匹配规则 */
+    mappings?: ImageURLMappings;
 }
 
 export declare class InternalWebGLRenderer extends THREE_2.WebGLRenderer {
-    constructor({ preserveDrawingBuffer, backgroundColor, backgroundAlpha, pixelRatio, antialias }: {
+    constructor({ preserveDrawingBuffer, backgroundColor, backgroundAlpha, pixelRatio, antialias, webgl2, }: {
         preserveDrawingBuffer?: boolean;
         backgroundColor?: number | THREE_2.Color;
         backgroundAlpha?: number;
         pixelRatio?: number;
         antialias?: boolean;
+        webgl2?: boolean;
     });
 }
 
 export declare interface Intersection {
     /** 焦点坐标 */
-    point: THREE_2.Vector3;
+    point: THREE.Vector3;
     /** 焦点面片 */
     face?: {
-        normal: THREE_2.Vector3;
+        normal: THREE.Vector3;
     } | null;
     /** 焦点距离 */
     distance: number;
@@ -1244,45 +1429,24 @@ export declare interface IntersectMeshInterface extends THREE_2.Object3D {
     dispose(): void;
 }
 
-export declare class LegacyPanoCircleMesh extends THREE_2.Object3D implements PanoCircleMeshInterface {
-    needsRender: boolean;
-    hitTestMesh: THREE_2.Mesh<THREE_2.BufferGeometry, THREE_2.MeshBasicMaterial>;
-    current: boolean;
-    loading: boolean;
-    disabled: boolean;
-    progress: number;
-    opacity: number;
-    private centerMesh;
-    private loadingMesh;
-    private progressMotion;
-    private opacityMotion;
-    private stopInterval?;
-    constructor();
-    setLoading(shown: boolean): void;
-    setDisabled(disabled: boolean): void;
-    setProgress(progress: number): void;
-    setOpacity(opacity: number): void;
-    setCurrent(current: boolean): void;
-    updateTime(time: number, deltaTime: number): void;
-    dispose(): void;
-}
-
 export declare type LooseWork = {
-    bvh?: boolean;
+    work_code?: string;
+    code?: string;
     modelAsync?: boolean;
     initial?: LooseWorkInitial;
     base_url?: string;
     model?: LooseWorkModel;
-    panorama: {
+    panorama?: {
         base_url?: string;
         pano_high_cube_base_url?: string;
         info?: LooseWorkPanorama[];
         list?: LooseWorkPanorama[];
     };
-    observers: LooseWorkObserver[];
+    observers?: LooseWorkObserver[];
 };
 
 export declare type LooseWorkInitial = {
+    mode?: string;
     pano_index?: number;
     pano?: number;
     longitude?: number;
@@ -1291,9 +1455,23 @@ export declare type LooseWorkInitial = {
 };
 
 export declare type LooseWorkModel = {
-    file_url: string;
+    file_url?: string;
     material_textures?: string[];
     material_base_url?: string;
+    tiles?: {
+        type?: 'point_cloud' | 'mesh' | string;
+        name?: string;
+        up_axis?: string;
+        tileset_url: string;
+    };
+    layers?: [
+        {
+        type?: 'point_cloud' | 'mesh' | string;
+        name?: string;
+        up_axis?: string;
+        tileset_url: string;
+    }
+    ];
 };
 
 export declare type LooseWorkObserver = {
@@ -1341,6 +1519,36 @@ export declare type LooseWorkVideo = {
     size: number[];
 };
 
+export declare type LooseWorkWithExtrinsics = {
+    work: LooseWork;
+    debug?: boolean;
+    /** 位姿 */
+    transform?: number[];
+    /** 可视区域 */
+    viewerRequestVolume?: BoundingVolumeJson;
+    /** 模型显示最大细化层级 */
+    modelMaxLevelOfDetail?: number;
+    /** 模型最大内存缓存 */
+    modelMaxMemoryUsage?: number;
+    /** 模型网络最大请求并发数 */
+    modelMaxRequests?: number;
+    /** 模型屏幕空间误差计算最大值 */
+    modelMaxScreenSpaceError?: number;
+};
+
+export declare interface MapviewControllerCustomInitArgs {
+    /** 默认俯仰角 */
+    defaultLatitude?: number;
+    /** 默认相机距离 */
+    defaultDistance?: number;
+    /** 最大俯仰角 */
+    maxLatitude?: number;
+    /** 最小俯仰角 */
+    minLatitude?: number;
+    /** 鼠标焦点环自定义创建器 */
+    intersectMeshCreator?: () => IntersectMeshInterface;
+}
+
 export declare type Mirror<T extends string> = Record<T, T>;
 
 /**
@@ -1349,6 +1557,7 @@ export declare type Mirror<T extends string> = Record<T, T>;
  * - **Model**: 模型游走模式
  * - **Floorplan**: 模型查看模式
  * - **Topview**: 户型图模式
+ * - **Mapview**: 地图模式
  * - **DepthPanorama**: 深度图游走模式
  * - **VRPanorama**: VR眼镜模式
  */
@@ -1357,6 +1566,8 @@ export declare type Mode =
 "Floorplan" | 
 /** 户型图模式 */
 "Topview" | 
+/** 地图模式 */
+"Mapview" | 
 /** 全景图游走模式 */
 "Panorama" | 
 /** VR眼镜模式 */
@@ -1364,7 +1575,9 @@ export declare type Mode =
 /** 模型游走模式 */
 "Model" | 
 /** 深度图游走模式 */
-"DepthPanorama";
+"DepthPanorama" | 
+/** XR眼镜模式*/
+"XRPanorama";
 
 /**
  * Five 模型
@@ -1374,98 +1587,94 @@ export declare type Mode =
  * 需要满足 your/path/filename.at3d.json_xxxxxx,
  * 通过 json_xxxxxx(<dataURL>) 方式返回。
  */
-export declare class Model extends PBMContainer implements Subscribe<ModelEventType> {
-    /** 是否加载完成 */
-    loaded: boolean;
-    /** 是否未加载 */
-    empty: boolean;
+export declare class Model extends THREE_2.Object3D {
+    /** work */
+    work: Work | null;
+    /** 模型的不同图层 */
+    viewLayers: {
+        name: string;
+        type: string;
+        upAxis: string;
+        coordinates: string;
+        scene: Tile3DModel;
+    }[];
+    onError: (error: Error) => void;
+    onShownFloorChange: (floorIndex: number | null) => void;
     /** 外接盒子的大小 */
     bounding: THREE_2.Box3;
     /** 当前显示的楼层 */
     shownFloor: number | null;
     /** 楼层的数量 */
     floorLength: number;
-    /**
-     * 判断是否注册了事件
-     * 具体可查看 {@link Subscribe.hasListener}
-     */
-    hasListener: SubscribeMixinType.hasListener<ModelEventType>;
-    /**
-     * 注册事件
-     * 具体可查看 {@link Subscribe.on}
-     */
-    on: SubscribeMixinType.on<ModelEventType>;
-    /**
-     * 注册事件(是否只执行一次)
-     * 具体可查看 {@link Subscribe.once}
-     */
-    once: SubscribeMixinType.once<ModelEventType>;
-    /**
-     * 解除事件
-     * 具体可查看 {@link Subscribe.off}
-     */
-    off: SubscribeMixinType.off<ModelEventType>;
-    /**
-     * 触发事件
-     * 具体可查看 {@link Subscribe.emit}
-     */
-    emit: SubscribeMixinType.emit<ModelEventType>;
-    /** bvh 树的计算结果 */
-    bvhs: BVH[] & {
-        loaded: boolean;
-    };
-    /** 网络跟踪 */
-    private networkSubscribe?;
-    /** 安全域名 */
-    private allowHosts?;
+    /** 材质贴图参数 */
+    textureOptions: TextureOptions;
+    /** 模型是否已经细化 */
+    refined: boolean;
+    /** 模型已经加载 */
+    loaded: boolean;
+    /** 当前样式参数 */
+    materialVersion: string;
+    private _materialValues;
+    private _materialVersionMap;
+    private _floorIndex;
+    private _clippers;
+    /** 样式缓存 */
+    private cache;
+    needsRender: boolean;
+    private disposed;
     constructor(options?: {
-        networkSubscribe?: NetworkSubscribe;
-        allowHosts?: string[];
+        onError?: (error: Error) => void;
+        onShownFloorChange?: (floorIndex: number | null) => void;
     });
+    get empty(): boolean;
+    /** 获取材质参数 */
+    getMaterial(): ModelMaterialValues;
+    /** 设置材质参数 */
+    setMaterial(values: Partial<ModelMaterialValues>): void;
     /**
      * 当前显示的楼层
-     * @deprecated
-     * 请用 shwonFloor 代替
-     */
-    get shownfloor(): number | null;
-    /**
-     * 获取模型边界线
-     * @param threshold - 面片间夹角阈值
-     * @returns 所有模型边界线
      */
-    getEdges(threshold?: number): THREE_2.Line3[];
+    get shownfloor(): PBMParameters['floorIndex'] | null;
+    set shownfloor(floorIndex: PBMParameters['floorIndex'] | null);
     /**
-     * 获取当前楼层数
-     * @deprecated
-     * 请使用 floorLength 参数代替
+     * 裁切
      */
-    hasFloors(): number;
-    private hasFloors_;
+    get clippers(): PBMParameters['clippers'];
+    set clippers(clippers: PBMParameters['clippers']);
     /**
      * 显示某楼层
      * @example
      * ```
      * model.show() //显示全部楼层
      * model.show(1) //显示第一楼层
-     * model.show(1, 0) //显示第一楼层, 并且其他楼层透明度为 0
      * ```
      */
-    show(): void;
-    show(floorIndex: number, hiddenOpacity?: number): void;
+    show(floorIndex?: number | null): void;
+    /**
+     * 获取模型边界线
+     * @param sphere - 获取区域
+     * @param threshold - 面片间夹角阈值
+     * @returns 所有模型边界线
+     */
+    getEdgesBySphere(sphere: THREE_2.Sphere, threshold?: number): THREE_2.Line3[];
     /**
      * 计算模型射线碰撞检测
      * @param raycaster - THREE 射线对象
      * @param floors - 和某一楼层做碰撞检测， 不传为和所有楼层做碰撞检测
      * @returns 返回碰撞
      */
-    intersectRaycaster(raycaster: THREE_2.Raycaster, floors?: number | number[]): Intersection[];
-    buildBVH(): void;
+    intersectRaycaster(raycaster: THREE_2.Raycaster): Intersection[];
     /**
      * 加载模型
-     * @param workModel - work 的 model 内容
+     * @param work - work 的
      * @param imageOptions - 图片参数
      */
-    load(workModel: WorkModel, textureOptions?: TextureOptions): Promise<void>;
+    load(work: Work, options?: {
+        networkSubscribe?: NetworkSubscribe;
+        requestProxy?: (url: string) => string | Promise<string>;
+        textureOptions?: TextureOptions;
+    }): Promise<void>;
+    update(renderer: THREE_2.WebGLRenderer, camera: Camera, mode: Mode): void;
     /**
      * 析构函数
      * @description
@@ -1477,45 +1686,31 @@ export declare class Model extends PBMContainer implements Subscribe<ModelEventT
 export declare interface ModelControllerCustomInitArgs extends PanoramaLikeControllerCustomInitArgs {
 }
 
-/**
- * Five 模型事件列表
- * @description
- * 可以通过 `five.model.on(METHOD_NAME, METHOD)` 调用
- */
-export declare interface ModelEventCallback extends ModelEventType {
+export declare interface ModelLodOptions {
+    maxDepth?: number;
 }
 
-/**
- * 模型事件列表
- * @description
- * 具体事件列表 请查看 {@link ModelEventCallback}
- */
-export declare type ModelEventType = {
-    /**
-     * 模型 bvh树 计算完成
-     * @description
-     * bvh 树用于高效的碰撞检测，可以在 `model.bvh` 属性来设置是否开启。默认开启。
-     * bvh 树计算需要一定事件，可能会暂时影响一些性能。计算完毕后，会对碰撞检测带来质的提升。
-     */
-    bvhLoaded(): void;
-    /** 模型三角面片结构加载完成 */
-    geometryLoaded(): void;
-    /** 模型材质结构加载完成 */
-    materialLoaded(): void;
-    /** 模型加载完成 */
-    loaded(): void;
-    /**
-     * 显示楼层改变
-     * @param shownFloor - 显示的楼层
-     */
-    shownFloorChange(shownFloor: number | null, totalFloorLength: number): void;
-    /**
-     * 内部错误
-     * @param error - 错误对象
-     */
-    error(error: Error): void;
+export declare type ModelMaterialValues = Pick<PBMParameters, 'pano0' | 'pano1' | 'modelAlpha' | 'progress' | 'useBlackTransition' | 'opacity' | 'constantColor' | 'useEDL' | 'pointShape' | 'pointColorType' | 'pointSizeType' | 'pointSize' | 'pointMinSize' | 'pointMaxSize' | 'pointSizeAdaptiveScale' | 'gradientTexture'>;
+
+export declare type Models = Model[] & {
+    needsRender: boolean;
+    bounding: THREE_2.Box3;
+    loaded: boolean;
+    refined: boolean;
+    intersectRaycaster(raycaster: THREE_2.Raycaster): Intersection[];
+    setMaterial(values: Partial<ModelMaterialValues>): void;
+    getMaterial(): ModelMaterialValues;
+    update(renderer: THREE_2.WebGLRenderer, camera: Camera, mode: Mode): void;
 };
 
+export declare interface MotionKeyframe<K extends string> {
+    progress: number;
+    value: MotionValue<K>;
+    key?: string;
+}
+
+export declare type MotionValue<K extends string> = Record<K, number>;
+
 /**
  * 点位移动参数
  */
@@ -1527,9 +1722,10 @@ export declare interface MovePanoOptions extends Partial<Omit<Pose, "offset">> {
      * @description
      * - `fly` 通过相机移动方式变化
      * - `fade` 通过渐变方式变化
+     * - `montage` 通过渐变穿插到黑屏方式变化
      * - `instant` 通过插入黑屏方式变化
      */
-    effect?: "fly" | "fade" | "instant";
+    effect?: "fly" | "fade" | "montage" | "instant";
     /**
      * 运动耗时
      * @description
@@ -1541,9 +1737,9 @@ export declare interface MovePanoOptions extends Partial<Omit<Pose, "offset">> {
     /** 运动曲线函数 */
     easing?: (k: number) => number;
     /** 运动开始回调 */
-    moveStartCallback?: (panoIndex: number, toPose: Pose) => void;
+    moveStartCallback?: (panoId: WorkPanoId, toPose: Pose) => void;
     /** 运动结束回调 */
-    moveEndCallback?: (panoIndex: number, pose: Pose) => void;
+    moveEndCallback?: (panoId: WorkPanoId, pose: Pose) => void;
     /**
      * 运动被取消回调
      * @description
@@ -1556,6 +1752,7 @@ export declare interface MovePanoOptions extends Partial<Omit<Pose, "offset">> {
 }
 
 export declare type NetWorkMeta = {
+    origin: string;
     source: string;
     headers: {
         [name: string]: string;
@@ -1566,7 +1763,23 @@ export declare type NetWorkMeta = {
     size?: number;
 };
 
-export declare type NetworkState = "ok" | "preload" | "error" | "timeout" | "forbidden";
+export declare interface NetworkOptions {
+    /** 超时时间 */
+    timeout?: number;
+    /** 请求代理 */
+    requestProxy?: (url: string) => string | Promise<string>;
+    /** 网络消息追踪 */
+    networkSubscribe?: NetworkSubscribe;
+    /** 安全域名 */
+    allowHosts?: string[];
+}
+
+export declare type NetworkResponse<T = any, E extends NetWorkMeta | NetWorkMeta[] = NetWorkMeta> = {
+    body: T;
+    meta: E;
+};
+
+export declare type NetworkState = "ok" | "preload" | "error" | "proxy-error" | "timeout" | "forbidden";
 
 export declare class NetworkSubscribe extends Subscribe<{
     network(source: string, type: NetworkType, state: NetworkState, detail: string): void;
@@ -1577,22 +1790,22 @@ export declare type NetworkType = "XMLHttpRequest" | "Script" | "Image" | "Link"
 
 export declare class PanoCircleMesh extends THREE_2.Object3D implements PanoCircleMeshInterface {
     needsRender: boolean;
-    private loadingMesh;
-    private disableMesh;
-    private centerMesh;
-    private ringMesh;
-    private progressMesh;
-    private ringRotateMotion;
+    private currentStartTime;
+    private currentMotion;
+    private ringMotion;
     private tapMotion;
+    private loadingOpacityMotion;
     private progressMotion;
     private progressOpacityMotion;
     private opacityMotion;
+    private disableMotion;
     progress: number;
     opacity: number;
     current: boolean;
     loading: boolean;
     disabled: boolean;
-    constructor();
+    private panoMesh;
+    constructor(options?: PanoCircleMeshOptions);
     setProgress(progress: number): void;
     setOpacity(opacity: number): void;
     setCurrent(current: boolean): void;
@@ -1603,6 +1816,44 @@ export declare class PanoCircleMesh extends THREE_2.Object3D implements PanoCirc
     dispose(): void;
 }
 
+export declare class PanoCircleMeshCustom extends THREE_2.Object3D implements PanoCircleMeshInterface {
+    needsRender: boolean;
+    private currentStartTime;
+    private currentMotion;
+    private tapMotion;
+    private loadingOpacityMotion;
+    private progressMotion;
+    private progressOpacityMotion;
+    private opacityMotion;
+    private disableMotion;
+    progress: number;
+    opacity: number;
+    current: boolean;
+    loading: boolean;
+    disabled: boolean;
+    private panoMesh;
+    constructor(options?: PanoCircleMeshCustomOptions);
+    setProgress(progress: number): void;
+    setOpacity(opacity: number): void;
+    setCurrent(current: boolean): void;
+    setLoading(loading: boolean): void;
+    setDisabled(disabled: boolean): void;
+    tap(): Promise<void>;
+    updateTime(time: number, deltaTime: number): void;
+    dispose(): void;
+}
+
+export declare interface PanoCircleMeshCustomOptions {
+    scale?: number;
+    color?: number;
+    map?: THREE_2.Texture;
+    mapAlpha?: number;
+    borderWidth?: number;
+    borderColor?: number;
+    mapUseColor?: boolean;
+    mapUseReverse?: boolean;
+}
+
 /**
  * 地面提示点位接口
  *
@@ -1636,6 +1887,43 @@ export declare interface PanoCircleMeshInterface extends THREE_2.Object3D {
     dispose(): void;
 }
 
+export declare interface PanoCircleMeshOptions {
+    scale?: number;
+    color?: number;
+}
+
+export declare class PanoCircleMeshSolid extends THREE_2.Object3D implements PanoCircleMeshInterface {
+    needsRender: boolean;
+    private currentStartTime;
+    private currentMotion;
+    private tapMotion;
+    private loadingOpacityMotion;
+    private progressMotion;
+    private progressOpacityMotion;
+    private opacityMotion;
+    private disableMotion;
+    progress: number;
+    opacity: number;
+    current: boolean;
+    loading: boolean;
+    disabled: boolean;
+    private panoMesh;
+    constructor(options?: PanoCircleMeshSolidOptions);
+    setProgress(progress: number): void;
+    setOpacity(opacity: number): void;
+    setCurrent(current: boolean): void;
+    setLoading(loading: boolean): void;
+    setDisabled(disabled: boolean): void;
+    tap(): Promise<void>;
+    updateTime(time: number, deltaTime: number): void;
+    dispose(): void;
+}
+
+export declare interface PanoCircleMeshSolidOptions {
+    scale?: number;
+    color?: number;
+}
+
 export declare interface PanoramaControllerCustomInitArgs extends PanoramaLikeControllerCustomInitArgs {
     /** 最远可移动观察点距离 */
     maxAccessibleDistance?: number;
@@ -1647,13 +1935,19 @@ export declare interface PanoramaControllerCustomInitArgs extends PanoramaLikeCo
      */
     panoTapTriggerRadius?: number;
     /** 地面观察点标识自定义创建器 */
-    panoCircleMeshCreator?: () => PanoCircleMeshInterface;
+    panoCircleMeshCreator?: (panoId: WorkPanoId) => PanoCircleMeshInterface;
+    /**
+     * 全景瓦片登记
+     * @param fov - 当前 fov
+     * @param viewSize - 当前绘制区域大小
+     * @returns 返回瓦片等级
+     */
     tileLevelForFov?: false | ((fov: number, viewSize: THREE_2.Vector2) => number);
+    /** 是否开启光照自适应效果 */
+    luminanceAdaptiveEffectEnable?: boolean;
 }
 
 export declare interface PanoramaLikeControllerCustomInitArgs {
-    /** 默认相机偏航角 */
-    defaultLongitude?: number;
     /** 默认相机俯仰角 */
     defaultLatitude?: number;
     /** 最大相机俯仰角 */
@@ -1682,46 +1976,77 @@ export declare interface PanoramaLikeControllerCustomInitArgs {
  * @param options - 配置参数， 可以在此二次设置 baseURL 等参数
  * @returns - 签署过的 Work 数据结构
  */
-export declare function parseWork(obj: Work | LooseWork | string | any, options?: ParseWorkOptions, urlTransform?: (origin: string, absolute: string, relative: string, type: "panorama" | "texture" | "model") => void): Work;
+export declare function parseWork(obj: Work | LooseWork | string | any, options?: ParseWorkOptions): Work;
 
 export declare type ParseWorkOptions = {
-    /** 重写 work 中的资源前缀 */
+    /** 重写资源前缀 */
     baseURL?: string;
-    /** work 中的资源地址使用短地址 */
+    /** 资源地址使用短地址 */
     shortPath?: boolean;
-    /** work 中的资源使用 jsonp 方式发布 */
+    /** 资源使用 jsonp 方式发布 */
     jsonp?: boolean;
-    /** work 中模型是否计算bvh碰撞数，默认计算 true */
-    modelBvh?: boolean;
+    /** 调试 */
+    debug?: boolean;
+    /** 位姿 */
+    transform?: THREE_2.Matrix4 | number[];
+    /** 可视区域 */
+    viewerRequestVolume?: BoundingVolume | BoundingVolumeJson;
+    /** 模型显示最大细化层级 */
+    modelMaxLevelOfDetail?: number;
+    /** 模型最大内存缓存 */
+    modelMaxMemoryUsage?: number;
+    /** 模型网络最大请求并发数 */
+    modelMaxRequests?: number;
+    /** 模型屏幕空间误差计算最大值 */
+    modelMaxScreenSpaceError?: number;
 };
 
 /** PBM 模型组 */
 export declare class PBMContainer extends THREE_2.Group {
+    pbmMaterialParametersVersion: number;
     /** 是否需要更新按需渲染 */
     needsRender: boolean;
-    private enableTransparent;
-    /** 获取是否有透明参数 */
-    getTransparent(): boolean;
-    /** 设置透明参数 */
-    setTransparent(bool: boolean): void;
+    /** 当前样式参数 */
+    materialParameters: PBMParameters;
+    cache: PBMMaterialReferenceCache;
+    constructor();
     /** 获取材质参数 */
-    getMaterial(): PBMParameters | null;
+    getMaterial(): PBMParameters;
     /** 设置材质参数 */
     setMaterial(parameters: Partial<PBMParameters>): void;
+    update(renderer: THREE_2.WebGLRenderer, camera: Camera): void;
     /** 析构材质 */
-    disposeMaterial(): void;
-    /** 析构模型网格 */
-    disposeGeometry(): void;
+    dispose(): void;
 }
 
 /** PBM 模型组 */
-export declare class PBMGroup extends PBMContainer {
-    /** 楼层序号 */
-    floorIndex: number;
+export declare class PBMGroup extends THREE_2.Group {
+    needsRender: boolean;
+}
+
+export declare class PBMMaterialReferenceCache {
+    cache: Record<string, {
+        count: number;
+        value: any;
+        dispose: () => void;
+    }>;
+    clear(): void;
+    get<T>(key: string, create: () => {
+        value: T;
+        dispose: () => void;
+    }): T;
+}
+
+/** PBM 对象 */
+export declare class PBMMesh extends THREE_2.Mesh<THREE_2.BufferGeometry, PBMMeshMaterial[]> {
+    /** 是否需要更新按需渲染 */
+    needsRender: boolean;
 }
 
 /** PBM 材质 */
-export declare class PBMMaterial extends THREE_2.ShaderMaterial implements PBMParameters {
+export declare class PBMMeshMaterial extends THREE_2.ShaderMaterial implements PBMParameters {
+    /** 更新版本 */
+    pbmMaterialParametersVersion: number;
     /** 起始点 */
     pano0: PBMPanoPicture | null;
     /** 结束点 */
@@ -1732,26 +2057,41 @@ export declare class PBMMaterial extends THREE_2.ShaderMaterial implements PBMPa
     progress: number;
     /** 全景图通过过度黑色混合 */
     useBlackTransition: boolean;
-    perspToOrtho: number;
     /** 模型透明度 */
     opacity: number;
-    originOpacity: number;
-    constructor(parameters?: Partial<PBMParameters>);
-}
-
-/** PBM 对象 */
-export declare class PBMMesh extends THREE_2.Mesh<THREE_2.BufferGeometry, PBMMaterial[]> {
-    /** 楼层序号 */
+    /** 模型颜色*/
+    constantColor: THREE_2.Vector3 | null;
+    /** 楼层参数*/
     floorIndex: number;
-    /** 是否需要更新按需渲染 */
-    needsRender: boolean;
+    /** 对外模型裁切参数*/
+    clippers: ClipperParameter[] | null;
+    /** edl*/
+    useEDL: boolean;
+    /** 点云着色方式*/
+    pointColorType: PBMPointColorType;
+    /** 点云大小绘制方式*/
+    pointSizeType: PBMPointSizeType;
+    /** 点云形状*/
+    pointShape: PBMPointShapeType;
+    /** 点云基础大小*/
+    pointSize: number;
+    /** 自适应点云大小因子*/
+    pointSizeAdaptiveScale: number;
+    /** 点云最大尺寸*/
+    pointMinSize: number;
+    /** 点云最小尺寸*/
+    pointMaxSize: number;
+    /** 高程彩色图*/
+    gradientTexture: THREE_2.Texture | null;
+    constructor(parameters?: Partial<PBMParameters>);
+    update(renderer: THREE_2.WebGLRenderer, camera: Camera, cache: PBMMaterialReferenceCache): void;
 }
 
 export declare interface PBMPanoPicture {
     /** 起始点位全景图 */
-    map: THREE_2.CubeTexture;
+    map: THREE_2.CubeTexture | TileCubeTextureTarget;
     /** 亮度增益 */
-    luminanceMap: THREE_2.CubeTexture | null;
+    luminanceMap: null | THREE_2.CubeTexture | TileCubeTextureTarget;
     /** 起始点全景图变换矩阵 4x4 */
     matrix: THREE_2.Matrix4;
 }
@@ -1768,9 +2108,47 @@ export declare interface PBMParameters {
     progress: number;
     /** 全景图通过过度黑色混合 */
     useBlackTransition: boolean;
-    perspToOrtho: number;
     /** 模型透明度 */
     opacity: number;
+    /** 楼层参数*/
+    floorIndex: number;
+    /** 模型裁切参数（工程侧调用）*/
+    clippers: ClipperParameter[] | null;
+    /** 模型颜色*/
+    constantColor: THREE_2.Vector3 | null;
+    /** 是否使用EDL*/
+    useEDL: boolean;
+    /** 点云形状*/
+    pointShape: PBMPointShapeType;
+    /** 点云着色方式*/
+    pointColorType: PBMPointColorType;
+    /** 点云大小绘制方式*/
+    pointSizeType: PBMPointSizeType;
+    /** 点云基础大小*/
+    pointSize: number;
+    /** 点云最大尺寸*/
+    pointMinSize: number;
+    /** 点云最小尺寸*/
+    pointMaxSize: number;
+    /** 自适应点云尺寸因子*/
+    pointSizeAdaptiveScale: number;
+    /** 高程彩色图*/
+    gradientTexture: THREE_2.Texture | null;
+}
+
+export declare enum PBMPointColorType {
+    RGB = "rgb",
+    ALTITUDE = "altitude"
+}
+
+export declare enum PBMPointShapeType {
+    SQUARE = "square",
+    CIRCLE = "circle"
+}
+
+export declare enum PBMPointSizeType {
+    FIXED = "fixed",
+    ADAPTIVE = "adaptive"
 }
 
 /**
@@ -1778,17 +2156,87 @@ export declare interface PBMParameters {
  * [[include: coordinate.md]]
  */
 export declare interface Pose {
-    /** 相机俯仰角 */
-    longitude: number;
     /** 相机偏航角 */
+    longitude: number;
+    /** 相机俯仰角 */
     latitude: number;
     /** 相机可视角度（垂直）*/
     fov: number;
     /** 相机位置*/
     offset: THREE_2.Vector3;
+    /** 相机距离 */
+    distance: number;
+}
+
+export declare const PROXY_CONTROLLER_EVENT_NAMES: readonly ["cameraDirectionUpdate", "cameraUpdate", "cameraPositionUpdate", "panoSelected", "moveToPano", "moveToPanoCanceled", "panoWillArrive", "movingToPano", "panoArrived", "panoWillLoad", "panoLoaded", "panoLoadError", "initAnimationEnded", "initAnimationWillStart", "wantsGesture", "gesture", "wantsTapGesture", "tapGesture", "wantsPressGesture", "pressGesture", "wantsPanGesture", "wantsInteriaPan", "panGesture", "interiaPan", "wantsPinchGesture", "pinchGesture", "wantsMouseWheel", "mouseWheel", "wantsShowIntersectionOnModel", "intersectionOnModelUpdate", "intersectionHidden", "textureStartLoad", "textureLoading", "textureAbort", "textureLoaded", "textureError", "webXRSessionStart", "webXRSessionEnd", "webXRControllerEvent"];
+
+export declare class RegionBoundingVolume implements BoundingVolume {
+    type: "regin";
+    west: number;
+    south: number;
+    east: number;
+    north: number;
+    minHeight: number;
+    maxHeight: number;
+    constructor();
+    fromJson({ region }: RegionBoundingVolumeJson): this;
+    toJson(): RegionBoundingVolumeJson;
+    copy(regionBoundingVolume: RegionBoundingVolume): this;
+    clone(): RegionBoundingVolume;
+    getBoundingBox(target: THREE_2.Box3): THREE_2.Box3;
+    toGeometry(): THREE_2.BufferGeometry;
+    applyMatrix4(matrix: THREE_2.Matrix4): this;
+    getCenter(result: THREE_2.Vector3): THREE_2.Vector3;
+    distanceTo(point: THREE_2.Vector3): number;
+    distanceSquaredTo(point: THREE_2.Vector3): number;
+    intersectPlane(plane: THREE_2.Plane): VolumePlaneIntersect;
+    intersectRay(ray: THREE_2.Ray): boolean;
 }
 
-export declare const PROXY_CONTROLLER_EVENT_NAMES: readonly ["cameraDirectionUpdate", "cameraUpdate", "cameraPositionUpdate", "panoSelected", "moveToPano", "moveToPanoCanceled", "panoWillArrive", "movingToPano", "panoArrived", "panoWillLoad", "panoLoaded", "panoLoadError", "initAnimationEnded", "initAnimationWillStart", "wantsGesture", "gesture", "wantsTapGesture", "tapGesture", "wantsPressGesture", "pressGesture", "wantsPanGesture", "wantsInteriaPan", "panGesture", "interiaPan", "wantsPinchGesture", "pinchGesture", "wantsMouseWheel", "mouseWheel", "wantsShowIntersectionOnModel", "intersectionOnModelUpdate", "intersectionHidden", "textureStartLoad", "textureLoading", "textureAbort", "textureLoaded", "textureError"];
+export declare type RegionBoundingVolumeJson = {
+    region: number[];
+};
+
+export declare type RequestResult = null | {
+    done: () => void;
+};
+
+/**
+ * Used to issue a request, without having them "deeply queued" by the browser.
+ * @todo - Track requests globally, across multiple servers
+ */
+export declare class RequestScheduler<Identiy> {
+    static DEFAULT_MAX_REQUESTS: number;
+    maxRequests: number;
+    private activeRequests;
+    /** Tracks the number of active requests and prioritizes/cancels queued requests. */
+    private requestQueue;
+    private requestMap;
+    private deferred;
+    constructor();
+    /**
+     * Called by an application that wants to issue a request, without having it deeply queued by the browser
+     *
+     * When the returned promise resolved, it is OK for the application to issue a request.
+     * The promise resolves to an object that contains a `done` method.
+     * When the application's request has completed (or failed), the application must call the `done` function
+     *
+     * @param identiy - Identiy
+     * @param getPriority - will be called when request "slots" open up, allowing the caller to update priority or cancel the request Highest priority executes first, priority less than 0 cancels the request
+     * @returns a promise resolves to a object (with a `done` field) when the request can be issued without queueing, resolves to `null` if the request has been cancelled (by the callback return less than 0). In this case the application should not issue the request
+     */
+    scheduleRequest(identiy: Identiy, getPriority: (identiy: Identiy) => number): Promise<RequestResult>;
+    reset(): void;
+    private issueRequest;
+    /** We check requests asynchronously, to prevent multiple updates */
+    private issueNewRequests;
+    /** Refresh all requests  */
+    private issueNewRequestsAsync;
+    /** Ensure all requests have updated priorities, and that no longer valid requests are cancelled */
+    private updateAllRequests;
+    /** Update a single request by calling the callback */
+    private updateRequest;
+}
 
 /** Five 场景*/
 export declare class Scene extends THREE_2.Scene {
@@ -1814,6 +2262,29 @@ export declare interface Scissor {
     height: number;
 }
 
+export declare class SphereBoundingVolume implements BoundingVolume {
+    type: "sphere";
+    center: THREE_2.Vector3;
+    radius: number;
+    constructor();
+    fromJson({ sphere }: SphereBoundingVolumeJson): this;
+    toJson(): SphereBoundingVolumeJson;
+    copy(sphereBoundingVolume: SphereBoundingVolume): this;
+    clone(): SphereBoundingVolume;
+    getBoundingBox(target: THREE_2.Box3): THREE_2.Box3;
+    toGeometry(): THREE_2.BufferGeometry;
+    applyMatrix4(matrix: THREE_2.Matrix4): this;
+    getCenter(result: THREE_2.Vector3): THREE_2.Vector3;
+    distanceSquaredTo(point: THREE_2.Vector3): number;
+    distanceTo(point: THREE_2.Vector3): number;
+    intersectPlane(plane: THREE_2.Plane): VolumePlaneIntersect;
+    intersectRay(ray: THREE_2.Ray): boolean;
+}
+
+export declare type SphereBoundingVolumeJson = {
+    sphere: number[];
+};
+
 /**
  * 状态
  * @description
@@ -1828,6 +2299,8 @@ export declare interface State extends Pose {
     mode: Mode;
     /** 观察点序号 */
     panoIndex: number;
+    /** 观察点id */
+    panoId: string;
 }
 
 /**
@@ -1884,6 +2357,13 @@ export declare class Subscribe<T extends SubscribeEventMap> {
      * @template K - 预设的监听事件名称
      */
     emit<K extends keyof T>(name: K, ...data: Parameters<T[K]>): boolean;
+    /**
+     * 等待事件
+     * @param name - 事件类型
+     * @returns 触发事件的数据
+     * @template K - 预设的监听事件名称
+     */
+    waitUnitl<K extends keyof T>(name: K): Promise<Parameters<T[K]>>;
 }
 
 export declare type SubscribeEventMap = {
@@ -1906,6 +2386,52 @@ export declare namespace SubscribeMixinType {
     export interface emit<T extends SubscribeEventMap> {
         <K extends keyof T>(name: K, ...data: Parameters<T[K]>): boolean;
     }
+    export interface waitUnitl<T extends SubscribeEventMap> {
+        <K extends keyof T>(name: K): Promise<Parameters<T[K]>>;
+    }
+}
+
+export declare class TextureLoader {
+    loadTexture(source: string, options?: {
+        imageURL?: {
+            transform?: (source: string, options: ImageURLOptions) => string;
+            options?: ImageURLOptions;
+        };
+        flipY?: boolean;
+        format?: THREE_2.PixelFormat;
+        minFilter?: THREE_2.TextureFilter;
+        magFilter?: THREE_2.TextureFilter;
+        wrapS?: THREE_2.Wrapping;
+        wrapT?: THREE_2.Wrapping;
+        maxSize?: THREE_2.Vector2;
+        viaAjax?: boolean;
+    } & NetworkOptions, onLoad?: (response: NetworkResponse<THREE_2.Texture>) => void, onError?: (error: Error) => void, onProgress?: (percent: number) => void, renderer?: THREE_2.WebGLRenderer): Promise<NetworkResponse<THREE_2.Texture>>;
+    loadCubeTexture(sources: WorkCubeImage, options: {
+        imageURL?: {
+            transform?: (source: string, options: ImageURLOptions) => string;
+            options?: ImageURLOptions;
+        };
+        format?: THREE_2.PixelFormat;
+        minFilter?: THREE_2.TextureFilter;
+        magFilter?: THREE_2.TextureFilter;
+        wrapS?: THREE_2.Wrapping;
+        wrapT?: THREE_2.Wrapping;
+        viaAjax?: boolean;
+    } & NetworkOptions, 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: {
+        tileImageSize?: number;
+        tileMaxLevel?: number;
+        imageURL?: {
+            transform?: (source: string, options: ImageURLOptions) => string;
+            options?: ImageURLOptions;
+        };
+        format?: THREE_2.PixelFormat;
+        minFilter?: THREE_2.TextureFilter;
+        magFilter?: THREE_2.TextureFilter;
+        wrapS?: THREE_2.Wrapping;
+        wrapT?: THREE_2.Wrapping;
+        viaAjax?: boolean;
+    } & NetworkOptions, onLoad: (response: NetworkResponse<TileCubeTextureTarget, NetWorkMeta[]>) => void, onError: (error: Error) => void, onProgress: (percent: number) => void, renderer: THREE_2.WebGLRenderer): Promise<NetworkResponse<TileCubeTextureTarget, NetWorkMeta[]>>;
 }
 
 /**
@@ -1927,19 +2453,352 @@ export declare interface TextureOptions {
     format?: "jpg" | "png" | "heif" | "webp" | "avif";
     /** 针对 textureOptions 是否自动通过模型贴图的数量计算需要的模型贴图的尺寸 默认 true */
     autoResize?: boolean;
+    /** 锐化参数 海外不支持 */
+    sharpen?: number;
+    mappings?: ImageURLMappings;
+}
+
+export declare class Tile {
+    id: string;
+    tileset: Tileset;
+    parent: Tile | null;
+    geometricError: number;
+    type: 'SCENEGRAPH' | 'EMPTY' | 'TILESET' | 'MESH';
+    content: {
+        uri: string;
+        group?: number;
+        boundingVolume?: BoundingVolume;
+        data?: TileContentData;
+        loadState: 'LOADING' | 'UNLOADED' | 'READY' | 'FAILED';
+        byteLength: number;
+    } | null;
+    extras: Record<string, any>;
+    refine: TileHeader['refine'];
+    boundingVolume?: BoundingVolume;
+    viewerRequestVolume?: BoundingVolume;
+    transform: THREE_2.Matrix4;
+    children: Tile[];
+    state: {
+        visible: boolean;
+        frameNumber: number;
+        selectedFrameNumber: number;
+        requestedFrameNumber: number;
+        touchedFrameNumber: number;
+        selectionDepth: number;
+        centerZDepth: number;
+        shouldRefine: boolean;
+        distanceToCamera: number;
+        screenSpaceError: number;
+        inRequestVolume: boolean;
+        visibilityPlaneMask: number;
+    };
+    constructor(id: string, header: TileHeader, tileset: Tileset, parent?: Tile);
+    updateState(frameState: TilesetFrameState): void;
+    get selected(): boolean;
+    get hasChildren(): boolean;
+    get siblingIndex(): number;
+    get hasTilesetContent(): boolean;
+    get hasRenderContent(): boolean;
+    get contentAvailable(): boolean;
+    get hasUnloadedContent(): boolean;
+    get hasEmptyContent(): boolean;
+    get contentReady(): boolean;
+    get contentByteLength(): number;
+    loadContent(): Promise<boolean>;
+    unloadContent(): boolean;
+    getScreenSpaceError(frameState: TilesetFrameState, distanceToCamera: number, useParentGeometricError: boolean): number;
+    getPriority(): number;
+}
+
+export declare class Tile3DModel extends THREE_2.Object3D {
+    static DEFAULT_MAX_LEVEL_OF_DETAIL: number;
+    static DEFAULT_MAX_MEMORY_USAGE: number;
+    static DEFAULT_MAX_SCREEN_SPACE_ERROR: number;
+    static DEFAULT_MAX_REQUESTS: number;
+    workCode: string;
+    tileset: Tileset;
+    maxLevelOfDetail: number;
+    boundingBox: THREE_2.Box3;
+    needsRefined: boolean;
+    refined: boolean;
+    loaded: boolean;
+    disposed: boolean;
+    needsRender: boolean;
+    lastRefineTime: number;
+    private nodeGroup;
+    private debugBoundingGroup;
+    private nodes;
+    private debugBoundings;
+    private unloadTileQueue;
+    constructor(workCode: string, tilesetHeader: TilesetHeader, options: Partial<Tile3DModelLoaderOptions>);
+    get debug(): boolean;
+    set debug(value: boolean);
+    get maxMemoryUsage(): number;
+    set maxMemoryUsage(value: number);
+    get viewDistanceScale(): number;
+    set viewDistanceScale(value: number);
+    get maxRequests(): number;
+    set maxRequests(value: number);
+    get maxScreenSpaceError(): number;
+    set maxScreenSpaceError(value: number);
+    loadContent(tile: Tile, options: {
+        allowHosts?: string[];
+        requestProxy?: (url: string) => string | Promise<string>;
+        networkSubscribe?: NetworkSubscribe;
+    }): Promise<boolean>;
+    intersectRaycaster(raycaster: THREE_2.Raycaster): Intersection[];
+    update(renderer: THREE_2.WebGLRenderer, camera: Camera): void;
+    dispose(): void;
+}
+
+/** Advanced loader options */
+export declare interface Tile3DModelLoaderOptions {
+    resourcePath: string;
+    allowHosts?: string[];
+    requestProxy?: (url: string) => string | Promise<string>;
+    networkSubscribe?: NetworkSubscribe;
+    onError?: (error: Error) => void;
+}
+
+export declare type TileContentData = {
+    type: 'b3dm' | 'pnts' | 'at3d' | 'pbm';
+    byteLength: number;
+    uri: string;
+    object: TileNode;
+};
+
+export declare interface TileCubeNode {
+    level: number;
+    face: "up" | "down" | "left" | "right" | "front" | "back";
+    position: THREE_2.Vector2;
+    size: number;
+    box: THREE_2.Box3;
+    children: TileCubeNode[];
+}
+
+export declare class TileCubeTextureTarget {
+    private tileTree;
+    private tileSources;
+    private options;
+    private renderer;
+    name: string;
+    needsRender: boolean;
+    private disposed;
+    private loadedCubeNodes;
+    private loadingCubeNodes;
+    private baseCubeTexture;
+    private _cubeRenderTarget;
+    private textures;
+    constructor(baseCubeTexture: THREE_2.CubeTexture, tileTree: TileCubeTree, tileSources: WorkTile[], options: {
+        textureSize: number;
+        tileImageSize: number;
+        textureLoader: TextureLoader;
+        imageURL?: {
+            transform?: (source: string, options: ImageURLOptions) => string;
+            options?: ImageURLOptions;
+        };
+        format?: THREE_2.PixelFormat;
+        minFilter?: THREE_2.TextureFilter;
+        magFilter?: THREE_2.TextureFilter;
+        wrapS?: THREE_2.Wrapping;
+        wrapT?: THREE_2.Wrapping;
+    } & NetworkOptions, 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 interface TileHeader {
+    content?: {
+        uri: string;
+        group?: number;
+        boundingVolume?: BoundingVolumeJson;
+    };
+    geometricError: number;
+    refine?: "REPLACE" | "ADD";
+    boundingVolume?: BoundingVolumeJson;
+    viewerRequestVolume?: BoundingVolumeJson;
+    transform?: number[];
+    children?: TileHeader[];
+    extras?: Record<string, any>;
+}
+
+export declare class TileNode extends THREE_2.Group {
+    bvhTree: BVH | undefined;
+    objType: 'mesh' | 'points';
+    constructor(obj: THREE_2.Object3D, objType: 'mesh' | 'points');
+    buildBvhTree(): void;
+    intersectRaycaster(raycaster: THREE_2.Raycaster): Intersection[];
+    dispose(): void;
+}
+
+export declare class Tileset {
+    static DEFAULT_VIEW_DISTANCE_SCALE: number;
+    static DEFAULT_MAX_MEMORY_USAGE: number;
+    static DEFAULT_MAX_SCREEN_SPACE_ERROR: number;
+    static DEFAULT_MAX_REQUESTS: number;
+    asset: {
+        version: string;
+        tilesetVersion: string;
+        gltfUpAxis: "X" | "Y" | "Z";
+    };
+    id: string;
+    frameNumber: number;
+    properties: Record<string, any>;
+    options: TilesetOptions;
+    root: Tile;
+    transfrom: THREE_2.Matrix4;
+    geometricError: number;
+    traverser: TilesetTraverser;
+    cache: TilesetCache;
+    requestScheduler: RequestScheduler<string>;
+    private memoryUsageInBytes;
+    maxMemoryUsage: number;
+    viewDistanceScale: number;
+    tiles: Map<string, Tile>;
+    private pendingCount;
+    constructor(id: string, header: TilesetHeader, options: TilesetOptions);
+    get maxRequests(): number;
+    set maxRequests(value: number);
+    get maxScreenSpaceError(): number;
+    set maxScreenSpaceError(value: number);
+    get selectedTiles(): Map<string, Tile>;
+    get needsRefinedTiles(): Map<string, Tile>;
+    /** Release resources */
+    reset(): void;
+    /** Is the tileset loaded (update needs to have been called at least once) */
+    isLoaded(): boolean;
+    /**
+     * The callback to post-process tiles after traversal procedure
+     * @param frameState - frame state for tile culling
+     */
+    private onTraversalEnd;
+    loadTile(tile: Tile): void;
+    unloadTile(tile: Tile): void;
+}
+
+export declare class TilesetCache {
+    private cacheNodeMap;
+    private list;
+    private sentinel;
+    constructor();
+    reset(): void;
+    touch(tile: Tile): void;
+    add(tile: Tile, addCallback?: (tile: Tile) => void): void;
+    unloadTile(tile: Tile, unloadCallback?: (tile: Tile) => void): void;
+    unloadTiles(isOverMemory: () => boolean, unloadCallback?: (tile: Tile) => void): void;
+    toArray(): Tile[];
+}
+
+export declare type TilesetFrameState = {
+    camera: {
+        position: THREE.Vector3;
+        direction: THREE.Vector3;
+        up: THREE.Vector3;
+    };
+    height: number;
+    cullingVolume: CullingVolume;
+    frameNumber: number;
+    sseDenominator: number;
+    maxLevelOfDetail: number;
+};
+
+export declare interface TilesetHeader {
+    asset: {
+        version: string;
+        tilesetVersion?: string;
+        gltfUpAxis?: "X" | "Y" | "Z";
+    };
+    properties?: Record<string, any>;
+    geometricError: number;
+    root: TileHeader;
+}
+
+export declare interface TilesetOptions {
+    onTileLoad: (tile: Tile) => any;
+    onTileUnload: (tile: Tile) => any;
+    onTileError: (tile: Tile, error: Error) => any;
+    contentLoader: (tile: Tile) => Promise<boolean>;
+    allowHosts?: string[];
+    requestProxy?: (url: string) => string | Promise<string>;
+    networkSubscribe?: NetworkSubscribe;
+}
+
+export declare class TilesetTraverser {
+    static DEFAULT_SKIP_LEVEL_OF_DETAIL: boolean;
+    static DEFAULT_LOAD_SIBLINGS: boolean;
+    static DEFAULT_MAX_SCREEN_SPACE_ERROR: number;
+    root: Tile | null;
+    loadSiblings: boolean;
+    skipLevelOfDetail: boolean;
+    maxScreenSpaceError: number;
+    onTraversalEnd: (frameState: TilesetFrameState) => any;
+    requestedTiles: Map<string, Tile>;
+    selectedTiles: Map<string, Tile>;
+    needsRefinedTiles: Map<string, Tile>;
+    emptyTiles: Map<string, Tile>;
+    private _traversalStack;
+    private _emptyTraversalStack;
+    constructor(onTraversalEnd: (frameState: TilesetFrameState) => any);
+    traverse(root: Tile, frameState: TilesetFrameState): void;
+    reset(): void;
+    private executeTraversal;
+    private updateChildTiles;
+    private updateAndPushChildren;
+    updateTile(tile: Tile, frameState: TilesetFrameState): void;
+    selectTile(tile: Tile, frameState: TilesetFrameState): void;
+    loadTile(tile: Tile, frameNumber: number): void;
+    touchTile(tile: Tile, frameState: TilesetFrameState): void;
+    private canTraverse;
+    private shouldLoadTile;
+    private shouldSelectTile;
+    private shouldRefine;
+    private updateTileVisibility;
+    private meetsScreenSpaceErrorEarly;
+    private compareDistanceToCamera;
+    private executeEmptyTraversal;
 }
 
 export declare interface TopviewControllerCustomInitArgs extends Omit<FloorplanControllerCustomInitArgs, "defaultLongitude" | "defaultLatitude" | "maxLatitude" | "minLatitude"> {
 }
 
+export declare enum VolumePlaneIntersect {
+    Outside = -1,
+    Intersecting = 0,
+    Inside = 1
+}
+
 export declare interface VRPanoramaControllerCustomInitArgs extends Omit<PanoramaControllerCustomInitArgs, "maxLatitude" | "minLatitude"> {
 }
 
+export declare type WebXRControllerKey = 'A' | 'B' | 'X' | 'Y' | 'RightTrigger' | 'RightPinch' | 'LeftTrigger' | 'LeftPinch' | 'LeftAxesLeft' | 'LeftAxesRight' | 'LeftAxesUp' | 'LeftAxesDown' | 'RightAxesLeft' | 'RightAxesRight' | 'RightAxesUp' | 'RightAxesDown';
+
+export declare interface WebXRControllerParams {
+    raycaster: THREE_2.Raycaster[];
+}
+
+export declare type WebXRControllerType = 'tap' | 'press' | 'axes';
+
+export declare type WebXREventTypes = {
+    /** WebXR模式开始，session完成坐标系设置*/
+    webXRSessionStart(): void;
+    /** WebXR模式结束，销毁session*/
+    webXRSessionEnd(): void;
+};
+
 export declare class Work {
     /** 名称 */
     name: string;
     /** 编号 */
-    workCode: string;
+    workCode: WorkCode;
     /** 允许访问的安全域名 */
     allowHosts: string[];
     /** 过期时间 */
@@ -1952,12 +2811,26 @@ export declare class Work {
     observers: WorkObserver[];
     /** 数据签发人 */
     issuer: string;
+    /** 控制参数 */
+    options: WorkOptions;
     /** 原始数据 */
-    raw: any;
-    constructor();
+    raw: {
+        works: string[];
+        options: string;
+    };
+    /**
+     * 解析 Work 数据
+     * @param obj - work 数据，从如数开发者平台获取
+     * @param options - 配置参数， 可以在此二次设置 baseURL 等参数
+     * @returns - 签署过的 Work 数据结构
+     */
+    static parse: typeof parseWork;
+    constructor(obj: Work | LooseWork | (Work | LooseWork)[] | any, options: ParseWorkOptions);
     toJSON(): any;
 }
 
+export declare type WorkCode = string;
+
 export declare interface WorkCubeImage {
     /** 全景图 up */
     up: string;
@@ -1984,25 +2857,54 @@ export declare interface WorkImage extends WorkCubeImage {
 }
 
 /** 初始化位姿参数 */
-export declare interface WorkInitial extends Omit<State, "offset"> {
+export declare interface WorkInitial {
+    /** 模态 */
+    mode?: Mode;
+    /** 点位序号 */
+    panoId?: string;
+    /** 相机水平角 */
+    longitude?: number;
+    /** 相机俯仰角 */
+    latitude?: number;
+    /** 相机可视角度（垂直）*/
+    fov?: number;
+    /** 相机观察点位置 [x, y, z] */
+    offset?: THREE_2.Vector3;
+    /** 相机距离观察点距离 */
+    distance?: number;
 }
 
 /** 模型数据 */
 export declare interface WorkModel {
+    /** work */
+    work: Work;
     /** 模型文件地址 at3d / domez */
-    file: string;
+    file?: string;
     /** 模型贴图文件地址 */
-    textures: string[];
+    textures?: string[];
     /** 模型贴图文件地址的父目录 */
-    textureBase: string;
-    /** 是否开启 bvh 碰撞树，开启会大大加快射线碰撞的执行效率 */
-    bvh: boolean;
+    textureBase?: string;
+    /** 3d tile */
+    layers: {
+        type: 'point_cloud' | 'mesh';
+        name: string;
+        upAxis: string;
+        tileset: string;
+    }[];
 }
 
 /** 每个点位的数据 */
 export declare interface WorkObserver {
+    /** work */
+    work: Work;
+    /** 序号 */
+    index: number;
     /** 点位序号 */
-    panoIndex: number;
+    panoId: WorkPanoId;
+    /** 点位所在楼层 */
+    floorIndex: number;
+    /** 点位 derived_id */
+    derivedId?: number;
     /** 点位是否激活可用 */
     active: boolean;
     /** 点位是否可加载 */
@@ -2012,19 +2914,44 @@ export declare interface WorkObserver {
     /** 点位视频 */
     video?: WorkVideo;
     /** 可以看到的相关点位序号 */
-    visibleNodes: number[];
+    visibleIds: string[];
     /** 可以连通的相关点位序号 */
-    accessibleNodes: number[];
-    /** 点位和模型的旋转对齐关系四元数 */
-    quaternion: THREE_2.Quaternion;
-    /** 点位和模型的地面位置坐标关系 */
+    accessibleIds: string[];
+    /** 点位和模型的地面坐标 */
     standingPosition: THREE_2.Vector3;
-    /** 点位和模型的观察点坐标关系 */
+    /** 点位和模型的观察点坐标 */
     position: THREE_2.Vector3;
-    /** 点位所在楼层 */
-    floorIndex: number;
+    /** 点位和模型的旋转对齐关系四元数 */
+    quaternion: THREE_2.Quaternion;
+}
+
+export declare interface WorkOptions {
+    /** 调试 */
+    debug?: boolean;
+    /** 位姿修正 */
+    transform: THREE_2.Matrix4;
+    /** 可观测区域 */
+    viewerRequestVolume?: BoundingVolume;
+    /** 模型显示最大细化层级 */
+    modelMaxLevelOfDetail?: number;
+    /** 模型最大内存缓存 */
+    modelMaxMemoryUsage?: number;
+    /** 模型网络最大请求并发数 */
+    modelMaxRequests?: number;
+    /** 模型屏幕空间误差计算最大值 */
+    modelMaxScreenSpaceError?: number;
 }
 
+export declare type WorkPanoId = string;
+
+export declare type Works = ReadonlyArray<Work> & {
+    resolvedObservers: WorkObserver[];
+    initial: WorkInitial;
+    getWork(workCode: WorkCode): Work | undefined;
+    getResolvedObserver(panoId: WorkPanoId): WorkObserver | undefined;
+    update(): void;
+};
+
 export declare interface WorkTile {
     level: number;
     size: number;
@@ -2046,4 +2973,11 @@ export declare interface WorkVideo {
     size: THREE_2.Vector2;
 }
 
+export declare class XRButton {
+    static createButton(onClickHook: () => void): HTMLAnchorElement | HTMLButtonElement;
+}
+
+export declare interface XRPanoramaControllerCustomInitArgs extends Omit<PanoramaControllerCustomInitArgs, "maxLatitude" | "minLatitude"> {
+}
+
 export { }