@itwin/frontend-tiles 4.1.0-dev.7 → 4.1.0-dev.71

package/src/BatchedModels.ts

@@ -1,58 +0,0 @@
-/*---------------------------------------------------------------------------------------------
-* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
-* See LICENSE.md in the project root for license terms and full copyright notice.
-*--------------------------------------------------------------------------------------------*/
-
-import { Id64, Id64String } from "@itwin/core-bentley";
-import { Range3d } from "@itwin/core-geometry";
-import { ModelExtentsProps } from "@itwin/core-common";
-import { IModelConnection, SpatialViewState } from "@itwin/core-frontend";
-
-export class BatchedModels {
-  private readonly _iModel: IModelConnection;
-  private _viewedModels!: Set<Id64String>;
-  private readonly _viewedModelIdPairs = new Id64.Uint32Set();
-  private readonly _modelRanges = new Map<Id64String, Range3d>();
-  private _modelRangePromise?: Promise<void>;
-
-  public constructor(view: SpatialViewState) {
-    this._iModel = view.iModel;
-    this.setViewedModels(view.modelSelector.models);
-  }
-
-  public setViewedModels(models: Set<Id64String>): void {
-    this._viewedModels = models;
-    this._viewedModelIdPairs.clear();
-    this._viewedModelIdPairs.addIds(models);
-
-    this._modelRangePromise = undefined;
-    const modelIds = Array.from(models).filter((modelId) => !this._modelRanges.has(modelId));
-    if (modelIds.length === 0)
-      return;
-
-    const modelRangePromise = this._modelRangePromise = this._iModel.models.queryExtents(modelIds).then((extents: ModelExtentsProps[]) => {
-      if (modelRangePromise !== this._modelRangePromise)
-        return;
-
-      this._modelRangePromise = undefined;
-      for (const extent of extents)
-        this._modelRanges.set(extent.id, Range3d.fromJSON(extent.extents));
-    }).catch(() => { });
-  }
-
-  public views(modelId: Id64String): boolean {
-    return this._viewedModels.has(modelId);
-  }
-
-  public isViewed(modelIdLo: number, modelIdHi: number): boolean {
-    return this._viewedModelIdPairs.has(modelIdLo, modelIdHi);
-  }
-
-  public unionRange(range: Range3d): void {
-    for (const id of this._viewedModels) {
-      const extent = this._modelRanges.get(id);
-      if (extent)
-        range.extendRange(extent);
-    }
-  }
-}

package/src/BatchedSpatialTileTreeRefs.ts

@@ -1,226 +0,0 @@
-/*---------------------------------------------------------------------------------------------
-* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
-* See LICENSE.md in the project root for license terms and full copyright notice.
-*--------------------------------------------------------------------------------------------*/
-
-import { assert } from "@itwin/core-bentley";
-import { RenderSchedule } from "@itwin/core-common";
-import {
-  AttachToViewportArgs, IModelConnection, SpatialTileTreeReferences, SpatialViewState, TileTreeLoadStatus, TileTreeOwner, TileTreeReference,
-} from "@itwin/core-frontend";
-import { AnimatedBatchedTileTreeReference, PrimaryBatchedTileTreeReference } from "./BatchedTileTreeReference";
-import { getBatchedTileTreeOwner } from "./BatchedTileTreeSupplier";
-import { BatchedModels } from "./BatchedModels";
-import { ComputeSpatialTilesetBaseUrl, createFallbackSpatialTileTreeReferences } from "./FrontendTiles";
-
-// Obtains tiles pre-published by mesh export service.
-class BatchedSpatialTileTreeReferences implements SpatialTileTreeReferences {
-  private readonly _view: SpatialViewState;
-  private readonly _models: BatchedModels;
-  private _currentScript?: RenderSchedule.Script;
-  private _primaryRef!: PrimaryBatchedTileTreeReference;
-  private readonly _animatedRefs: AnimatedBatchedTileTreeReference[] = [];
-  private _onModelSelectorChanged?: () => void;
-
-  public constructor(baseUrl: URL, view: SpatialViewState) {
-    this._view = view;
-    this._models = new BatchedModels(view);
-
-    const script = view.displayStyle.scheduleScript;
-    this._currentScript = script?.requiresBatching ? script : undefined;
-
-    this.load(baseUrl, view.iModel);
-
-    assert(undefined !== this._primaryRef);
-  }
-
-  private load(baseUrl: URL, iModel: IModelConnection): void {
-    const treeOwner = getBatchedTileTreeOwner(iModel, { baseUrl, script: this._currentScript });
-    this._primaryRef = new PrimaryBatchedTileTreeReference(treeOwner, this._models);
-
-    this.populateAnimatedReferences(treeOwner);
-
-    const onScriptChanged = (newScript: RenderSchedule.Script | undefined) => {
-      if (!newScript?.requiresBatching)
-        newScript = undefined;
-
-      const currentScript = this._currentScript;
-      this._currentScript = newScript;
-
-      if (newScript !== currentScript)
-        if (!newScript || !currentScript || !newScript.equals(currentScript))
-          this.load(baseUrl, iModel);
-    };
-
-    let removeScriptChangedListener = this._view.displayStyle.onScheduleScriptChanged.addListener((newScript) => onScriptChanged(newScript));
-    this._view.onDisplayStyleChanged.addListener((newStyle) => {
-      removeScriptChangedListener();
-      onScriptChanged(newStyle.scheduleScript);
-      removeScriptChangedListener = this._view.displayStyle.onScheduleScriptChanged.addListener((newScript) => onScriptChanged(newScript));
-    });
-  }
-
-  public *[Symbol.iterator](): Iterator<TileTreeReference> {
-    yield this._primaryRef;
-
-    for (const animatedRef of this._animatedRefs)
-      yield animatedRef;
-  }
-
-  private populateAnimatedReferences(treeOwner: TileTreeOwner): void {
-    this._animatedRefs.length = 0;
-    const script = this._currentScript;
-    if (!script)
-      return;
-
-    const getCurrentTimePoint = () => this._view.displayStyle.settings.timePoint ?? script.duration.low;
-    for (const timeline of script.modelTimelines) {
-      const nodeIds = timeline.transformBatchIds;
-      for (const nodeId of nodeIds) {
-        this._animatedRefs.push(new AnimatedBatchedTileTreeReference(treeOwner, {
-          timeline,
-          nodeId,
-          getCurrentTimePoint,
-        }));
-      }
-    }
-  }
-
-  public update(): void {
-    this._models.setViewedModels(this._view.modelSelector.models);
-    if (this._onModelSelectorChanged)
-      this._onModelSelectorChanged();
-  }
-
-  public attachToViewport(args: AttachToViewportArgs): void {
-    this._onModelSelectorChanged = () => args.invalidateSymbologyOverrides();
-  }
-
-  public detachFromViewport(): void {
-    this._onModelSelectorChanged = undefined;
-  }
-
-  public setDeactivated(): void {
-    // Used for debugging. Unimplemented here.
-  }
-}
-
-// A placeholder used by [[ProxySpatialTileTreeReferences]] until asynchronous loading completes.
-// It provides a TileTreeOwner that never loads a tile tree.
-// This ensures that [ViewState.areAllTileTreesLoaded]($frontend) will not return `true` while we are loading.
-class ProxyTileTreeReference extends TileTreeReference {
-  private readonly _treeOwner: TileTreeOwner;
-
-  public constructor(iModel: IModelConnection) {
-    super();
-    this._treeOwner = {
-      iModel,
-      tileTree: undefined,
-      loadStatus: TileTreeLoadStatus.NotLoaded,
-      load: () => undefined,
-      dispose: () => { },
-      loadTree: async () => Promise.resolve(undefined),
-    };
-  }
-
-  public override get treeOwner() {
-    return this._treeOwner;
-  }
-
-  // eslint-disable-next-line @typescript-eslint/naming-convention
-  public override get _isLoadingComplete() {
-    return false;
-  }
-}
-
-// Serves as a placeholder while we asynchronously obtain the base URL for a pre-published tileset (or asynchronously determine
-// that no such tileset exists).
-class ProxySpatialTileTreeReferences implements SpatialTileTreeReferences {
-  // Once async loading completes, all methods will be forwarded to this implementation.
-  private _impl?: SpatialTileTreeReferences;
-  private readonly _proxyRef: ProxyTileTreeReference;
-  // Retained if attachToViewport is called while we are still loading; and reset if detachFromViewport is called while loading.
-  private _attachArgs?: AttachToViewportArgs;
-
-  public constructor(view: SpatialViewState, getBaseUrl: Promise<URL | undefined>) {
-    this._proxyRef = new ProxyTileTreeReference(view.iModel);
-    getBaseUrl.then((url: URL | undefined) => {
-      if (url) {
-        this.setTreeRefs(new BatchedSpatialTileTreeReferences(url, view));
-      } else {
-        this.setTreeRefs(createFallbackSpatialTileTreeReferences(view));
-      }
-    }).catch(() => {
-      this.setTreeRefs(createFallbackSpatialTileTreeReferences(view));
-    });
-  }
-
-  private setTreeRefs(refs: SpatialTileTreeReferences): void {
-    this._impl = refs;
-    if (this._attachArgs) {
-      this._impl.attachToViewport(this._attachArgs);
-      this._attachArgs.invalidateSymbologyOverrides();
-      this._attachArgs = undefined;
-    }
-  }
-
-  public update(): void {
-    this._impl?.update();
-  }
-
-  public attachToViewport(args: AttachToViewportArgs): void {
-    if (this._impl)
-      this._impl.attachToViewport(args);
-    else
-      this._attachArgs = args;
-  }
-
-  public detachFromViewport(): void {
-    if (this._impl)
-      this._impl.detachFromViewport();
-    else
-      this._attachArgs = undefined;
-  }
-
-  public setDeactivated(): void { }
-
-  public *[Symbol.iterator](): Iterator<TileTreeReference> {
-    if (this._impl) {
-      for (const ref of this._impl)
-        yield ref;
-    } else {
-      yield this._proxyRef;
-    }
-  }
-}
-
-const iModelToBaseUrl = new Map<IModelConnection, URL | null | Promise<URL | undefined>>();
-
-/** @internal */
-export function createBatchedSpatialTileTreeReferences(view: SpatialViewState, computeBaseUrl: ComputeSpatialTilesetBaseUrl): SpatialTileTreeReferences {
-  const iModel = view.iModel;
-  let entry = iModelToBaseUrl.get(iModel);
-  if (undefined === entry) {
-    const promise = computeBaseUrl(iModel);
-    iModelToBaseUrl.set(iModel, entry = promise);
-    iModel.onClose.addOnce(() => iModelToBaseUrl.delete(iModel));
-    promise.then((url: URL | undefined) => {
-      if (iModelToBaseUrl.has(iModel))
-        iModelToBaseUrl.set(iModel, url ?? null);
-    }).catch(() => {
-      if (iModelToBaseUrl.has(iModel))
-        iModelToBaseUrl.set(iModel, null);
-    });
-  }
-
-  if (null === entry) {
-    // No tileset exists for this iModel - use default tile generation instead.
-    return createFallbackSpatialTileTreeReferences(view);
-  }
-
-  if (entry instanceof Promise)
-    return new ProxySpatialTileTreeReferences(view, entry);
-
-  return new BatchedSpatialTileTreeReferences(entry, view);
-}
-

package/src/BatchedTile.ts

@@ -1,206 +0,0 @@
-/*---------------------------------------------------------------------------------------------
-* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
-* See LICENSE.md in the project root for license terms and full copyright notice.
-*--------------------------------------------------------------------------------------------*/
-
-import { assert, BeTimePoint, ByteStream, Logger } from "@itwin/core-bentley";
-import { ColorDef, Tileset3dSchema } from "@itwin/core-common";
-import {
-  GltfReaderProps, GraphicBuilder, ImdlReader, IModelApp, RealityTileLoader, RenderSystem, Tile, TileBoundingBoxes, TileContent,
-  TileDrawArgs, TileParams, TileRequest, TileRequestChannel, TileTreeLoadStatus, TileUser, TileVisibility, Viewport,
-} from "@itwin/core-frontend";
-import { loggerCategory } from "./LoggerCategory";
-import { BatchedTileTree } from "./BatchedTileTree";
-import { BatchedTileContentReader } from "./BatchedTileContentReader";
-import { getMaxLevelsToSkip } from "./FrontendTiles";
-
-/** @internal */
-export interface BatchedTileParams extends TileParams {
-  childrenProps: Tileset3dSchema.Tile[] | undefined;
-}
-
-let channel: TileRequestChannel | undefined;
-
-/** @internal */
-export class BatchedTile extends Tile {
-  private readonly _childrenProps?: Tileset3dSchema.Tile[];
-  private readonly _unskippable: boolean;
-
-  public get batchedTree(): BatchedTileTree {
-    return this.tree as BatchedTileTree;
-  }
-
-  public constructor(params: BatchedTileParams, tree: BatchedTileTree) {
-    super(params, tree);
-
-    // The root tile never has content, so it doesn't count toward max levels to skip.
-    this._unskippable = 0 === (this.depth % getMaxLevelsToSkip());
-
-    if (params.childrenProps?.length)
-      this._childrenProps = params.childrenProps;
-
-    if (!this.contentId) {
-      this.setIsReady();
-      // mark "undisplayable"
-      this._maximumSize = 0;
-    }
-  }
-
-  private get _batchedChildren(): BatchedTile[] | undefined {
-    return this.children as BatchedTile[] | undefined;
-  }
-
-  public override computeLoadPriority(viewports: Iterable<Viewport>, _users: Iterable<TileUser>): number {
-    // Prioritize tiles closer to camera and center of attention (zoom point or screen center).
-    return RealityTileLoader.computeTileLocationPriority(this, viewports, this.tree.iModelTransform);
-  }
-
-  public selectTiles(selected: Set<BatchedTile>, args: TileDrawArgs, closestDisplayableAncestor: BatchedTile | undefined): void {
-    const vis = this.computeVisibility(args);
-    if (TileVisibility.OutsideFrustum === vis)
-      return;
-
-    if (this._unskippable) {
-      // Prevent this tile's content from being unloaded due to memory pressure.
-      args.touchedTiles.add(this);
-      args.markUsed(this);
-    }
-
-    closestDisplayableAncestor = this.hasGraphics ? this : closestDisplayableAncestor;
-    if (TileVisibility.TooCoarse === vis && (this.isReady || !this._unskippable)) {
-      args.markUsed(this);
-      args.markReady(this);
-      const childrenLoadStatus = this.loadChildren();
-      if (TileTreeLoadStatus.Loading === childrenLoadStatus)
-        args.markChildrenLoading();
-
-      const children = this._batchedChildren;
-      if (children) {
-        for (const child of children)
-          child.selectTiles(selected, args, closestDisplayableAncestor);
-
-        return;
-      }
-    }
-
-    // We want to display this tile. Request its content if not already loaded.
-    if ((TileVisibility.Visible === vis || this._unskippable) && !this.isReady)
-      args.insertMissing(this);
-
-    if (closestDisplayableAncestor)
-      selected.add(closestDisplayableAncestor);
-  }
-
-  protected override _loadChildren(resolve: (children: Tile[] | undefined) => void, reject: (error: Error) => void): void {
-    let children: BatchedTile[] | undefined;
-    if (this._childrenProps) {
-      try {
-        for (const childProps of this._childrenProps) {
-          const params = this.batchedTree.reader.readTileParams(childProps, this);
-          const child = new BatchedTile(params, this.batchedTree);
-          children = children ?? [];
-          children.push(child);
-        }
-      } catch (err) {
-        Logger.logException(loggerCategory, err);
-        children = undefined;
-        if (err instanceof Error)
-          reject(err);
-      }
-    }
-
-    resolve(children);
-  }
-
-  public override get channel(): TileRequestChannel {
-    if (!channel) {
-      channel = new TileRequestChannel("itwinjs-batched-models", 20);
-      IModelApp.tileAdmin.channels.add(channel);
-    }
-
-    return channel;
-  }
-
-  public override async requestContent(_isCanceled: () => boolean): Promise<TileRequest.Response> {
-    const url = new URL(this.contentId, this.batchedTree.reader.baseUrl);
-    url.search = this.batchedTree.reader.baseUrl.search;
-    const response = await fetch(url.toString());
-    return response.arrayBuffer();
-  }
-
-  public override async readContent(data: TileRequest.ResponseData, system: RenderSystem, shouldAbort?: () => boolean): Promise<TileContent> {
-    assert(data instanceof Uint8Array);
-    if (!(data instanceof Uint8Array))
-      return { };
-
-    let reader: ImdlReader | BatchedTileContentReader | undefined = ImdlReader.create({
-      stream: ByteStream.fromUint8Array(data),
-      iModel: this.tree.iModel,
-      modelId: this.tree.modelId,
-      is3d: true,
-      isLeaf: this.isLeaf,
-      system,
-      isCanceled: shouldAbort,
-      timeline: this.batchedTree.scheduleScript,
-      options: {
-        tileId: this.contentId,
-      },
-    });
-
-    if (!reader) {
-      const gltfProps = GltfReaderProps.create(data, false, this.batchedTree.reader.baseUrl);
-      if (gltfProps) {
-        reader = new BatchedTileContentReader({
-          props: gltfProps,
-          iModel: this.tree.iModel,
-          system,
-          shouldAbort,
-          vertexTableRequired: true,
-          modelId: this.tree.modelId,
-          isLeaf: this.isLeaf,
-          range: this.range,
-        });
-      }
-    }
-
-    if (!reader)
-      return { };
-
-    return reader.read();
-  }
-
-  protected override addRangeGraphic(builder: GraphicBuilder, type: TileBoundingBoxes): void {
-    if (TileBoundingBoxes.ChildVolumes !== type) {
-      super.addRangeGraphic(builder, type);
-      return;
-    }
-
-    builder.setSymbology(ColorDef.green, ColorDef.green, 2);
-    builder.addRangeBox(this.range);
-
-    this.loadChildren();
-    const children = this.children;
-    if (!children)
-      return;
-
-    builder.setSymbology(ColorDef.blue, ColorDef.blue.withTransparency(0xdf), 1);
-    for (const child of children) {
-      const range = child.range;
-      builder.addRangeBox(range);
-      builder.addRangeBox(range, true);
-    }
-  }
-
-  public prune(olderThan: BeTimePoint): void {
-    const children = this._batchedChildren;
-    if (!children)
-      return;
-
-    if (this.usageMarker.isExpired(olderThan)) {
-      this.disposeChildren();
-    } else {
-      for (const child of children)
-        child.prune(olderThan);
-    }
-  }
-}

package/src/BatchedTileContentReader.ts

@@ -1,96 +0,0 @@
-/*---------------------------------------------------------------------------------------------
-* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
-* See LICENSE.md in the project root for license terms and full copyright notice.
-*--------------------------------------------------------------------------------------------*/
-
-import { assert, Id64, Id64String } from "@itwin/core-bentley";
-import { Range3d } from "@itwin/core-geometry";
-import { Feature, FeatureTable, TileReadStatus } from "@itwin/core-common";
-import {
-  GltfDataType, GltfMeshPrimitive, GltfReader, GltfReaderArgs, GltfReaderResult,
-} from "@itwin/core-frontend";
-
-interface BatchedTileReaderArgs extends GltfReaderArgs {
-  modelId: Id64String;
-  isLeaf: boolean;
-  range: Range3d;
-}
-
-/** Read batched tiles in 3d Tiles 1.1 format. Currently, we prefer to produce tiles in iMdl format, so this goes unused for now.
- * @internal
- */
-export class BatchedTileContentReader extends GltfReader {
-  private readonly _modelId: Id64String;
-  private readonly _isLeaf: boolean;
-  private readonly _range: Range3d;
-
-  public constructor(args: BatchedTileReaderArgs) {
-    super(args);
-    this._modelId = args.modelId;
-    this._isLeaf = args.isLeaf;
-    this._range = args.range;
-  }
-
-  public override async read(): Promise<GltfReaderResult> {
-    const featureTable = this.readFeatureTable();
-    await this.resolveResources();
-    if (this._isCanceled)
-      return { readStatus: TileReadStatus.Canceled, isLeaf: this._isLeaf };
-
-    return this.readGltfAndCreateGraphics(this._isLeaf, featureTable, this._range);
-  }
-
-  private readFeatureTable(): FeatureTable | undefined {
-    // ###TODO we're just assuming there's one property table with one u64 property containing element Ids.
-    const tables = this._glTF.extensions?.EXT_structural_metadata?.propertyTables;
-    const table = tables ? tables[0] : undefined;
-    const elementIdProperty = table?.properties ? table.properties.ElementId : undefined;
-    if (!elementIdProperty)
-      return undefined;
-
-    const bufferView = this._bufferViews[elementIdProperty.values];
-    if (!bufferView || undefined === bufferView.buffer)
-      return undefined;
-
-    const bufferData = this._buffers[bufferView.buffer]?.resolvedBuffer;
-    if (!bufferData)
-      return undefined;
-
-    assert(undefined !== bufferView.byteLength); // required by spec; TypeScript interface is wrong.
-    const byteOffset = bufferView.byteOffset ?? 0;
-    const bytes = bufferData.subarray(byteOffset, byteOffset + bufferView.byteLength);
-
-    // 2 u32s per element Id.
-    const elementIds = new Uint32Array(bytes.buffer, bytes.byteOffset, bytes.byteLength / 4);
-    const numFeatures = elementIds.length / 2;
-    const featureTable = new FeatureTable(numFeatures, this._modelId);
-    for (let i = 0; i < numFeatures; i++) {
-      const elementId = Id64.fromUint32Pair(elementIds[i * 2], elementIds[i * 2 + 1]);
-      featureTable.insertWithIndex(new Feature(elementId), i);
-    }
-
-    return featureTable;
-  }
-
-  protected override readPrimitiveFeatures(primitive: GltfMeshPrimitive): Feature | number[] | undefined {
-    const ext = primitive.extensions?.EXT_mesh_features;
-    if (ext) {
-      // ###TODO making assumptions here.
-      const view = this.getBufferView(primitive.attributes, `_FEATURE_ID_${ext.featureIds[0].attribute}`);
-      // NB: 32-bit integers are not supported, but 8- and 16-bit integers will be converted to them.
-      // With more than 64k features in the tile we represent the Ids as floats instead.
-      const featureIds = view?.toBufferData(GltfDataType.Float) ?? view?.toBufferData(GltfDataType.UInt32);
-      if (view && featureIds) {
-        const indices = [];
-        for (let i = 0; i < featureIds.count; i++) {
-          const featureId = featureIds.buffer[i * view.stride];
-          indices.push(featureId);
-        }
-
-        return indices;
-      }
-    }
-
-    return new Feature(this._modelId);
-  }
-}

package/src/BatchedTileTree.ts

@@ -1,74 +0,0 @@
-/*---------------------------------------------------------------------------------------------
-* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
-* See LICENSE.md in the project root for license terms and full copyright notice.
-*--------------------------------------------------------------------------------------------*/
-
-import { BeTimePoint } from "@itwin/core-bentley";
-import { RenderMode, RenderSchedule, ViewFlagOverrides } from "@itwin/core-common";
-import {
-  Tile, TileDrawArgs, TileTree, TileTreeParams,
-} from "@itwin/core-frontend";
-import { BatchedTile, BatchedTileParams } from "./BatchedTile";
-import { BatchedTilesetReader } from "./BatchedTilesetReader";
-
-/** @internal */
-export interface BatchedTileTreeParams extends TileTreeParams {
-  rootTile: BatchedTileParams;
-  reader: BatchedTilesetReader;
-  script?: RenderSchedule.Script;
-}
-
-const viewFlagOverrides: ViewFlagOverrides = {
-  renderMode: RenderMode.SmoothShade,
-  visibleEdges: false,
-};
-
-/** @internal */
-export class BatchedTileTree extends TileTree {
-  private readonly _rootTile: BatchedTile;
-  public readonly reader: BatchedTilesetReader;
-  public readonly scheduleScript?: RenderSchedule.Script;
-
-  public constructor(params: BatchedTileTreeParams) {
-    super(params);
-    this._rootTile = new BatchedTile(params.rootTile, this);
-    this.reader = params.reader;
-    this.scheduleScript = params.script;
-  }
-
-  public override get rootTile(): BatchedTile {
-    return this._rootTile;
-  }
-
-  public override get is3d(): boolean {
-    return true;
-  }
-
-  public override get maxDepth(): number | undefined {
-    return undefined;
-  }
-
-  public override get viewFlagOverrides(): ViewFlagOverrides {
-    return viewFlagOverrides;
-  }
-
-  // eslint-disable-next-line @typescript-eslint/naming-convention
-  public override _selectTiles(args: TileDrawArgs): Tile[] {
-    const selected = new Set<BatchedTile>();
-    this.rootTile.selectTiles(selected, args, undefined);
-    return Array.from(selected);
-  }
-
-  public override draw(args: TileDrawArgs): void {
-    const tiles = this.selectTiles(args);
-    for (const tile of tiles)
-      tile.drawGraphics(args);
-
-    args.drawGraphics();
-  }
-
-  public override prune(): void {
-    const olderThan = BeTimePoint.now().minus(this.expirationTime);
-    this.rootTile.prune(olderThan);
-  }
-}