@itwin/frontend-tiles 4.0.0-dev.46

package/package.json

@@ -0,0 +1,61 @@
+{
+  "name": "@itwin/frontend-tiles",
+  "version": "4.0.0-dev.46",
+  "description": "Experimental alternative technique for visualizing the contents of iModels",
+  "main": "lib/cjs/frontend-tiles.js",
+  "module": "lib/esm/frontend-tiles.js",
+  "typings": "lib/cjs/frontend-tiles",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/iTwin/itwinjs-core/tree/master/extensions/frontend-tiles"
+  },
+  "keywords": [
+    "Bentley",
+    "BIM",
+    "iModel",
+    "UI",
+    "Widget"
+  ],
+  "author": {
+    "name": "Bentley Systems, Inc.",
+    "url": "http://www.bentley.com"
+  },
+  "peerDependencies": {
+    "@itwin/core-bentley": "4.0.0-dev.46",
+    "@itwin/core-common": "4.0.0-dev.46",
+    "@itwin/core-frontend": "4.0.0-dev.46",
+    "@itwin/core-geometry": "4.0.0-dev.46"
+  },
+  "devDependencies": {
+    "@itwin/build-tools": "4.0.0-dev.46",
+    "@itwin/core-bentley": "4.0.0-dev.46",
+    "@itwin/core-common": "4.0.0-dev.46",
+    "@itwin/core-frontend": "4.0.0-dev.46",
+    "@itwin/core-geometry": "4.0.0-dev.46",
+    "@itwin/eslint-plugin": "nightly",
+    "@types/node": "^18.11.5",
+    "eslint": "^7.11.0",
+    "rimraf": "^3.0.2",
+    "typescript": "~4.4.0"
+  },
+  "eslintConfig": {
+    "plugins": [
+      "@itwin"
+    ],
+    "extends": "plugin:@itwin/itwinjs-recommended"
+  },
+  "scripts": {
+    "build": "npm run -s build:cjs",
+    "build:ci": "npm run -s build && 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",
+    "docs": "",
+    "extract-api": "betools extract-api --entry=frontend-tiles",
+    "lint": "eslint -f visualstudio \"./src/**/*.ts\" 1>&2",
+    "test": "",
+    "cover": ""
+  },
+  "readme": "# @itwin/core-frontend\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/BatchedSpatialTileTreeRefs.ts

@@ -0,0 +1,34 @@
+/*---------------------------------------------------------------------------------------------
+* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
+* See LICENSE.md in the project root for license terms and full copyright notice.
+*--------------------------------------------------------------------------------------------*/
+
+import {
+  IModelConnection, SpatialTileTreeReferences, TileTreeReference,
+} from "@itwin/core-frontend";
+import { createBatchedTileTreeReference } from "./BatchedTileTreeReference";
+
+class TreeRefs implements SpatialTileTreeReferences {
+  private readonly _treeRef: TileTreeReference;
+
+  public constructor(treeRef: TileTreeReference) {
+    this._treeRef = treeRef;
+  }
+
+  public *[Symbol.iterator](): Iterator<TileTreeReference> {
+    yield this._treeRef;
+  }
+
+  public update(): void {
+  }
+
+  public setDeactivated(): void {
+    // This exists chiefly for debugging. Unimplemented here.
+  }
+}
+
+/** @internal */
+export function createBatchedSpatialTileTreeReferences(iModel: IModelConnection, computeBaseUrl: (iModel: IModelConnection) => URL): SpatialTileTreeReferences {
+  const treeRef = createBatchedTileTreeReference(iModel, computeBaseUrl(iModel));
+  return new TreeRefs(treeRef);
+}

package/src/BatchedTile.ts

@@ -0,0 +1,186 @@
+/*---------------------------------------------------------------------------------------------
+* 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";
+
+/** @internal */
+export interface BatchedTileParams extends TileParams {
+  childrenProps: Tileset3dSchema.Tile[] | undefined;
+}
+
+/** @internal */
+export class BatchedTile extends Tile {
+  private readonly _childrenProps?: Tileset3dSchema.Tile[];
+
+  public get batchedTree(): BatchedTileTree {
+    return this.tree as BatchedTileTree;
+  }
+
+  public constructor(params: BatchedTileParams, tree: BatchedTileTree) {
+    super(params, tree);
+    if (params.childrenProps?.length)
+      this._childrenProps = params.childrenProps;
+
+    if (!this.contentId)
+      this.setIsReady();
+  }
+
+  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: BatchedTile[], args: TileDrawArgs): void {
+    const vis = this.computeVisibility(args);
+    if (TileVisibility.OutsideFrustum === vis)
+      return;
+
+    // ###TODO proper tile refinement. Currently we simply load each level of the tree in succession until we find a tile that
+    // meets screen space error. Moreover, while we wait for children to load we stop displaying the parent.
+    // Prefer to skip some levels where appropriate.
+    // More importantly, fix tile tree structure so that children can be substituted for (portions of) parents more quickly, especially near the camera
+    // (need non-overlapping child volumes).
+    if (!this.isReady) {
+      args.insertMissing(this);
+      return;
+    }
+
+    if (TileVisibility.Visible === vis && this.hasGraphics) {
+      args.markReady(this);
+      selected.push(this);
+      return;
+    }
+
+    args.markUsed(this);
+    if (this.isReady) {
+      const childrenStatus = this.loadChildren();
+      if (TileTreeLoadStatus.Loading === childrenStatus)
+        args.markChildrenLoading();
+
+      const children = this._batchedChildren;
+      if (children)
+        for (const child of children)
+          child.selectTiles(selected, args);
+    }
+  }
+
+  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 {
+    return IModelApp.tileAdmin.channels.getForHttp("itwinjs-batched-models");
+  }
+
+  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,
+      system,
+      isCanceled: shouldAbort,
+      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

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

@@ -0,0 +1,71 @@
+/*---------------------------------------------------------------------------------------------
+* 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, 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;
+}
+
+const viewFlagOverrides: ViewFlagOverrides = {
+  renderMode: RenderMode.SmoothShade,
+  visibleEdges: false,
+};
+
+/** @internal */
+export class BatchedTileTree extends TileTree {
+  private readonly _rootTile: BatchedTile;
+  public readonly reader: BatchedTilesetReader;
+
+  public constructor(params: BatchedTileTreeParams) {
+    super(params);
+    this._rootTile = new BatchedTile(params.rootTile, this);
+    this.reader = params.reader;
+  }
+
+  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: BatchedTile[] = [];
+    this.rootTile.selectTiles(selected, args);
+    return 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);
+  }
+}

package/src/BatchedTileTreeReference.ts

@@ -0,0 +1,28 @@
+/*---------------------------------------------------------------------------------------------
+* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
+* See LICENSE.md in the project root for license terms and full copyright notice.
+*--------------------------------------------------------------------------------------------*/
+
+import {
+  IModelConnection, TileTreeOwner, TileTreeReference,
+} from "@itwin/core-frontend";
+import { getBatchedTileTreeOwner } from "./BatchedTileTreeSupplier";
+
+class BatchedTileTreeReference extends TileTreeReference {
+  private readonly _treeOwner: TileTreeOwner;
+
+  public constructor(treeOwner: TileTreeOwner) {
+    super();
+    this._treeOwner = treeOwner;
+  }
+
+  public override get treeOwner(): TileTreeOwner {
+    return this._treeOwner;
+  }
+}
+
+/** @internal */
+export function createBatchedTileTreeReference(iModel: IModelConnection, baseUrl: URL): TileTreeReference {
+  const owner = getBatchedTileTreeOwner(iModel, baseUrl);
+  return new BatchedTileTreeReference(owner);
+}

package/src/BatchedTileTreeSupplier.ts

@@ -0,0 +1,45 @@
+/*---------------------------------------------------------------------------------------------
+* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
+* See LICENSE.md in the project root for license terms and full copyright notice.
+*--------------------------------------------------------------------------------------------*/
+
+import { compareStrings, Logger } from "@itwin/core-bentley";
+import {
+  IModelConnection, TileTree, TileTreeOwner, TileTreeSupplier,
+} from "@itwin/core-frontend";
+import { loggerCategory } from "./LoggerCategory";
+import { BatchedTilesetReader } from "./BatchedTilesetReader";
+import { BatchedTileTree } from "./BatchedTileTree";
+
+/** @internal */
+export type TreeId = URL;
+
+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 async createTileTree(baseUrl: TreeId, iModel: IModelConnection): Promise<TileTree | undefined> {
+    const url = new URL("tileset.json", baseUrl);
+    url.search = baseUrl.search;
+    try {
+      const response = await fetch(url.toString());
+      const json = await response.json();
+
+      const reader = new BatchedTilesetReader(json, iModel, baseUrl);
+      const params = await reader.readTileTreeParams();
+      return new BatchedTileTree(params);
+    } catch (err) {
+      Logger.logException(loggerCategory, err);
+      return undefined;
+    }
+  }
+}
+
+const batchedTileTreeSupplier: TileTreeSupplier = new BatchedTileTreeSupplier();
+
+/** @internal */
+export function getBatchedTileTreeOwner(iModel: IModelConnection, baseUrl: URL): TileTreeOwner {
+  return iModel.tiles.getTileTreeOwner(baseUrl, batchedTileTreeSupplier);
+}

package/src/BatchedTilesetReader.ts

@@ -0,0 +1,115 @@
+/*---------------------------------------------------------------------------------------------
+* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
+* See LICENSE.md in the project root for license terms and full copyright notice.
+*--------------------------------------------------------------------------------------------*/
+
+import {
+  Angle, Matrix3d, Point3d, Range3d, Transform, Vector3d,
+} from "@itwin/core-geometry";
+import { Tileset3dSchema as schema } from "@itwin/core-common";
+import { IModelConnection, RealityModelTileUtils, TileLoadPriority } from "@itwin/core-frontend";
+import { BatchedTileTreeParams } from "./BatchedTileTree";
+import { BatchedTile, BatchedTileParams } from "./BatchedTile";
+
+function isTileset3d(json: unknown): json is schema.Tileset {
+  if (typeof json !== "object")
+    return false;
+
+  const props = json as schema.Tileset;
+
+  if (!props.root || !props.asset)
+    return false;
+
+  // ###TODO spec requires geometricError to be present on tileset and all tiles; exporter is omitting from tileset.
+  if (undefined === props.geometricError)
+    props.geometricError = props.root.geometricError;
+
+  return true;
+}
+
+function rangeFromBoundingVolume(vol: schema.BoundingVolume): Range3d {
+  if (vol.box) {
+    const center = new Point3d(vol.box[0], vol.box[1], vol.box[2]);
+    const ux = new Vector3d(vol.box[3], vol.box[4], vol.box[5]);
+    const uy = new Vector3d(vol.box[6], vol.box[7], vol.box[8]);
+    const uz = new Vector3d(vol.box[9], vol.box[10], vol.box[11]);
+
+    const range = Range3d.createNull();
+    for (let i = -1; i <= 1; i += 2)
+      for (let j = -1; j <= 1; j += 2)
+        for (let k = -1; k <= 1; k += 2)
+          range.extendPoint(center.plus3Scaled(ux, i, uy, j, uz, k));
+
+    return range;
+  } else if (vol.sphere) {
+    const center = new Point3d(vol.sphere[0], vol.sphere[1], vol.sphere[2]);
+    const radius = vol.sphere[3];
+    return Range3d.createXYZXYZ(center.x - radius, center.y - radius, center.z - radius, center.x + radius, center.y + radius, center.z + radius);
+  }
+
+  // We won't get region bounding volumes in our tiles.
+  throw new Error("region bounding volume unimplemented");
+}
+
+function transformFromJSON(json: schema.Transform): Transform {
+  const translation = new Point3d(json[12], json[13], json[14]);
+  const matrix = Matrix3d.createRowValues(
+    json[0], json[4], json[8],
+    json[1], json[5], json[9],
+    json[2], json[6], json[10]
+  );
+
+  return Transform.createOriginAndMatrix(translation, matrix);
+}
+
+/** @internal */
+export class BatchedTilesetReader {
+  private readonly _iModel: IModelConnection;
+  private readonly _tileset: schema.Tileset;
+  public readonly baseUrl: URL;
+
+  public constructor(json: unknown, iModel: IModelConnection, baseUrl: URL) {
+    if (!isTileset3d(json))
+      throw new Error("Invalid tileset JSON");
+
+    this._iModel = iModel;
+    this._tileset = json;
+    this.baseUrl = baseUrl;
+  }
+
+  public readTileParams(json: schema.Tile, parent?: BatchedTile): BatchedTileParams {
+    const content = json.content;
+    const geometricError = json.geometricError;
+    const range = rangeFromBoundingVolume(json.boundingVolume);
+    const isLeaf = undefined === json.children || json.children.length === 0;
+
+    // ###TODO evaluate this. The geometric errors in the tiles seem far too small.
+    const maximumSizeScale = 8;
+    return {
+      parent,
+      contentId: content?.uri ?? "",
+      range,
+      contentRange: content?.boundingVolume ? rangeFromBoundingVolume(content.boundingVolume) : undefined,
+      isLeaf,
+      maximumSize: maximumSizeScale * RealityModelTileUtils.maximumSizeFromGeometricTolerance(range, geometricError),
+      childrenProps: isLeaf ? undefined : json.children,
+    };
+  }
+
+  public async readTileTreeParams(): Promise<BatchedTileTreeParams> {
+    const root = this._tileset.root;
+    const location = root.transform ? transformFromJSON(root.transform) : Transform.createIdentity();
+    // y axis is up in glTF. we want z up.
+    location.multiplyTransformMatrix3d(Matrix3d.createRotationAroundVector(Vector3d.create(1, 0, 0), Angle.createRadians(Angle.piOver2Radians))!, location);
+
+    return {
+      id: "spatial-models",
+      modelId: this._iModel.transientIds.getNext(),
+      iModel: this._iModel,
+      location,
+      priority: TileLoadPriority.Primary,
+      rootTile: this.readTileParams(root),
+      reader: this,
+    };
+  }
+}

package/src/FrontendTiles.ts

@@ -0,0 +1,24 @@
+/*---------------------------------------------------------------------------------------------
+* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
+* See LICENSE.md in the project root for license terms and full copyright notice.
+*--------------------------------------------------------------------------------------------*/
+
+import { IModelConnection, SpatialTileTreeReferences, SpatialViewState } from "@itwin/core-frontend";
+import { createBatchedSpatialTileTreeReferences } from "./BatchedSpatialTileTreeRefs";
+
+/** 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.
+   */
+  computeSpatialTilesetBaseUrl: (iModel: IModelConnection) => URL;
+}
+
+/** Initialize the frontend-tiles package to obtain tiles for spatial views.
+ * @alpha
+ */
+export function initializeFrontendTiles(options: FrontendTilesOptions): void {
+  SpatialTileTreeReferences.create = (view: SpatialViewState) => createBatchedSpatialTileTreeReferences(view.iModel, options.computeSpatialTilesetBaseUrl);
+}

package/src/LoggerCategory.ts

@@ -0,0 +1,8 @@
+/*---------------------------------------------------------------------------------------------
+* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
+* See LICENSE.md in the project root for license terms and full copyright notice.
+*--------------------------------------------------------------------------------------------*/
+
+/** @internal */
+export const loggerCategory = "frontend-tiles";
+

package/src/frontend-tiles.ts

@@ -0,0 +1,6 @@
+/*---------------------------------------------------------------------------------------------
+* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
+* See LICENSE.md in the project root for license terms and full copyright notice.
+*--------------------------------------------------------------------------------------------*/
+
+export * from "./FrontendTiles";