@realsee/five 6.2.1 → 6.3.0-alpha.1

package/five/index.d.ts

@@ -119,6 +119,7 @@ export declare class Camera extends THREE_2.Camera {
     pose: CameraPose;
     private perspectiveCamera;
     private orthographicCamera;
+    time: number;
     needsRender: boolean;
     refineModel: boolean;
     private lastValues;
@@ -144,7 +145,7 @@ export declare class Camera extends THREE_2.Camera {
     get perspectiveProjectionMatrixInverse(): THREE_2.Matrix4;
     get orthographicProjectionMatrix(): THREE_2.Matrix4;
     get orthographicProjectionMatrixInverse(): THREE_2.Matrix4;
-    updateTime(_time: number, _deltaTime: number): void;
+    updateTime(time: number, _deltaTime: number): void;
     get isPerspectiveCamera(): boolean;
     get isOrthographicCamera(): boolean;
     copy(source: this, recursive?: boolean): this;
@@ -1025,12 +1026,18 @@ export declare interface FiveLoadOptions {
         maxLevelOfDetail?: number;
         /** 模型跳过层级加载 */
         skipLevelOfDetail?: boolean;
+        /** 模型最精细 */
+        mostDetail?: boolean;
         /** 模型加载不在视野中的兄弟节点 */
         loadSiblings?: boolean;
+        /** 模型加载不在视野中的所有节点 */
+        loadAll?: boolean;
         /** 模型最大内存缓存 */
         maxMemoryUsage?: number;
         /** 模型网络最大请求并发数 */
         maxRequests?: number;
+        /** 模型网络请求顺序 */
+        requestOrder?: 'SCREEN_SPACE_ERROR' | 'SCREEN_LEVEL_VERTICAL' | 'SCREEN_VERTICAL';
         /** 模型屏幕空间误差计算最大值 */
         maxScreenSpaceError?: number;
     };
@@ -1676,6 +1683,19 @@ export declare function loadPbm(url: string, options: {
     fetcher: Fetcher;
 }): Promise<ParsedResultType>;
 
+export declare function loadPly<Type extends 'geometry' | 'mesh' | 'points' | 'line' | 'pbmPointCloud', ResultType = {
+    'geometry': THREE_2.BufferGeometry;
+    'mesh': THREE_2.Mesh<THREE_2.BufferGeometry, THREE_2.MeshBasicMaterial>;
+    'points': THREE_2.Points<THREE_2.BufferGeometry, THREE_2.PointsMaterial>;
+    'line': THREE_2.Line<THREE_2.BufferGeometry, THREE_2.LineBasicMaterial>;
+    'pbmPointCloud': PBMPointCloud;
+}[Type]>(url: string, options: {
+    propertyNameMapping?: Record<string, string>;
+    customPropertyMapping?: Record<string, string[]>;
+    type?: Type;
+    fetcher: Fetcher;
+}): Promise<ParsedResultType<ResultType>>;
+
 export declare function loadPnts(url: string, options: {
     fetcher: Fetcher;
     computeBoundingBox?: boolean;
@@ -1944,12 +1964,18 @@ export declare class Model extends THREE_2.Object3D {
             maxLevelOfDetail?: number;
             /** 模型越层级加载 */
             skipLevelOfDetail?: boolean;
+            /** 模型是否最密 */
+            mostDetail?: boolean;
             /** 模型加载不在视野中的兄弟节点 */
             loadSiblings?: boolean;
+            /** 模型加载不在视野中的所有节点 */
+            loadAll?: boolean;
             /** 模型最大内存缓存 */
             maxMemoryUsage?: number;
             /** 模型网络最大请求并发数 */
             maxRequests?: number;
+            /** 模型网络请求顺序 */
+            requestOrder?: 'SCREEN_SPACE_ERROR' | 'SCREEN_LEVEL_VERTICAL' | 'SCREEN_VERTICAL';
             /** 模型屏幕空间误差计算最大值 */
             maxScreenSpaceError?: number;
         };
@@ -2386,11 +2412,11 @@ export declare interface PanoTextureEvent extends BaseEvent {
     error: Error | null;
 }
 
-export declare type ParsedResultType = {
-    type: 'b3dm' | 'pnts' | 'at3d' | 'pbm' | 'dome' | 'domez' | 'glb';
+export declare type ParsedResultType<Scene = THREE_2.Object3D> = {
+    type: 'none' | 'b3dm' | 'pnts' | 'at3d' | 'pbm' | 'dome' | 'domez' | 'glb' | 'ply';
     byteLength: number;
     uri: string;
-    scene: THREE_2.Object3D;
+    scene: Scene;
     textures: THREE_2.Texture[];
     dispose: () => void;
 };
@@ -2445,8 +2471,8 @@ export declare class PBMGroup extends THREE_2.Group {
 
 /** PBM 对象 */
 export declare class PBMMesh extends THREE_2.Mesh<THREE_2.BufferGeometry, PBMMeshMaterial[]> {
-    model?: Model;
     constructor(geometry: THREE_2.BufferGeometry, materials: PBMMeshMaterial[]);
+    update(renderer: THREE_2.WebGLRenderer, camera: Camera, model: Model): void;
 }
 
 /** PBM 材质 */
@@ -2493,6 +2519,8 @@ export declare class PBMMeshMaterial extends THREE_2.ShaderMaterial implements P
     opacity: PBMParameters['opacity'];
     /** 模型颜色*/
     constantColor: PBMParameters['constantColor'];
+    /** 楼层样式*/
+    floorStyle: PBMParameters['floorStyle'];
     /** 楼层参数*/
     shownFloorIndex: PBMParameters['shownFloorIndex'];
     /** 亮度 */
@@ -2515,6 +2543,8 @@ export declare class PBMMeshMaterial extends THREE_2.ShaderMaterial implements P
     pointScale: PBMParameters['pointScale'];
     /** 点云背面绘制方式*/
     pointBack: PBMParameters['pointBack'];
+    /** 点云出现动画时间 */
+    pointAppearAnimationDuration: PBMParameters['pointAppearAnimationDuration'];
     /** 点云像素最小值*/
     pointMinPixel: PBMParameters['pointMinPixel'];
     /** 点云像素最大值*/
@@ -2523,11 +2553,12 @@ export declare class PBMMeshMaterial extends THREE_2.ShaderMaterial implements P
     gradientTexture: PBMParameters['gradientTexture'];
     /** 所属楼层*/
     floor: number;
+    /** 点云平整度*/
+    evennessPlane: PBMParameters['evennessPlane'];
     constructor(shaderType?: 'none' | 'basic' | 'phong', parameters?: Partial<PBMParameters>);
     onBeforeCompile(shader: THREE_2.Shader, renderer: THREE_2.WebGLRenderer): void;
     refreshUniforms(renderer: THREE_2.WebGLRenderer): void;
-    update(renderer: THREE_2.WebGLRenderer, camera: THREE_2.Camera): void;
-    syncModel(model: Model): void;
+    update(renderer: THREE_2.WebGLRenderer, camera: Camera, model: Model): void;
     copy(source: PBMMeshMaterial): this;
 }
 
@@ -2556,6 +2587,8 @@ export declare interface PBMParameters {
     transition: 'BLACK' | 'SPREAD' | 'FADE';
     /** 模型透明度 */
     opacity: number;
+    /** 楼层样式 */
+    floorStyle: 'VISIBILITY' | 'OPACITY';
     /** 楼层参数*/
     shownFloorIndex: number;
     /** 模型裁切参数（工程侧调用）*/
@@ -2580,12 +2613,87 @@ export declare interface PBMParameters {
     pointBack: 'VISIBLE' | 'HIDDEN' | 'DARK';
     /** 点云基础大小*/
     pointScale: number;
+    /** 点云出现动画时间 */
+    pointAppearAnimationDuration: number;
     /** 点云最小尺寸*/
     pointMinPixel: number;
     /** 点云最大尺寸*/
     pointMaxPixel: number;
     /** 高程彩色图*/
     gradientTexture: THREE_2.Texture | null;
+    /** 点云平整度*/
+    evennessPlane: {
+        depth: number;
+        points: THREE_2.Vector3[];
+    };
+}
+
+/** PBM 对象 */
+export declare class PBMPointCloud extends THREE_2.Points<THREE_2.BufferGeometry, PBMPointCloudMaterial> {
+    private pointRange;
+    private motion;
+    constructor(geometry: THREE_2.BufferGeometry, materials: PBMPointCloudMaterial);
+    update(renderer: THREE_2.WebGLRenderer, camera: Camera, model: Model): void;
+}
+
+export declare class PBMPointCloudMaterial extends THREE_2.ShaderMaterial implements PBMParameters {
+    /** 更新版本 */
+    syncModelVersion?: string;
+    /** 起始点 */
+    pano0: PBMParameters['pano0'];
+    /** 结束点 */
+    pano1: PBMParameters['pano1'];
+    /** 全景图混合程度 [0-1] */
+    progress: PBMParameters['progress'];
+    /** 全景图过度混合 */
+    transition: PBMParameters['transition'];
+    /** 楼层样式 */
+    floorStyle: PBMParameters['floorStyle'];
+    /** 楼层参数*/
+    shownFloorIndex: PBMParameters['shownFloorIndex'];
+    /** 亮度 */
+    brightness: PBMParameters['brightness'];
+    /** 对外模型裁切参数*/
+    clippers: PBMParameters['clippers'];
+    /** 模型颜色*/
+    constantColor: PBMParameters['constantColor'];
+    /** 全景和点云/模型的混合程度*/
+    modelAlpha: PBMParameters['modelAlpha'];
+    /** 是否使用EDL*/
+    useEDL: PBMParameters['useEDL'];
+    /** 是否使用HQ*/
+    useHQWeight: PBMParameters['useHQWeight'];
+    /** 是否使用HQ_DEPTH_MASK*/
+    useHQDepth: PBMParameters['useHQDepth'];
+    /** 点云着色方式*/
+    pointColor: PBMParameters['pointColor'];
+    /** 点云大小绘制方式*/
+    pointSize: PBMParameters['pointSize'];
+    /** 点云形状*/
+    pointShape: PBMParameters['pointShape'];
+    /** 点云基础缩放*/
+    pointScale: PBMParameters['pointScale'];
+    /** 点云背面绘制方式*/
+    pointBack: PBMParameters['pointBack'];
+    /** 点云出现动画时间 */
+    pointAppearAnimationDuration: PBMParameters['pointAppearAnimationDuration'];
+    /** 点云像素最小值*/
+    pointMinPixel: PBMParameters['pointMinPixel'];
+    /** 点云像素最大值*/
+    pointMaxPixel: PBMParameters['pointMaxPixel'];
+    /** 高程彩色图*/
+    gradientTexture: PBMParameters['gradientTexture'];
+    /** 所属楼层*/
+    floor: number;
+    /** 点云平整度*/
+    evennessPlane: {
+        depth: number;
+        points: THREE_2.Vector3[];
+    };
+    constructor(parameters?: Partial<PBMParameters>);
+    onBeforeCompile(shader: THREE_2.Shader, renderer: THREE_2.WebGLRenderer): void;
+    update(renderer: THREE_2.WebGLRenderer, camera: Camera, model: Model): void;
+    copy(source: PBMPointCloudMaterial): this;
 }
 
 /**
@@ -2921,6 +3029,7 @@ export declare class Tile {
         touchedFrameNumber: number;
         distanceToCamera: number;
         centerZDepth: number;
+        centerScreenY: number;
         screenSpaceError: number;
         inRequestVolume: boolean;
         visibilityPlaneMask: number;
@@ -2946,8 +3055,6 @@ export declare class Tile {
     get hasEmptyContent(): boolean;
     get contentReady(): boolean;
     get contentByteLength(): number;
-    loadContent(): Promise<boolean>;
-    unloadContent(): boolean;
     getScreenSpaceError(frameState: TilesetFrameState, distanceToCamera: number, useParentGeometricError: boolean): number;
     getPriority(): number;
 }
@@ -2958,8 +3065,11 @@ export declare class Tile3DModel extends THREE_2.Object3D {
     static DEFAULT_MAX_MEMORY_USAGE: number;
     static DEFAULT_MAX_SCREEN_SPACE_ERROR: number;
     static DEFAULT_SKIP_LEVEL_OF_DETAIL: boolean;
+    static DEFAULT_MOST_DETAIL: boolean;
     static DEFAULT_LOAD_SIBLINGS: boolean;
+    static DEFAULT_LOAD_ALL: boolean;
     static DEFAULT_MAX_REQUESTS: number;
+    static DEFAULT_REQUEST_ORDER: TileRequestOrder;
     modelIndex: number;
     debug: boolean;
     type: 'point_cloud' | 'mesh';
@@ -2992,20 +3102,30 @@ export declare class Tile3DModel extends THREE_2.Object3D {
     cacheCameras: (THREE_2.PerspectiveCamera | Camera)[];
     private clearStencilObject;
     private disposed;
-    private unloadTileQueue;
     private renderer?;
+    private renderObjects;
+    private backfaceObjects;
+    private debugObjects;
+    private tileObjects;
     constructor(model: Model, tilesetHeader: TilesetHeader, options: Tile3DModelLoaderOptions);
     getRenderHash(): string;
     get maxMemoryUsage(): number;
     set maxMemoryUsage(value: number);
     get maxRequests(): number;
     set maxRequests(value: number);
+    get requestOrder(): TileRequestOrder;
+    set requestOrder(value: TileRequestOrder);
     get skipLevelOfDetail(): boolean;
     set skipLevelOfDetail(value: boolean);
+    get mostDetail(): boolean;
+    set mostDetail(value: boolean);
     get loadSiblings(): boolean;
     set loadSiblings(value: boolean);
+    get loadAll(): boolean;
+    set loadAll(value: boolean);
     get maxScreenSpaceError(): number;
     set maxScreenSpaceError(value: number);
+    get trajectories(): Trajectory[];
     localToEnu(vector: THREE_2.Vector3): THREE_2.Vector3;
     enuToLocal(vector: THREE_2.Vector3): THREE_2.Vector3;
     localToEcef(vector: THREE_2.Vector3): THREE_2.Vector3;
@@ -3018,9 +3138,11 @@ export declare class Tile3DModel extends THREE_2.Object3D {
     ecefToWorld(vector: THREE_2.Vector3): THREE_2.Vector3;
     worldToLla(vector: THREE_2.Vector3): THREE_2.Vector3;
     llaToWorld(vector: THREE_2.Vector3): THREE_2.Vector3;
-    loadContent(tile: Tile): Promise<boolean>;
-    unloadContent(tile: Tile): void;
+    loadContent(tile: Tile): Promise<void>;
+    unloadContent(tile: Tile): Promise<void>;
     loadAllTilesets(): Promise<void>;
+    loadTrajectory(trajectory: Trajectory): Promise<void>;
+    unloadTrajectory(trajectory: Trajectory): Promise<void>;
     intersectRaycaster(raycaster: THREE_2.Raycaster, sortByDistance?: boolean, target?: Intersection[]): Intersection[];
     private cloneSkipBackfaceObject;
     update(renderer: THREE_2.WebGLRenderer, camera: Camera): void;
@@ -3049,20 +3171,26 @@ export declare interface Tile3DModelLoaderOptions {
 }
 
 export declare class TileCache {
+    private options;
     private cacheNodeMap;
     private list;
     private sentinel;
-    constructor();
+    constructor(options?: TileCacheOptions);
     reset(): void;
-    touch(tile: Tile): void;
-    add(tile: Tile, addCallback?: (tile: Tile) => void): void;
-    unloadTile(tile: Tile, unloadCallback?: (tile: Tile) => void): void;
-    unloadTiles(isOverMemory: () => boolean, unloadCallback?: (tile: Tile) => void): void;
+    touchTile(tile: Tile): void;
+    loadTile(tile: Tile): void;
+    unloadTile(tile: Tile): void;
+    unloadTiles(isOverMemory: () => boolean): void;
     toArray(): Tile[];
 }
 
+export declare type TileCacheOptions = {
+    onTileLoad?: (tile: Tile) => void;
+    onTileUnload?: (tile: Tile) => void;
+};
+
 export declare type TileContentData = {
-    type: 'b3dm' | 'pnts' | 'at3d' | 'pbm' | 'dome' | 'domez' | 'glb';
+    type: 'none' | 'b3dm' | 'pnts' | 'at3d' | 'pbm' | 'dome' | 'domez' | 'glb' | 'ply';
     byteLength: number;
     uri: string;
     object: TileNode;
@@ -3138,70 +3266,47 @@ export declare interface TileHeader {
     extras?: Record<string, any>;
 }
 
-export declare class TileNode extends THREE_2.Group {
+export declare class TileNode extends THREE_2.Object3D {
     private contentObject;
     private disposer;
     private disposers;
-    constructor(contentObject: THREE_2.Object3D, disposer?: () => void);
+    materials: THREE_2.Material[];
+    pbmObjects: (PBMMesh | PBMPointCloud)[];
+    constructor(name: string, contentObject: THREE_2.Object3D, disposer?: () => void);
     generateBvhTree(): Promise<this>;
     intersectRaycaster(raycaster: THREE_2.Raycaster, sortByDistance?: boolean, target?: Intersection[]): Intersection[];
+    update(renderer: THREE_2.WebGLRenderer, camera: Camera, model: Model): void;
     dispose(): void;
     clone(): this;
 }
 
-/** Tracks one request */
-export declare type TileRequest<Identiy> = {
-    identiy: Identiy;
-    priority: number;
-    getPriority: (identiy: Identiy) => number;
-    resolve: (requestResult: TileRequestResult) => void;
-};
-
-export declare type TileRequestResult = null | {
-    done: () => void;
-};
+export declare type TileRequestOrder = 'SCREEN_SPACE_ERROR' | 'SCREEN_LEVEL_VERTICAL' | 'SCREEN_VERTICAL';
 
-/**
- * Used to issue a request, without having them "deeply queued" by the browser.
- */
-export declare class TileRequestScheduler<Identiy> {
-    tileset: Tileset;
+export declare class TileRequestScheduler {
+    private tileset;
+    private options;
     private activeRequests;
-    /** Tracks the number of active requests and prioritizes/cancels queued requests. */
     private requestQueue;
-    private requestMap;
-    private deferred;
-    constructor(tileset: Tileset);
-    /**
-     * Called by an application that wants to issue a request, without having it deeply queued by the browser
-     *
-     * When the returned promise resolved, it is OK for the application to issue a request.
-     * The promise resolves to an object that contains a `done` method.
-     * When the application's request has completed (or failed), the application must call the `done` function
-     *
-     * @param identiy - Identiy
-     * @param getPriority - will be called when request "slots" open up, allowing the caller to update priority or cancel the request Highest priority executes first, priority less than 0 cancels the request
-     * @returns a promise resolves to a object (with a `done` field) when the request can be issued without queueing, resolves to `null` if the request has been cancelled (by the callback return less than 0). In this case the application should not issue the request
-     */
-    scheduleRequest(identiy: Identiy, getPriority: (identiy: Identiy) => number): Promise<TileRequestResult>;
+    constructor(tileset: Tileset, options: TileRequestSchedulerOptions);
     reset(): void;
-    private issueRequest;
-    /** We check requests asynchronously, to prevent multiple updates */
-    private issueNewRequests;
-    /** Refresh all requests  */
-    private issueNewRequestsAsync;
-    /** Ensure all requests have updated priorities, and that no longer valid requests are cancelled */
-    private updateAllRequests;
-    /** Update a single request by calling the callback */
-    private updateRequest;
+    update(requestTiles: Tile[], order: TileRequestOrder, frameState: TilesetFrameState): void;
 }
 
+export declare type TileRequestSchedulerOptions = {
+    onTileSkip?: (tile: Tile) => void;
+    onTileLoad?: (tile: Tile) => void;
+    onTileError?: (tile: Tile, error: Error) => void;
+};
+
 export declare class Tileset {
     static DEFAULT_MAX_MEMORY_USAGE: number;
     static DEFAULT_MAX_SCREEN_SPACE_ERROR: number;
     static DEFAULT_SKIP_LEVEL_OF_DETAIL: boolean;
+    static DEFAULT_MOST_DETAIL: boolean;
     static DEFAULT_LOAD_SIBLINGS: boolean;
+    static DEFAULT_LOAD_ALL: boolean;
     static DEFAULT_MAX_REQUESTS: number;
+    static DEFAULT_REQUEST_ORDER: TileRequestOrder;
     asset: {
         version: string;
         tilesetVersion: string;
@@ -3212,6 +3317,7 @@ export declare class Tileset {
             imageWidth: number;
             imageHeight: number;
         };
+        trajectories?: TrajectoryHeader[];
         [key: string]: any;
     };
     id: string;
@@ -3222,50 +3328,43 @@ export declare class Tileset {
     properties: Record<string, any>;
     options: TilesetOptions;
     root: Tile;
-    rootMeta: {
-        creationTime?: string;
-        upAxis?: string;
-        coordinate?: {
-            base_keyframe: number;
-            base_trajectory: number;
-            coordinate_system: string;
-            ground_height: number;
-            lon_lat_alt: [number, number, number];
-            pose_ecef_to_enu: number[];
-            pose_enu_to_ecef: number[];
-            version: number;
-        };
-    };
+    rootMeta: NonNullable<TilesetHeader['rootMeta']>;
     transform: THREE_2.Matrix4;
     transformIsIdentity: boolean;
     geometricError: number;
     cache: TileCache;
-    requestScheduler: TileRequestScheduler<string>;
+    requestScheduler: TileRequestScheduler;
     private normalTraverser;
     private skipTraverser;
+    private mostDetailTraverser;
     private memoryUsageInBytes;
     maxMemoryUsage: number;
     maxScreenSpaceError: number;
     skipLevelOfDetail: boolean;
+    mostDetail: boolean;
     loadSiblings: boolean;
+    loadAll: boolean;
     maxRequests: number;
+    tileRequestOrder: TileRequestOrder;
     loadedTiles: Set<Tile>;
     needsRefinedTiles: Set<Tile>;
     requestedTiles: Tile[];
     selectedTiles: Tile[];
-    private pendingCount;
+    unloadTiles: Tile[];
+    trajectories: Trajectory[];
+    selectedTrajectories: Trajectory[];
+    pointLength: number;
+    floorLength: number;
     constructor(id: string, header: TilesetHeader, options: TilesetOptions);
     private get traverser();
     /** Release resources */
     reset(): void;
-    /** Is the tileset loaded (update needs to have been called at least once) */
-    isLoaded(): boolean;
-    traverse(frameState: TilesetFrameState, cacheFrameStates?: TilesetFrameState[]): void;
-    loadTile(tile: Tile): void;
-    unloadTile(tile: Tile): void;
+    update(frameState: TilesetFrameState, cacheFrameStates?: TilesetFrameState[]): void;
 }
 
 export declare type TilesetFrameState = {
+    frameNumber: number;
+    time: number;
     camera: {
         type: "PerspectiveCamera" | "OrthographicCamera";
         near: number;
@@ -3279,11 +3378,9 @@ export declare type TilesetFrameState = {
     height: number;
     pixelRatio: number;
     cullingVolume: CullingVolume;
-    frameNumber: number;
     sseDenominator: number;
     minLevelOfDetail: number;
     maxLevelOfDetail: number;
-    maxScreenSpaceError: number;
 };
 
 export declare interface TilesetHeader {
@@ -3297,6 +3394,10 @@ export declare interface TilesetHeader {
             imageWidth: number;
             imageHeight: number;
         };
+        trajectories?: {
+            version: string;
+            list: TrajectoryHeader[];
+        };
         [key: string]: any;
     };
     properties?: Record<string, any>;
@@ -3305,7 +3406,11 @@ export declare interface TilesetHeader {
     rootMeta?: {
         creationTime?: string;
         upAxis?: string;
+        numFloors?: number;
+        numTotalPoints?: number;
+        numTrajectories?: number;
         coordinate?: {
+            version: number;
             base_keyframe: number;
             base_trajectory: number;
             coordinate_system: string;
@@ -3313,7 +3418,6 @@ export declare interface TilesetHeader {
             lon_lat_alt: [number, number, number];
             pose_ecef_to_enu: number[];
             pose_enu_to_ecef: number[];
-            version: number;
         };
     };
 }
@@ -3321,15 +3425,59 @@ export declare interface TilesetHeader {
 export declare interface TilesetOptions {
     url?: string;
     referer?: string;
-    contentLoader: (tile: Tile) => Promise<boolean>;
+    tileLoader: (tile: Tile) => Promise<void>;
+    tileUnloader: (tile: Tile) => Promise<void>;
     onTileLoad: (tile: Tile) => any;
     onTileUnload: (tile: Tile) => any;
     onTileError: (tile: Tile, error: Error) => any;
+    trajectoryLoader: (trajectory: Trajectory) => Promise<void>;
+    trajectoryUnloader: (trajectory: Trajectory) => Promise<void>;
+    onTrajectoryLoad: (trajectory: Trajectory) => any;
+    onTrajectoryUnload: (trajectory: Trajectory) => any;
+    onTrajectoryError: (trajectory: Trajectory, error: Error) => any;
 }
 
 export declare interface TopviewControllerCustomInitArgs extends Omit<FloorplanControllerCustomInitArgs, "defaultLongitude" | "defaultLatitude" | "maxLatitude" | "minLatitude"> {
 }
 
+export declare class Trajectory {
+    index: number;
+    name: string;
+    tileset: Tileset;
+    transform: THREE_2.Matrix4;
+    visible: boolean;
+    content: {
+        uri: string;
+        color: THREE_2.Color;
+        data?: TrajectoryContentData;
+        loadState: 'LOADING' | 'UNLOADED' | 'READY' | 'FAILED';
+        byteLength: number;
+    };
+    constructor(index: number, header: TrajectoryHeader, tileset: Tileset);
+}
+
+export declare type TrajectoryContentData = {
+    byteLength: number;
+    uri: string;
+    object: TrajectoryNode;
+};
+
+export declare interface TrajectoryHeader {
+    file: string;
+    name: string;
+    color?: number | string;
+    transform?: number[];
+}
+
+export declare class TrajectoryNode extends THREE_2.Object3D {
+    name: string;
+    private line;
+    private edge;
+    constructor(name: string, line: THREE_2.Line<THREE_2.BufferGeometry, THREE_2.ShaderMaterial>, edge: THREE_2.Points<THREE_2.BufferGeometry, THREE_2.ShaderMaterial>);
+    update(renderer: THREE_2.WebGLRenderer, camera: Camera, model: Model): void;
+    dispose(): void;
+}
+
 export declare enum VolumePlaneIntersect {
     Outside = -1,
     Intersecting = 0,