@realsee/five 6.0.0-alpha.7 → 6.0.0-alpha.70

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;
@@ -64,7 +73,7 @@ export declare interface BoundingVolume {
     distanceSquaredTo(point: THREE_2.Vector3): number;
     distanceTo(point: THREE_2.Vector3): 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;
@@ -90,70 +99,13 @@ export declare class BoxBoundingVolume implements BoundingVolume {
     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 +113,16 @@ export declare class Camera extends THREE_2.Camera {
     near: number;
     far: number;
     perspToOrtho: THREE_2.Vector2;
-    orthoDistance: number;
+    screenHeight: number;
+    pixelRatio: number;
     /** 相机姿态 */
     pose: CameraPose;
     private perspectiveCamera;
     private orthographicCamera;
     needsRender: 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, screenHeight?: number, pixelRatio?: number);
+    get orthoDistance(): number;
     get zoom(): number;
     get top(): number;
     get bottom(): number;
@@ -203,17 +157,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(clipperParameters: ClipperParameter[], camera: THREE_2.Camera): void;
-    private projectPlanes;
-}
-
 export declare interface ClipperParameter {
     clippingBoxMatrix: THREE_2.Matrix4;
     floorIndex?: number;
@@ -284,10 +227,26 @@ export declare type ControllerEventTypes = {
     "xr.session.start"(event: XRSessionEvent_2): void;
     /** XR 手势（按钮） */
     "xr.gesture.tap"(event: XRGestureEvent): void;
+    /** XR 手势（按钮） */
+    "xr.gesture.press"(event: XRGestureEvent): void;
+    /** XR 手势（按钮） */
+    "xr.gesture.buttonUp"(event: XRGestureEvent): void;
+    /** XR 手势（按钮） */
+    "xr.gesture.buttonDown"(event: XRGestureEvent): void;
+    /** XR手柄更新*/
+    "xr.controller.update"(event: XRControllerEvent): void;
     /** 抛出错误 */
     "error"(error: Error): void;
 };
 
+export declare type CoordinatesSystemTransformer = {
+    name: string;
+    transformToEarthCentered: (xyz: THREE.Vector3) => THREE.Matrix4 | Promise<THREE.Matrix4>;
+} | {
+    name: string;
+    transformToUpAxisZ: (xyz: THREE.Vector3) => THREE.Matrix4 | Promise<THREE.Matrix4>;
+};
+
 export declare class CullingVolume {
     static get MASK_OUTSIDE(): number;
     static get MASK_INSIDE(): number;
@@ -295,6 +254,7 @@ 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;
     computeVisibility(boundingVolume: BoundingVolume): VolumePlaneIntersect;
     computeVisibilityWithPlaneMask(boundingVolume: BoundingVolume, parentPlaneMask: number): number;
 }
@@ -307,6 +267,8 @@ export declare class CullingVolume {
  */
 export declare function defaultImageURLTransform(source: string, options: ImageURLOptions): string;
 
+export declare const defaultPbmParameters: PBMParameters;
+
 export declare interface DepthPanoramaControllerCustomInitArgs extends PanoramaLikeControllerCustomInitArgs {
     /** 最远可移动观察点距离 */
     maxAccessibleDistance?: number;
@@ -363,6 +325,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;
     /** 渲染后 */
@@ -381,6 +345,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展示器
  *
@@ -398,6 +370,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
@@ -429,6 +403,8 @@ export declare class Five extends Subscribe<EventTypes> {
     currentMode: Mode;
     /** 内部使用的 `THREE.Scene` */
     scene: Scene;
+    /** 供外部放置需要在xr场景下产生遮挡的物体们*/
+    xrCustomObjectsScene: THREE_2.Scene;
     /** 内部使用的 `Camera` */
     camera: Camera;
     /**
@@ -474,12 +450,6 @@ export declare class Five extends Subscribe<EventTypes> {
      * 平衡加载时间和图片质量
      */
     textureOptions: TextureOptions;
-    /**
-     * 模型lod的配置参数
-     * @description
-     * 可以配置加载模型lod的相关参数
-     */
-    modelLodOptions: ModelLodOptions;
     /**
      * 模型贴图的配置参数
      * @description
@@ -506,6 +476,10 @@ export declare class Five extends Subscribe<EventTypes> {
      * ```
      */
     state: State;
+    /**
+     * 模型坐标转换
+     */
+    coordinatesSystemTransformers: CoordinatesSystemTransformer[];
     info: null | {
         memory: {
             geometries: number;
@@ -531,6 +505,7 @@ export declare class Five extends Subscribe<EventTypes> {
     private modelGroup;
     private helperGroup;
     private modeChangeDuration;
+    private enableWheel;
     private onlyRenderIfNeeds;
     private poweredByRealsee;
     private controller?;
@@ -670,7 +645,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
@@ -681,7 +656,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
@@ -943,6 +922,10 @@ export declare interface FiveInitArgs {
      * 给予更多外部操作的空间。
      */
     videoInstance?: HTMLVideoElement;
+    /**
+     * 模型坐标转换
+     */
+    coordinatesSystemTransformers?: CoordinatesSystemTransformer[];
     /** 全景图游走模式下的特定参数 */
     panorama?: ControllerCustomInitTypes["Panorama"];
     /** 模型游走模式下的特定参数 */
@@ -966,6 +949,10 @@ export declare interface FiveInitArgs {
      * @default `800`
      */
     modeChangeDuration?: number;
+    /**
+     * 是否支持滚轮
+     */
+    enableWheel?: boolean;
     /**
      * 插件定义
      * @description
@@ -980,22 +967,12 @@ export declare interface FiveInitArgs {
      * 是否使用webgl2渲染执行环境, 默认值 false
      */
     webgl2?: boolean;
-    /**
-     * 是否开启模型裁切
-     */
-    localClippingEnabled?: boolean;
     /**
      * 请求代理
      * @param url - 发起的请求
      * @returns 返回的请求
      */
     requestProxy?(url: string): string | Promise<string>;
-    /**
-     * 模型lod相关的配置，maxDepth为加载的最大深度
-     */
-    modelLod?: {
-        maxDepth?: number;
-    };
 }
 
 /**
@@ -1026,6 +1003,8 @@ parameters: Parameters<T>[1]
 export declare type FivePluginInstance<T extends FivePlugin<any, any>> = ReturnType<T>;
 
 export declare interface FloorplanControllerCustomInitArgs {
+    /** 默认水平角 */
+    defaultLongitude?: number;
     /** 默认俯仰角 */
     defaultLatitude?: number;
     /** 最大俯仰角 */
@@ -1098,8 +1077,9 @@ export declare interface ImageOptions {
 }
 
 export declare function imageSupport(): Promise<{
-    avif: boolean;
     webp: boolean;
+    avif: boolean;
+    heif: boolean;
 }>;
 
 export declare interface ImageURLMappings {
@@ -1131,8 +1111,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;
@@ -1147,15 +1129,9 @@ 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;
 }
 
 export declare class IntersectMesh extends THREE_2.Object3D implements IntersectMeshInterface {
@@ -1470,6 +1446,17 @@ export declare type LegacyEventType = {
      * axes代表控制杆，axes数组的0-1元素分别代表左控制器的左（-1）右（1）,左控制器的上（-1）下（1），axes数组的2-3元素同理
      */
     webXRControllerEvent(type: WebXRControllerType, key: WebXRControllerKey, params: WebXRControllerParams): void;
+    /**
+     * xr控制器的Axes原始实时数据状态
+     */
+    webXRAxesUpdate(type: 'left' | 'right', param: WebXRAxesParams): void;
+    /**
+     * xr控制器的控制器射线更新
+     */
+    webXRControllerRayUpdate(raycaster: {
+        leftRay?: THREE_2.Raycaster;
+        rightRay?: THREE_2.Raycaster;
+    }): void;
     /**
      * 准备加载 Work 数据
      * @param input - 输入的 work
@@ -1568,6 +1555,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;
@@ -1665,6 +1688,8 @@ export declare type LooseWorkWithExtrinsics = {
     transform?: number[];
     /** 可视区域 */
     viewerRequestVolume?: BoundingVolumeJson;
+    /** 模型显示最小细化层级 */
+    modelMinLevelOfDetail?: number;
     /** 模型显示最大细化层级 */
     modelMaxLevelOfDetail?: number;
     /** 模型最大内存缓存 */
@@ -1676,6 +1701,8 @@ export declare type LooseWorkWithExtrinsics = {
 };
 
 export declare interface MapviewControllerCustomInitArgs {
+    /** 默认水平角 */
+    defaultLongitude?: number;
     /** 默认俯仰角 */
     defaultLatitude?: number;
     /** 默认相机距离 */
@@ -1740,7 +1767,18 @@ export declare class Model extends THREE_2.Object3D {
         type: string;
         upAxis: string;
         coordinates: string;
-        scene: Tile3DModel;
+        scene: Tile3DModel | null;
+        error: Error | null;
+        coordinatesToWorldPoint: (coordinates: {
+            longitude: number;
+            latitude: number;
+            altitude: number;
+        }) => THREE_2.Vector3;
+        worldPointToCoordinates: (point: THREE_2.Vector3) => {
+            longitude: number;
+            latitude: number;
+            altitude: number;
+        };
     }[];
     onError: (error: Error) => void;
     onShownFloorChange: (floorIndex: number | null) => void;
@@ -1751,37 +1789,43 @@ 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;
+    coordinatesSystemTransformers: CoordinatesSystemTransformer[];
+    /** 缓存相机 */
+    cacheCameras: (THREE_2.PerspectiveCamera | Camera)[];
+    /** 当前样式参数 */
+    materialVersion: number;
+    private materialParameters;
     private disposed;
     constructor(options?: {
+        coordinatesSystemTransformers?: CoordinatesSystemTransformer[];
         onError?: (error: Error) => void;
         onShownFloorChange?: (floorIndex: number | null) => void;
         onLoad?: () => void;
     });
     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
@@ -1790,7 +1834,7 @@ export declare class Model extends THREE_2.Object3D {
      * model.show(1) //显示第一楼层
      * ```
      */
-    show(floorIndex?: PBMParameters['floorIndex'] | null): void;
+    show(floor?: number | null): void;
     /**
      * 裁切
      */
@@ -1809,15 +1853,13 @@ 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;
     }): Promise<void>;
     update(renderer: THREE_2.WebGLRenderer, camera: Camera, mode: Mode): void;
@@ -1842,16 +1884,33 @@ 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;
 };
@@ -1908,6 +1967,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;
@@ -1931,6 +2002,8 @@ export declare interface NetworkOptions {
     allowHosts?: string[];
 }
 
+export declare type NetworkProgressCallback = (percent: number) => void;
+
 export declare interface NetworkResourceEvent extends BaseEvent {
     source: string;
     requestType: NetworkType;
@@ -1943,6 +2016,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<{
@@ -1950,6 +2028,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 {
@@ -2165,6 +2249,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 数据，从如数开发者平台获取
@@ -2189,6 +2281,8 @@ export declare type ParseWorkOptions = {
     /** 可视区域 */
     viewerRequestVolume?: BoundingVolume | BoundingVolumeJson;
     /** 模型显示最大细化层级 */
+    modelMinLevelOfDetail?: number;
+    /** 模型显示最大细化层级 */
     modelMaxLevelOfDetail?: number;
     /** 模型最大内存缓存 */
     modelMaxMemoryUsage?: number;
@@ -2205,87 +2299,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;
+    progress: PBMParameters['progress'];
     /** 全景图通过过度黑色混合 */
-    useBlackTransition: boolean;
+    useBlackTransition: PBMParameters['useBlackTransition'];
     /** 模型透明度 */
-    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 {
@@ -2312,7 +2392,7 @@ export declare interface PBMParameters {
     /** 模型透明度 */
     opacity: number;
     /** 楼层参数*/
-    floorIndex: number;
+    shownFloorIndex: number;
     /** 模型裁切参数（工程侧调用）*/
     clippers: ClipperParameter[] | null;
     /** 模型颜色*/
@@ -2324,38 +2404,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]]
@@ -2375,7 +2440,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"];
+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";
@@ -2502,7 +2567,7 @@ export declare class SphereBoundingVolume implements BoundingVolume {
     distanceSquaredTo(point: THREE_2.Vector3): number;
     distanceTo(point: THREE_2.Vector3): 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 = {
@@ -2621,7 +2686,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;
@@ -2634,7 +2699,9 @@ export declare class TextureLoader {
         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;
@@ -2646,7 +2713,9 @@ export declare class TextureLoader {
         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;
@@ -2660,7 +2729,9 @@ export declare class TextureLoader {
         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[]>>;
 }
 
 /**
@@ -2714,7 +2785,6 @@ export declare class Tile {
         requestedFrameNumber: number;
         touchedFrameNumber: number;
         selectionDepth: number;
-        centerZDepth: number;
         shouldRefine: boolean;
         distanceToCamera: number;
         screenSpaceError: number;
@@ -2740,57 +2810,58 @@ 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;
+    objType: 'mesh' | 'point_cloud';
+    model: Model;
+    search: string;
     tileset: Tileset;
+    minLevelOfDetail: number;
     maxLevelOfDetail: number;
     boundingBox: THREE_2.Box3;
     needsRefined: boolean;
     refined: boolean;
+    refineProgress: [number, number];
     loaded: boolean;
-    disposed: boolean;
     needsRender: boolean;
-    lastRefineTime: number;
+    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, objType: 'mesh' | 'point_cloud', 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);
     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 {
+    fetcher: Fetcher;
     resourcePath: string;
-    allowHosts?: string[];
-    requestProxy?: (url: string) => string | Promise<string>;
-    networkSubscribe?: NetworkSubscribe;
+    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;
@@ -2831,7 +2902,9 @@ export declare class TileCubeTextureTarget {
         magFilter?: THREE_2.TextureFilter;
         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;
@@ -2861,11 +2934,9 @@ 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);
+    intersectRaycaster(raycaster: THREE_2.Raycaster, sortByDistance?: boolean, target?: Intersection[]): Intersection[];
     dispose(): void;
 }
 
@@ -2877,26 +2948,35 @@ 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;
     frameNumber: number;
     properties: Record<string, any>;
     options: TilesetOptions;
     root: Tile;
-    transfrom: THREE_2.Matrix4;
+    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>;
@@ -2905,11 +2985,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;
 }
@@ -2932,11 +3008,14 @@ export declare type TilesetFrameState = {
         position: THREE.Vector3;
         direction: THREE.Vector3;
         up: THREE.Vector3;
+        visible: boolean;
     };
     height: number;
+    pixelRatio: number;
     cullingVolume: CullingVolume;
     frameNumber: number;
     sseDenominator: number;
+    minLevelOfDetail: number;
     maxLevelOfDetail: number;
 };
 
@@ -2944,7 +3023,14 @@ 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;
@@ -2952,13 +3038,10 @@ export declare interface TilesetHeader {
 }
 
 export declare interface TilesetOptions {
+    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 {
@@ -2969,15 +3052,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;
@@ -3008,13 +3091,30 @@ export declare enum VolumePlaneIntersect {
 export declare interface VRPanoramaControllerCustomInitArgs extends Omit<PanoramaControllerCustomInitArgs, "maxLatitude" | "minLatitude"> {
 }
 
+export declare interface WebXRAxesParams {
+    raycaster: {
+        leftRay?: THREE_2.Raycaster;
+        rightRay?: THREE_2.Raycaster;
+    };
+    axesState: {
+        up: number;
+        down: number;
+        left: number;
+        right: number;
+    };
+    deltaTime: number;
+}
+
 export declare type WebXRControllerKey = XRGestureEvent['buttons'];
 
 export declare interface WebXRControllerParams {
-    raycaster: THREE_2.Raycaster[];
+    raycaster: {
+        leftRay: THREE_2.Raycaster;
+        rightRay: THREE_2.Raycaster;
+    };
 }
 
-export declare type WebXRControllerType = 'tap' | 'press' | 'axes';
+export declare type WebXRControllerType = 'tap' | 'press' | 'axes' | 'buttonUp' | 'buttonDown';
 
 export declare class Work {
     /** 名称 */
@@ -3130,6 +3230,8 @@ export declare interface WorkObserver {
     floorIndex: number;
     /** 点位 derived_id */
     derivedId?: number;
+    /** 点位 derived_id_str */
+    derivedIdStr?: string;
     /** 点位是否激活可用 */
     active: boolean;
     /** 点位是否可加载 */
@@ -3161,6 +3263,8 @@ export declare interface WorkOptions {
     transform: THREE_2.Matrix4;
     /** 可观测区域 */
     viewerRequestVolume?: BoundingVolume;
+    /** 模型显示最小细化层级 */
+    modelMinLevelOfDetail?: number;
     /** 模型显示最大细化层级 */
     modelMaxLevelOfDetail?: number;
     /** 模型最大内存缓存 */
@@ -3215,18 +3319,55 @@ export declare class XRButton {
     static createButton(onClickHook: () => void): HTMLAnchorElement | HTMLButtonElement;
 }
 
+export declare interface XRControllerEvent extends BaseEvent {
+    left: {
+        axes: {
+            up: number;
+            down: number;
+            left: number;
+            right: number;
+        };
+        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 {
     session: XRSession | null;
-    buttons: null | 'A' | 'B' | 'X' | 'Y' | 'RightTrigger' | 'RightPinch' | 'LeftTrigger' | 'LeftPinch' | 'LeftAxesLeft' | 'LeftAxesRight' | 'LeftAxesUp' | 'LeftAxesDown' | 'RightAxesLeft' | 'RightAxesRight' | 'RightAxesUp' | 'RightAxesDown';
+    buttons: 'A' | 'B' | 'X' | 'Y' | 'RightTrigger' | 'RightPinch' | 'LeftTrigger' | 'LeftPinch' | 'LeftAxesLeft' | 'LeftAxesRight' | 'LeftAxesUp' | 'LeftAxesDown' | 'RightAxesLeft' | 'RightAxesRight' | 'RightAxesUp' | 'RightAxesDown';
     machineType: 'Pico' | 'Oculus';
     isFirst: boolean;
     isFinal: boolean;
     controllers: {
-        raycaster: THREE_2.Raycaster;
-    }[];
+        raycaster: {
+            leftRay: THREE_2.Raycaster;
+            rightRay: THREE_2.Raycaster;
+        };
+    };
 }
 
 export declare interface XRPanoramaControllerCustomInitArgs extends Omit<PanoramaControllerCustomInitArgs, "maxLatitude" | "minLatitude"> {
+    onlyUseRightController?: boolean;
 }
 
 declare interface XRSessionEvent_2 extends BaseEvent {