@realsee/five 6.0.0-alpha.4 → 6.0.0-alpha.41

package/five/index.d.ts

@@ -13,6 +13,15 @@ export declare interface AddableObject extends THREE_2.Object3D {
     setTime?(time: number): void;
 }
 
+declare interface AjaxOptions<T extends AjaxResponseType = AjaxResponseType> extends NetworkOptions {
+    /** 数据返回类型 */
+    responseType?: T;
+}
+
+declare type AjaxResponseType = "arraybuffer" | "blob" | "text";
+
+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;
@@ -118,7 +127,8 @@ export declare class BVH {
 export declare class BVHIntersect {
     triangle: [BVHVector3, BVHVector3, BVHVector3];
     intersectionPoint: BVHVector3;
-    constructor(triangle: [BVHVector3, BVHVector3, BVHVector3], intersectionPoint: BVHVector3);
+    triangleIndex: number;
+    constructor(triangle: [BVHVector3, BVHVector3, BVHVector3], intersectionPoint: BVHVector3, triangleIndex: number);
 }
 
 /**
@@ -162,13 +172,15 @@ export declare class Camera extends THREE_2.Camera {
     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, orthoDistance?: number, screenHeight?: number, pixelRatio?: number);
     get zoom(): number;
     get top(): number;
     get bottom(): number;
@@ -203,17 +215,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,6 +285,14 @@ 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;
 };
@@ -307,6 +316,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;
@@ -381,6 +392,14 @@ export declare type EventTypes = Pick<ControllerEventTypes, typeof PROXY_CONTROL
     "dispose"(): void;
 };
 
+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 +417,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 +450,8 @@ export declare class Five extends Subscribe<EventTypes> {
     currentMode: Mode;
     /** 内部使用的 `THREE.Scene` */
     scene: Scene;
+    /** 供外部放置需要在xr场景下产生遮挡的物体们*/
+    xrCustomObjectsScene: THREE_2.Scene;
     /** 内部使用的 `Camera` */
     camera: Camera;
     /**
@@ -604,11 +627,17 @@ export declare class Five extends Subscribe<EventTypes> {
      */
     get enableIOSEDR(): boolean;
     set enableIOSEDR(enable: boolean);
+    /**
+     * 后处理类型
+     */
+    get postProcessingType(): PostProcessingType;
     /**
      * 是否开启EDL模式
      */
     get enableEDL(): boolean;
     set enableEDL(enable: boolean);
+    get enableHQ(): boolean;
+    set enableHQ(enable: boolean);
     /**
      * 是否开启后处理
      */
@@ -664,7 +693,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
@@ -675,7 +704,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
@@ -1020,6 +1053,8 @@ parameters: Parameters<T>[1]
 export declare type FivePluginInstance<T extends FivePlugin<any, any>> = ReturnType<T>;
 
 export declare interface FloorplanControllerCustomInitArgs {
+    /** 默认水平角 */
+    defaultLongitude?: number;
     /** 默认俯仰角 */
     defaultLatitude?: number;
     /** 最大俯仰角 */
@@ -1092,8 +1127,9 @@ export declare interface ImageOptions {
 }
 
 export declare function imageSupport(): Promise<{
-    avif: boolean;
     webp: boolean;
+    avif: boolean;
+    heif: boolean;
 }>;
 
 export declare interface ImageURLMappings {
@@ -1150,6 +1186,7 @@ export declare interface Intersection {
     } | null;
     /** 焦点距离 */
     distance: number;
+    floor: number;
 }
 
 export declare class IntersectMesh extends THREE_2.Object3D implements IntersectMeshInterface {
@@ -1464,6 +1501,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
@@ -1562,6 +1610,41 @@ 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;
+}): Promise<ParsedResultType>;
+
 export declare type LooseWork = {
     work_code?: string;
     code?: string;
@@ -1659,6 +1742,8 @@ export declare type LooseWorkWithExtrinsics = {
     transform?: number[];
     /** 可视区域 */
     viewerRequestVolume?: BoundingVolumeJson;
+    /** 模型显示最小细化层级 */
+    modelMinLevelOfDetail?: number;
     /** 模型显示最大细化层级 */
     modelMaxLevelOfDetail?: number;
     /** 模型最大内存缓存 */
@@ -1670,6 +1755,8 @@ export declare type LooseWorkWithExtrinsics = {
 };
 
 export declare interface MapviewControllerCustomInitArgs {
+    /** 默认水平角 */
+    defaultLongitude?: number;
     /** 默认俯仰角 */
     defaultLatitude?: number;
     /** 默认相机距离 */
@@ -1747,17 +1834,15 @@ export declare class Model extends THREE_2.Object3D {
     textureOptions: TextureOptions;
     /** 模型是否已经细化 */
     refined: boolean;
+    /** 模型细化进度 */
+    refineProgress: [number, number];
     /** 模型已经加载 */
     loaded: boolean;
-    /** 当前样式参数 */
-    materialVersion: string;
-    private _materialValues;
-    private _materialVersionMap;
-    private _floorIndex;
-    private _clippers;
-    /** 样式缓存 */
-    private cache;
+    /** 是否更新 */
     needsRender: boolean;
+    /** 当前样式参数 */
+    materialVersion: number;
+    private materialParameters;
     private disposed;
     constructor(options?: {
         onError?: (error: Error) => void;
@@ -1766,16 +1851,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 shownFloorIndex(): PBMParameters['shownFloorIndex'];
+    set shownFloorIndex(floorIndex: PBMParameters['shownFloorIndex']);
     /**
      * 当前显示的楼层
      */
-    get shownFloor(): PBMParameters['floorIndex'] | null;
-    set shownFloor(floorIndex: PBMParameters['floorIndex'] | null);
-    get shownfloor(): PBMParameters['floorIndex'] | null;
-    set shownfloor(floorIndex: PBMParameters['floorIndex'] | null);
+    get shownFloor(): number | null;
+    set shownFloor(floor: number | null);
     /**
      * 显示某楼层
      * @example
@@ -1784,7 +1872,7 @@ export declare class Model extends THREE_2.Object3D {
      * model.show(1) //显示第一楼层
      * ```
      */
-    show(floorIndex?: PBMParameters['floorIndex'] | null): void;
+    show(floor?: number | null): void;
     /**
      * 裁切
      */
@@ -1803,15 +1891,13 @@ export declare class Model extends THREE_2.Object3D {
      * @param floors - 和某一楼层做碰撞检测， 不传为和所有楼层做碰撞检测
      * @returns 返回碰撞
      */
-    intersectRaycaster(raycaster: THREE_2.Raycaster): Intersection[];
+    intersectRaycaster(raycaster: THREE_2.Raycaster, floor?: number | null): 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;
@@ -1836,14 +1922,15 @@ export declare interface ModelLodOptions {
     maxDepth?: number;
 }
 
-export declare type ModelMaterialValues = Pick<PBMParameters, 'pano0' | 'pano1' | 'modelAlpha' | 'progress' | 'useBlackTransition' | 'opacity' | 'constantColor' | 'useEDL' | 'pointShape' | 'pointColorType' | 'pointSizeType' | 'pointSize' | 'pointMinSize' | 'pointMaxSize' | 'pointSizeAdaptiveScale' | 'gradientTexture'>;
+export declare type 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;
     intersectRaycaster(raycaster: THREE_2.Raycaster): Intersection[];
     setMaterial(values: Partial<ModelMaterialValues>): void;
     getMaterial(): ModelMaterialValues;
@@ -1902,6 +1989,18 @@ export declare interface MovePanoOptions extends Partial<Omit<State, "offset" |
     moveCancelCallback?: () => void;
 }
 
+declare class NetworkAbortError extends Error {
+    constructor(source: string, type: NetworkType);
+}
+
+declare type NetworkError = NetworkResponseError | NetworkAbortError | NetworkTimeoutError | NetworkFirbiddenError;
+
+declare type NetworkErrorCallback = (error: NetworkError) => void;
+
+declare class NetworkFirbiddenError extends Error {
+    constructor(source: string, type: NetworkType, reason: string);
+}
+
 export declare type NetWorkMeta = {
     origin: string;
     source: string;
@@ -1925,6 +2024,8 @@ export declare interface NetworkOptions {
     allowHosts?: string[];
 }
 
+declare type NetworkProgressCallback = (percent: number) => void;
+
 export declare interface NetworkResourceEvent extends BaseEvent {
     source: string;
     requestType: NetworkType;
@@ -1937,6 +2038,11 @@ export declare type NetworkResponse<T = any, E extends NetWorkMeta | NetWorkMeta
     meta: E;
 };
 
+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<{
@@ -1944,6 +2050,12 @@ export declare class NetworkSubscribe extends Subscribe<{
 }> {
 }
 
+declare type NetworkSuccessCallback<T = any> = (response: NetworkResponse<T>) => void;
+
+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 {
@@ -2159,6 +2271,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 数据，从如数开发者平台获取
@@ -2183,6 +2303,8 @@ export declare type ParseWorkOptions = {
     /** 可视区域 */
     viewerRequestVolume?: BoundingVolume | BoundingVolumeJson;
     /** 模型显示最大细化层级 */
+    modelMinLevelOfDetail?: number;
+    /** 模型显示最大细化层级 */
     modelMaxLevelOfDetail?: number;
     /** 模型最大内存缓存 */
     modelMaxMemoryUsage?: number;
@@ -2199,83 +2321,71 @@ 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: PBMParameters['useHQWeight'];
+    /** HQDepthMask*/
+    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'];
     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 {
@@ -2302,46 +2412,35 @@ export declare interface PBMParameters {
     /** 模型透明度 */
     opacity: number;
     /** 楼层参数*/
-    floorIndex: number;
+    shownFloorIndex: number;
     /** 模型裁切参数（工程侧调用）*/
     clippers: ClipperParameter[] | null;
     /** 模型颜色*/
     constantColor: THREE_2.Vector3 | null;
     /** 是否使用EDL*/
     useEDL: boolean;
+    /** 是否使用HQ*/
+    useHQWeight: boolean;
+    /** 是否使用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]]
@@ -2359,7 +2458,9 @@ export declare interface Pose {
     distance: number;
 }
 
-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 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", "xr.controller.update"];
 
 export declare class RegionBoundingVolume implements BoundingVolume {
     type: "regin";
@@ -2605,7 +2706,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;
@@ -2618,7 +2719,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;
@@ -2630,7 +2733,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;
@@ -2644,7 +2749,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[]>>;
 }
 
 /**
@@ -2724,57 +2831,59 @@ 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;
+    objType: 'mesh' | 'point_cloud';
+    model: Model;
     workCode: string;
+    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;
-    private nodeGroup;
-    private debugBoundingGroup;
+    frameState: TilesetFrameState | null;
+    nodeGroup: THREE_2.Group;
+    debugBoundingGroup: THREE_2.Group;
     private nodes;
     private debugBoundings;
     private unloadTileQueue;
-    constructor(workCode: string, tilesetHeader: TilesetHeader, options: Partial<Tile3DModelLoaderOptions>);
+    constructor(workCode: string, 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, distanceOrder: boolean): 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;
@@ -2815,7 +2924,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;
@@ -2845,9 +2956,11 @@ export declare interface TileHeader {
 }
 
 export declare class TileNode extends THREE_2.Group {
+    objType: 'mesh' | 'point_cloud';
     bvhTree: BVH | undefined;
-    objType: 'mesh' | 'points';
-    constructor(obj: THREE_2.Object3D, objType: 'mesh' | 'points');
+    private objDisposer;
+    private floorsArray;
+    constructor(obj: THREE_2.Object3D, objType: 'mesh' | 'point_cloud', objDisposer: () => void);
     buildBvhTree(): void;
     intersectRaycaster(raycaster: THREE_2.Raycaster): Intersection[];
     dispose(): void;
@@ -2861,7 +2974,7 @@ export declare class Tileset {
     asset: {
         version: string;
         tilesetVersion: string;
-        gltfUpAxis: "X" | "Y" | "Z";
+        gltfUpAxis: "Y" | "Z";
     };
     id: string;
     frameNumber: number;
@@ -2875,7 +2988,6 @@ export declare class Tileset {
     requestScheduler: RequestScheduler<string>;
     private memoryUsageInBytes;
     maxMemoryUsage: number;
-    viewDistanceScale: number;
     tiles: Map<string, Tile>;
     private pendingCount;
     constructor(id: string, header: TilesetHeader, options: TilesetOptions);
@@ -2918,9 +3030,11 @@ export declare type TilesetFrameState = {
         up: THREE.Vector3;
     };
     height: number;
+    pixelRatio: number;
     cullingVolume: CullingVolume;
     frameNumber: number;
     sseDenominator: number;
+    minLevelOfDetail: number;
     maxLevelOfDetail: number;
 };
 
@@ -2928,7 +3042,7 @@ export declare interface TilesetHeader {
     asset: {
         version: string;
         tilesetVersion?: string;
-        gltfUpAxis?: "X" | "Y" | "Z";
+        gltfUpAxis?: "Y" | "Z";
     };
     properties?: Record<string, any>;
     geometricError: number;
@@ -2936,13 +3050,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 {
@@ -2992,15 +3103,34 @@ 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 {
+    /** five load 会对其赋值 */
+    fetcher: Fetcher;
     /** 名称 */
     name: string;
     /** 编号 */
@@ -3114,6 +3244,8 @@ export declare interface WorkObserver {
     floorIndex: number;
     /** 点位 derived_id */
     derivedId?: number;
+    /** 点位 derived_id_str */
+    derivedIdStr?: string;
     /** 点位是否激活可用 */
     active: boolean;
     /** 点位是否可加载 */
@@ -3145,6 +3277,8 @@ export declare interface WorkOptions {
     transform: THREE_2.Matrix4;
     /** 可观测区域 */
     viewerRequestVolume?: BoundingVolume;
+    /** 模型显示最小细化层级 */
+    modelMinLevelOfDetail?: number;
     /** 模型显示最大细化层级 */
     modelMaxLevelOfDetail?: number;
     /** 模型最大内存缓存 */
@@ -3199,15 +3333,51 @@ 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"> {