@itwin/frontend-tiles 3.7.0-dev.6 → 3.7.0-dev.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@itwin/frontend-tiles",
-  "version": "3.7.0-dev.6",
+  "version": "3.7.0-dev.8",
   "description": "Experimental alternative technique for visualizing the contents of iModels",
   "main": "lib/cjs/frontend-tiles.js",
   "module": "lib/esm/frontend-tiles.js",
@@ -22,18 +22,18 @@
     "url": "http://www.bentley.com"
   },
   "peerDependencies": {
-    "@itwin/core-bentley": "3.7.0-dev.6",
-    "@itwin/core-common": "3.7.0-dev.6",
-    "@itwin/core-frontend": "3.7.0-dev.6",
-    "@itwin/core-geometry": "3.7.0-dev.6"
+    "@itwin/core-bentley": "3.7.0-dev.8",
+    "@itwin/core-common": "3.7.0-dev.8",
+    "@itwin/core-frontend": "3.7.0-dev.8",
+    "@itwin/core-geometry": "3.7.0-dev.8"
   },
   "devDependencies": {
-    "@itwin/build-tools": "3.7.0-dev.6",
-    "@itwin/core-bentley": "3.7.0-dev.6",
-    "@itwin/core-common": "3.7.0-dev.6",
-    "@itwin/core-frontend": "3.7.0-dev.6",
-    "@itwin/core-geometry": "3.7.0-dev.6",
-    "@itwin/eslint-plugin": "3.7.0-dev.6",
+    "@itwin/build-tools": "3.7.0-dev.8",
+    "@itwin/core-bentley": "3.7.0-dev.8",
+    "@itwin/core-common": "3.7.0-dev.8",
+    "@itwin/core-frontend": "3.7.0-dev.8",
+    "@itwin/core-geometry": "3.7.0-dev.8",
+    "@itwin/eslint-plugin": "3.7.0-dev.8",
     "@types/node": "18.11.5",
     "eslint": "^7.11.0",
     "rimraf": "^3.0.2",

package/src/BatchedSpatialTileTreeRefs.ts

@@ -4,11 +4,13 @@
 *--------------------------------------------------------------------------------------------*/
 
 import {
-  AttachToViewportArgs, IModelConnection, SpatialTileTreeReferences, SpatialViewState, TileTreeReference,
+  AttachToViewportArgs, IModelConnection, SpatialTileTreeReferences, SpatialViewState, TileTreeLoadStatus, TileTreeOwner, TileTreeReference,
 } from "@itwin/core-frontend";
 import { BatchedTileTreeReference } from "./BatchedTileTreeReference";
+import { ComputeSpatialTilesetBaseUrl, createFallbackSpatialTileTreeReferences } from "./FrontendTiles";
 
-class TreeRefs implements SpatialTileTreeReferences {
+// Obtains tiles pre-published by mesh export service.
+class BatchedSpatialTileTreeReferences implements SpatialTileTreeReferences {
   private readonly _treeRef: BatchedTileTreeReference;
 
   public constructor(treeRef: BatchedTileTreeReference) {
@@ -36,8 +38,123 @@ class TreeRefs implements SpatialTileTreeReferences {
   }
 }
 
+// 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) {
+        const ref = BatchedTileTreeReference.create(view, url);
+        this.setTreeRefs(new BatchedSpatialTileTreeReferences(ref));
+      } 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: (iModel: IModelConnection) => URL): SpatialTileTreeReferences {
-  const treeRef = BatchedTileTreeReference.create(view, computeBaseUrl(view.iModel));
-  return new TreeRefs(treeRef);
+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);
+
+  const ref = BatchedTileTreeReference.create(view, entry);
+  return new BatchedSpatialTileTreeReferences(ref);
 }

package/src/BatchedTile.ts

@@ -12,6 +12,7 @@ import {
 import { loggerCategory } from "./LoggerCategory";
 import { BatchedTileTree } from "./BatchedTileTree";
 import { BatchedTileContentReader } from "./BatchedTileContentReader";
+import { getMaxLevelsToSkip } from "./FrontendTiles";
 
 /** @internal */
 export interface BatchedTileParams extends TileParams {
@@ -105,7 +106,7 @@ export class BatchedTile extends Tile {
     // This tile is too coarse to draw. Try to draw something more appropriate.
     // If it is not ready to draw, we may want to skip loading in favor of loading its descendants.
     // If we previously loaded and later unloaded content for this tile to free memory, don't force it to reload its content - proceed to children.
-    const maximumLevelsToSkip = IModelApp.tileAdmin.maximumLevelsToSkip;
+    const maximumLevelsToSkip = getMaxLevelsToSkip();
     let canSkipThisTile = (this._hadGraphics && !this.hasGraphics) /* || this.depth < this.iModelTree.maxInitialTilesToSkip */ ;
     if (canSkipThisTile) {
       numSkipped = 1;

package/src/BatchedTileTreeReference.ts

@@ -3,8 +3,11 @@
 * See LICENSE.md in the project root for license terms and full copyright notice.
 *--------------------------------------------------------------------------------------------*/
 
-import { Id64 } from "@itwin/core-bentley";
-import { BatchType, FeatureAppearance, FeatureAppearanceProvider, FeatureAppearanceSource, GeometryClass } from "@itwin/core-common";
+import { Id64, Id64String } from "@itwin/core-bentley";
+import { Range3d } from "@itwin/core-geometry";
+import {
+  BatchType, FeatureAppearance, FeatureAppearanceProvider, FeatureAppearanceSource, GeometryClass, ModelExtentsProps,
+} from "@itwin/core-common";
 import {
   AttachToViewportArgs, SpatialViewState, TileTreeOwner, TileTreeReference,
 } from "@itwin/core-frontend";
@@ -15,6 +18,8 @@ export class BatchedTileTreeReference extends TileTreeReference implements Featu
   private readonly _treeOwner: TileTreeOwner;
   private readonly _view: SpatialViewState;
   private readonly _viewedModels = new Id64.Uint32Set();
+  private readonly _modelRanges = new Map<Id64String, Range3d>();
+  private _modelRangePromise?: Promise<void>;
   private _onModelSelectorChanged?: () => void;
 
   private constructor(treeOwner: TileTreeOwner, view: SpatialViewState) {
@@ -44,8 +49,35 @@ export class BatchedTileTreeReference extends TileTreeReference implements Featu
   public updateViewedModels(): void {
     this._viewedModels.clear();
     this._viewedModels.addIds(this._view.modelSelector.models);
-    if (this._onModelSelectorChanged)
-      this._onModelSelectorChanged();
+    if (!this._onModelSelectorChanged) {
+      // Don't bother updating model ranges if we're not attached to a viewport.
+      return;
+    }
+
+    this._onModelSelectorChanged();
+
+    this._modelRangePromise = undefined;
+    const modelIds = Array.from(this._view.modelSelector.models).filter((modelId) => !this._modelRanges.has(modelId));
+    if (modelIds.length === 0)
+      return;
+
+    const modelRangePromise = this._modelRangePromise = this._treeOwner.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 override unionFitRange(union: Range3d): void {
+    this._viewedModels.forEach((low: number, high: number) => {
+      const id = Id64.fromUint32Pair(low, high);
+      const extent = this._modelRanges.get(id);
+      if (extent)
+        union.extendRange(extent);
+    });
   }
 
   public override getAppearanceProvider(): FeatureAppearanceProvider | undefined {

package/src/FrontendTiles.ts

@@ -6,19 +6,47 @@
 import { IModelConnection, SpatialTileTreeReferences, SpatialViewState } from "@itwin/core-frontend";
 import { createBatchedSpatialTileTreeReferences } from "./BatchedSpatialTileTreeRefs";
 
+/** A function that can provide the base URL where a tileset representing all of the spatial models in a given iModel are stored.
+ * The tileset is expected to reside at "baseUrl/tileset.json" and to have been produced by the [mesh export service](https://developer.bentley.com/apis/mesh-export/).
+ * If no such tileset exists for the given iModel, return `undefined`.
+ * @see [[FrontendTilesOptions.computeSpatialTilesetBaseUrl]].
+ * @alpha
+ */
+export type ComputeSpatialTilesetBaseUrl = (iModel: IModelConnection) => Promise<URL | undefined>;
+
 /** Options supplied to [[initializeFrontendTiles]].
  * @alpha
  */
 export interface FrontendTilesOptions {
-  /** Given an iModel, provide the base URL where the tiles are stored representing all of the spatial models in the iModel.
-   * It is expected that baseUrl/tileset.json exists and contains a 3d tileset in which all relative URLs are relative to baseUrl.
+  /** Provide the base URL for the pre-published tileset for a given iModel. */
+  computeSpatialTilesetBaseUrl: ComputeSpatialTilesetBaseUrl;
+  /** The maximum number of levels in the tile tree to skip loading if they do not provide the desired level of detail for the current view.
+   * Default: 4.
+   * Reducing this value will load more intermediate tiles, which causes more gradual refinement: low-resolution tiles will display quickly, followed more gradually by
+   * successively higher-resolution ones.
+   * Increasing the value jumps more directly to tiles of the exact level of detail desired, which may load more, smaller tiles up-front, leaving some areas of the view
+   * vacant for longer; and when zooming out some newly-exposed areas of the view may remain vacant for longer because no lower-resolution tiles are initially available to
+   * fill them. However, tiles close to the viewer (and therefore likely of most interest to them) will refine to an appropriate level of detail more quickly.
    */
-  computeSpatialTilesetBaseUrl: (iModel: IModelConnection) => URL;
+  maxLevelsToSkip?: number;
+}
+
+/** @internal */
+export const createFallbackSpatialTileTreeReferences = SpatialTileTreeReferences.create;
+
+let maxLevelsToSkip = 4;
+
+/** @internal */
+export function getMaxLevelsToSkip(): number {
+  return maxLevelsToSkip;
 }
 
 /** Initialize the frontend-tiles package to obtain tiles for spatial views.
  * @alpha
  */
 export function initializeFrontendTiles(options: FrontendTilesOptions): void {
+  if (undefined !== options.maxLevelsToSkip && options.maxLevelsToSkip >= 0)
+    maxLevelsToSkip = options.maxLevelsToSkip;
+
   SpatialTileTreeReferences.create = (view: SpatialViewState) => createBatchedSpatialTileTreeReferences(view, options.computeSpatialTilesetBaseUrl);
 }

package/.rush/temp/package-deps_build_ci.json

@@ -1,21 +0,0 @@
-{
-  "files": {
-    "extensions/frontend-tiles/.rush/temp/shrinkwrap-deps.json": "26b8d7130ce28f6f411cc64fa48f47de86afe4d9",
-    "extensions/frontend-tiles/LICENSE.md": "77dfb5043040cc16a3611930daba56d86ef54334",
-    "extensions/frontend-tiles/README.md": "4ea38e83e862cdfa6fab08adc92eb62bcb2fe238",
-    "extensions/frontend-tiles/config/rush-project.json": "10683a57d3bd2b8ae364fbe8f844c01619f1a821",
-    "extensions/frontend-tiles/package.json": "a824dc1f48483b2d57e4505147140e84857da0b4",
-    "extensions/frontend-tiles/src/BatchedSpatialTileTreeRefs.ts": "6e3311dba4539560b7585d640676d98f0c33912a",
-    "extensions/frontend-tiles/src/BatchedTile.ts": "b67686d0bcea3a6a1a9c563a1574d82e546ee9fa",
-    "extensions/frontend-tiles/src/BatchedTileContentReader.ts": "7a1392a3e55882eedd68f0fb098db9009f190a3e",
-    "extensions/frontend-tiles/src/BatchedTileTree.ts": "bc27ba7b54de36cfe58ce3ecd62c7795569d3509",
-    "extensions/frontend-tiles/src/BatchedTileTreeReference.ts": "0c57e84a7d361ef6d81c1c7c419e9f5891683843",
-    "extensions/frontend-tiles/src/BatchedTileTreeSupplier.ts": "916587d978864b4f9595b560ee1bac3033a123f5",
-    "extensions/frontend-tiles/src/BatchedTilesetReader.ts": "0cc90a58fc8f4cafab8c2bbdac6dc1186337b4f0",
-    "extensions/frontend-tiles/src/FrontendTiles.ts": "441dade9ada6338bf2e4db805b2af944f8f17a36",
-    "extensions/frontend-tiles/src/LoggerCategory.ts": "458e67157ea150f6bff37674320dfc8cf5886049",
-    "extensions/frontend-tiles/src/frontend-tiles.ts": "2778da0ad9afc43273e7105641ef1213edc47a83",
-    "extensions/frontend-tiles/tsconfig.json": "67be9deac4eea3b76c3e1a66b0e9004ed0f6255e"
-  },
-  "arguments": "npm run -s build && npm run -s build:esm "
-}