@itwin/core-frontend/lib/esm/tile/RealityTileTree.d.ts

iTwin.js frontend components

/** @packageDocumentation
 * @module Tiles
 */
import { Id64String } from "@itwin/core-bentley";
import { Range3d, Transform } from "@itwin/core-geometry";
import { ViewFlagOverrides } from "@itwin/core-common";
import { GeoConverter } from "../GeoServices";
import { GraphicBuilder } from "../render/GraphicBuilder";
import { SceneContext } from "../ViewContext";
import { RealityTile, RealityTileLoader, RealityTileParams, Tile, TileDrawArgs, TileGeometryCollector, TileParams, TileTree, TileTreeParams } from "./internal";
/** @internal */
export declare class TraversalDetails {
    queuedChildren: Tile[];
    childrenSelected: boolean;
    shouldSelectParent: boolean;
    initialize(): void;
}
/** @internal */
export declare class TraversalChildrenDetails {
    private _childDetails;
    initialize(): void;
    getChildDetail(index: number): TraversalDetails;
    combine(parentDetails: TraversalDetails): void;
}
/** @internal */
export declare class TraversalSelectionContext {
    selected: Tile[];
    displayedDescendants: Tile[][];
    preloadDebugBuilder?: GraphicBuilder | undefined;
    private _maxSelectionCount?;
    preloaded: Set<RealityTile>;
    missing: RealityTile[];
    get selectionCountExceeded(): boolean;
    constructor(selected: Tile[], displayedDescendants: Tile[][], preloadDebugBuilder?: GraphicBuilder | undefined, _maxSelectionCount?: number | undefined);
    selectOrQueue(tile: RealityTile, args: TileDrawArgs, traversalDetails: TraversalDetails): void;
    preload(tile: RealityTile, args: TileDrawArgs): void;
    select(tiles: RealityTile[], args: TileDrawArgs): void;
}
/** Provides access to per-feature properties within a [[RealityTileTree]].
 * A [[RealityTileTree]] may refer to a tileset in one of the [3D Tiles 1.0](https://docs.ogc.org/cs/18-053r2/18-053r2.html).
 * Tiles within such tilesets may include a [batch table](https://github.com/CesiumGS/3d-tiles/tree/main/specification/TileFormats/BatchTable) describing subcomponents ("features") within the tile.
 * For example, a tileset representing a building may encode each door, window, and wall as separate features.
 * The batch table may additionally contain metadata in JSON format describing each feature.
 *
 * During tile decoding, iTwin.js assigns unique, transient [Id64String]($bentley)s to each unique feature within the tileset.
 * When interacting with tileset features (e.g., via a [[SelectionSet]] or [[HitDetail]]), the features are identified by these transient Ids.
 * The tile tree's BatchTableProperties maintains the mapping between the transient Ids and the per-feature properties.
 *
 * The following example illustrates one way to obtain the properties of a specific feature within a reality model's batch table:
 * ```ts
 * [[include:GetBatchTableFeatureProperties]]
 * ```
 *
 * @see [[RealityTileTree.batchTableProperties]] to obtain the batch table properties for a TileTree.
 * @beta
 */
export interface BatchTableProperties {
    /** Obtain the JSON properties associated with the specified transient Id.
     * @param id The transient Id mapped to the feature of interest.
     * @returns A corresponding JSON object representing the feature's properties, or `undefined` if no such properties exist.
     * @note Treat the JSON properties as read-only - do not modify them.
     */
    getFeatureProperties(id: Id64String): Record<string, any> | undefined;
    /** Obtain an iterator over all of the features in the batch table and their properties. */
    entries(): Iterable<{
        id: Id64String;
        properties: Record<string, any>;
    }>;
}
/** @internal */
export interface RealityTileTreeParams extends TileTreeParams {
    readonly loader: RealityTileLoader;
    readonly yAxisUp?: boolean;
    readonly rootTile: RealityTileParams;
    readonly rootToEcef?: Transform;
    readonly gcsConverterAvailable: boolean;
    readonly baseUrl?: string;
    readonly reprojectGeometry?: boolean;
}
/** Base class for a [[TileTree]] representing a reality model (e.g., a point cloud or photogrammetry mesh) or 3d terrain with map imagery.
 * The tiles within the tree are instances of [[RealityTile]]s.
 * @public
 */
export declare class RealityTileTree extends TileTree {
    /** @internal */
    traversalChildrenByDepth: TraversalChildrenDetails[];
    /** @internal */
    readonly loader: RealityTileLoader;
    /** @internal */
    readonly yAxisUp: boolean;
    /** @internal */
    cartesianRange: Range3d;
    /** @internal */
    cartesianTransitionDistance: number;
    /** @internal */
    protected _gcsConverter: GeoConverter | undefined;
    /** @internal */
    protected _rootTile: RealityTile;
    /** @internal */
    protected _rootToEcef?: Transform;
    /** @internal */
    protected _ecefToDb?: Transform;
    /** @internal */
    readonly baseUrl?: string;
    /** If set to true, tile geometry will be reprojected using the tile's reprojection transform when geometry is collected.
     * @internal */
    reprojectGeometry?: boolean;
    /** @internal */
    constructor(params: RealityTileTreeParams);
    /** The mapping of per-feature JSON properties from this tile tree's batch table, if one is defined.
     * @beta
     */
    get batchTableProperties(): BatchTableProperties | undefined;
    /** @internal */
    get rootTile(): RealityTile;
    /** @internal */
    get is3d(): boolean;
    /** @internal */
    get maxDepth(): number;
    /** @internal */
    get minDepth(): number;
    /** @internal */
    get isContentUnbounded(): boolean;
    /** @internal */
    get isTransparent(): boolean;
    /** @internal */
    protected _selectTiles(args: TileDrawArgs): Tile[];
    /** @internal */
    get viewFlagOverrides(): ViewFlagOverrides;
    /** @internal */
    get parentsAndChildrenExclusive(): boolean;
    /** @internal */
    createTile(props: TileParams): RealityTile;
    /** Collect tiles from this tile tree based on the criteria implemented by `collector`.
     * @internal
     */
    collectTileGeometry(collector: TileGeometryCollector): void;
    /** @internal */
    prune(): void;
    /** @internal */
    draw(args: TileDrawArgs): void;
    /** @internal */
    protected collectClassifierGraphics(args: TileDrawArgs, selectedTiles: RealityTile[]): void;
    /** @internal */
    getTraversalChildren(depth: number): TraversalChildrenDetails;
    /** @internal */
    doReprojectChildren(tile: Tile): boolean;
    /** @internal */
    reprojectAndResolveChildren(parent: Tile, children: Tile[], resolve: (children: Tile[] | undefined) => void): void;
    /** @internal */
    getBaseRealityDepth(_sceneContext: SceneContext): number;
    /** Scan the list of currently selected reality tiles, and fire the viewport's 'onMapLayerScaleRangeVisibilityChanged ' event
     * if any scale range visibility change is detected for one more map-layer definition.
     * @internal
     */
    reportTileVisibility(_args: TileDrawArgs, _selected: RealityTile[]): void;
    /** @internal */
    selectRealityTiles(args: TileDrawArgs, displayedDescendants: RealityTile[][], preloadDebugBuilder?: GraphicBuilder): RealityTile[];
    /** @internal */
    protected logTiles(label: string, tiles: IterableIterator<Tile>): void;
}
//# sourceMappingURL=RealityTileTree.d.ts.map