@itwin/core-frontend 3.6.0-dev.5 → 3.6.0-dev.50

package/lib/cjs/tile/map/MapTileTree.js

@@ -7,7 +7,7 @@
  * @module Tiles
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getGcsConverterAvailable = exports.MapTileTreeReference = exports.MapTileTree = void 0;
+exports.getGcsConverterAvailable = exports.MapTileTreeReference = exports.MapTileTree = exports.MapTileTreeScaleRangeVisibility = void 0;
 const core_bentley_1 = require("@itwin/core-bentley");
 const core_common_1 = require("@itwin/core-common");
 const core_geometry_1 = require("@itwin/core-geometry");
@@ -20,6 +20,19 @@ const scratchPoint = core_geometry_1.Point3d.create();
 const scratchCorners = [core_geometry_1.Point3d.createZero(), core_geometry_1.Point3d.createZero(), core_geometry_1.Point3d.createZero(), core_geometry_1.Point3d.createZero(), core_geometry_1.Point3d.createZero(), core_geometry_1.Point3d.createZero(), core_geometry_1.Point3d.createZero(), core_geometry_1.Point3d.createZero()];
 const scratchCorner = core_geometry_1.Point3d.createZero();
 const scratchZNormal = core_geometry_1.Vector3d.create(0, 0, 1);
+/** Map tile tree scale range visibility values.
+ * @beta */
+var MapTileTreeScaleRangeVisibility;
+(function (MapTileTreeScaleRangeVisibility) {
+    /** state is currently unknown (i.e. never been displayed)  */
+    MapTileTreeScaleRangeVisibility[MapTileTreeScaleRangeVisibility["Unknown"] = 0] = "Unknown";
+    /** all currently selected tree tiles are visible (i.e within the scale range)  */
+    MapTileTreeScaleRangeVisibility[MapTileTreeScaleRangeVisibility["Visible"] = 1] = "Visible";
+    /** all currently selected tree tiles are hidden (i.e outside the scale range)  */
+    MapTileTreeScaleRangeVisibility[MapTileTreeScaleRangeVisibility["Hidden"] = 2] = "Hidden";
+    /** currently selected tree tiles are partially visible (i.e some tiles are within the scale range, and some are outside.) */
+    MapTileTreeScaleRangeVisibility[MapTileTreeScaleRangeVisibility["Partial"] = 3] = "Partial";
+})(MapTileTreeScaleRangeVisibility = exports.MapTileTreeScaleRangeVisibility || (exports.MapTileTreeScaleRangeVisibility = {}));
 /** A [quad tree](https://en.wikipedia.org/wiki/Quadtree) consisting of [[MapTile]]s representing the map imagery draped onto the surface of the Earth.
  * A `MapTileTree` enables display of a globe or planar map with [map imagery](https://en.wikipedia.org/wiki/Tiled_web_map) obtained from any number of sources, such as
  * [Bing](https://learn.microsoft.com/en-us/bingmaps/), [OpenStreetMap](https://wiki.openstreetmap.org/wiki/API), and [GIS servers](https://wiki.openstreetmap.org/wiki/API).
@@ -34,8 +47,9 @@ class MapTileTree extends internal_1.RealityTileTree {
     constructor(params, ecefToDb, bimElevationBias, geodeticOffset, sourceTilingScheme, id, applyTerrain) {
         super(params);
         /** @internal */
-        this.imageryTrees = [];
+        this.layerImageryTrees = [];
         this._layerSettings = new Map();
+        this._imageryTreeState = new Map();
         this._modelIdToIndex = new Map();
         /** @internal */
         this.layerClassifiers = new Map();
@@ -84,14 +98,34 @@ class MapTileTree extends internal_1.RealityTileTree {
         // by depth so that painters algorithm will approximate correct depth display.
         return this.useDepthBuffer ? this.loader.parentsAndChildrenExclusive : false;
     }
+    /** Return the imagery tile tree state of matching the provided imagery tree id.
+     * @internal
+     */
+    getImageryTreeState(imageryTreeId) {
+        return this._imageryTreeState.get(imageryTreeId);
+    }
+    /** Return a cloned dictionary of the imagery tile tree states
+     * @internal
+     */
+    cloneImageryTreeState() {
+        const clone = new Map();
+        for (const [treeId, state] of this._imageryTreeState) {
+            clone.set(treeId, state.clone());
+        }
+        return clone;
+    }
     /** @internal */
     tileFromQuadId(quadId) {
         return this._rootTile.tileFromQuadId(quadId);
     }
-    /** @internal */
+    /** Add a new imagery tile tree / map-layer settings pair and initialize the imagery tile tree state.
+     * @internal
+     */
     addImageryLayer(tree, settings, index) {
-        this.imageryTrees.push(tree);
+        this.layerImageryTrees.push({ tree, settings });
         this._layerSettings.set(tree.modelId, settings);
+        if (!this._imageryTreeState.has(tree.modelId))
+            this._imageryTreeState.set(tree.modelId, new internal_1.ImageryTileTreeState());
         this._modelIdToIndex.set(tree.modelId, index);
     }
     /** @internal */
@@ -110,7 +144,7 @@ class MapTileTree extends internal_1.RealityTileTree {
     }
     /** @internal */
     clearImageryTreesAndClassifiers() {
-        this.imageryTrees.length = 0;
+        this.layerImageryTrees.length = 0;
         this._layerSettings.clear();
         this._modelIdToIndex.clear();
         this.layerClassifiers.clear();
@@ -123,7 +157,7 @@ class MapTileTree extends internal_1.RealityTileTree {
     get maxDepth() {
         var _a;
         let maxDepth = this.loader.maxDepth;
-        (_a = this.imageryTrees) === null || _a === void 0 ? void 0 : _a.forEach((imageryTree) => maxDepth = Math.max(maxDepth, imageryTree.maxDepth));
+        (_a = this.layerImageryTrees) === null || _a === void 0 ? void 0 : _a.forEach((layerImageryTree) => maxDepth = Math.max(maxDepth, layerImageryTree.tree.maxDepth));
         return maxDepth;
     }
     /** @internal */
@@ -311,6 +345,69 @@ class MapTileTree extends internal_1.RealityTileTree {
             resolveCorners(gridPoints);
         }
     }
+    /** Scan the list of currently selected reality tiles, and fire the viewport's 'onMapLayerScaleRangeVisibilityChanged ' event
+     * if any scale range visibility change is detected for one more map-layer definition.
+     * @internal
+     */
+    reportTileVisibility(args, selected) {
+        const debugControl = args.context.target.debugControl;
+        const layersVisibilityBefore = this.cloneImageryTreeState();
+        const changes = new Array();
+        if (!layersVisibilityBefore)
+            return;
+        for (const [treeId] of layersVisibilityBefore) {
+            const treeVisibility = this.getImageryTreeState(treeId);
+            if (treeVisibility) {
+                treeVisibility.reset();
+            }
+        }
+        let allTilesRead = true;
+        for (const selectedTile of selected) {
+            if (selectedTile instanceof internal_1.MapTile) {
+                if (!selectedTile.isReady)
+                    allTilesRead = false;
+                let selectedImageryTiles = selectedTile.imageryTiles;
+                if (selectedTile.hiddenImageryTiles) {
+                    selectedImageryTiles = selectedImageryTiles ? [...selectedImageryTiles, ...selectedTile.hiddenImageryTiles] : selectedTile.hiddenImageryTiles;
+                }
+                if (selectedImageryTiles) {
+                    for (const selectedImageryTile of selectedImageryTiles) {
+                        const treeState = this.getImageryTreeState(selectedImageryTile.tree.id);
+                        if (treeState) {
+                            if (selectedImageryTile.isOutOfLodRange) {
+                                treeState.setScaleRangeVisibility(false);
+                            }
+                            else {
+                                treeState.setScaleRangeVisibility(true);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        if (!allTilesRead)
+            changes;
+        for (const [treeId, prevState] of layersVisibilityBefore) {
+            const newState = this.getImageryTreeState(treeId);
+            if (newState) {
+                const prevVisibility = prevState.getScaleRangeVisibility();
+                const visibility = newState.getScaleRangeVisibility();
+                if (prevVisibility !== visibility) {
+                    if (debugControl && debugControl.logRealityTiles) {
+                        // eslint-disable-next-line no-console
+                        console.log(`ImageryTileTree '${treeId}' changed prev state: '${MapTileTreeScaleRangeVisibility[prevVisibility]}' new state: '${MapTileTreeScaleRangeVisibility[visibility]}'`);
+                    }
+                    const mapLayersIndexes = args.context.viewport.getMapLayerIndexesFromIds(this.id, treeId);
+                    for (const index of mapLayersIndexes) {
+                        changes.push({ index: index.index, isOverlay: index.isOverlay, visibility });
+                    }
+                }
+            }
+        }
+        if (changes.length !== 0) {
+            args.context.viewport.onMapLayerScaleRangeVisibilityChanged.raiseEvent(changes);
+        }
+    }
     /** @internal */
     getFractionalTileCorners(quadId) {
         const corners = [];
@@ -435,7 +532,7 @@ class MapTreeSupplier {
     async createTileTree(id, iModel) {
         let bimElevationBias = 0, terrainProvider, geodeticOffset = 0;
         let applyTerrain = id.applyTerrain;
-        const modelId = iModel.transientIds.next;
+        const modelId = iModel.transientIds.getNext();
         const gcsConverterAvailable = await getGcsConverterAvailable(iModel);
         const terrainOpts = {
             wantSkirts: id.wantSkirts,
@@ -627,11 +724,28 @@ class MapTileTreeReference extends internal_1.TileTreeReference {
         const treeIndex = index + baseLayerIndex;
         return index < 0 || treeIndex >= this._layerTrees.length ? undefined : this._layerTrees[treeIndex];
     }
+    /** Return the map-layer scale range visibility for the provided map-layer index.
+   * @internal
+   */
+    getMapLayerScaleRangeVisibility(index) {
+        var _a;
+        const tree = this.treeOwner.tileTree;
+        if (undefined !== tree) {
+            const tileTreeRef = this.getLayerImageryTreeRef(index);
+            const treeId = (_a = tileTreeRef === null || tileTreeRef === void 0 ? void 0 : tileTreeRef.treeOwner.tileTree) === null || _a === void 0 ? void 0 : _a.id;
+            if (treeId !== undefined) {
+                const treeState = tree.getImageryTreeState(treeId);
+                if (treeState !== undefined)
+                    return treeState.getScaleRangeVisibility();
+            }
+        }
+        return MapTileTreeScaleRangeVisibility.Unknown;
+    }
     initializeLayers(context) {
         const tree = this.treeOwner.load();
         if (undefined === tree)
             return false; // Not loaded yet.
-        tree.imageryTrees.length = 0;
+        tree.layerImageryTrees.length = 0;
         if (0 === this._layerTrees.length)
             return !this.isOverlay;
         let treeIndex = this._layerTrees.length - 1;
@@ -643,7 +757,10 @@ class MapTileTreeReference extends internal_1.TileTreeReference {
         }
         for (; treeIndex < this._layerTrees.length; treeIndex++) {
             const layerTreeRef = this._layerTrees[treeIndex];
-            if (layerTreeRef && internal_1.TileTreeLoadStatus.NotFound !== layerTreeRef.treeOwner.loadStatus && layerTreeRef.layerSettings.visible && !layerTreeRef.layerSettings.allSubLayersInvisible) {
+            // Load tile tree for each configured layer.
+            // Note: Non-visible layer are also added to allow proper tile tree scale range visibility reporting.
+            if (layerTreeRef && internal_1.TileTreeLoadStatus.NotFound !== layerTreeRef.treeOwner.loadStatus
+                && !layerTreeRef.layerSettings.allSubLayersInvisible) {
                 const layerTree = layerTreeRef.treeOwner.load();
                 if (undefined === layerTree)
                     return false; // Not loaded yet.