@realsee/five/five/model/tile3d/index.d.ts

Realsee Renderer SDK

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);
}