@realsee/five 6.0.0-alpha.10 → 6.0.0-alpha.100

package/five/index.d.ts

@@ -13,6 +13,15 @@ export declare interface AddableObject extends THREE_2.Object3D {
     setTime?(time: number): void;
 }
 
+export declare interface AjaxOptions<T extends AjaxResponseType = AjaxResponseType> extends NetworkOptions {
+    /** 数据返回类型 */
+    responseType?: T;
+}
+
+export declare type AjaxResponseType = "arraybuffer" | "blob" | "text";
+
+export declare type AjaxResponseTypeMapping<K extends AjaxResponseType> = K extends "arraybuffer" ? ArrayBuffer : K extends "blob" ? Blob : K extends "text" ? string : never;
+
 export declare interface AnimationFrame {
     callback: (time: number, deltaTime: number, ...args: any[]) => void;
     once: boolean;
@@ -61,10 +70,11 @@ export declare interface BoundingVolume {
     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;
+    distanceSquaredToPoint(point: THREE_2.Vector3): number;
+    distanceToPoint(point: THREE_2.Vector3): number;
+    distanceToPlane(plane: THREE_2.Plane): number;
     intersectPlane(plane: THREE_2.Plane): VolumePlaneIntersect;
-    intersectRay(ray: THREE_2.Ray): boolean;
+    intersectRay(ray: THREE_2.Ray, far?: number): boolean;
     clone(): BoundingVolume;
     copy(boundingVolume: this): this;
     fromJson(json: any): this;
@@ -85,75 +95,19 @@ export declare class BoxBoundingVolume implements BoundingVolume {
     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;
+    distanceSquaredToPoint(point: THREE_2.Vector3): number;
+    distanceToPoint(point: THREE_2.Vector3): number;
+    distanceToPlane(plane: THREE_2.Plane): 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;
+    intersectRay(ray: THREE_2.Ray, far?: number): boolean;
 }
 
 export declare type BoxBoundingVolumeJson = {
     box: number[];
 };
 
-export declare class BVH {
-    trianglesArray?: Float32Array;
-    offsetArray?: Uint32Array;
-    rootNode?: BVHNode;
-    create(trianglesArray: Float32Array): this;
-    splitNode(maxTrianglesPerNode: number): this;
-    /**
-     * 计算射线与三角形的碰撞
-     * @param rayOrigin - 射线的原点坐标
-     * @param rayDirection - 设想的方向向量
-     * @param backfaceCulling - 是否背面剔除
-     * @return 碰撞焦点数组
-     */
-    intersectRay(rayOrigin: BVHVector3, rayDirection: BVHVector3, backfaceCulling: boolean): BVHIntersect[];
-    trianglesInSphere(center: BVHVector3, radius: number): Float32Array;
-    dispose(): void;
-}
-
-export declare class BVHIntersect {
-    triangle: [BVHVector3, BVHVector3, BVHVector3];
-    intersectionPoint: BVHVector3;
-    constructor(triangle: [BVHVector3, BVHVector3, BVHVector3], intersectionPoint: BVHVector3);
-}
-
-/**
- * A node in the BVH structure
- * @param extents - the min coords of this node's bounding box
- * @param startIndex - an index in the bbox array, where the first element of this node is located
- * @param endIndex - an index in the bbox array, where the last of this node is located, plus 1 (meaning that its non-inclusive).
- * @param level - distance of this node from the root for the bvh tree. root node has level=0, its children have level=1 etc.
- */
-export declare class BVHNode {
-    extents: ArrayLike<number>;
-    startIndex: number;
-    endIndex: number;
-    node0?: BVHNode;
-    node1?: BVHNode;
-    constructor(extents: ArrayLike<number>, startIndex: number, endIndex: number);
-}
-
-export declare class BVHVector3 {
-    x: number;
-    y: number;
-    z: number;
-    constructor(x: number, y: number, z: number);
-    copy(v: BVHVector3): this;
-    set(x: number, y: number, z: number): this;
-    fromArray(array: number[], firstElementPos?: number): this;
-    add(v: BVHVector3): this;
-    multiplyScalar(scalar: number): this;
-    subVectors(a: BVHVector3, b: BVHVector3): this;
-    dot(v: BVHVector3): number;
-    cross(v: BVHVector3): this;
-    crossVectors(a: BVHVector3, b: BVHVector3): this;
-    clone(): BVHVector3;
-}
-
 /** Five 相机 */
 export declare class Camera extends THREE_2.Camera {
     fov: number;
@@ -161,14 +115,17 @@ export declare class Camera extends THREE_2.Camera {
     near: number;
     far: number;
     perspToOrtho: THREE_2.Vector2;
-    orthoDistance: number;
+    resolution: THREE_2.Vector2;
+    pixelRatio: number;
     /** 相机姿态 */
     pose: CameraPose;
     private perspectiveCamera;
     private orthographicCamera;
     needsRender: boolean;
+    refineModel: boolean;
     private lastValues;
-    constructor(fov: number, aspect?: number, near?: number, far?: number, perspToOrtho?: THREE_2.Vector2, orthoDistance?: number);
+    constructor(fov: number, aspect?: number, near?: number, far?: number, perspToOrtho?: THREE_2.Vector2, resolution?: THREE_2.Vector2, pixelRatio?: number);
+    get orthoDistance(): number;
     get zoom(): number;
     get top(): number;
     get bottom(): number;
@@ -203,17 +160,6 @@ 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(clipperParameter: ClipperParameter | ClipperParameter[], camera: THREE_2.Camera): void;
-    private projectPlanes;
-}
-
 export declare interface ClipperParameter {
     clippingBoxMatrix: THREE_2.Matrix4;
     floorIndex?: number;
@@ -225,7 +171,6 @@ export declare type ControllerCustomInitTypes = {
     Panorama: PanoramaControllerCustomInitArgs;
     VRPanorama: VRPanoramaControllerCustomInitArgs;
     Model: ModelControllerCustomInitArgs;
-    DepthPanorama: DepthPanoramaControllerCustomInitArgs;
     Mapview: MapviewControllerCustomInitArgs;
     XRPanorama: XRPanoramaControllerCustomInitArgs;
 };
@@ -303,6 +248,10 @@ export declare class CullingVolume {
     planes: THREE_2.Plane[];
     constructor(planes?: THREE_2.Plane[]);
     setFromFrustum(frustum: THREE_2.Frustum): this;
+    setFromCamera(camera: THREE_2.Camera): this;
+    applyMatrix4(matrix: THREE_2.Matrix4): void;
+    copy(cullingVolume: CullingVolume): this;
+    clone(): CullingVolume;
     computeVisibility(boundingVolume: BoundingVolume): VolumePlaneIntersect;
     computeVisibilityWithPlaneMask(boundingVolume: BoundingVolume, parentPlaneMask: number): number;
 }
@@ -315,19 +264,7 @@ export declare class CullingVolume {
  */
 export declare function defaultImageURLTransform(source: string, options: ImageURLOptions): string;
 
-export declare interface DepthPanoramaControllerCustomInitArgs extends PanoramaLikeControllerCustomInitArgs {
-    /** 最远可移动观察点距离 */
-    maxAccessibleDistance?: number;
-    /**
-     * 点击地面观察点标识的判定范围
-     * @description
-     * 如果在判定范围内则确定去到目标点，
-     * 否则寻找点击位置方向最适合的点（可能会走到一个离相机更近的点）。
-     */
-    panoTapTriggerRadius?: number;
-    /** 地面观察点标识自定义创建器 */
-    panoCircleMeshCreator?: (pano: Pano) => PanoCircleMeshInterface;
-}
+export declare const defaultPbmParameters: PBMParameters;
 
 /**
  * Five 事件列表
@@ -371,6 +308,8 @@ export declare type EventTypes = Pick<ControllerEventTypes, typeof PROXY_CONTROL
     "model.changeShownFloor"(event: ModelEvent): void;
     /** 模型加载完成 */
     "models.load"(event: ModelsEvent): void;
+    /** 模型细化完成 */
+    "models.refined"(event: ModelsEvent): void;
     /** 渲染前 */
     "render.prepare"(event: RenderEvent): void;
     /** 渲染后 */
@@ -389,6 +328,14 @@ export declare type EventTypes = Pick<ControllerEventTypes, typeof PROXY_CONTROL
     "dispose"(): void;
 };
 
+export declare class Fetcher {
+    private options;
+    constructor(options?: NetworkOptions);
+    ajax<T extends AjaxResponseType = "text">(source: string, options?: AjaxOptions<T>, onLoad?: NetworkSuccessCallback<AjaxResponseTypeMapping<T>>, onError?: NetworkErrorCallback, onProgress?: NetworkProgressCallback): Promise<NetworkResponse<AjaxResponseTypeMapping<T>>>;
+    loadImage<T extends HTMLImageElement = HTMLImageElement>(source: string, options?: NetworkOptions, onLoad?: NetworkSuccessCallback, onError?: NetworkErrorCallback, onProgress?: NetworkProgressCallback, target?: T): Promise<NetworkResponse<T>>;
+    preload(source: string, options?: NetworkOptions): Promise<void>;
+}
+
 /**
  * 如视 VR Web展示器
  *
@@ -406,6 +353,8 @@ export declare class Five extends Subscribe<EventTypes> {
     static get version(): string;
     static get dracoPath(): string;
     static set dracoPath(path: string);
+    static get ktx2Path(): string;
+    static set ktx2Path(path: string);
     /**
      * Five 的显示模式，可以通过 `five.changeMode` `five.setState` 来切换
      * @description
@@ -414,7 +363,6 @@ export declare class Five extends Subscribe<EventTypes> {
      * Model 模型游走模式
      * Floorplan 模型查看模式
      * Topview 户型图模式
-     * DepthPanorama 深度图游走模式
      * VRPanorama VR眼镜模式
      * XRPanorama VR硬件模式
      * ```
@@ -463,6 +411,7 @@ export declare class Five extends Subscribe<EventTypes> {
     /** 当前加载的模型 */
     models: Models;
     private lastModels;
+    private lastWorks?;
     /**
      * 是否需要渲染
      * @description
@@ -484,12 +433,6 @@ export declare class Five extends Subscribe<EventTypes> {
      * 平衡加载时间和图片质量
      */
     textureOptions: TextureOptions;
-    /**
-     * 模型lod的配置参数
-     * @description
-     * 可以配置加载模型lod的相关参数
-     */
-    modelLodOptions: ModelLodOptions;
     /**
      * 模型贴图的配置参数
      * @description
@@ -541,6 +484,7 @@ export declare class Five extends Subscribe<EventTypes> {
     private modelGroup;
     private helperGroup;
     private modeChangeDuration;
+    private enableWheel;
     private onlyRenderIfNeeds;
     private poweredByRealsee;
     private controller?;
@@ -630,7 +574,7 @@ export declare class Five extends Subscribe<EventTypes> {
      */
     get enablePostProcessing(): boolean;
     set enablePostProcessing(enable: boolean);
-    updateConfiguration(args: Pick<FiveInitArgs, "panorama" | "model" | "floorplan" | "topview" | "mapview" | "depthPanorama" | "vrPanorama" | "imageOptions" | "textureOptions">): void;
+    updateConfiguration(args: Pick<FiveInitArgs, "panorama" | "model" | "floorplan" | "topview" | "mapview" | "vrPanorama" | "imageOptions" | "textureOptions">, refresh?: boolean): void;
     /**
      * 将显示区域加载到页面 DOM 中
      * @description
@@ -680,7 +624,7 @@ export declare class Five extends Subscribe<EventTypes> {
      * @param userAction - 是否用户触发
      * @returns Promise 是否移动成功
      */
-    updateCamera(pose: Partial<Omit<Pose, "offset">>, duration: number, userAction?: boolean): Promise<void>;
+    updateCamera(pose: Partial<Pose>, duration: number, userAction?: boolean): Promise<void>;
     /**
      * 通过帧动画移动相机。（不触发点位移动）
      * @description
@@ -691,7 +635,11 @@ export declare class Five extends Subscribe<EventTypes> {
      * @param userAction - 是否用户触发
      * @returns Promise 是否移动成功
      */
-    updateCameraWithKeyframes(keyframes: MotionKeyframe<Exclude<keyof Pose, "offset">>[], duration: number, userAction?: boolean): Promise<void>;
+    updateCameraWithKeyframes(keyframes: {
+        progress: number;
+        value: Pose;
+        key?: string;
+    }[], duration: number, userAction?: boolean): Promise<void>;
     /**
      * 获取当前相机经纬度
      * @deprecated 请使用使用 getPose
@@ -722,19 +670,22 @@ export declare class Five extends Subscribe<EventTypes> {
      *  - "inherit" 使用当前姿态
      *  - "initial" 使用 Work 数据中的 initial 姿态
      *  - State 自定义姿态
-     * @param duration - 切换时间
+     * @param options - 切换时间, 切换效果
      */
-    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>;
+    load(inputWork: string | Work | LooseWork | string[] | Work[] | LooseWork[] | LooseWorkWithExtrinsics[] | Promise<Work | LooseWork | Work[] | LooseWork[] | LooseWorkWithExtrinsics[]>, state?: "inherit" | "initial" | Partial<State>, options?: number | FiveLoadOptions, userAction?: boolean): Promise<void>;
     private load_;
     /**
      * 切换模态
      * @param mode - 切换到的模态
      * @param state - 切换完成时的姿态
-     * @param duration - 模态切换动画用时
+     * @param options - 模态切换动画用时
      * @param userAction - 是否时用户动作触发 默认 true
      * @param force - 必须重新初始化 controller
      */
-    changeMode<T extends Mode>(mode: T, state?: Partial<Omit<State, "mode">>, duration?: number, userAction?: boolean, force?: boolean): Promise<void>;
+    changeMode<T extends Mode>(mode: T, state?: Partial<Omit<State, "mode">>, options?: number | {
+        duration?: number;
+        effect?: MovePanoEffect;
+    }, userAction?: boolean, force?: boolean): Promise<void>;
     /**
      * 获取画面中的像素颜色
      * @param x - 获取像素区域的起始坐标 x
@@ -963,8 +914,6 @@ export declare interface FiveInitArgs {
     topview?: ControllerCustomInitTypes["Topview"];
     /** 地图模式下的特定参数 */
     mapview?: ControllerCustomInitTypes["Mapview"];
-    /** 深度图游走模式下的特定参数 */
-    depthPanorama?: ControllerCustomInitTypes["DepthPanorama"];
     /** VR眼镜模式下的特定参数 */
     vrPanorama?: ControllerCustomInitTypes["VRPanorama"];
     /** XR眼镜模式下的特定参数 */
@@ -976,6 +925,10 @@ export declare interface FiveInitArgs {
      * @default `800`
      */
     modeChangeDuration?: number;
+    /**
+     * 是否支持滚轮
+     */
+    enableWheel?: boolean;
     /**
      * 插件定义
      * @description
@@ -990,21 +943,64 @@ export declare interface FiveInitArgs {
      * 是否使用webgl2渲染执行环境, 默认值 false
      */
     webgl2?: boolean;
-    /**
-     * 是否开启模型裁切
-     */
-    localClippingEnabled?: boolean;
     /**
      * 请求代理
      * @param url - 发起的请求
      * @returns 返回的请求
      */
     requestProxy?(url: string): string | Promise<string>;
+}
+
+export declare interface FiveLoadOptions {
+    /** 切换运动时间 */
+    duration?: number;
+    /** 切换运动全景图效果 */
+    effect?: MovePanoEffect;
+    /** 全景图游走模式下的特定参数 */
+    panorama?: ControllerCustomInitTypes["Panorama"];
+    /** 模型游走模式下的特定参数 */
+    model?: ControllerCustomInitTypes["Model"];
+    /** 模型查看模式下的特定参数 */
+    floorplan?: ControllerCustomInitTypes["Floorplan"];
+    /** 户型图模式下的特定参数 */
+    topview?: ControllerCustomInitTypes["Topview"];
+    /** 地图模式下的特定参数 */
+    mapview?: ControllerCustomInitTypes["Mapview"];
+    /** VR眼镜模式下的特定参数 */
+    vrPanorama?: ControllerCustomInitTypes["VRPanorama"];
+    /** XR眼镜模式下的特定参数 */
+    xrPanorama?: ControllerCustomInitTypes["XRPanorama"];
     /**
-     * 模型lod相关的配置，maxDepth为加载的最大深度
+     * 全景图的配置参数
+     * @description
+     * 可以动态对配置在 `work` 数据中的全景图片在 runtime 做 url 调整。
+     * 平衡加载时间和图片质量
+     */
+    imageOptions?: ImageOptions;
+    /**
+     * 模型贴图的配置参数
+     * @description
+     * 可以动态对配置在 `work` 数据中的模型贴图在 runtime 做 url 调整。
+     * 平衡加载时间和图片质量
      */
-    modelLod?: {
-        maxDepth?: number;
+    textureOptions?: TextureOptions;
+    "3d-tiles"?: {
+        /** 调试模式 */
+        debug?: boolean;
+        /** 显示图层 */
+        showLayers?: boolean | string[];
+        /** 可观测区域 */
+        viewerRequestVolume?: BoundingVolume;
+        /** 模型显示最小细化层级 */
+        minLevelOfDetail?: number;
+        /** 模型显示最大细化层级 */
+        maxLevelOfDetail?: number;
+        /** 模型最大内存缓存 */
+        maxMemoryUsage?: number;
+        /** 模型网络最大请求并发数 */
+        maxRequests?: number;
+        /** 模型屏幕空间误差计算最大值 */
+        maxScreenSpaceError?: number;
     };
 }
 
@@ -1036,6 +1032,8 @@ parameters: Parameters<T>[1]
 export declare type FivePluginInstance<T extends FivePlugin<any, any>> = ReturnType<T>;
 
 export declare interface FloorplanControllerCustomInitArgs {
+    /** 默认水平角 */
+    defaultLongitude?: number;
     /** 默认俯仰角 */
     defaultLatitude?: number;
     /** 最大俯仰角 */
@@ -1108,8 +1106,9 @@ export declare interface ImageOptions {
 }
 
 export declare function imageSupport(): Promise<{
-    avif: boolean;
     webp: boolean;
+    avif: boolean;
+    heif: boolean;
 }>;
 
 export declare interface ImageURLMappings {
@@ -1141,8 +1140,10 @@ export declare interface ImageURLOptions {
 }
 
 export declare class InternalWebGLRenderer extends THREE_2.WebGLRenderer {
-    constructor({ preserveDrawingBuffer, backgroundColor, backgroundAlpha, pixelRatio, antialias, webgl2, }: {
+    constructor({ preserveDrawingBuffer, premultipliedAlpha, stencil, backgroundColor, backgroundAlpha, pixelRatio, antialias, webgl2, }: {
         preserveDrawingBuffer?: boolean;
+        premultipliedAlpha?: boolean;
+        stencil?: boolean;
         backgroundColor?: number | THREE_2.Color;
         backgroundAlpha?: number;
         pixelRatio?: number;
@@ -1157,15 +1158,11 @@ export declare interface IntersectEvent extends BaseEvent {
     intersection: Intersection | null;
 }
 
-export declare interface Intersection {
-    /** 焦点坐标 */
-    point: THREE.Vector3;
-    /** 焦点面片 */
-    face?: {
-        normal: THREE.Vector3;
-    } | null;
-    /** 焦点距离 */
-    distance: number;
+export declare interface Intersection extends THREE_2.Intersection {
+    /** 楼层 */
+    floor: number;
+    model?: Model;
+    viewLayer?: ModelViewLayer;
 }
 
 export declare class IntersectMesh extends THREE_2.Object3D implements IntersectMeshInterface {
@@ -1488,8 +1485,8 @@ export declare type LegacyEventType = {
      * xr控制器的控制器射线更新
      */
     webXRControllerRayUpdate(raycaster: {
-        leftRay: THREE_2.Raycaster;
-        rightRay: THREE_2.Raycaster;
+        leftRay?: THREE_2.Raycaster;
+        rightRay?: THREE_2.Raycaster;
     }): void;
     /**
      * 准备加载 Work 数据
@@ -1589,6 +1586,42 @@ export declare type LegacyEventType = {
     network(source: string, type: NetworkType, state: NetworkState, detail: string): void;
 };
 
+export declare function loadAt3d(url: string, options: {
+    textureOptions?: TextureOptions;
+    textureBaseUri?: string;
+    textureArray?: string[];
+    fetcher: Fetcher;
+}): Promise<ParsedResultType>;
+
+export declare function loadB3dm(url: string, options: {
+    upAxis: 'X' | 'Y' | 'Z';
+    fetcher: Fetcher;
+}): Promise<ParsedResultType>;
+
+export declare function loadDome(url: string, options: {
+    textureOptions: TextureOptions;
+    textureBaseUri?: string;
+    fetcher: Fetcher;
+}): Promise<ParsedResultType>;
+
+export declare function loadDomez(url: string, options: {
+    textureOptions: TextureOptions;
+    textureBaseUri?: string;
+    fetcher: Fetcher;
+}): Promise<ParsedResultType>;
+
+export declare function loadPbm(url: string, options: {
+    textureOptions?: TextureOptions;
+    textureBaseUri?: string;
+    textureArray?: string[];
+    fetcher: Fetcher;
+}): Promise<ParsedResultType>;
+
+export declare function loadPnts(url: string, options: {
+    fetcher: Fetcher;
+    computeBoundingBox?: boolean;
+}): Promise<ParsedResultType>;
+
 export declare type LooseWork = {
     work_code?: string;
     code?: string;
@@ -1671,6 +1704,7 @@ export declare type LooseWorkPanorama = {
         back: string;
     };
     tiles?: number[];
+    tile_size?: number[];
 };
 
 export declare type LooseWorkVideo = {
@@ -1679,24 +1713,14 @@ export declare type LooseWorkVideo = {
     size: number[];
 };
 
-export declare type LooseWorkWithExtrinsics = {
+export declare type LooseWorkWithExtrinsics = ParseWorkOptions & {
+    /** work 数据 */
     work: LooseWork;
-    debug?: boolean;
-    /** 位姿 */
-    transform?: number[];
-    /** 可视区域 */
-    viewerRequestVolume?: BoundingVolumeJson;
-    /** 模型显示最大细化层级 */
-    modelMaxLevelOfDetail?: number;
-    /** 模型最大内存缓存 */
-    modelMaxMemoryUsage?: number;
-    /** 模型网络最大请求并发数 */
-    modelMaxRequests?: number;
-    /** 模型屏幕空间误差计算最大值 */
-    modelMaxScreenSpaceError?: number;
 };
 
 export declare interface MapviewControllerCustomInitArgs {
+    /** 默认水平角 */
+    defaultLongitude?: number;
     /** 默认俯仰角 */
     defaultLatitude?: number;
     /** 默认相机距离 */
@@ -1705,6 +1729,8 @@ export declare interface MapviewControllerCustomInitArgs {
     maxLatitude?: number;
     /** 最小俯仰角 */
     minLatitude?: number;
+    /** cameraType */
+    cameraType?: "perspective" | "orthographic" | "auto";
     /** 鼠标焦点环自定义创建器 */
     intersectMeshCreator?: () => IntersectMeshInterface;
 }
@@ -1718,7 +1744,6 @@ export declare type Mirror<T extends string> = Record<T, T>;
  * - **Floorplan**: 模型查看模式
  * - **Topview**: 户型图模式
  * - **Mapview**: 地图模式
- * - **DepthPanorama**: 深度图游走模式
  * - **VRPanorama**: VR眼镜模式
  */
 export declare type Mode = 
@@ -1734,8 +1759,6 @@ export declare type Mode =
 "VRPanorama" | 
 /** 模型游走模式 */
 "Model" | 
-/** 深度图游走模式 */
-"DepthPanorama" | 
 /** XR眼镜模式*/
 "XRPanorama";
 
@@ -1756,13 +1779,7 @@ export declare class Model extends THREE_2.Object3D {
     /** work */
     work: Work | null;
     /** 模型的不同图层 */
-    viewLayers: {
-        name: string;
-        type: string;
-        upAxis: string;
-        coordinates: string;
-        scene: Tile3DModel;
-    }[];
+    viewLayers: ModelViewLayer[];
     onError: (error: Error) => void;
     onShownFloorChange: (floorIndex: number | null) => void;
     onLoad: () => void;
@@ -1772,19 +1789,20 @@ export declare class Model extends THREE_2.Object3D {
     floorLength: number;
     /** 材质贴图参数 */
     textureOptions: TextureOptions;
+    autoRefine: boolean;
     /** 模型是否已经细化 */
     refined: boolean;
+    /** 模型细化进度 */
+    refineProgress: [number, number];
     /** 模型已经加载 */
     loaded: boolean;
-    /** 当前样式参数 */
-    materialVersion: string;
-    private _materialValues;
-    private _materialVersionMap;
-    private _floorIndex;
-    private _clippers;
-    /** 样式缓存 */
-    private cache;
+    /** 是否更新 */
     needsRender: boolean;
+    /** 缓存相机 */
+    cacheCameras: (THREE_2.PerspectiveCamera | Camera)[];
+    /** 当前样式参数 */
+    materialVersion: number;
+    private materialParameters;
     private disposed;
     constructor(options?: {
         onError?: (error: Error) => void;
@@ -1793,16 +1811,19 @@ export declare class Model extends THREE_2.Object3D {
     });
     get empty(): boolean;
     /** 获取材质参数 */
-    getMaterial(): ModelMaterialValues;
+    getMaterial(): PBMParameters;
     /** 设置材质参数 */
-    setMaterial(values: Partial<ModelMaterialValues>): void;
+    setMaterial(values: Partial<PBMParameters>): void;
     /**
      * 当前显示的楼层
      */
-    get shownFloor(): PBMParameters['floorIndex'] | null;
-    set shownFloor(floorIndex: PBMParameters['floorIndex'] | null);
-    get shownfloor(): PBMParameters['floorIndex'] | null;
-    set shownfloor(floorIndex: PBMParameters['floorIndex'] | null);
+    get shownFloorIndex(): PBMParameters['shownFloorIndex'];
+    set shownFloorIndex(floorIndex: PBMParameters['shownFloorIndex']);
+    /**
+     * 当前显示的楼层
+     */
+    get shownFloor(): number | null;
+    set shownFloor(floor: number | null);
     /**
      * 显示某楼层
      * @example
@@ -1811,7 +1832,7 @@ export declare class Model extends THREE_2.Object3D {
      * model.show(1) //显示第一楼层
      * ```
      */
-    show(floorIndex?: PBMParameters['floorIndex'] | null): void;
+    show(floor?: number | null): void;
     /**
      * 裁切
      */
@@ -1830,16 +1851,32 @@ export declare class Model extends THREE_2.Object3D {
      * @param floors - 和某一楼层做碰撞检测， 不传为和所有楼层做碰撞检测
      * @returns 返回碰撞
      */
-    intersectRaycaster(raycaster: THREE_2.Raycaster): Intersection[];
+    intersectRaycaster(raycaster: THREE_2.Raycaster, floor?: undefined | null | number, sortByDistance?: boolean): Intersection[];
     /**
      * 加载模型
      * @param work - work 的
      * @param imageOptions - 图片参数
      */
     load(work: Work, options?: {
-        networkSubscribe?: NetworkSubscribe;
-        requestProxy?: (url: string) => string | Promise<string>;
         textureOptions?: TextureOptions;
+        "3d-tiles"?: {
+            /** 调试模式 */
+            debug?: boolean;
+            /** 显示图层 */
+            showLayers?: boolean | string[];
+            /** 可观测区域 */
+            viewerRequestVolume?: BoundingVolume;
+            /** 模型显示最小细化层级 */
+            minLevelOfDetail?: number;
+            /** 模型显示最大细化层级 */
+            maxLevelOfDetail?: number;
+            /** 模型最大内存缓存 */
+            maxMemoryUsage?: number;
+            /** 模型网络最大请求并发数 */
+            maxRequests?: number;
+            /** 模型屏幕空间误差计算最大值 */
+            maxScreenSpaceError?: number;
+        };
     }): Promise<void>;
     update(renderer: THREE_2.WebGLRenderer, camera: Camera, mode: Mode): void;
     /**
@@ -1859,21 +1896,35 @@ export declare interface ModelEvent extends BaseEvent {
     error: Error | null;
 }
 
-export declare interface ModelLodOptions {
-    maxDepth?: number;
-}
-
-export declare type ModelMaterialValues = Pick<PBMParameters, 'pano0' | 'pano1' | 'modelAlpha' | 'progress' | 'useBlackTransition' | 'opacity' | 'constantColor' | 'useEDL' | 'useHQWeight' | 'useHQDepth' | 'pointShape' | 'pointColorType' | 'pointSizeType' | 'pointSize' | 'pointMinSize' | 'pointMaxSize' | 'pointSizeAdaptiveScale' | 'gradientTexture'>;
+export declare type ModelMaterialValues = Omit<PBMParameters, 'clippers' | 'shownFloorIndex'>;
 
 export declare type Models = Model[] & {
     needsRender: boolean;
+    /** 包围盒 */
     bounding: THREE_2.Box3;
+    /** 是否家在完成 */
     loaded: boolean;
+    /** 是否细化完成 */
     refined: boolean;
-    materialVersion: string;
+    /** 细化成都 */
+    refineProgress: [number, number];
+    materialVersion: number;
+    /** 缓存相机 */
+    cacheCameras: (THREE_2.PerspectiveCamera | Camera)[];
+    /** 是否自动更新模型 */
+    autoUpdate: boolean;
+    /**
+     * 计算模型射线碰撞检测
+     * @param raycaster - THREE 射线对象
+     * @param floors - 和某一楼层做碰撞检测， 不传为和所有楼层做碰撞检测
+     * @returns 返回碰撞
+     */
     intersectRaycaster(raycaster: THREE_2.Raycaster): Intersection[];
+    /** 设置材质参数 */
     setMaterial(values: Partial<ModelMaterialValues>): void;
+    /** 获取材质参数 */
     getMaterial(): ModelMaterialValues;
+    /** 更新模型 */
     update(renderer: THREE_2.WebGLRenderer, camera: Camera, mode: Mode): void;
 };
 
@@ -1881,6 +1932,46 @@ 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 tileset(): Tileset;
+    get name(): string;
+    get type(): "point_cloud" | "mesh";
+    get upAxis(): string;
+    get groundHeight(): number;
+    get model(): Model;
+    /**
+     * @deprecated
+     * 使用 modelViewLayer.scene.localToLla(new THREE.Vector()) 替代
+     */
+    get coordinates(): string;
+    /**
+     * @deprecated
+     * 使用 modelViewLayer.scene.coordinateTransform 替代
+     */
+    getTransformMatrix4(target?: THREE_2.Matrix4): THREE_2.Matrix4;
+    /**
+     * @deprecated
+     * 使用 modelViewLayer.scene.llaToWorld 替代
+     */
+    coordinatesToWorldPoint(coordinates: {
+        longitude: number;
+        latitude: number;
+        altitude: number;
+    }): THREE_2.Vector3;
+    /**
+     * @deprecated
+     * 使用 modelViewLayer.scene.llaToWorld 替代
+     */
+    worldPointToCoordinates(point: THREE_2.Vector3): {
+        longitude: number;
+        latitude: number;
+        altitude: number;
+    };
+}
+
 export declare interface MotionKeyframe<K extends string> {
     progress: number;
     value: MotionValue<K>;
@@ -1889,21 +1980,27 @@ export declare interface MotionKeyframe<K extends string> {
 
 export declare type MotionValue<K extends string> = Record<K, number>;
 
+/**
+ * 动画模式
+ * @description
+ * - `fly` 通过相机移动方式变化
+ * - `instant` 直接变化
+ * - `fade` 通过渐变方式变化
+ * - `montage` 通过渐变穿插到黑屏方式变化
+ * - `spread` 通过扩散方式变化
+ * - `zoomin` 通过放大变化
+ * - `zoomout` 通过缩小变化
+ */
+export declare type MovePanoEffect = "fly" | "instant" | "fade" | "montage" | "spread" | "zoomin" | "zoomout";
+
 /**
  * 点位移动参数
  */
 export declare interface MovePanoOptions extends Partial<Omit<State, "offset" | 'distance' | 'mode'>> {
-    /** 是否通过初始化参数限制 fov, latitude */
-    limit?: boolean;
     /**
      * 动画模式
-     * @description
-     * - `fly` 通过相机移动方式变化
-     * - `fade` 通过渐变方式变化
-     * - `montage` 通过渐变穿插到黑屏方式变化
-     * - `instant` 通过插入黑屏方式变化
      */
-    effect?: "fly" | "fade" | "montage" | "instant";
+    effect?: MovePanoEffect;
     /**
      * 运动耗时
      * @description
@@ -1912,8 +2009,6 @@ export declare interface MovePanoOptions extends Partial<Omit<State, "offset" |
      * - `不传或者null` 通过距离和速度（速度为five初始化设置）
      */
     duration?: number | ((distance: number, speed: number) => number) | string | null;
-    /** 运动曲线函数 */
-    easing?: (k: number) => number;
     /** 运动开始回调 */
     moveStartCallback?: (toState: State) => void;
     /** 运动结束回调 */
@@ -1929,6 +2024,18 @@ export declare interface MovePanoOptions extends Partial<Omit<State, "offset" |
     moveCancelCallback?: () => void;
 }
 
+export declare class NetworkAbortError extends Error {
+    constructor(source: string, type: NetworkType);
+}
+
+export declare type NetworkError = NetworkResponseError | NetworkAbortError | NetworkTimeoutError | NetworkFirbiddenError;
+
+export declare type NetworkErrorCallback = (error: NetworkError) => void;
+
+export declare class NetworkFirbiddenError extends Error {
+    constructor(source: string, type: NetworkType, reason: string);
+}
+
 export declare type NetWorkMeta = {
     origin: string;
     source: string;
@@ -1952,6 +2059,8 @@ export declare interface NetworkOptions {
     allowHosts?: string[];
 }
 
+export declare type NetworkProgressCallback = (percent: number) => void;
+
 export declare interface NetworkResourceEvent extends BaseEvent {
     source: string;
     requestType: NetworkType;
@@ -1964,6 +2073,11 @@ export declare type NetworkResponse<T = any, E extends NetWorkMeta | NetWorkMeta
     meta: E;
 };
 
+export declare class NetworkResponseError extends Error {
+    httpStatus: number;
+    constructor(source: string, type: NetworkType, status: number);
+}
+
 export declare type NetworkState = "ok" | "preload" | "error" | "proxy-error" | "timeout" | "forbidden";
 
 export declare class NetworkSubscribe extends Subscribe<{
@@ -1971,6 +2085,12 @@ export declare class NetworkSubscribe extends Subscribe<{
 }> {
 }
 
+export declare type NetworkSuccessCallback<T = any> = (response: NetworkResponse<T>) => void;
+
+export declare class NetworkTimeoutError extends Error {
+    constructor(source: string, type: NetworkType, timeout: number);
+}
+
 export declare type NetworkType = "XMLHttpRequest" | "Script" | "Image" | "Link";
 
 export declare interface ObjectEvent extends BaseEvent {
@@ -2186,6 +2306,14 @@ export declare interface PanoTextureEvent extends BaseEvent {
     error: Error | null;
 }
 
+export declare type ParsedResultType = {
+    type: 'b3dm' | 'pnts' | 'at3d' | 'pbm' | 'dome' | 'domez' | 'glb';
+    byteLength: number;
+    uri: string;
+    object: THREE_2.Object3D;
+    dispose: () => void;
+};
+
 /**
  * 解析 Work 数据
  * @param obj - work 数据，从如数开发者平台获取
@@ -2195,6 +2323,8 @@ export declare interface PanoTextureEvent extends BaseEvent {
 export declare function parseWork(obj: Work | LooseWork | string | any, options?: ParseWorkOptions): Work;
 
 export declare type ParseWorkOptions = {
+    /** 位姿 */
+    transform?: THREE_2.Matrix4 | number[];
     /** 重置 WorkCode */
     workCode?: string | ((input: any) => string);
     /** 重写资源前缀 */
@@ -2203,20 +2333,12 @@ export declare type ParseWorkOptions = {
     shortPath?: boolean;
     /** 资源使用 jsonp 方式发布 */
     jsonp?: boolean;
-    /** 调试 */
-    debug?: boolean;
-    /** 位姿 */
-    transform?: THREE_2.Matrix4 | number[];
-    /** 可视区域 */
-    viewerRequestVolume?: BoundingVolume | BoundingVolumeJson;
-    /** 模型显示最大细化层级 */
-    modelMaxLevelOfDetail?: number;
-    /** 模型最大内存缓存 */
-    modelMaxMemoryUsage?: number;
-    /** 模型网络最大请求并发数 */
-    modelMaxRequests?: number;
-    /** 模型屏幕空间误差计算最大值 */
-    modelMaxScreenSpaceError?: number;
+    traverseResource?: (resource: {
+        origin: string;
+        absolute: string;
+        relative: string;
+        type: "panorama" | "texture" | "model";
+    }) => void;
 };
 
 /** PBM 模型组 */
@@ -2226,87 +2348,73 @@ export declare class PBMContainer extends THREE_2.Group {
     needsRender: boolean;
     /** 当前样式参数 */
     materialParameters: PBMParameters;
-    cache: PBMMaterialReferenceCache;
     constructor();
     /** 获取材质参数 */
     getMaterial(): PBMParameters;
     /** 设置材质参数 */
     setMaterial(parameters: Partial<PBMParameters>): void;
-    update(renderer: THREE_2.WebGLRenderer, camera: Camera): void;
-    /** 析构材质 */
-    dispose(): void;
 }
 
 /** PBM 模型组 */
 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;
+    model?: Model;
+    constructor(geometry: THREE_2.BufferGeometry, materials: PBMMeshMaterial[]);
 }
 
 /** PBM 材质 */
 export declare class PBMMeshMaterial extends THREE_2.ShaderMaterial implements PBMParameters {
     /** 更新版本 */
-    pbmMaterialParametersVersion: number;
+    syncModelVersion?: string;
     /** 起始点 */
-    pano0: PBMPanoPicture | null;
+    pano0: PBMParameters['pano0'];
     /** 结束点 */
-    pano1: PBMPanoPicture | null;
+    pano1: PBMParameters['pano1'];
     /** 模型贴图和全景图的混合程度 [0-1] */
-    modelAlpha: number;
+    modelAlpha: PBMParameters['modelAlpha'];
     /** 全景图混合程度 [0-1] */
-    progress: number;
-    /** 全景图通过过度黑色混合 */
-    useBlackTransition: boolean;
+    progress: PBMParameters['progress'];
+    /** 全景图过度混合 */
+    transition: PBMParameters['transition'];
     /** 模型透明度 */
-    opacity: number;
+    opacity: PBMParameters['opacity'];
     /** 模型颜色*/
-    constantColor: THREE_2.Vector3 | null;
+    constantColor: PBMParameters['constantColor'];
     /** 楼层参数*/
-    floorIndex: number;
+    shownFloorIndex: PBMParameters['shownFloorIndex'];
     /** 对外模型裁切参数*/
-    clippers: ClipperParameter[] | null;
+    clippers: PBMParameters['clippers'];
     /** edl*/
-    useEDL: boolean;
+    useEDL: PBMParameters['useEDL'];
     /** hq*/
-    useHQWeight: boolean;
+    useHQWeight: PBMParameters['useHQWeight'];
     /** HQDepthMask*/
-    useHQDepth: boolean;
+    useHQDepth: PBMParameters['useHQDepth'];
     /** 点云着色方式*/
-    pointColorType: PBMPointColorType;
+    pointColor: PBMParameters['pointColor'];
     /** 点云大小绘制方式*/
-    pointSizeType: PBMPointSizeType;
+    pointSize: PBMParameters['pointSize'];
     /** 点云形状*/
-    pointShape: PBMPointShapeType;
+    pointShape: PBMParameters['pointShape'];
     /** 点云基础大小*/
-    pointSize: number;
-    /** 自适应点云大小因子*/
-    pointSizeAdaptiveScale: number;
-    /** 点云最大尺寸*/
-    pointMinSize: number;
-    /** 点云最小尺寸*/
-    pointMaxSize: number;
+    pointScale: PBMParameters['pointScale'];
+    /** 点云背面绘制方式*/
+    pointBack: PBMParameters['pointBack'];
+    /** 点云像素最小值*/
+    pointMinPixel: PBMParameters['pointMinPixel'];
+    /** 点云像素最大值*/
+    pointMaxPixel: PBMParameters['pointMaxPixel'];
     /** 高程彩色图*/
-    gradientTexture: THREE_2.Texture | null;
+    gradientTexture: PBMParameters['gradientTexture'];
+    /** 所属楼层*/
+    floor: number;
     constructor(parameters?: Partial<PBMParameters>);
-    update(renderer: THREE_2.WebGLRenderer, camera: Camera, cache: PBMMaterialReferenceCache): void;
+    onBeforeCompile(shader: THREE_2.Shader, renderer: THREE_2.WebGLRenderer): void;
+    update(renderer: THREE_2.WebGLRenderer, camera: THREE_2.Camera): void;
+    syncModel(model: Model): void;
 }
 
 export declare interface PBMPanoPicture {
@@ -2316,6 +2424,8 @@ export declare interface PBMPanoPicture {
     luminanceMap: null | THREE_2.CubeTexture | TileCubeTextureTarget;
     /** 起始点全景图变换矩阵 4x4 */
     matrix: THREE_2.Matrix4;
+    /** 缩放 */
+    zoom: number;
 }
 
 /** PBM 材质参数 */
@@ -2328,12 +2438,12 @@ export declare interface PBMParameters {
     modelAlpha: number;
     /** 全景图混合程度 [0-1] */
     progress: number;
-    /** 全景图通过过度黑色混合 */
-    useBlackTransition: boolean;
+    /** 全景图过度混合 */
+    transition: 'BLACK' | 'SPREAD' | 'FADE';
     /** 模型透明度 */
     opacity: number;
     /** 楼层参数*/
-    floorIndex: number;
+    shownFloorIndex: number;
     /** 模型裁切参数（工程侧调用）*/
     clippers: ClipperParameter[] | null;
     /** 模型颜色*/
@@ -2345,38 +2455,23 @@ export declare interface PBMParameters {
     /** 是否使用HQ_DEPTH_MASK*/
     useHQDepth: boolean;
     /** 点云形状*/
-    pointShape: PBMPointShapeType;
+    pointShape: 'SQUARE' | 'CIRCLE';
     /** 点云着色方式*/
-    pointColorType: PBMPointColorType;
+    pointColor: 'RGB' | 'ALTITUDE';
     /** 点云大小绘制方式*/
-    pointSizeType: PBMPointSizeType;
+    pointSize: 'FIXED' | 'ATTENUATION' | 'GEOMETRIC';
+    /** 点云背面绘制方式*/
+    pointBack: 'VISIBLE' | 'HIDDEN' | 'DARK';
     /** 点云基础大小*/
-    pointSize: number;
+    pointScale: number;
     /** 点云最大尺寸*/
-    pointMinSize: number;
+    pointMinPixel: number;
     /** 点云最小尺寸*/
-    pointMaxSize: number;
-    /** 自适应点云尺寸因子*/
-    pointSizeAdaptiveScale: number;
+    pointMaxPixel: 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"
-}
-
 /**
  * 相机位姿
  * [[include: coordinate.md]]
@@ -2396,7 +2491,7 @@ export declare interface Pose {
 
 export declare type PostProcessingType = 'edl' | 'hq' | 'luminance' | null;
 
-export declare const PROXY_CONTROLLER_EVENT_NAMES: readonly ["gesture.pan", "gesture.tap", "gesture.press", "gesture.pinch", "gesture.mousewheel", "gesture.mousemove", "gesture.momentum", "initAnimation.start", "initAnimation.end", "camera.update", "intersect.update", "pano.select", "pano.moveTo", "pano.moving", "pano.arrived", "pano.cancel", "pano.error", "pano.texture.load", "pano.texture.progress", "pano.texture.success", "pano.texture.error", "pano.texture.abort", "xr.session.start", "xr.session.end", "xr.gesture.tap", "xr.gesture.press", "xr.gesture.buttonUp", "xr.gesture.buttonDown"];
+export declare const PROXY_CONTROLLER_EVENT_NAMES: readonly ["gesture.pan", "gesture.tap", "gesture.press", "gesture.pinch", "gesture.mousewheel", "gesture.mousemove", "gesture.momentum", "initAnimation.start", "initAnimation.end", "camera.update", "intersect.update", "pano.select", "pano.moveTo", "pano.moving", "pano.arrived", "pano.cancel", "pano.error", "pano.texture.load", "pano.texture.progress", "pano.texture.success", "pano.texture.error", "pano.texture.abort", "xr.session.start", "xr.session.end", "xr.gesture.tap", "xr.gesture.press", "xr.gesture.buttonUp", "xr.gesture.buttonDown", "xr.controller.update"];
 
 export declare class RegionBoundingVolume implements BoundingVolume {
     type: "regin";
@@ -2415,8 +2510,9 @@ export declare class RegionBoundingVolume implements BoundingVolume {
     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;
+    distanceToPoint(point: THREE_2.Vector3): number;
+    distanceSquaredToPoint(point: THREE_2.Vector3): number;
+    distanceToPlane(plane: THREE_2.Plane): number;
     intersectPlane(plane: THREE_2.Plane): VolumePlaneIntersect;
     intersectRay(ray: THREE_2.Ray): boolean;
 }
@@ -2520,10 +2616,11 @@ export declare class SphereBoundingVolume implements BoundingVolume {
     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;
+    distanceSquaredToPoint(point: THREE_2.Vector3): number;
+    distanceToPoint(point: THREE_2.Vector3): number;
+    distanceToPlane(plane: THREE_2.Plane): number;
     intersectPlane(plane: THREE_2.Plane): VolumePlaneIntersect;
-    intersectRay(ray: THREE_2.Ray): boolean;
+    intersectRay(ray: THREE_2.Ray, far?: number): boolean;
 }
 
 export declare type SphereBoundingVolumeJson = {
@@ -2642,7 +2739,7 @@ export declare namespace SubscribeMixinType {
 }
 
 export declare class TextureLoader {
-    loadTexture(source: string, options?: {
+    loadTexture(source: string, options: {
         imageURL?: {
             transform?: (source: string, options: ImageURLOptions) => string;
             options?: ImageURLOptions;
@@ -2651,11 +2748,14 @@ export declare class TextureLoader {
         format?: THREE_2.PixelFormat;
         minFilter?: THREE_2.TextureFilter;
         magFilter?: THREE_2.TextureFilter;
+        generateMipmaps?: boolean;
         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>>;
+        timeout?: number;
+        fetcher: Fetcher;
+    }, 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;
@@ -2664,12 +2764,14 @@ export declare class TextureLoader {
         format?: THREE_2.PixelFormat;
         minFilter?: THREE_2.TextureFilter;
         magFilter?: THREE_2.TextureFilter;
+        generateMipmaps?: boolean;
         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[]>>;
+        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: {
-        tileImageSize?: number;
         tileMaxLevel?: number;
         imageURL?: {
             transform?: (source: string, options: ImageURLOptions) => string;
@@ -2678,10 +2780,13 @@ export declare class TextureLoader {
         format?: THREE_2.PixelFormat;
         minFilter?: THREE_2.TextureFilter;
         magFilter?: THREE_2.TextureFilter;
+        generateMipmaps?: boolean;
         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[]>>;
+        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[]>>;
 }
 
 /**
@@ -2735,7 +2840,6 @@ export declare class Tile {
         requestedFrameNumber: number;
         touchedFrameNumber: number;
         selectionDepth: number;
-        centerZDepth: number;
         shouldRefine: boolean;
         distanceToCamera: number;
         screenSpaceError: number;
@@ -2761,57 +2865,95 @@ export declare class Tile {
 }
 
 export declare class Tile3DModel extends THREE_2.Object3D {
+    static DEFAULT_MIN_LEVEL_OF_DETAIL: number;
     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;
+    type: 'point_cloud' | 'mesh';
+    upAxis: string;
+    model: Model;
+    viewLayer?: ModelViewLayer;
+    search: string;
+    groundHeight: number | null;
+    coordinateTransform: {
+        localToEnuMatrix: THREE_2.Matrix4;
+        enuToLocalMatrix: THREE_2.Matrix4;
+        enuToEcefMatrix: THREE_2.Matrix4;
+        ecefToEnuMatrix: THREE_2.Matrix4;
+        viewToEcefMatrix: THREE_2.Matrix4;
+        ecefToViewMatrix: THREE_2.Matrix4;
+    };
     tileset: Tileset;
+    idle: boolean;
+    minLevelOfDetail: number;
     maxLevelOfDetail: number;
     boundingBox: THREE_2.Box3;
     needsRefined: boolean;
     refined: boolean;
+    refineProgress: [number, number];
     loaded: boolean;
-    disposed: boolean;
     needsRender: boolean;
-    lastRefineTime: number;
-    nodeGroup: THREE_2.Group;
-    debugBoundingGroup: THREE_2.Group;
+    cacheCameras: (THREE_2.PerspectiveCamera | Camera)[];
+    private lastRefineTime;
+    private disposed;
+    private nodeGroup;
+    private debugBoundingGroup;
     private nodes;
     private debugBoundings;
     private unloadTileQueue;
-    constructor(workCode: string, tilesetHeader: TilesetHeader, options: Partial<Tile3DModelLoaderOptions>);
+    constructor(model: Model, tilesetHeader: TilesetHeader, options: 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);
+    localToEnu(vector: THREE_2.Vector3): THREE_2.Vector3;
+    enuToLocal(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;
+    llaToLocal(vector: THREE_2.Vector3): THREE_2.Vector3;
+    worldToEnu(vector: THREE_2.Vector3): THREE_2.Vector3;
+    enuToWorld(vector: THREE_2.Vector3): THREE_2.Vector3;
+    worldToEcef(vector: THREE_2.Vector3): THREE_2.Vector3;
+    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, options: {
-        allowHosts?: string[];
-        requestProxy?: (url: string) => string | Promise<string>;
-        networkSubscribe?: NetworkSubscribe;
+        fetcher: Fetcher;
     }): Promise<boolean>;
-    intersectRaycaster(raycaster: THREE_2.Raycaster): Intersection[];
+    intersectRaycaster(raycaster: THREE_2.Raycaster, sortByDistance?: boolean, target?: Intersection[]): Intersection[];
     update(renderer: THREE_2.WebGLRenderer, camera: Camera): void;
     dispose(): void;
 }
 
 /** Advanced loader options */
 export declare interface Tile3DModelLoaderOptions {
+    name: string;
+    type: 'point_cloud' | 'mesh';
+    upAxis: string;
+    referer: string;
+    fetcher: Fetcher;
     resourcePath: string;
-    allowHosts?: string[];
-    requestProxy?: (url: string) => string | Promise<string>;
-    networkSubscribe?: NetworkSubscribe;
+    groundHeight: number | null;
+    coordinateTransform: {
+        localToEnuMatrix: THREE_2.Matrix4;
+        enuToLocalMatrix: THREE_2.Matrix4;
+        enuToEcefMatrix: THREE_2.Matrix4;
+        ecefToEnuMatrix: THREE_2.Matrix4;
+        viewToEcefMatrix: THREE_2.Matrix4;
+        ecefToViewMatrix: THREE_2.Matrix4;
+    };
+    search?: string;
     onError?: (error: Error) => void;
 }
 
 export declare type TileContentData = {
-    type: 'b3dm' | 'pnts' | 'at3d' | 'pbm';
+    type: 'b3dm' | 'pnts' | 'at3d' | 'pbm' | 'dome' | 'domez' | 'glb';
     byteLength: number;
     uri: string;
     object: TileNode;
@@ -2841,7 +2983,6 @@ export declare class TileCubeTextureTarget {
     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;
@@ -2850,9 +2991,12 @@ export declare class TileCubeTextureTarget {
         format?: THREE_2.PixelFormat;
         minFilter?: THREE_2.TextureFilter;
         magFilter?: THREE_2.TextureFilter;
+        generateMipmaps?: boolean;
         wrapS?: THREE_2.Wrapping;
         wrapT?: THREE_2.Wrapping;
-    } & NetworkOptions, renderer: THREE_2.WebGLRenderer);
+        timeout?: number;
+        fetcher: Fetcher;
+    }, renderer: THREE_2.WebGLRenderer);
     get cubeRenderTarget(): THREE_2.WebGLCubeRenderTarget | null;
     set cubeRenderTarget(cubeRenderTarget: THREE_2.WebGLCubeRenderTarget | null);
     private requestTile;
@@ -2882,11 +3026,10 @@ export declare interface TileHeader {
 }
 
 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[];
+    private disposers;
+    constructor(obj: THREE_2.Object3D, objDisposer: () => void);
+    generateBvhTree(): Promise<void>;
+    intersectRaycaster(raycaster: THREE_2.Raycaster, sortByDistance?: boolean, target?: Intersection[]): Intersection[];
     dispose(): void;
 }
 
@@ -2898,26 +3041,50 @@ export declare class Tileset {
     asset: {
         version: string;
         tilesetVersion: string;
-        gltfUpAxis: "X" | "Y" | "Z";
+        gltfUpAxis: "Y" | "Z";
+        overview?: {
+            imageFile: string;
+            worldFile: string;
+            imageWidth: number;
+            imageHeight: number;
+        };
+        [key: string]: any;
     };
     id: string;
+    referer: string;
     frameNumber: number;
     properties: Record<string, any>;
     options: TilesetOptions;
     root: Tile;
-    transfrom: THREE_2.Matrix4;
+    rootMeta: {
+        creationTime?: string;
+        upAxis?: string;
+        coordinate?: {
+            base_keyframe: number;
+            base_trajectory: number;
+            coordinate_system: string;
+            ground_height: number;
+            lon_lat_alt: [number, number, number];
+            pose_ecef_to_enu: number[];
+            pose_enu_to_ecef: number[];
+            version: number;
+        };
+    };
+    transform: THREE_2.Matrix4;
+    transformIsIdentity: boolean;
     geometricError: number;
-    traverser: TilesetTraverser;
+    private traverser;
     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 skipLevelOfDetail(): boolean;
+    set skipLevelOfDetail(value: boolean);
     get maxScreenSpaceError(): number;
     set maxScreenSpaceError(value: number);
     get selectedTiles(): Map<string, Tile>;
@@ -2926,11 +3093,7 @@ export declare class Tileset {
     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;
+    traverse(frameState: TilesetFrameState, cacheFrameStates?: TilesetFrameState[]): void;
     loadTile(tile: Tile): void;
     unloadTile(tile: Tile): void;
 }
@@ -2950,14 +3113,19 @@ export declare class TilesetCache {
 
 export declare type TilesetFrameState = {
     camera: {
+        type: "PerspectiveCamera" | "OrthographicCamera";
         position: THREE.Vector3;
         direction: THREE.Vector3;
         up: THREE.Vector3;
+        visible: boolean;
+        refine: boolean;
     };
     height: number;
+    pixelRatio: number;
     cullingVolume: CullingVolume;
     frameNumber: number;
     sseDenominator: number;
+    minLevelOfDetail: number;
     maxLevelOfDetail: number;
 };
 
@@ -2965,21 +3133,40 @@ export declare interface TilesetHeader {
     asset: {
         version: string;
         tilesetVersion?: string;
-        gltfUpAxis?: "X" | "Y" | "Z";
+        gltfUpAxis?: "Y" | "Z";
+        overview?: {
+            imageFile: string;
+            worldFile: string;
+            imageWidth: number;
+            imageHeight: number;
+        };
+        [key: string]: any;
     };
     properties?: Record<string, any>;
     geometricError: number;
     root: TileHeader;
+    rootMeta?: {
+        creationTime?: string;
+        upAxis?: string;
+        coordinate?: {
+            base_keyframe: number;
+            base_trajectory: number;
+            coordinate_system: string;
+            ground_height: number;
+            lon_lat_alt: [number, number, number];
+            pose_ecef_to_enu: number[];
+            pose_enu_to_ecef: number[];
+            version: number;
+        };
+    };
 }
 
 export declare interface TilesetOptions {
+    referer?: string;
+    contentLoader: (tile: Tile) => Promise<boolean>;
     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 {
@@ -2990,15 +3177,15 @@ export declare class TilesetTraverser {
     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 _canSelectTile;
     private _traversalStack;
     private _emptyTraversalStack;
-    constructor(onTraversalEnd: (frameState: TilesetFrameState) => any);
-    traverse(root: Tile, frameState: TilesetFrameState): void;
+    constructor();
+    traverse(root: Tile, frameState: TilesetFrameState, cacheFrameStates?: TilesetFrameState[]): void;
     reset(): void;
     private executeTraversal;
     private updateChildTiles;
@@ -3031,8 +3218,8 @@ export declare interface VRPanoramaControllerCustomInitArgs extends Omit<Panoram
 
 export declare interface WebXRAxesParams {
     raycaster: {
-        leftRay: THREE_2.Raycaster;
-        rightRay: THREE_2.Raycaster;
+        leftRay?: THREE_2.Raycaster;
+        rightRay?: THREE_2.Raycaster;
     };
     axesState: {
         up: number;
@@ -3071,8 +3258,19 @@ export declare class Work {
     observers: WorkObserver[];
     /** 数据签发人 */
     issuer: string;
-    /** 控制参数 */
-    options: WorkOptions;
+    /** 位姿修正 */
+    transform: THREE_2.Matrix4;
+    /**
+     * 控制参数
+     * @deprecated 通过 work.transform 替换
+     */
+    options: {
+        /**
+         * 位姿修正
+         * @deprecated 通过 work.transform 替换
+         */
+        transform: THREE_2.Matrix4;
+    };
     /** 原始数据 */
     raw: {
         works: string[];
@@ -3102,14 +3300,16 @@ export declare interface WorkCubeImage {
     front: string;
     /** 全景图 back */
     back: string;
+    /** 分辨率表 */
+    sizeList?: number[];
 }
 
 /** 全景图 */
 export declare interface WorkImage extends WorkCubeImage {
-    /** 深度图 */
-    depth?: string;
     /** 光照强度图 */
-    luminance?: WorkCubeImage;
+    luminance?: WorkCubeImage & {
+        tiles?: WorkTile[];
+    };
     /** 瓦片信息 */
     tiles?: WorkTile[];
 }
@@ -3168,6 +3368,8 @@ export declare interface WorkObserver {
     floorIndex: number;
     /** 点位 derived_id */
     derivedId?: number;
+    /** 点位 derived_id_str */
+    derivedIdStr?: string;
     /** 点位是否激活可用 */
     active: boolean;
     /** 点位是否可加载 */
@@ -3192,23 +3394,6 @@ export declare interface WorkObserver {
     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 interface WorkResolvedObserver extends WorkObserver {
     isResolved: true;
 }
@@ -3231,6 +3416,7 @@ export declare interface WorksEvent extends BaseEvent {
 export declare interface WorkTile {
     level: number;
     size: number;
+    scale: number;
     up: string;
     down: string;
     right: string;
@@ -3254,20 +3440,36 @@ export declare class XRButton {
 }
 
 export declare interface XRControllerEvent extends BaseEvent {
-    controller: {
-        type: 'left' | 'right';
+    left: {
         axes: {
             up: number;
             down: number;
             left: number;
             right: number;
         };
-        raycaster: {
-            leftRay: THREE_2.Raycaster;
-            rightRay: THREE_2.Raycaster;
+        raycaster: THREE_2.Raycaster;
+        deltaTime: number;
+    };
+    right: {
+        axes: {
+            up: number;
+            down: number;
+            left: number;
+            right: number;
         };
+        raycaster: THREE_2.Raycaster;
         deltaTime: number;
     };
+    buttons: {
+        X: boolean;
+        Y: boolean;
+        LeftTrigger: boolean;
+        LeftPinch: boolean;
+        A: boolean;
+        B: boolean;
+        RightTrigger: boolean;
+        RightPinch: boolean;
+    };
 }
 
 export declare interface XRGestureEvent extends BaseEvent {