@itwin/core-frontend 3.1.0-dev.1 → 3.1.0-dev.8

package/lib/esm/tile/TileAdmin.js

@@ -10,8 +10,8 @@ import { BackendError, CloudStorageTileCache, defaultTileOptions, EdgeType, getM
 import { IModelApp } from "../IModelApp";
 import { IpcApp } from "../IpcApp";
 import { IModelConnection } from "../IModelConnection";
-import { UniqueViewportSets } from "../ViewportSet";
-import { DisclosedTileTreeSet, LRUTileList, TileLoadStatus, TileRequest, TileRequestChannels, } from "./internal";
+import { Viewport } from "../Viewport";
+import { DisclosedTileTreeSet, LRUTileList, TileLoadStatus, TileRequest, TileRequestChannels, UniqueTileUserSets, } from "./internal";
 /** Manages [[Tile]]s and [[TileTree]]s on behalf of [[IModelApp]]. Its responsibilities include scheduling requests for tile content via a priority queue;
  * keeping track of and imposing limits upon the amount of GPU memory consumed by tiles; and notifying listeners of tile-related events.
  * @see [[IModelApp.tileAdmin]] to access the instance of the TileAdmin.
@@ -24,11 +24,11 @@ export class TileAdmin {
      */
     constructor(isMobile, rpcConcurrency, options) {
         var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q;
-        this._viewports = new Set();
-        this._requestsPerViewport = new Map();
-        this._tileUsagePerViewport = new Map();
+        this._users = new Set();
+        this._requestsPerUser = new Map();
+        this._tileUsagePerUser = new Map();
         this._selectedAndReady = new Map();
-        this._viewportSetsForRequests = new UniqueViewportSets();
+        this._tileUserSetsForRequests = new UniqueTileUserSets();
         this._totalElided = 0;
         this._rpcInitialized = false;
         this._tileTreePropsRequests = [];
@@ -98,7 +98,10 @@ export class TileAdmin {
         // If unspecified skip one level before preloading  of parents of context tiles.
         this.contextPreloadParentSkip = Math.max(0, Math.min((options.contextPreloadParentSkip === undefined ? 1 : options.contextPreloadParentSkip), 5));
         this._cleanup = this.addLoadListener(() => {
-            this._viewports.forEach((vp) => vp.invalidateScene());
+            this._users.forEach((user) => {
+                if (user instanceof Viewport)
+                    user.invalidateScene();
+            });
         });
     }
     /** Create a TileAdmin suitable for passing to [[IModelApp.startup]] via [[IModelAppOptions.tileAdmin]] to customize aspects of
@@ -112,7 +115,7 @@ export class TileAdmin {
         return new TileAdmin(isMobile, rpcConcurrency, props);
     }
     /** @internal */
-    get emptyViewportSet() { return UniqueViewportSets.emptySet; }
+    get emptyTileUserSet() { return UniqueTileUserSets.emptySet; }
     /** Returns basic statistics about the TileAdmin's current state. */
     get statistics() {
         let numActiveTileTreePropsRequests = 0;
@@ -218,13 +221,13 @@ export class TileAdmin {
         // Free up any additional memory as required to keep within our limit.
         this.freeMemory();
     }
-    /** Iterate over the tiles that have content loaded but are not selected for display in any viewport.
+    /** Iterate over the tiles that have content loaded but are not in use by any [[TileUser]].
      * @alpha
      */
     get unselectedLoadedTiles() {
         return this._lruList.unselectedTiles;
     }
-    /** Iterate over the tiles that have content loaded and are selected for display in any viewport.
+    /** Iterate over the tiles that have content loaded and are in use by any [[TileUser]].
      * @alpha
      */
     get selectedLoadedTiles() {
@@ -232,48 +235,52 @@ export class TileAdmin {
     }
     /** Returns the number of pending and active requests associated with the specified viewport. */
     getNumRequestsForViewport(vp) {
+        return this.getNumRequestsForUser(vp);
+    }
+    /** Returns the number of pending and active requests associated with the specified user. */
+    getNumRequestsForUser(user) {
         var _a;
-        const requests = this.getRequestsForViewport(vp);
+        const requests = this.getRequestsForUser(user);
         let count = (_a = requests === null || requests === void 0 ? void 0 : requests.size) !== null && _a !== void 0 ? _a : 0;
-        const tiles = this.getTilesForViewport(vp);
+        const tiles = this.getTilesForUser(user);
         if (tiles)
             count += tiles.external.requested;
         return count;
     }
-    /** Returns the current set of Tiles requested by the specified Viewport.
+    /** Returns the current set of Tiles requested by the specified TileUser.
      * Do not modify the set or the Tiles.
      * @internal
      */
-    getRequestsForViewport(vp) {
-        return this._requestsPerViewport.get(vp);
+    getRequestsForUser(user) {
+        return this._requestsPerUser.get(user);
     }
-    /** Specifies the set of tiles currently requested for use by a viewport. This set replaces any previously specified for the same viewport.
+    /** Specifies the set of tiles currently requested for use by a TileUser. This set replaces any previously specified for the same user.
      * The requests are not actually processed until the next call to [[TileAdmin.process].
-     * This is typically invoked when the viewport recreates its scene, e.g. in response to camera movement.
+     * This is typically invoked when a viewport recreates its scene, e.g. in response to camera movement.
      * @internal
      */
-    requestTiles(vp, tiles) {
-        this._requestsPerViewport.set(vp, tiles);
+    requestTiles(user, tiles) {
+        this._requestsPerUser.set(user, tiles);
     }
-    /** Returns two sets of tiles associated with the specified Viewport's current scene.
+    /** Returns two sets of tiles associated with the specified user - typically, a viewport's current scene.
      * Do not modify the returned sets.
      * @internal
      */
-    getTilesForViewport(vp) {
-        return this._selectedAndReady.get(vp);
+    getTilesForUser(user) {
+        return this._selectedAndReady.get(user);
     }
-    /** Adds the specified tiles to the sets of selected and ready tiles for the specified Viewport.
+    /** Adds the specified tiles to the sets of selected and ready tiles for the specified TileUser.
      * The TileAdmin takes ownership of the `ready` set - do not modify it after passing it in.
      * @internal
      */
-    addTilesForViewport(vp, selected, ready) {
+    addTilesForUser(user, selected, ready) {
         // "selected" are tiles we are drawing.
-        this._lruList.markSelectedForViewport(vp.viewportId, selected);
+        this._lruList.markUsed(user.tileUserId, selected);
         // "ready" are tiles we want to draw but can't yet because, for example, their siblings are not yet ready to be drawn.
-        this._lruList.markSelectedForViewport(vp.viewportId, ready);
-        const entry = this.getTilesForViewport(vp);
+        this._lruList.markUsed(user.tileUserId, ready);
+        const entry = this.getTilesForUser(user);
         if (undefined === entry) {
-            this._selectedAndReady.set(vp, { ready, selected: new Set(selected), external: { selected: 0, requested: 0, ready: 0 } });
+            this._selectedAndReady.set(user, { ready, selected: new Set(selected), external: { selected: 0, requested: 0, ready: 0 } });
             return;
         }
         for (const tile of selected)
@@ -282,51 +289,49 @@ export class TileAdmin {
             entry.ready.add(tile);
     }
     /** Disclose statistics about tiles that are handled externally from TileAdmin. At this time, that means OrbitGT point cloud tiles.
-     * These statistics are included in the return value of [[getTilesForViewport]].
+     * These statistics are included in the return value of [[getTilesForUser]].
      * @internal
      */
-    addExternalTilesForViewport(vp, statistics) {
-        const entry = this.getTilesForViewport(vp);
+    addExternalTilesForUser(user, statistics) {
+        const entry = this.getTilesForUser(user);
         if (!entry) {
-            this._selectedAndReady.set(vp, { ready: new Set(), selected: new Set(), external: { ...statistics } });
+            this._selectedAndReady.set(user, { ready: new Set(), selected: new Set(), external: { ...statistics } });
             return;
         }
         entry.external.requested += statistics.requested;
         entry.external.selected += statistics.selected;
         entry.external.ready += statistics.ready;
     }
-    /** Clears the sets of tiles associated with a viewport's current scene.
-     * @internal
-     */
-    clearTilesForViewport(vp) {
-        this._selectedAndReady.delete(vp);
-        this._lruList.clearSelectedForViewport(vp.viewportId);
+    /** Clears the sets of tiles associated with a TileUser. */
+    clearTilesForUser(user) {
+        this._selectedAndReady.delete(user);
+        this._lruList.clearUsed(user.tileUserId);
     }
-    /** Indicates that the TileAdmin should cease tracking the specified viewport, e.g. because it is about to be destroyed.
-     * Any requests which are of interest only to the specified viewport will be canceled.
-     * @internal
+    /** Indicates that the TileAdmin should cease tracking the specified TileUser, e.g. because it is about to be destroyed.
+     * Any requests which are of interest only to the specified user will be canceled.
      */
-    forgetViewport(vp) {
-        this.onViewportIModelClosed(vp);
-        this._viewports.delete(vp);
+    forgetUser(user) {
+        this.onUserIModelClosed(user);
+        this._users.delete(user);
     }
-    /** Indicates that the TileAdmin should track tile requests for the specified viewport.
-     * This is invoked by the Viewport constructor and should not be invoked from elsewhere.
-     * @internal
+    /** Indicates that the TileAdmin should track tile requests for the specified TileUser.
+     * This is invoked by the Viewport constructor and should be invoked manually for any non-Viewport TileUser.
+     * [[forgetUser]] must be later invoked to unregister the user.
      */
-    registerViewport(vp) {
-        this._viewports.add(vp);
+    registerUser(user) {
+        this._users.add(user);
     }
-    /** Iterable over all viewports registered with TileAdmin. This may include [[OffScreenViewports]].
+    /** Iterable over all TileUsers registered with TileAdmin. This may include [[OffScreenViewports]].
      * @alpha
      */
-    get viewports() {
-        return this._viewports;
+    get tileUsers() {
+        return this._users;
     }
     /** @internal */
     invalidateAllScenes() {
-        for (const vp of this.viewports)
-            vp.invalidateScene();
+        for (const user of this.tileUsers)
+            if (user instanceof Viewport)
+                user.invalidateScene();
     }
     /** @internal */
     onShutDown() {
@@ -338,46 +343,46 @@ export class TileAdmin {
         this.channels.onShutDown();
         for (const req of this._tileTreePropsRequests)
             req.abandon();
-        this._requestsPerViewport.clear();
-        this._viewportSetsForRequests.clear();
-        this._tileUsagePerViewport.clear();
+        this._requestsPerUser.clear();
+        this._tileUserSetsForRequests.clear();
+        this._tileUsagePerUser.clear();
         this._tileTreePropsRequests.length = 0;
         this._lruList.dispose();
     }
-    /** Returns the union of the input set and the input viewport, to be associated with a [[TileRequest]].
+    /** Returns the union of the input set and the input TileUser, to be associated with a [[TileRequest]].
      * @internal
      */
-    getViewportSetForRequest(vp, vps) {
-        return this._viewportSetsForRequests.getViewportSet(vp, vps);
+    getTileUserSetForRequest(user, users) {
+        return this._tileUserSetsForRequests.getTileUserSet(user, users);
     }
-    /** Marks the Tile as "in use" by the specified Viewport, where the tile defines what "in use" means.
-     * A tile will not be discarded while it is in use by any Viewport.
+    /** Marks the Tile as "in use" by the specified TileUser, where the tile defines what "in use" means.
+     * A tile will not be discarded while it is in use by any TileUser.
      * @see [[TileTree.prune]]
      * @internal
      */
-    markTileUsedByViewport(marker, vp) {
-        let set = this._tileUsagePerViewport.get(vp);
+    markTileUsed(marker, user) {
+        let set = this._tileUsagePerUser.get(user);
         if (!set)
-            this._tileUsagePerViewport.set(vp, set = new Set());
+            this._tileUsagePerUser.set(user, set = new Set());
         set.add(marker);
     }
-    /** Returns true if the Tile is currently in use by any Viewport.
-     * @see [[markTileUsedByViewport]].
+    /** Returns true if the Tile is currently in use by any TileUser.
+     * @see [[markTileUsed]].
      * @internal
      */
     isTileInUse(marker) {
         // eslint-disable-next-line @typescript-eslint/naming-convention
-        for (const [_viewport, markers] of this._tileUsagePerViewport)
+        for (const [_user, markers] of this._tileUsagePerUser)
             if (markers.has(marker))
                 return true;
         return false;
     }
-    /** Indicates that the TileAdmin should reset usage tracking for the specified viewport, e.g. because the viewport is about
-     * to recreate its scene. Any tiles currently marked as "in use" by this viewport no longer will be.
+    /** Indicates that the TileAdmin should reset usage tracking for the specified TileUser, e.g. because the user is a Viewport about
+     * to recreate its scene. Any tiles currently marked as "in use" by this user no longer will be.
      * @internal
      */
-    clearUsageForViewport(vp) {
-        this._tileUsagePerViewport.delete(vp);
+    clearUsageForUser(user) {
+        this._tileUsagePerUser.delete(user);
     }
     /** @internal */
     async requestTileTreeProps(iModel, treeId) {
@@ -500,12 +505,12 @@ export class TileAdmin {
             this._tileTreePropsRequests[i].dispatch();
     }
     processQueue() {
-        // Mark all requests as being associated with no Viewports, indicating they are no longer needed.
-        this._viewportSetsForRequests.clearAll();
+        // Mark all requests as being associated with no users, indicating they are no longer needed.
+        this._tileUserSetsForRequests.clearAll();
         // Notify channels that we are enqueuing new requests.
         this.channels.swapPending();
-        // Repopulate pending requests queue from each viewport. We do NOT sort by priority while doing so.
-        this._requestsPerViewport.forEach((value, key) => this.processRequests(key, value));
+        // Repopulate pending requests queue from each user. We do NOT sort by priority while doing so.
+        this._requestsPerUser.forEach((value, key) => this.processRequests(key, value));
         // Ask channels to update their queues and dispatch requests.
         this.channels.process();
     }
@@ -520,18 +525,18 @@ export class TileAdmin {
         const needPurge = this._nextPurgeTime.before(now);
         if (!needPrune && !needPurge)
             return;
-        // Identify all of the TileTrees being displayed by all of the Viewports known to the TileAdmin.
-        // A single viewport can display tiles from more than one IModelConnection.
+        // Identify all of the TileTrees in use by all of the TileUsers known to the TileAdmin.
+        // NOTE: A single viewport can display tiles from more than one IModelConnection.
         // NOTE: A viewport may be displaying no trees - but we need to record its IModel so we can purge those which are NOT being displayed
         //  NOTE: That won't catch external tile trees previously used by that viewport.
         const trees = new DisclosedTileTreeSet();
         const treesByIModel = needPurge ? new Map() : undefined;
-        for (const vp of this._viewports) {
-            if (!vp.iModel.isOpen) // case of closing an IModelConnection while keeping the Viewport open, possibly for reuse with a different IModelConnection.
+        for (const user of this._users) {
+            if (!user.iModel.isOpen) // case of closing an IModelConnection while keeping the Viewport open, possibly for reuse with a different IModelConnection.
                 continue;
-            vp.discloseTileTrees(trees);
-            if (treesByIModel && undefined === treesByIModel.get(vp.iModel))
-                treesByIModel.set(vp.iModel, new Set());
+            user.discloseTileTrees(trees);
+            if (treesByIModel && undefined === treesByIModel.get(user.iModel))
+                treesByIModel.set(user.iModel, new Set());
         }
         if (needPrune) {
             // Request that each displayed tile tree discard any tiles and/or tile content that is no longer needed.
@@ -546,21 +551,21 @@ export class TileAdmin {
                     treesByIModel.set(tree.iModel, set = new Set());
                 set.add(tree);
             }
-            // Discard any tile trees that are no longer in use by any viewport.
+            // Discard any tile trees that are no longer in use by any user.
             const olderThan = now.minus(this.tileTreeExpirationTime);
             for (const entry of treesByIModel)
                 entry[0].tiles.purge(olderThan, entry[1]);
             this._nextPurgeTime = now.plus(this.tileTreeExpirationTime);
         }
     }
-    processRequests(vp, tiles) {
+    processRequests(user, tiles) {
         for (const tile of tiles) {
             if (undefined === tile.request) {
                 // ###TODO: This assertion triggers for AttachmentViewports used for rendering 3d sheet attachments.
                 // Determine why and fix.
                 // assert(tile.loadStatus === Tile.LoadStatus.NotLoaded);
                 if (TileLoadStatus.NotLoaded === tile.loadStatus) {
-                    const request = new TileRequest(tile, vp);
+                    const request = new TileRequest(tile, user);
                     tile.request = request;
                     assert(this.channels.has(request.channel));
                     request.channel.append(request);
@@ -571,33 +576,33 @@ export class TileAdmin {
                 assert(undefined !== req);
                 if (undefined !== req) {
                     // Request may already be dispatched (in channel's active requests) - if so do not re-enqueue!
-                    if (req.isQueued && 0 === req.viewports.length)
+                    if (req.isQueued && 0 === req.users.length)
                         req.channel.append(req);
-                    req.addViewport(vp);
-                    assert(0 < req.viewports.length);
+                    req.addUser(user);
+                    assert(0 < req.users.length);
                 }
             }
         }
     }
-    // NB: This does *not* remove from this._viewports - the viewport could later be reused with a different IModelConnection.
-    onViewportIModelClosed(vp) {
-        this.clearUsageForViewport(vp);
-        this.clearTilesForViewport(vp);
-        // NB: vp will be removed from ViewportSets in process() - but if we can establish that only this vp wants a given tile, cancel its request immediately.
-        const tiles = this._requestsPerViewport.get(vp);
+    // NB: This does *not* remove from this._users - a viewport could later be reused with a different IModelConnection.
+    onUserIModelClosed(user) {
+        this.clearUsageForUser(user);
+        this.clearTilesForUser(user);
+        // NB: user will be removed from TileUserSets in process() - but if we can establish that only this user wants a given tile, cancel its request immediately.
+        const tiles = this._requestsPerUser.get(user);
         if (undefined !== tiles) {
             for (const tile of tiles) {
                 const request = tile.request;
-                if (undefined !== request && 1 === request.viewports.length)
+                if (undefined !== request && 1 === request.users.length)
                     request.cancel();
             }
-            this._requestsPerViewport.delete(vp);
+            this._requestsPerUser.delete(user);
         }
     }
     onIModelClosed(iModel) {
-        this._requestsPerViewport.forEach((_req, vp) => {
-            if (vp.iModel === iModel)
-                this.onViewportIModelClosed(vp);
+        this._requestsPerUser.forEach((_req, user) => {
+            if (user.iModel === iModel)
+                this.onUserIModelClosed(user);
         });
         // Remove any TileTreeProps requests associated with this iModel.
         this._tileTreePropsRequests = this._tileTreePropsRequests.filter((req) => {