@realsee/five 6.8.0-alpha.1 → 6.8.0-alpha.11

package/five/model/shaders/pbm_mesh_standard/vertex.d.ts

@@ -0,0 +1,2 @@
+declare const _default: string;
+export default _default;

package/five/model/shaders/pbm_pointcloud/fragment.d.ts

@@ -0,0 +1,2 @@
+declare const _default: string;
+export default _default;

package/five/model/shaders/pbm_pointcloud/vertex.d.ts

@@ -0,0 +1,2 @@
+declare const _default: string;
+export default _default;

package/five/model/tile3d/header.d.ts

@@ -0,0 +1,88 @@
+import { BoundingVolumeJson } from '../../utils/volume';
+export interface TileHeader {
+    content?: {
+        uri?: string;
+        url?: string;
+        group?: number;
+        boundingVolume?: BoundingVolumeJson;
+    };
+    geometricError: number;
+    refine?: "REPLACE" | "ADD";
+    boundingVolume?: BoundingVolumeJson;
+    viewerRequestVolume?: BoundingVolumeJson;
+    transform?: number[];
+    children?: TileHeader[];
+    extras?: Record<string, any>;
+}
+export interface TrajectoryHeader {
+    file: string;
+    name: string;
+    color?: number | string;
+    transform?: number[];
+}
+export interface TilesetHeader {
+    tilesetUrl: string;
+    asset: {
+        version: string;
+        tilesetVersion?: string;
+        gltfUpAxis?: "Y" | "Z";
+        /** 俯视图 */
+        overview?: {
+            imageFile: string;
+            worldFile: string;
+            imageWidth: number;
+            imageHeight: number;
+        };
+        /** 轨迹数据 */
+        trajectories?: {
+            version: string;
+            list: TrajectoryHeader[];
+        };
+        [key: string]: any;
+    };
+    /**
+     * @deprecated
+     * 老数据，记录层高。现在记录在 tile 的 extra 中
+     */
+    properties?: {
+        floorInfo?: {
+            ground: number;
+            height: number;
+        }[];
+    };
+    geometricError: number;
+    root: TileHeader;
+    rootMeta?: {
+        /** 创建时间 */
+        creationTime?: string;
+        /** 天轴 X Y Z */
+        upAxis?: string;
+        /** 楼层数 */
+        numFloors?: number;
+        /** 点云的点数量 */
+        numTotalPoints?: number;
+        /** 采集轨迹数量 */
+        numTrajectories?: number;
+        /** 点云的 pnts 数据的排序规则 */
+        pntsOrder?: "RANDOM" | "UNSORTED";
+        /** 坐标参数 */
+        coordinate?: {
+            version: number;
+            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[];
+        };
+        /** 任务触发参数 */
+        taskParameters?: {
+            /** 是否跑点云均匀化 "0" "1" 的字符串 */
+            point_homogenization?: string;
+            /** 是否跑点云均匀化参数 "数字" 的字符串 */
+            homo_point_density?: string;
+        };
+    };
+}
+export declare function normalizeTilesetHeader(input: any, tilesetUrl: string): TilesetHeader;

package/five/model/tile3d/index.d.ts

@@ -0,0 +1,214 @@
+import * as THREE from 'three';
+import { Camera } from '../../core/camera';
+import { Tileset } from './tileset';
+import { Tile } from './tile';
+import { Trajectory } from './trajectory';
+import { TilesetHeader } from './header';
+import { Intersection } from '../intersection';
+import { Fetcher } from '../../utils/ajax';
+import { Parameter } from '../parameter';
+import type { ModelScene } from '../model-scene';
+import type { Model } from '../model';
+export interface TileCoordinateSystem {
+    enuToEcefMatrix: THREE.Matrix4;
+    ecefToEnuMatrix: THREE.Matrix4;
+}
+/** Advanced loader options */
+export interface Tile3DOptions {
+    name: string;
+    light: boolean;
+    type: 'point_cloud' | 'mesh' | "gaussian_splatting";
+    upAxis: string;
+    fetcher: Fetcher;
+    search?: string;
+    groundHeight: number | null;
+    coordinateSystem: TileCoordinateSystem;
+    error?: Error | null;
+}
+export declare class Tile3D extends THREE.Object3D {
+    type: 'point_cloud' | 'mesh' | "gaussian_splatting";
+    parent: Model | null;
+    /** meta 信息加载错误 */
+    error?: Error | null;
+    /** 加载错误 */
+    onError?: (error: Error) => void;
+    /** 当瓦片加载 */
+    onTileLoad?: (tile: Tile) => void;
+    /** 当瓦片卸载 */
+    onTileUnload?: (tile: Tile) => void;
+    /** 更新帧次数 */
+    frameNumber: number;
+    parameter: Parameter;
+    light: boolean;
+    upAxis: string;
+    fetcher: Fetcher;
+    search: string;
+    groundHeight: number | null;
+    coordinateSystem: TileCoordinateSystem;
+    tileset: Tileset;
+    boundingBox: THREE.Box3;
+    autoRefine: boolean;
+    refined: boolean;
+    refineProgress: [number, number];
+    loaded: boolean;
+    private clearStencilObject;
+    private disposed;
+    private renderer?;
+    private renderObjects;
+    private backfaceObjects;
+    private tileObjects;
+    constructor(tilesetHeader: TilesetHeader, options: Tile3DOptions);
+    get viewerRequestVolume(): import("../../utils/volume").BoundingVolume;
+    set viewerRequestVolume(value: import("../../utils/volume").BoundingVolume);
+    get tiles(): Tile[];
+    get trajectories(): Trajectory[];
+    getRecommendProps(options?: {
+        powerPreference?: 'high' | 'default';
+    }): {
+        pointScale: number;
+        pointMinPixel: number;
+        maxScreenSpaceError: number;
+    };
+    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.Raycaster, target?: Intersection[]): Intersection[];
+    update(renderer: THREE.WebGLRenderer, camera: Camera, modelScene: ModelScene, model: Model): boolean;
+    dispose(): void;
+    /**
+     * @deprecated
+     * use this.parent instead.
+     */
+    get model(): Model;
+    /**
+     * @deprecated
+     * it's self
+     */
+    get scene(): this;
+    /**
+     * @deprecated
+     * it's self
+     */
+    get viewLayer(): this;
+    localToEnu(vector: THREE.Vector3): THREE.Vector3;
+    enuToLocal(vector: THREE.Vector3): THREE.Vector3;
+    enuToEcef(vector: THREE.Vector3): THREE.Vector3;
+    ecefToEnu(vector: THREE.Vector3): THREE.Vector3;
+    localToEcef(vector: THREE.Vector3): THREE.Vector3;
+    ecefToLocal(vector: THREE.Vector3): THREE.Vector3;
+    localToLla(vector: THREE.Vector3): THREE.Vector3;
+    llaToLocal(vector: THREE.Vector3): THREE.Vector3;
+    worldToEnu(vector: THREE.Vector3): THREE.Vector3;
+    enuToWorld(vector: THREE.Vector3): THREE.Vector3;
+    worldToEcef(vector: THREE.Vector3): THREE.Vector3;
+    ecefToWorld(vector: THREE.Vector3): THREE.Vector3;
+    worldToLla(vector: THREE.Vector3): THREE.Vector3;
+    llaToWorld(vector: THREE.Vector3): THREE.Vector3;
+    /**
+     * @deprecated
+     * 使用 localToLla(new THREE.Vector()) 替代
+     */
+    get coordinates(): string;
+    /**
+     * @deprecated
+     * 使用 coordinateSystem 替代
+     */
+    getTransformMatrix4(target?: THREE.Matrix4): THREE.Matrix4;
+    /**
+     * @deprecated
+     * 使用 llaToWorld 替代
+     */
+    coordinatesToWorldPoint(coordinates: {
+        longitude: number;
+        latitude: number;
+        altitude: number;
+    }): THREE.Vector3;
+    /**
+     * @deprecated
+     * 使用 llaToWorld 替代
+     */
+    worldPointToCoordinates(point: THREE.Vector3): {
+        longitude: number;
+        latitude: number;
+        altitude: number;
+    };
+    /**
+     * @deprecated
+     * Use `.parameter.reset('brightness')` instead
+     */
+    resetBrightness(): void;
+    /**
+     * @deprecated
+     * use `.parameter.minLevelOfDetail` `.parameter.set('minLevelOfDetail', minLevelOfDetail)` instend
+     */
+    get minLevelOfDetail(): number;
+    set minLevelOfDetail(value: number);
+    /**
+     * @deprecated
+     * use `.parameter.maxLevelOfDetail` `.parameter.set('maxLevelOfDetail', maxLevelOfDetail)` instend
+     */
+    get maxLevelOfDetail(): number;
+    set maxLevelOfDetail(value: number);
+    /**
+     * @deprecated
+     * use `.parameter.minGeometricError` `.parameter.set('minGeometricError', minGeometricError)` instend
+     */
+    get minGeometricError(): number;
+    set minGeometricError(value: number);
+    /**
+     * @deprecated
+     * use `.parameter.maxGeometricError` `.parameter.set('maxGeometricError', maxGeometricError)` instend
+     */
+    get maxGeometricError(): number;
+    set maxGeometricError(value: number);
+    /**
+     * @deprecated
+     * use `.parameter.panoramaMinGeometricError` `.parameter.set('panoramaMinGeometricError', panoramaMinGeometricError)` instend
+     */
+    get panoramaMinGeometricError(): number;
+    set panoramaMinGeometricError(value: number);
+    /**
+     * @deprecated
+     * use `.parameter.skipLevelOfDetail` `.parameter.set('skipLevelOfDetail', skipLevelOfDetail)` instend
+     */
+    get skipLevelOfDetail(): boolean;
+    set skipLevelOfDetail(value: boolean);
+    /**
+     * @deprecated
+     * use `.parameter.mostDetail` `.parameter.set('mostDetail', mostDetail)` instend
+     */
+    get mostDetail(): boolean;
+    set mostDetail(value: boolean);
+    /**
+     * @deprecated
+     * use `.parameter.loadSiblings` `.parameter.set('loadSiblings', loadSiblings)` instend
+     */
+    get loadSiblings(): boolean;
+    set loadSiblings(value: boolean);
+    /**
+     * @deprecated
+     * use `.parameter.maxMemoryUsage` `.parameter.set('maxMemoryUsage', maxMemoryUsage)` instend
+     */
+    get maxMemoryUsage(): number;
+    set maxMemoryUsage(value: number);
+    /**
+     * @deprecated
+     * use `.parameter.maxRequests` `.parameter.set('maxRequests', maxRequests)` instend
+     */
+    get maxRequests(): number;
+    set maxRequests(value: number);
+    /**
+     * @deprecated
+     * use `.parameter.requestOrder` `.parameter.set('requestOrder', requestOrder)` instend
+     */
+    get requestOrder(): import("./types").TileRequestOrder;
+    set requestOrder(value: import("./types").TileRequestOrder);
+    /**
+     * @deprecated
+     * use `.parameter.maxScreenSpaceError` `.parameter.set('maxScreenSpaceError', maxScreenSpaceError)` instend
+     */
+    get maxScreenSpaceError(): number;
+    set maxScreenSpaceError(value: number);
+}

package/five/model/tile3d/tile-cache.d.ts

@@ -0,0 +1,18 @@
+import { Tile } from './tile';
+export type TileCacheOptions = {
+    onTileLoad?: (tile: Tile) => void;
+    onTileUnload?: (tile: Tile) => void;
+};
+export declare class TileCache {
+    private options;
+    private cacheNodeMap;
+    private list;
+    private sentinel;
+    constructor(options?: TileCacheOptions);
+    reset(): void;
+    touchTile(tile: Tile): void;
+    loadTile(tile: Tile): void;
+    unloadTile(tile: Tile): void;
+    unloadTiles(isOverMemory: () => boolean): void;
+    toArray(): Tile[];
+}

package/five/model/tile3d/tile-content.d.ts

@@ -0,0 +1,10 @@
+import * as THREE from 'three';
+import { Tile } from './tile';
+import { Fetcher } from '../../utils/ajax';
+export declare function loadTileContent<T extends Tile>(tile: T, options: {
+    light: boolean;
+    fetcher: Fetcher;
+    search?: string;
+    renderer?: THREE.WebGLRenderer;
+}): Promise<T>;
+export declare function unloadTileContent(tile: Tile): void;

package/five/model/tile3d/tile-node.d.ts

@@ -0,0 +1,24 @@
+import * as THREE from 'three';
+import { Intersection } from '../intersection';
+import type { Camera } from '../../core/camera';
+import type { Tile } from './tile';
+import { PBMMesh, PBMSkinnedMesh } from '../objects/pbmMesh';
+import { PBMPointCloud } from '../objects/pbmPointCloud';
+import { PBMGSObject } from '../objects/pbmGSObject';
+import type { ResolvedParameterValue } from '../parameter';
+import type { ModelScene } from '../model-scene';
+import type { Tile3D } from './index';
+export declare class TileNode extends THREE.Object3D {
+    materials: THREE.Material[];
+    animations: THREE.AnimationClip[];
+    pbmObjects: (PBMMesh | PBMSkinnedMesh | PBMPointCloud | PBMGSObject)[];
+    private contentObject;
+    private appearMotion;
+    private disposers;
+    constructor(name: string, contentObject: THREE.Object3D, animations: THREE.AnimationClip[], disposer?: () => void);
+    generateBvhTree(): Promise<this>;
+    intersectRaycaster(raycaster: THREE.Raycaster, target?: Intersection[]): Intersection[];
+    update(renderer: THREE.WebGLRenderer, camera: Camera, modelScene: ModelScene, tile3d: Tile3D, tile: Tile, parameterValue: ResolvedParameterValue): boolean;
+    dispose(): void;
+    clone(): this;
+}

package/five/model/tile3d/tile-request-scheduler.d.ts

@@ -0,0 +1,17 @@
+import type { Tileset } from './tileset';
+import type { Tile } from './tile';
+import type { FrameState, TileRequestOrder } from './types';
+export type TileRequestSchedulerOptions = {
+    onTileSkip?: (tile: Tile) => void;
+    onTileLoad?: (tile: Tile) => void;
+    onTileError?: (tile: Tile, error: Error) => void;
+};
+export declare class TileRequestScheduler {
+    private tileset;
+    private options;
+    private activeRequests;
+    private requestQueue;
+    constructor(tileset: Tileset, options: TileRequestSchedulerOptions);
+    reset(): void;
+    update(requestTiles: Tile[], order: TileRequestOrder, frameState: FrameState): void;
+}

package/five/model/tile3d/tile.d.ts

@@ -0,0 +1,79 @@
+import * as THREE from 'three';
+import type { Tileset } from './tileset';
+import type { FrameState } from './types';
+import { BoundingVolume } from '../../utils/volume';
+import { TileHeader } from './header';
+import { TileNode } from './tile-node';
+import { LoadResultType } from '../loaders/shared';
+export type TileContentData = {
+    type: LoadResultType['type'];
+    byteLength: number;
+    memoryUsage: number;
+    uri: string;
+    object: TileNode;
+};
+export declare class Tile {
+    id: string;
+    tileset: Tileset;
+    parent: Tile | null;
+    contentParent: Tile | null;
+    geometricError: number;
+    type: 'SCENEGRAPH' | 'EMPTY' | 'TILESET';
+    floor: number;
+    content: {
+        uri: string;
+        group?: number;
+        data?: TileContentData;
+        loadState: 'LOADING' | 'UNLOADED' | 'READY' | 'FAILED';
+        loadProgress: number;
+        loadStateUpdateTime: number;
+        loadfailRetryDelay: number;
+        byteLength: number;
+        memoryUsage: number;
+    } | null;
+    level: number;
+    levelOfContent: number;
+    extras: Record<string, any>;
+    refine: TileHeader['refine'];
+    boundingVolume?: BoundingVolume;
+    viewerRequestVolume?: BoundingVolume;
+    transform: THREE.Matrix4;
+    children: Tile[];
+    state: {
+        visible: boolean;
+        frameNumber: number;
+        selectedFrameNumber: number;
+        requestedFrameNumber: number;
+        touchedFrameNumber: number;
+        distanceToCamera: number;
+        centerZDepth: number;
+        centerScreenY: number;
+        screenSpaceError: number;
+        inRequestVolume: boolean;
+        visibilityPlaneMask: number;
+        shouldRefine: boolean;
+        stackLength: number;
+        finalResolution: boolean;
+        selectionDepth: number;
+        shouldSelect: boolean;
+        lastSelect: boolean;
+        ancestorWithContent: Tile | null;
+        ancestorWithContentAvailable: Tile | null;
+    };
+    constructor(id: string, header: TileHeader, tileset: Tileset, parent?: Tile);
+    traverse(callback: (tile: Tile) => void): void;
+    updateState(frameState: FrameState): void;
+    get selected(): boolean;
+    get hasChildren(): boolean;
+    get siblingIndex(): number;
+    get hasTilesetContent(): boolean;
+    get hasRenderContent(): boolean;
+    get contentAvailable(): boolean;
+    get hasUnloadedContent(): boolean;
+    get hasEmptyContent(): boolean;
+    get contentReady(): boolean;
+    get contentByteLength(): number;
+    get contentMemoryUsage(): number;
+    getScreenSpaceError(frameState: FrameState, distanceToCamera: number, useParentGeometricError: boolean): number;
+    getPriority(frameState: FrameState): number;
+}

package/five/model/tile3d/tileset-base-traverser.d.ts

@@ -0,0 +1,59 @@
+import type { Tileset } from './tileset';
+import type { Tile } from './tile';
+import type { FrameState } from './types';
+export 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.
+     * @type Number
+     */
+    get length(): number;
+    /**
+     * Gets the element at an index.
+     * @param 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 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;
+    peek(): T | undefined;
+}
+declare class TilesetBaseTraverser {
+    tileset: Tileset;
+    protected _canSelectTile: boolean;
+    private _loadAllTilesTraversalStack;
+    constructor(tileset: Tileset);
+    traverse(root: Tile, frameState: FrameState, cacheFrameStates?: FrameState[]): void;
+    reset(): void;
+    protected updateTile(tile: Tile, frameState: FrameState): void;
+    protected selectTile(tile: Tile, frameState: FrameState): void;
+    protected loadTile(tile: Tile, frameState: FrameState): void;
+    protected touchTile(tile: Tile, frameState: FrameState): void;
+    protected canTraverse(tile: Tile, frameState: FrameState): boolean;
+    protected updateTileVisibility(tile: Tile, frameState: FrameState): void;
+    protected anyChildrenVisible(tile: Tile, frameState: FrameState): boolean;
+    protected meetsScreenSpaceErrorEarly(tile: Tile, frameState: FrameState): boolean;
+    protected sortTilesByDistanceToCamera(tiles: Tile[]): void;
+}
+export { TilesetBaseTraverser };

package/five/model/tile3d/tileset-most-detail-traverser.d.ts

@@ -0,0 +1,14 @@
+import type { Tileset } from './tileset';
+import type { Tile } from './tile';
+import type { FrameState } from './types';
+import { TilesetBaseTraverser } from './tileset-base-traverser';
+export declare class TilesetMostDetailTraverser extends TilesetBaseTraverser {
+    private _traversalStack;
+    constructor(tileset: Tileset);
+    protected canTraverse(tile: Tile, frameState: FrameState): boolean;
+    traverse(root: Tile, frameState: FrameState, cacheFrameStates: FrameState[]): void;
+    reset(): void;
+    private executeTraversal;
+    private updateAndPushChildren;
+    private selectDesiredTile;
+}

package/five/model/tile3d/tileset-normal-traverser.d.ts

@@ -0,0 +1,15 @@
+import type { Tileset } from './tileset';
+import type { Tile } from './tile';
+import type { FrameState } from './types';
+import { TilesetBaseTraverser } from './tileset-base-traverser';
+export declare class TilesetNormalTraverser extends TilesetBaseTraverser {
+    private _traversalStack;
+    private _emptyTraversalStack;
+    constructor(tileset: Tileset);
+    traverse(root: Tile, frameState: FrameState, cacheFrameStates?: FrameState[]): void;
+    reset(): void;
+    private executeTraversal;
+    private updateAndPushChildren;
+    private selectDesiredTile;
+    private executeEmptyTraversal;
+}

package/five/model/tile3d/tileset-skip-traverser.d.ts

@@ -0,0 +1,60 @@
+import type { Tileset } from './tileset';
+import type { Tile } from './tile';
+import type { FrameState } from './types';
+import { TilesetBaseTraverser } from './tileset-base-traverser';
+declare class TilesetSkipTraverser extends TilesetBaseTraverser {
+    private baseScreenSpaceError;
+    private skipScreenSpaceErrorFactor;
+    private skipLevels;
+    private _traversalStack;
+    private _descendantTraversalStack;
+    private _selectionTraversalStack;
+    private _selectionTraversalancestorStack;
+    constructor(tileset: Tileset);
+    traverse(root: Tile, frameState: FrameState, cacheFrameStates?: FrameState[]): void;
+    reset(): void;
+    private executeTraversal;
+    private updateAndPushChildren;
+    private selectDesiredTile;
+    /**
+     * Mark descendant tiles for rendering, and update as needed
+     */
+    private selectDescendants;
+    /**
+     * Determine if a tile has reached the limit of level of detail skipping.
+     * If so, it should _not_ be skipped: it should be loaded and rendered
+     *
+     * @private
+     * @param {Cesium3DTileset} tileset
+     * @param {Cesium3DTile} tile
+     * @returns {boolean} true if this tile should not be skipped
+     */
+    private reachedSkippingThreshold;
+    /**
+     * Update links to the ancestor tiles that have content
+     */
+    private updateTileAncestorContentLinks;
+    /**
+     * Determine if a tile is part of the base traversal.
+     * If not, this tile could be considered for level of detail skipping
+     */
+    private inBaseTraversal;
+    /**
+     * Traverse the tree and check if their selected frame is the current frame. If so, add it to a selection queue.
+     * This is a preorder traversal so children tiles are selected before ancestor tiles.
+     *
+     * The reason for the preorder traversal is so that tiles can easily be marked with their
+     * selection depth. A tile's _selectionDepth is its depth in the tree where all non-selected tiles are removed.
+     * This property is important for use in the stencil test because we want to render deeper tiles on top of their
+     * ancestors. If a tileset is very deep, the depth is unlikely to fit into the stencil buffer.
+     *
+     * We want to select children before their ancestors because there is no guarantee on the relationship between
+     * the children's z-depth and the ancestor's z-depth. We cannot rely on Z because we want the child to appear on top
+     * of ancestor regardless of true depth. The stencil tests used require children to be drawn first.
+     *
+     * NOTE: 3D Tiles uses 3 bits from the stencil buffer meaning this will not work when there is a chain of
+     * selected tiles that is deeper than 7. This is not very likely.
+     */
+    private traverseAndSelect;
+}
+export { TilesetSkipTraverser };