@realsee/five 5.0.0-alpha.126 → 5.0.0-alpha.129

package/five/index.d.ts

@@ -1,4 +1,8 @@
+import Matrix3 from '@math.gl/core/dist/esm/classes/matrix3';
+import Matrix4 from '@math.gl/core/dist/esm/classes/matrix4';
+import Quaternion from '@math.gl/core/dist/esm/classes/quaternion';
 import * as THREE_2 from 'three';
+import Vector3 from '@math.gl/core/dist/esm/classes/vector3';
 
 export declare interface AddableObject extends THREE_2.Object3D {
     needsRender?: boolean;
@@ -35,6 +39,51 @@ export declare class AnimationFrameLoop {
     disponse(): void;
 }
 
+declare interface B3DMMapping {
+    b3dm_base_url: string;
+    b3dm_url: Record<string, string>;
+}
+
+declare class BoundingSphere {
+    center: Vector3;
+    radius: number;
+    constructor(center?: number[], radius?: number);
+    fromCenterRadius(center: number[], radius: number): this;
+    fromCornerPoints(corner: number[], oppositeCorner: number[]): this;
+    equals(right: BoundingSphere): boolean;
+    clone(): BoundingSphere;
+    union(boundingSphere: BoundingSphere): BoundingSphere;
+    expand(point: number[]): this;
+    transform(transform: Matrix4): this;
+    distanceSquaredTo(point: number[]): number;
+    distanceTo(point: number[]): number;
+    intersectPlane(plane: Plane): number;
+}
+
+declare interface BoundingVolume {
+    /**
+     * Applies a 4x4 affine transformation matrix to a bounding sphere.
+     * @param sphere The bounding sphere to apply the transformation to.
+     * @param transform The transformation matrix to apply to the bounding sphere.
+     * @returns itself, i.e. the modified BoundingVolume.
+     */
+    transform(transform: readonly number[]): this;
+    /** Computes the estimated distance squared from the closest point on a bounding sphere to a point. */
+    distanceSquaredTo(point: readonly number[]): number;
+    /** Computes the estimated distance from the closest point on a bounding sphere to a point. */
+    distanceTo(point: readonly number[]): number;
+    /**
+     * Determines which side of a plane the oriented bounding box is located.
+     *
+     * @param plane The plane to test against.
+     * @returns
+     *  - `INTERSECTION.INSIDE` if the entire box is on the side of the plane the normal is pointing.
+     *  - `INTERSECTION.OUTSIDE` if the entire box is on the opposite side.
+     *  - `INTERSECTION.INTERSECTING` if the box intersects the plane.
+     */
+    intersectPlane(plane: Plane): number;
+}
+
 export declare class BVH {
     trianglesArray?: Float32Array;
     offsetArray?: Uint32Array;
@@ -91,6 +140,13 @@ export declare class BVHVector3 {
     clone(): BVHVector3;
 }
 
+declare class CacheNode<T> {
+    item: T;
+    previous: CacheNode<T> | null;
+    next: CacheNode<T> | null;
+    constructor(item: T, previous: CacheNode<T> | null, next: CacheNode<T> | null);
+}
+
 /** Five 相机 */
 export declare class Camera extends THREE_2.PerspectiveCamera {
     /** 相机姿态 */
@@ -119,6 +175,7 @@ export declare type ControllerCustomInitTypes = {
     VRPanorama: VRPanoramaControllerCustomInitArgs;
     Model: ModelControllerCustomInitArgs;
     DepthPanorama: DepthPanoramaControllerCustomInitArgs;
+    Mapview: MapviewControllerCustomInitArgs;
 };
 
 export declare type ControllerEventTypes = {
@@ -408,6 +465,20 @@ export declare type ControllerEventTypes = {
     error(error: Error): void;
 };
 
+declare class CullingVolume {
+    static get MASK_OUTSIDE(): number;
+    static get MASK_INSIDE(): number;
+    static get MASK_INDETERMINATE(): number;
+    planes: Plane[];
+    constructor(planes?: Plane[]);
+    fromBoundingSphere(boundingSphere: {
+        center: Vector3;
+        radius: number;
+    }): this;
+    computeVisibility(boundingVolume: BoundingVolume): number;
+    computeVisibilityWithPlaneMask(boundingVolume: BoundingVolume, parentPlaneMask: number): number;
+}
+
 /**
  * URL 地址的转换
  * @param source - url 原地址
@@ -455,14 +526,14 @@ export declare type EventTypes = Pick<ControllerEventTypes, typeof PROXY_CONTROL
      * @param work - 归一化的标准 work
      * @param state - 加载时的姿态
      */
-    willLoad(input: any, work: Work, state: Omit<State, "offset">): void;
+    willLoad(input: any, work: Work, state: Omit<State, "offset" | "distance">): void;
     /**
      * 开始加载 Work 数据
      * @param input - 输入的 work
      * @param work - 归一化的标准 work
      * @param state - 加载时的姿态
      */
-    load(input: any, work: Work, state: Omit<State, "offset">): void;
+    load(input: any, work: Work, state: Omit<State, "offset" | "distance">): void;
     /**
      * 加载完 Work 数据
      * @param input - 输入的 work
@@ -768,7 +839,7 @@ export declare class Five extends Subscribe<EventTypes> {
     set enableIOSEDR(enable: boolean);
     get enablePostProcessing(): boolean;
     set enablePostProcessing(enable: boolean);
-    updateConfiguration(args: Pick<FiveInitArgs, "panorama" | "model" | "floorplan" | "topview" | "depthPanorama" | "vrPanorama" | "imageOptions">): void;
+    updateConfiguration(args: Pick<FiveInitArgs, "panorama" | "model" | "floorplan" | "topview" | "mapview" | "depthPanorama" | "vrPanorama" | "imageOptions">): void;
     /**
      * 将显示区域加载到页面 DOM 中
      * @description
@@ -1110,6 +1181,8 @@ export declare interface FiveInitArgs {
     floorplan?: ControllerCustomInitTypes["Floorplan"];
     /** 户型图模式下的特定参数 */
     topview?: ControllerCustomInitTypes["Topview"];
+    /** 地图模式下的特定参数 */
+    mapview?: ControllerCustomInitTypes["Mapview"];
     /** 深度图游走模式下的特定参数 */
     depthPanorama?: ControllerCustomInitTypes["DepthPanorama"];
     /** VR眼镜模式下的特定参数 */
@@ -1164,6 +1237,11 @@ parameters: Parameters<T>[1]
  */
 export declare type FivePluginInstance<T extends FivePlugin<any, any>> = ReturnType<T>;
 
+declare interface FloorInfo {
+    ground: number;
+    height: number;
+}
+
 export declare interface FloorplanControllerCustomInitArgs {
     /** 默认偏航角 */
     defaultLongitude?: number;
@@ -1181,6 +1259,18 @@ export declare interface FloorplanControllerCustomInitArgs {
     minFov?: number;
 }
 
+declare type FrameState = {
+    camera: {
+        position: number[];
+        direction: number[];
+        up: number[];
+    };
+    height: number;
+    cullingVolume: CullingVolume;
+    frameNumber: number;
+    sseDenominator: number;
+};
+
 export declare type GestureTypes = "pan" | "tap" | "pinch" | "press" | "mouseWheel";
 
 export declare function getViewportScale(): number;
@@ -1207,6 +1297,11 @@ export declare interface ImageOptions {
     mappings?: ImageURLMappings;
 }
 
+export declare function imageSupport(): Promise<{
+    avif: boolean;
+    webp: boolean;
+}>;
+
 export declare interface ImageURLMappings {
     [publicDomain: string]: {
         "pano": [string, string];
@@ -1293,6 +1388,20 @@ export declare class LegacyPanoCircleMesh extends THREE_2.Object3D implements Pa
     dispose(): void;
 }
 
+/** Advanced loader options */
+declare interface LoaderOptions {
+    updateInterval: number;
+    maxMemoryUsage: number;
+    maxScreenSpaceError: number;
+    viewDistanceScale: number;
+    throttleRequests: boolean;
+    maxRequests: number;
+    onNodeCreated: (node: PBMGroup) => void;
+    allowHosts?: string[];
+    networkSubscribe?: NetworkSubscribe;
+    maxDepth?: number;
+}
+
 export declare type LooseWork = {
     bvh?: boolean;
     modelAsync?: boolean;
@@ -1367,6 +1476,65 @@ export declare type LooseWorkVideo = {
     size: number[];
 };
 
+declare class ManagedArray<T> {
+    private map;
+    private array;
+    private _length;
+    constructor();
+    /**
+     * Gets or sets the length of the array.
+     * If the set length is greater than the length of the internal array, the internal array is resized.
+     *
+     * @memberof ManagedArray.prototype
+     * @type Number
+     */
+    get length(): number;
+    /**
+     * Gets the element at an index.
+     * @param { Number } index The index to get.
+     */
+    get(index: number): T;
+    /**
+     * Sets the element at an index. Resizes the array if index is greater than the length of the array.
+     *
+     * @param {Number} index The index to set.
+     * @param {*} element The element to set at index.
+     */
+    set(index: number, element: T): void;
+    delete(element: T): void;
+    /**
+     * Push an element into the array.
+     *
+     * @param {*} element The element to push.
+     */
+    push(element: T): void;
+    /**
+     * Pop an element from the array.
+     *
+     * @returns {*} The last element in the array.
+     */
+    pop(): T;
+    reset(): void;
+    find(target: T): boolean;
+}
+
+export declare interface MapviewControllerCustomInitArgs {
+    /** 默认偏航角 */
+    defaultLongitude?: number;
+    /** 默认俯仰角 */
+    defaultLatitude?: number;
+    /** 默认相机距离 */
+    defaultDistance?: number;
+    /** 最大俯仰角 */
+    maxLatitude?: number;
+    /** 最小俯仰角 */
+    minLatitude?: number;
+    /** 最大相机距离 */
+    maxDistance?: number;
+    /** 最小相机距离 */
+    minDistance?: number;
+}
+
 export declare type Mirror<T extends string> = Record<T, T>;
 
 /**
@@ -1375,6 +1543,7 @@ export declare type Mirror<T extends string> = Record<T, T>;
  * - **Model**: 模型游走模式
  * - **Floorplan**: 模型查看模式
  * - **Topview**: 户型图模式
+ * - **Mapview**: 地图模式
  * - **DepthPanorama**: 深度图游走模式
  * - **VRPanorama**: VR眼镜模式
  */
@@ -1383,6 +1552,8 @@ export declare type Mode =
 "Floorplan" | 
 /** 户型图模式 */
 "Topview" | 
+/** 地图模式 */
+"Mapview" | 
 /** 全景图游走模式 */
 "Panorama" | 
 /** VR眼镜模式 */
@@ -1411,6 +1582,10 @@ export declare class Model extends PBMContainer implements Subscribe<ModelEventT
     shownFloor: number | null;
     /** 楼层的数量 */
     floorLength: number;
+    /** 模型瓦片 */
+    originModel?: PBMContainer;
+    /** 模型瓦片 */
+    tiledModel?: Tile3DModel;
     /**
      * 判断是否注册了事件
      * 具体可查看 {@link Subscribe.hasListener}
@@ -1454,6 +1629,15 @@ export declare class Model extends PBMContainer implements Subscribe<ModelEventT
      * 请用 shwonFloor 代替
      */
     get shownfloor(): number | null;
+    /**
+     * 当前模型是否支持瓦片
+     */
+    get hasTiles(): boolean;
+    /**
+     * 是否开启瓦片
+     */
+    get enableTiles(): boolean;
+    set enableTiles(enable: boolean);
     /**
      * 获取模型边界线
      * @param threshold - 面片间夹角阈值
@@ -1478,6 +1662,8 @@ export declare class Model extends PBMContainer implements Subscribe<ModelEventT
      */
     show(): void;
     show(floorIndex: number, hiddenOpacity?: number): void;
+    private at3dShow;
+    private b3dmShow;
     /**
      * 计算模型射线碰撞检测
      * @param raycaster - THREE 射线对象
@@ -1492,6 +1678,7 @@ export declare class Model extends PBMContainer implements Subscribe<ModelEventT
      * @param imageOptions - 图片参数
      */
     load(workModel: WorkModel, textureOptions?: TextureOptions): Promise<void>;
+    update(renderer: THREE_2.WebGLRenderer, camera: THREE_2.PerspectiveCamera): void;
     /**
      * 析构函数
      * @description
@@ -1602,6 +1789,23 @@ export declare class NetworkSubscribe extends Subscribe<{
 
 export declare type NetworkType = "XMLHttpRequest" | "Script" | "Image" | "Link";
 
+declare class OrientedBoundingBox {
+    center: Vector3;
+    halfAxes: Matrix3;
+    constructor(center?: number[], halfAxes?: number[]);
+    get halfSize(): number[];
+    get quaternion(): Quaternion;
+    fromCenterHalfSizeQuaternion(center: number[], halfSize: number[], quaternion: number[]): this;
+    clone(): OrientedBoundingBox;
+    equals(right: OrientedBoundingBox): boolean;
+    getBoundingSphere(result?: BoundingSphere): BoundingSphere;
+    intersectPlane(plane: Plane): number;
+    distanceTo(point: number[]): number;
+    distanceSquaredTo(point: number[]): number;
+    computePlaneDistances(position: Vector3, direction: Vector3, result?: number[]): number[];
+    transform(transformation: number[]): this;
+}
+
 export declare class PanoCircleMesh extends THREE_2.Object3D implements PanoCircleMeshInterface {
     needsRender: boolean;
     private loadingMesh;
@@ -1764,6 +1968,8 @@ export declare class PBMMaterial extends THREE_2.ShaderMaterial implements PBMPa
     /** 模型透明度 */
     opacity: number;
     originOpacity: number;
+    /** 楼层切割参数*/
+    floorInfo: THREE_2.Vector3 | null;
     constructor(parameters?: Partial<PBMParameters>);
 }
 
@@ -1799,6 +2005,22 @@ export declare interface PBMParameters {
     perspToOrtho: number;
     /** 模型透明度 */
     opacity: number;
+    /** 楼层切割参数*/
+    floorInfo?: THREE_2.Vector3 | null;
+}
+
+declare class Plane {
+    normal: Vector3;
+    distance: number;
+    constructor(normal?: number[], distance?: number);
+    fromNormalDistance(normal: number[], distance: number): this;
+    fromPointNormal(point: number[], normal: number[]): this;
+    fromCoefficients(a: number, b: number, c: number, d: number): this;
+    clone(): Plane;
+    equals(right: Plane): boolean;
+    getPointDistance(point: number[]): number;
+    transform(matrix4: Matrix4): this;
+    projectPointOntoPlane(point: number[], result?: number[]): Vector3;
 }
 
 /**
@@ -1814,10 +2036,62 @@ export declare interface Pose {
     fov: number;
     /** 相机位置*/
     offset: THREE_2.Vector3;
+    /** 相机距离 */
+    distance: number;
 }
 
 export declare const PROXY_CONTROLLER_EVENT_NAMES: readonly ["cameraDirectionUpdate", "cameraUpdate", "cameraPositionUpdate", "panoSelected", "moveToPano", "moveToPanoCanceled", "panoWillArrive", "movingToPano", "panoArrived", "panoWillLoad", "panoLoaded", "panoLoadError", "initAnimationEnded", "initAnimationWillStart", "wantsGesture", "gesture", "wantsTapGesture", "tapGesture", "wantsPressGesture", "pressGesture", "wantsPanGesture", "wantsInteriaPan", "panGesture", "interiaPan", "wantsPinchGesture", "pinchGesture", "wantsMouseWheel", "mouseWheel", "wantsShowIntersectionOnModel", "intersectionOnModelUpdate", "intersectionHidden", "textureStartLoad", "textureLoading", "textureAbort", "textureLoaded", "textureError"];
 
+declare type RequestResult = null | {
+    done: () => void;
+};
+
+/**
+ * Used to issue a request, without having them "deeply queued" by the browser.
+ * @todo - Track requests globally, across multiple servers
+ */
+declare class RequestScheduler<Identiy> {
+    private props;
+    private activeRequestCount;
+    /** Tracks the number of active requests and prioritizes/cancels queued requests. */
+    private requestQueue;
+    private requestMap;
+    private deferred;
+    constructor(props?: RequestSchedulerOptions);
+    /**
+     * Called by an application that wants to issue a request, without having it deeply queued by the browser
+     *
+     * When the returned promise resolved, it is OK for the application to issue a request.
+     * The promise resolves to an object that contains a `done` method.
+     * When the application's request has completed (or failed), the application must call the `done` function
+     *
+     * @param identiy
+     * @param getPriority will be called when request "slots" open up,
+     *    allowing the caller to update priority or cancel the request
+     *    Highest priority executes first, priority < 0 cancels the request
+     * @returns a promise
+     *   - resolves to a object (with a `done` field) when the request can be issued without queueing,
+     *   - resolves to `null` if the request has been cancelled (by the callback return < 0).
+     *     In this case the application should not issue the request
+     */
+    scheduleRequest(identiy: Identiy, getPriority?: (identiy: Identiy) => number): Promise<RequestResult>;
+    private issueRequest;
+    /** We check requests asynchronously, to prevent multiple updates */
+    private issueNewRequests;
+    /** Refresh all requests  */
+    private issueNewRequestsAsync;
+    /** Ensure all requests have updated priorities, and that no longer valid requests are cancelled */
+    private updateAllRequests;
+    /** Update a single request by calling the callback */
+    private updateRequest;
+}
+
+/** RequestScheduler Options */
+declare type RequestSchedulerOptions = {
+    throttleRequests?: boolean;
+    maxRequests?: number;
+};
+
 /** Five 场景*/
 export declare class Scene extends THREE_2.Scene {
     add(...objects: AddableObject[]): this;
@@ -1960,6 +2234,288 @@ export declare interface TextureOptions {
     mappings?: ImageURLMappings;
 }
 
+/**
+ * A Tile3DHeader represents a tile as Tileset3D. When a tile is first created, its content is not loaded;
+ * the content is loaded on-demand when needed based on the view.
+ * Do not construct this directly, instead access tiles through {@link Tileset3D#tileVisible}.
+ */
+declare class Tile3D {
+    cacheNode?: CacheNode<Tile3D>;
+    tileset: Tileset3D;
+    header: TilesetJSONNode;
+    content?: TileContent;
+    parent?: Tile3D;
+    boundingVolume: OrientedBoundingBox;
+    contentState: "UNLOADED" | "LOADING" | "PROCESSING" | "READY" | "FAILED";
+    children: Tile3D[];
+    depth: number;
+    selectionDepth: number;
+    transform: Matrix4;
+    computedTransform: Matrix4;
+    frameNumber: number;
+    touchedFrameNumber: number;
+    requestedFrameNumber: number;
+    selectedFrameNumber: number;
+    distanceToCamera: number;
+    centerZDepth: number;
+    screenSpaceError: number;
+    visibilityPlaneMask: number;
+    visible: boolean;
+    shouldRefine: boolean;
+    /**
+     * @constructs
+     * Create a TileHeader instance
+     * @param tileset - Tileset3D instance
+     * @param header - tile header - JSON loaded from a dataset
+     * @param parentHeader - parent TileHeader instance
+     */
+    constructor(tileset: Tileset3D, header: TilesetJSONNode, parentHeader?: Tile3D);
+    get id(): string;
+    get refine(): "REPLACE" | "ADD";
+    get type(): "EMPTY" | "SCENEGRAPH" | "MESH";
+    get contentUrl(): string;
+    get lodMetricType(): "geometricError";
+    get lodMetricValue(): number;
+    get hasEmptyContent(): boolean;
+    get selected(): boolean;
+    /** Returns true if tile is not an empty tile and not an external tileset */
+    get hasRenderContent(): boolean;
+    /** Returns true if tile has children */
+    get hasChildren(): boolean;
+    /**
+     * Determines if the tile's content is ready. This is automatically `true` for
+     * tiles with empty content.
+     */
+    get contentReady(): boolean;
+    /**
+     * Determines if the tile has available content to render.  `true` if the tile's
+     * content is ready or if it has expired content this renders while new content loads; otherwise,
+     */
+    get contentAvailable(): boolean;
+    /** Returns true if tile has renderable content but it's unloaded */
+    get hasUnloadedContent(): boolean;
+    /**
+     * Determines if the tile's content has not be requested. `true` if tile's
+     * content has not be requested; otherwise, `false`.
+     */
+    get contentUnloaded(): boolean;
+    get contentFailed(): boolean;
+    /** Get the tile's screen space error. */
+    getScreenSpaceError(frameState: FrameState, useParentLodMetric: boolean): number;
+    getPriority(): number;
+    /**
+     *  Requests the tile's content.
+     * The request may not be made if the Request Scheduler can't prioritize it.
+     */
+    loadContent(): Promise<boolean>;
+    unloadContent(): void;
+    /**
+     * Update the tile's visibility
+     */
+    updateVisibility(frameState: FrameState): void;
+    visibility(frameState: FrameState, parentVisibilityPlaneMask: number): number;
+    /**
+     * Computes the (potentially approximate) distance from the closest point of the tile's bounding volume to the camera.
+     * @param frameState The frame state.
+     * @returns {Number} The distance, in meters, or zero if the camera is inside the bounding volume.
+     */
+    distanceToTile(frameState: FrameState): number;
+    updateTransform(parentTransform?: Matrix4): void;
+}
+
+export declare class Tile3DModel extends PBMContainer {
+    tileset?: Tileset3D;
+    private options;
+    private nodeGroup;
+    private boundingGroup;
+    private nodes;
+    private boundings;
+    private unloadTileQueue;
+    private timer;
+    private clock;
+    private lastCameraTransform;
+    private lastCameraAspect;
+    private lastCameraFov;
+    private sseDenominator;
+    private lastCamera;
+    private lastRenderer;
+    private enabled;
+    constructor(loaderOptions?: Partial<LoaderOptions>);
+    get enable(): boolean;
+    set enable(value: boolean);
+    load(url: WorkModelTiles_2): void;
+    update(renderer: THREE_2.WebGLRenderer, camera: THREE_2.PerspectiveCamera): void;
+    private tilesetUpdate;
+    reset(): void;
+}
+
+declare interface TileContent {
+    version: 1;
+    magic: number;
+    byteLength: number;
+    header: {
+        featureTableJsonByteLength: number;
+        featureTableBinaryByteLength: number;
+        batchTableJsonByteLength: number;
+        batchTableBinaryByteLength: number;
+        batchLength: number;
+    };
+    featureTableJson: Record<string, any>;
+    featureTableBinary: Uint8Array;
+    batchTableJson: Record<string, any>;
+    batchTableBinary: Uint8Array;
+    rotateYtoZ: boolean;
+    gltfUpAxis: "X" | "Y" | "Z";
+    gltfArrayBuffer: ArrayBuffer;
+    gltfByteOffset: number;
+    gltfByteLength: number;
+    rtcCenter?: Float32Array;
+}
+
+declare class Tileset3D {
+    rawJson: any;
+    options: Tileset3dOptions;
+    root: Tile3D;
+    traverser: Tileset3DTraverser;
+    cache: TilesetCache;
+    requestScheduler: RequestScheduler<string>;
+    selectedTiles: Tile3D[];
+    requestedTiles: Tile3D[];
+    memoryUsageInBytes: number;
+    frameNumber: number;
+    private _tiles;
+    private pendingCount;
+    b3dmMapping: B3DMMapping;
+    /**
+     * Create a new Tileset3D
+     * @param json
+     * @param options
+     */
+    constructor(json: TilesetJSON, options: Tileset3dOptions);
+    get maxMemoryUsage(): number;
+    get asset(): any;
+    get type(): any;
+    get basePath(): any;
+    get modelMatrix(): Matrix4;
+    get geometricError(): number;
+    get lodMetricType(): number;
+    get lodMetricValue(): number;
+    get refine(): 'ADD' | "REPLACE";
+    get tiles(): Tile3D[];
+    get floorInfo(): FloorInfo[];
+    /** Release resources */
+    reset(): void;
+    /** Is the tileset loaded (update needs to have been called at least once) */
+    isLoaded(): boolean;
+    /**
+     * The callback to post-process tiles after traversal procedure
+     * @param frameState - frame state for tile culling
+     */
+    private onTraversalEnd;
+    loadTile(tile: Tile3D): void;
+    unloadTile(tile: Tile3D): void;
+}
+
+declare interface Tileset3dOptions {
+    throttleRequests: boolean;
+    maxRequests: number;
+    maxMemoryUsage: number;
+    modelMatrix: Matrix4;
+    maxScreenSpaceError: number;
+    viewDistanceScale: number;
+    onTileLoad: (tile: Tile3D) => any;
+    onTileUnload: (tile: Tile3D) => any;
+    onTileError: (tile: Tile3D, message: string) => any;
+    contentLoader: (tile: Tile3D) => Promise<void>;
+    onTraversalComplete: (selectedTiles: Tile3D[]) => Tile3D[];
+    allowHosts?: string[];
+    networkSubscribe?: NetworkSubscribe;
+    maxDepth?: number;
+}
+
+declare class Tileset3DTraverser {
+    root: Tile3D | null;
+    options: TilesetTraverserProps;
+    requestedTiles: Record<string, Tile3D>;
+    selectedTiles: Record<string, Tile3D>;
+    emptyTiles: Record<string, Tile3D>;
+    protected _traversalStack: ManagedArray<Tile3D>;
+    protected _emptyTraversalStack: ManagedArray<Tile3D>;
+    protected _frameNumber: number | null;
+    constructor(options: TilesetTraverserProps);
+    traverse(root: Tile3D, frameState: FrameState): void;
+    reset(): void;
+    executeTraversal(root: Tile3D, frameState: FrameState): void;
+    updateChildTiles(tile: Tile3D, frameState: FrameState): boolean;
+    updateAndPushChildren(tile: Tile3D, frameState: FrameState, stack: ManagedArray<Tile3D>, depth: number): boolean;
+    updateTile(tile: Tile3D, frameState: FrameState): void;
+    selectTile(tile: Tile3D, frameState: FrameState): void;
+    loadTile(tile: Tile3D, frameState: FrameState): void;
+    touchTile(tile: Tile3D, frameState: FrameState): void;
+    canTraverse(tile: Tile3D, frameState: FrameState, useParentMetric?: boolean, ignoreVisibility?: boolean): boolean;
+    shouldLoadTile(tile: Tile3D): boolean;
+    shouldSelectTile(tile: Tile3D): boolean;
+    shouldRefine(tile: Tile3D, frameState: FrameState, useParentMetric: boolean): boolean;
+    updateTileVisibility(tile: Tile3D, frameState: FrameState): void;
+    meetsScreenSpaceErrorEarly(tile: Tile3D, frameState: FrameState): boolean;
+    compareDistanceToCamera(a: Tile3D, b: Tile3D): number;
+    anyChildrenVisible(tile: Tile3D, frameState: FrameState): boolean;
+    everyChildrenVisibleIsLoaded(tile: Tile3D): boolean;
+    executeEmptyTraversal(root: Tile3D, frameState: FrameState): boolean;
+}
+
+declare class TilesetCache {
+    private list;
+    private sentinel;
+    constructor();
+    reset(): void;
+    touch(tile: Tile3D): void;
+    add(tile: Tile3D, addCallback?: (tile: Tile3D) => void): void;
+    unloadTile(tile: Tile3D, unloadCallback?: (tile: Tile3D) => void): void;
+    unloadTiles(isOverMemory: () => boolean, unloadCallback?: (tile: Tile3D) => void): void;
+}
+
+declare interface TilesetJSON {
+    asset: {
+        gltfUpAxis: "X" | "Y" | "Z";
+        version: "1.0";
+    };
+    basePath: string;
+    lodMetricType: "geometricError";
+    geometricError: number;
+    lodMetricValue: number;
+    root: TilesetJSONNode;
+    type: "TILES3D";
+    floorInfo: FloorInfo[] | [];
+    b3dmMapping: B3DMMapping;
+}
+
+declare interface TilesetJSONNode {
+    boundingVolume: {
+        box: number[];
+    };
+    content: {
+        uri: string;
+    };
+    id: string;
+    transform?: number[];
+    contentUrl?: string;
+    children: TilesetJSONNode[];
+    lodMetricType: "geometricError";
+    geometricError: number;
+    lodMetricValue: number;
+    refine: "REPLACE" | "ADD";
+    type: "EMPTY" | "SCENEGRAPH" | "MESH";
+}
+
+declare type TilesetTraverserProps = {
+    loadSiblings: boolean;
+    skipLevelOfDetail: boolean;
+    maxScreenSpaceError: number;
+    maxDepth?: number;
+    onTraversalEnd: (frameState: FrameState) => any;
+};
+
 export declare interface TopviewControllerCustomInitArgs extends Omit<FloorplanControllerCustomInitArgs, "defaultLongitude" | "defaultLatitude" | "maxLatitude" | "minLatitude"> {
 }
 
@@ -2026,7 +2582,7 @@ export declare interface WorkImage extends WorkCubeImage {
 }
 
 /** 初始化位姿参数 */
-export declare interface WorkInitial extends Omit<State, "offset"> {
+export declare interface WorkInitial extends Omit<State, "offset" | "distance"> {
 }
 
 /** 模型数据 */
@@ -2039,6 +2595,22 @@ export declare interface WorkModel {
     textureBase: string;
     /** 是否开启 bvh 碰撞树，开启会大大加快射线碰撞的执行效率 */
     bvh: boolean;
+    tiles?: WorkModelTiles;
+}
+
+/** 模型瓦片 */
+export declare interface WorkModelTiles {
+    tileset_url: string;
+    tileset_url_md5: string;
+    b3md_mappings_url: string;
+    b3md_mappings_url_md5: string;
+}
+
+declare interface WorkModelTiles_2 {
+    tileset_url: string;
+    tileset_url_md5: string;
+    b3md_mappings_url: string;
+    b3md_mappings_url_md5: string;
 }
 
 /** 每个点位的数据 */