@realsee/five 6.8.0-alpha.3 → 6.8.0-alpha.31

package/five/model/parameter.d.ts

@@ -0,0 +1,141 @@
+import * as THREE from 'three';
+import { type PBMCustomShader, type PBMPanoPicture, type PBMPanoDepth, type PBMRefinedScreen, type PBMTransition, type PBMFloorStyle, type PBMColorStyle, type PBMClipperParameter, type PBMPanoFilter, type PBMPointShape, type PBMPointSize, type PBMPointBack } from './materials/pbmMaterial';
+import type { TileRequestOrder } from './tile3d/types';
+import type { Camera } from '../core/camera';
+export interface ParameterMaterialValue {
+    /** 自定义材质*/
+    customShaders: readonly PBMCustomShader[];
+    /**
+     * 是否生效标注
+     * 开启后，模型顶点上会预置 `_feature_id_rsmask` 标记。
+     * _feature_id_rsmask=1，在俯视等特定视角下，引擎会自动隐藏被标记的顶点对应的 Mesh，从而实现“开盖”效果，让室内布局观测更加清晰、观感更好。
+     */
+    vertexMarks: boolean;
+    /** 起始点 */
+    pano0: PBMPanoPicture | null;
+    /** 结束点 */
+    pano1: PBMPanoPicture | null;
+    /** 起始点深度 */
+    pano0Depth: PBMPanoDepth | null;
+    /** 结束点深度 */
+    pano1Depth: PBMPanoDepth | null;
+    /** 全景图滤镜 */
+    panoFilter: PBMPanoFilter | null;
+    /** 细化瓦片的屏幕渲染 */
+    refinedScreen: PBMRefinedScreen | null;
+    /** 模型贴图和全景图的混合程度 [0-1] */
+    modelAlpha: number;
+    /** 全景图混合程度 [0-1] */
+    progress: number;
+    /** 全景图过度混合 */
+    transition: PBMTransition;
+    /** 模型透明度 */
+    opacity: number;
+    /** 楼层样式 */
+    floorStyle: PBMFloorStyle;
+    /** 颜色样式 */
+    colorStyle: PBMColorStyle;
+    /** 模型颜色*/
+    constantColor: THREE.Vector3;
+    /** 楼层参数*/
+    shownFloorIndex: number;
+    /** 模型裁切参数（工程侧调用）*/
+    clippers: readonly PBMClipperParameter[];
+    /** 亮度 */
+    brightness: number;
+    /** 是否使用HQ*/
+    useHQWeight: boolean;
+    /** 是否使用HQ_DEPTH_MASK*/
+    useHQDepth: boolean;
+    /** 点云形状*/
+    pointShape: PBMPointShape;
+    /** 点云大小绘制方式*/
+    pointSize: PBMPointSize;
+    /** 点云背面绘制方式*/
+    pointBack: PBMPointBack;
+    /** 点云基础大小*/
+    pointScale: number;
+    /** 点云最小尺寸*/
+    pointMinPixel: number;
+    /** 点云最大尺寸*/
+    pointMaxPixel: number;
+    /** 点云出现动画 */
+    pointAppearAnimation: boolean;
+    /** 饱和度调整值*/
+    colorSaturation: number;
+    /** 亮度调整值*/
+    colorBrightness: number;
+    /** outline增益*/
+    outlineGain: number;
+    /** distance增益*/
+    distanceGain: number;
+    /** 高程着色材质*/
+    gradientTexture: THREE.Texture | null;
+    /** 是否产生阴影 */
+    castShadow: boolean;
+    /** 是否接受阴影 */
+    receiveShadow: boolean;
+    /** 半透明叠加渲染*/
+    useAddBlend: boolean;
+    /** 包围盒 */
+    boundingBox: THREE.Box3;
+    /** 3dgs球谐阶数*/
+    gaussianSplattingSHDegree: number;
+}
+export interface ParameterTilesetValue {
+    /** 模型显示最小细化层级 */
+    minLevelOfDetail: number;
+    /** 模型显示最大细化层级 */
+    maxLevelOfDetail: number;
+    /** 模型显示最小细化误差 */
+    minGeometricError: number;
+    /** 模型显示最大细化误差 */
+    maxGeometricError: number;
+    /** 全景态下模型显示最小细化误差 */
+    panoramaMinGeometricError: number;
+    /** 模型越层级加载 */
+    skipLevelOfDetail: boolean;
+    /** 模型是否最密 */
+    mostDetail: boolean;
+    /** 模型加载不在视野中的兄弟节点 */
+    loadSiblings: boolean;
+    /** 模型不加载在不在视野中的节点 */
+    cameraCulling: boolean;
+    /** 模型最大内存缓存 */
+    maxMemoryUsage: number;
+    /** 模型网络最大请求并发数 */
+    maxRequests: number;
+    /** 模型网络请求顺序 */
+    requestOrder: TileRequestOrder;
+    /** 模型屏幕空间误差计算最大值 */
+    maxScreenSpaceError: number;
+    memoryAdjustedScreenSpaceError: boolean;
+    /** 缓存相机 */
+    cacheCameras: readonly (Camera | THREE.PerspectiveCamera)[];
+}
+export interface ParameterValue extends ParameterMaterialValue, ParameterTilesetValue {
+}
+export interface ResolvedParameterValue extends ParameterValue {
+    versionNumber: number;
+}
+export interface Parameter extends Readonly<Partial<ParameterValue>> {
+}
+export declare class Parameter {
+    static createDefault(): Required<ParameterValue>;
+    static resolveValueTo(target: Partial<ResolvedParameterValue>, ...parameterValues: Partial<ParameterValue>[]): ResolvedParameterValue;
+    static resolveValue<T extends keyof ParameterValue>(name: T, ...parameterValues: Partial<ParameterValue>[]): ParameterValue[T];
+    static resolveValue(...parameterValues: Partial<ParameterValue>[]): ResolvedParameterValue;
+    id: string;
+    versionNumber: number;
+    private value;
+    private unbind;
+    constructor(initialValue?: Partial<ParameterValue>);
+    resolveValue<T extends keyof ParameterValue>(name: T, ...values: Partial<ParameterValue>[]): ParameterValue[T];
+    resolveValue(...baseValues: Partial<ParameterValue>[]): ResolvedParameterValue;
+    private assignValue;
+    set<T extends keyof ParameterValue>(name: T, value: ParameterValue[T]): this;
+    set(values: Partial<ParameterValue>): this;
+    reset(...names: (keyof ParameterValue)[]): this;
+    resetAll(): this;
+    copy(value: Partial<ParameterValue>): this;
+}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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,216 @@
+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 { type BoundingVolume } from '../../utils/volume';
+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;
+    private currentResolvedParameterValue;
+    constructor(tilesetHeader: TilesetHeader, options: Tile3DOptions);
+    get viewerRequestVolume(): BoundingVolume | undefined;
+    set viewerRequestVolume(value: BoundingVolume | undefined);
+    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 | null;
+    /**
+     * @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 { PBMGaussianSplattingObject } from '../objects/pbmGaussianSplattingObject';
+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 | PBMGaussianSplattingObject)[];
+    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;
+}