@itwin/frontend-tiles 3.7.4 → 4.0.0-dev.100

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@itwin/frontend-tiles",
-  "version": "3.7.4",
+  "version": "4.0.0-dev.100",
   "description": "Experimental alternative technique for visualizing the contents of iModels",
   "main": "lib/cjs/frontend-tiles.js",
   "module": "lib/esm/frontend-tiles.js",
@@ -8,7 +8,8 @@
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "https://github.com/iTwin/itwinjs-core/tree/master/extensions/frontend-tiles"
+    "url": "https://github.com/iTwin/itwinjs-core.git",
+    "directory": "extensions/frontend-tiles"
   },
   "keywords": [
     "Bentley",
@@ -22,22 +23,22 @@
     "url": "http://www.bentley.com"
   },
   "peerDependencies": {
-    "@itwin/core-bentley": "3.7.4",
-    "@itwin/core-common": "3.7.4",
-    "@itwin/core-frontend": "3.7.4",
-    "@itwin/core-geometry": "3.7.4"
+    "@itwin/core-bentley": "4.0.0-dev.100",
+    "@itwin/core-common": "4.0.0-dev.100",
+    "@itwin/core-frontend": "4.0.0-dev.100",
+    "@itwin/core-geometry": "4.0.0-dev.100"
   },
   "devDependencies": {
-    "@itwin/build-tools": "3.7.4",
-    "@itwin/core-bentley": "3.7.4",
-    "@itwin/core-common": "3.7.4",
-    "@itwin/core-frontend": "3.7.4",
-    "@itwin/core-geometry": "3.7.4",
-    "@itwin/eslint-plugin": "3.7.4",
-    "@types/node": "18.11.5",
-    "eslint": "^7.11.0",
+    "@itwin/eslint-plugin": "^4.0.0-dev.33",
+    "@types/node": "^18.11.5",
+    "eslint": "^8.36.0",
     "rimraf": "^3.0.2",
-    "typescript": "~4.4.0"
+    "typescript": "~5.0.2",
+    "@itwin/build-tools": "4.0.0-dev.100",
+    "@itwin/core-bentley": "4.0.0-dev.100",
+    "@itwin/core-common": "4.0.0-dev.100",
+    "@itwin/core-frontend": "4.0.0-dev.100",
+    "@itwin/core-geometry": "4.0.0-dev.100"
   },
   "eslintConfig": {
     "plugins": [
@@ -46,8 +47,7 @@
     "extends": "plugin:@itwin/itwinjs-recommended"
   },
   "scripts": {
-    "build": "npm run -s build:cjs",
-    "build:ci": "npm run -s build && npm run -s build:esm",
+    "build": "npm run -s build:cjs && npm run -s build:esm",
     "build:cjs": "tsc 1>&2 --outDir lib/cjs",
     "build:esm": "tsc 1>&2 --module ES2020 --outDir lib/esm",
     "clean": "rimraf lib .rush/temp/package-deps*.json",
@@ -56,6 +56,5 @@
     "lint": "eslint -f visualstudio \"./src/**/*.ts\" 1>&2",
     "test": "",
     "cover": ""
-  },
-  "readme": "# @itwin/frontend-tiles\r\n\r\nCopyright © Bentley Systems, Incorporated. All rights reserved. See LICENSE.md for license terms and full copyright notice.\r\n\r\n## Description\r\n\r\nThe __@itwin/frontend-tiles__ package provides an experimental alternative technique for visualizing the contents of an iModel. Use `initializeFrontendTiles` to activate it.\r\n\r\n## Documentation\r\n\r\nSee the [iTwin.js](https://www.itwinjs.org) documentation for more information.\r\n\r\n"
+  }
 }

package/src/BatchedModels.ts

@@ -0,0 +1,58 @@
+/*---------------------------------------------------------------------------------------------
+* 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

@@ -3,38 +3,105 @@
 * 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 { BatchedTileTreeReference } from "./BatchedTileTreeReference";
+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 _treeRef: BatchedTileTreeReference;
+  private readonly _view: SpatialViewState;
+  private readonly _models: BatchedModels;
+  private _currentScript?: RenderSchedule.Script;
+  private _primaryRef!: PrimaryBatchedTileTreeReference;
+  private readonly _animatedRefs: AnimatedBatchedTileTreeReference[] = [];
+  private _onModelSelectorChanged?: () => void;
 
-  public constructor(treeRef: BatchedTileTreeReference) {
-    this._treeRef = treeRef;
+  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._treeRef;
+    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._treeRef.updateViewedModels();
+    this._models.setViewedModels(this._view.modelSelector.models);
+    if (this._onModelSelectorChanged)
+      this._onModelSelectorChanged();
   }
 
   public attachToViewport(args: AttachToViewportArgs): void {
-    this._treeRef.attachToViewport(args);
+    this._onModelSelectorChanged = () => args.invalidateSymbologyOverrides();
   }
 
   public detachFromViewport(): void {
-    this._treeRef.detachFromViewport();
+    this._onModelSelectorChanged = undefined;
   }
 
   public setDeactivated(): void {
-    // This exists chiefly for debugging. Unimplemented here.
+    // Used for debugging. Unimplemented here.
   }
 }
 
@@ -79,8 +146,7 @@ class ProxySpatialTileTreeReferences implements SpatialTileTreeReferences {
     this._proxyRef = new ProxyTileTreeReference(view.iModel);
     getBaseUrl.then((url: URL | undefined) => {
       if (url) {
-        const ref = BatchedTileTreeReference.create(view, url);
-        this.setTreeRefs(new BatchedSpatialTileTreeReferences(ref));
+        this.setTreeRefs(new BatchedSpatialTileTreeReferences(url, view));
       } else {
         this.setTreeRefs(createFallbackSpatialTileTreeReferences(view));
       }
@@ -155,6 +221,6 @@ export function createBatchedSpatialTileTreeReferences(view: SpatialViewState, c
   if (entry instanceof Promise)
     return new ProxySpatialTileTreeReferences(view, entry);
 
-  const ref = BatchedTileTreeReference.create(view, entry);
-  return new BatchedSpatialTileTreeReferences(ref);
+  return new BatchedSpatialTileTreeReferences(entry, view);
 }
+

package/src/BatchedTile.ts

@@ -141,6 +141,7 @@ export class BatchedTile extends Tile {
       isLeaf: this.isLeaf,
       system,
       isCanceled: shouldAbort,
+      timeline: this.batchedTree.scheduleScript,
       options: {
         tileId: this.contentId,
       },

package/src/BatchedTileTree.ts

@@ -4,7 +4,7 @@
 *--------------------------------------------------------------------------------------------*/
 
 import { BeTimePoint } from "@itwin/core-bentley";
-import { RenderMode, ViewFlagOverrides } from "@itwin/core-common";
+import { RenderMode, RenderSchedule, ViewFlagOverrides } from "@itwin/core-common";
 import {
   Tile, TileDrawArgs, TileTree, TileTreeParams,
 } from "@itwin/core-frontend";
@@ -15,6 +15,7 @@ import { BatchedTilesetReader } from "./BatchedTilesetReader";
 export interface BatchedTileTreeParams extends TileTreeParams {
   rootTile: BatchedTileParams;
   reader: BatchedTilesetReader;
+  script?: RenderSchedule.Script;
 }
 
 const viewFlagOverrides: ViewFlagOverrides = {
@@ -26,11 +27,13 @@ const viewFlagOverrides: ViewFlagOverrides = {
 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 {

package/src/BatchedTileTreeReference.ts

@@ -3,85 +3,53 @@
 * 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 { Range3d, Transform } from "@itwin/core-geometry";
 import {
-  BatchType, FeatureAppearance, FeatureAppearanceProvider, FeatureAppearanceSource, GeometryClass, ModelExtentsProps,
+  BatchType, FeatureAppearance, FeatureAppearanceProvider, FeatureAppearanceSource, GeometryClass, RenderSchedule,
 } from "@itwin/core-common";
 import {
-  AttachToViewportArgs, SpatialViewState, TileTreeOwner, TileTreeReference,
+  AnimationNodeId, formatAnimationBranchId, SceneContext, TileDrawArgs, TileTree, TileTreeOwner, TileTreeReference,
 } from "@itwin/core-frontend";
-import { getBatchedTileTreeOwner } from "./BatchedTileTreeSupplier";
+import { BatchedModels } from "./BatchedModels";
 
 /** @internal */
-export class BatchedTileTreeReference extends TileTreeReference implements FeatureAppearanceProvider {
-  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) {
+export abstract class BatchedTileTreeReference extends TileTreeReference {
+  protected readonly _treeOwner: TileTreeOwner;
+
+  protected constructor(treeOwner: TileTreeOwner) {
     super();
     this._treeOwner = treeOwner;
-    this._view = view;
-  }
-
-  public static create(view: SpatialViewState, baseUrl: URL): BatchedTileTreeReference {
-    const owner = getBatchedTileTreeOwner(view.iModel, baseUrl);
-    return new BatchedTileTreeReference(owner, view);
   }
 
   public override get treeOwner(): TileTreeOwner {
     return this._treeOwner;
   }
 
-  public attachToViewport(args: AttachToViewportArgs): void {
-    this._onModelSelectorChanged = () => args.invalidateSymbologyOverrides();
-    this.updateViewedModels();
+  protected computeBaseTransform(tree: TileTree): Transform {
+    return super.computeTransform(tree);
   }
 
-  public detachFromViewport(): void {
-    this._onModelSelectorChanged = undefined;
+  protected override computeTransform(tree: TileTree): Transform {
+    const baseTf = this.computeBaseTransform(tree);
+    // ###TODO this.view.modelDisplayTransformProvider?.getModelDisplayTransform(modelId...)
+    return baseTf;
   }
+}
+
+export class PrimaryBatchedTileTreeReference extends BatchedTileTreeReference implements FeatureAppearanceProvider {
+  private readonly _models: BatchedModels;
 
-  public updateViewedModels(): void {
-    this._viewedModels.clear();
-    this._viewedModels.addIds(this._view.modelSelector.models);
-    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 constructor(treeOwner: TileTreeOwner, models: BatchedModels) {
+    super(treeOwner);
+    this._models = models;
   }
 
-  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 unionFitRange(range: Range3d): void {
+    this._models.unionRange(range);
   }
 
   public override getAppearanceProvider(): FeatureAppearanceProvider | undefined {
-    return this._onModelSelectorChanged ? this : undefined;
+    return this;
   }
 
   public getFeatureAppearance(
@@ -93,10 +61,53 @@ export class BatchedTileTreeReference extends TileTreeReference implements Featu
     type: BatchType,
     animationNodeId: number
   ): FeatureAppearance | undefined {
-    // ###TODO: Until MultiModelPackedFeatureTable is hooked up we'll always get the transient model Id - remove check after that.
-    if (modelHi !== 0xffffff00 && !this._viewedModels.has(modelLo, modelHi))
+    if (!this._models.isViewed(modelLo, modelHi))
       return undefined;
 
     return source.getAppearance(elemLo, elemHi, subcatLo, subcatHi, geomClass, modelLo, modelHi, type, animationNodeId);
   }
+
+  public override getAnimationTransformNodeId() {
+    return AnimationNodeId.Untransformed;
+  }
+}
+
+export interface AnimationNode {
+  readonly timeline: RenderSchedule.ModelTimeline;
+  readonly nodeId: number;
+  getCurrentTimePoint(): number;
+}
+
+export class AnimatedBatchedTileTreeReference extends BatchedTileTreeReference {
+  private readonly _node: AnimationNode;
+  private readonly _branchId: string;
+
+  public constructor(treeOwner: TileTreeOwner, node: AnimationNode) {
+    super(treeOwner);
+    this._node = node;
+    this._branchId = formatAnimationBranchId(node.timeline.modelId, node.nodeId);
+  }
+
+  public override getAnimationTransformNodeId(): number {
+    return this._node.nodeId;
+  }
+
+  public override computeBaseTransform(tree: TileTree): Transform {
+    const tf = super.computeBaseTransform(tree);
+    const animTf = this._node.timeline.getTransform(this._node.nodeId, this._node.getCurrentTimePoint());
+    if (animTf)
+      animTf.multiplyTransformTransform(tf, tf);
+
+    return tf;
+  }
+
+  public override createDrawArgs(context: SceneContext): TileDrawArgs | undefined {
+    const animBranch = context.viewport.target.animationBranches?.branchStates.get(this._branchId);
+    if (animBranch && animBranch.omit)
+      return undefined;
+
+    const args = super.createDrawArgs(context);
+    // ###TODO args.boundingRange = args.tree.getTransformNodeRange(this._animationTransformNodeId);
+    return args;
+  }
 }

package/src/BatchedTileTreeSupplier.ts

@@ -3,7 +3,8 @@
 * See LICENSE.md in the project root for license terms and full copyright notice.
 *--------------------------------------------------------------------------------------------*/
 
-import { compareStrings, Logger } from "@itwin/core-bentley";
+import { comparePossiblyUndefined, compareStrings, Logger } from "@itwin/core-bentley";
+import { RenderSchedule } from "@itwin/core-common";
 import {
   IModelConnection, TileTree, TileTreeOwner, TileTreeSupplier,
 } from "@itwin/core-frontend";
@@ -12,15 +13,19 @@ import { BatchedTilesetReader } from "./BatchedTilesetReader";
 import { BatchedTileTree } from "./BatchedTileTree";
 
 /** @internal */
-export type TreeId = URL;
+export interface BatchedTileTreeId {
+  baseUrl: URL;
+  script?: RenderSchedule.Script;
+}
 
 class BatchedTileTreeSupplier implements TileTreeSupplier {
-  public compareTileTreeIds(lhs: TreeId, rhs: TreeId): number {
-    // Currently each iModel has exactly 1 unique tile tree for all spatial models.
-    return compareStrings(lhs.toString(), rhs.toString());
+  public compareTileTreeIds(lhs: BatchedTileTreeId, rhs: BatchedTileTreeId): number {
+    return compareStrings(lhs.toString(), rhs.toString())
+      || comparePossiblyUndefined((x, y) => x.compareTo(y), lhs.script, rhs.script);
   }
 
-  public async createTileTree(baseUrl: TreeId, iModel: IModelConnection): Promise<TileTree | undefined> {
+  public async createTileTree(treeId: BatchedTileTreeId, iModel: IModelConnection): Promise<TileTree | undefined> {
+    const baseUrl = treeId.baseUrl;
     const url = new URL("tileset.json", baseUrl);
     url.search = baseUrl.search;
     try {
@@ -29,6 +34,8 @@ class BatchedTileTreeSupplier implements TileTreeSupplier {
 
       const reader = new BatchedTilesetReader(json, iModel, baseUrl);
       const params = await reader.readTileTreeParams();
+
+      params.script = treeId.script;
       return new BatchedTileTree(params);
     } catch (err) {
       Logger.logException(loggerCategory, err);
@@ -40,6 +47,6 @@ class BatchedTileTreeSupplier implements TileTreeSupplier {
 const batchedTileTreeSupplier: TileTreeSupplier = new BatchedTileTreeSupplier();
 
 /** @internal */
-export function getBatchedTileTreeOwner(iModel: IModelConnection, baseUrl: URL): TileTreeOwner {
-  return iModel.tiles.getTileTreeOwner(baseUrl, batchedTileTreeSupplier);
+export function getBatchedTileTreeOwner(iModel: IModelConnection, treeId: BatchedTileTreeId): TileTreeOwner {
+  return iModel.tiles.getTileTreeOwner(treeId, batchedTileTreeSupplier);
 }

package/.rush/temp/operation/build_ci/state.json

@@ -1,3 +0,0 @@
-{
-  "nonCachedDurationMs": 18590.74739998579
-}