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

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

@@ -9,10 +9,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getGcsConverterAvailable = exports.MapTileTreeReference = exports.MapTileTree = void 0;
 const core_bentley_1 = require("@itwin/core-bentley");
-const core_geometry_1 = require("@itwin/core-geometry");
 const core_common_1 = require("@itwin/core-common");
+const core_geometry_1 = require("@itwin/core-geometry");
 const ApproximateTerrainHeights_1 = require("../../ApproximateTerrainHeights");
-const IModelApp_1 = require("../../IModelApp");
 const PlanarClipMaskState_1 = require("../../PlanarClipMaskState");
 const FeatureSymbology_1 = require("../../render/FeatureSymbology");
 const internal_1 = require("../internal");
@@ -30,6 +29,8 @@ class MapTileTree extends internal_1.RealityTileTree {
         this.sourceTilingScheme = sourceTilingScheme;
         this.imageryTrees = [];
         this._layerSettings = new Map();
+        this._modelIdToIndex = new Map();
+        this.layerClassifiers = new Map();
         this._mercatorTilingScheme = new internal_1.WebMercatorTilingScheme();
         this._mercatorFractionToDb = this._mercatorTilingScheme.computeMercatorFractionToDb(ecefToDb, bimElevationBias, params.iModel, applyTerrain);
         const quadId = new internal_1.QuadId(sourceTilingScheme.rootLevel, 0, 0);
@@ -47,6 +48,7 @@ class MapTileTree extends internal_1.RealityTileTree {
         if (applyTerrain) {
             this.minEarthEllipsoid = core_geometry_1.Ellipsoid.createCenterMatrixRadii(this.globeOrigin, this.ecefToDb.matrix, core_geometry_1.Constant.earthRadiusWGS84.equator + globalHeightRange.low, core_geometry_1.Constant.earthRadiusWGS84.equator + globalHeightRange.low, core_geometry_1.Constant.earthRadiusWGS84.polar + globalHeightRange.low);
             this.maxEarthEllipsoid = core_geometry_1.Ellipsoid.createCenterMatrixRadii(this.globeOrigin, this.ecefToDb.matrix, core_geometry_1.Constant.earthRadiusWGS84.equator + globalHeightRange.high, core_geometry_1.Constant.earthRadiusWGS84.equator + globalHeightRange.high, core_geometry_1.Constant.earthRadiusWGS84.polar + globalHeightRange.high);
+            this.produceGeometry = id.produceGeometry;
         }
         else {
             this.minEarthEllipsoid = this.earthEllipsoid;
@@ -69,19 +71,28 @@ class MapTileTree extends internal_1.RealityTileTree {
     tileFromQuadId(quadId) {
         return this._rootTile.tileFromQuadId(quadId);
     }
-    addImageryLayer(tree, settings) {
-        const maxLayers = IModelApp_1.IModelApp.renderSystem.maxRealityImageryLayers;
-        if (this.imageryTrees.length < maxLayers) {
-            this.imageryTrees.push(tree);
-            this._layerSettings.set(tree.modelId, settings);
-        }
-        else {
-            // TBD -- Notify user that layers is being ignored?
-        }
+    addImageryLayer(tree, settings, index) {
+        this.imageryTrees.push(tree);
+        this._layerSettings.set(tree.modelId, settings);
+        this._modelIdToIndex.set(tree.modelId, index);
+    }
+    addModelLayer(layerTreeRef, context) {
+        const classifier = context.addPlanarClassifier(`MapLayer ${this.modelId}-${layerTreeRef.layerIndex}`, layerTreeRef);
+        if (classifier)
+            this.layerClassifiers.set(layerTreeRef.layerIndex, classifier);
     }
-    clearImageryLayers() {
+    collectClassifierGraphics(args, selectedTiles) {
+        super.collectClassifierGraphics(args, selectedTiles);
+        this.layerClassifiers.forEach((layerClassifier) => {
+            if (!(args instanceof internal_1.GraphicsCollectorDrawArgs))
+                layerClassifier.collectGraphics(args.context, { modelId: this.modelId, tiles: selectedTiles, location: args.location, isPointCloud: this.isPointCloud });
+        });
+    }
+    clearImageryTreesAndClassifiers() {
         this.imageryTrees.length = 0;
         this._layerSettings.clear();
+        this._modelIdToIndex.clear();
+        this.layerClassifiers.clear();
     }
     get isTransparent() {
         return this.mapTransparent || this.baseTransparent;
@@ -93,9 +104,12 @@ class MapTileTree extends internal_1.RealityTileTree {
         return maxDepth;
     }
     createPlanarChild(params, quadId, corners, normal, rectangle, chordHeight, heightRange) {
+        const childAvailable = this.mapLoader.isTileAvailable(quadId);
+        if (!childAvailable && this.produceGeometry)
+            return undefined;
         const patch = new internal_1.PlanarTilePatch(corners, normal, chordHeight);
         const cornerNormals = this.getCornerRays(rectangle);
-        const ctor = this.mapLoader.isTileAvailable(quadId) ? internal_1.MapTile : internal_1.UpsampledMapTile;
+        const ctor = childAvailable ? internal_1.MapTile : internal_1.UpsampledMapTile;
         return new ctor(params, this, quadId, patch, rectangle, heightRange, cornerNormals);
     }
     createGlobeChild(params, quadId, _rangeCorners, rectangle, ellipsoidPatch, heightRange) {
@@ -270,10 +284,8 @@ class MapTileTree extends internal_1.RealityTileTree {
         return this.sourceTilingScheme.tileXYToRectangle(quadId.column, quadId.row, quadId.level);
     }
     getLayerIndex(imageryTreeId) {
-        for (let index = 0; index < this.imageryTrees.length; index++)
-            if (imageryTreeId === this.imageryTrees[index].modelId)
-                return index;
-        return -1;
+        const index = this._modelIdToIndex.get(imageryTreeId);
+        return index === undefined ? -1 : index;
     }
     getLayerTransparency(imageryTreeId) {
         const layerSettings = this._layerSettings.get(imageryTreeId);
@@ -313,7 +325,7 @@ class MapTreeSupplier {
             cmp = (0, core_bentley_1.compareStringsOrUndefined)(lhs.maskModelIds, rhs.maskModelIds);
             if (0 === cmp) {
                 cmp = (0, core_bentley_1.compareBooleans)(lhs.isOverlay, rhs.isOverlay);
-                if (0 === cmp && !lhs.isOverlay) {
+                if (0 === cmp) {
                     cmp = (0, core_bentley_1.compareBooleans)(lhs.wantSkirts, rhs.wantSkirts);
                     if (0 === cmp) {
                         cmp = (0, core_bentley_1.compareBooleans)(lhs.wantNormals, rhs.wantNormals);
@@ -335,8 +347,11 @@ class MapTreeSupplier {
                                                         cmp = (0, core_bentley_1.compareNumbers)(lhs.terrainHeightOrigin, rhs.terrainHeightOrigin);
                                                         if (0 === cmp) {
                                                             cmp = (0, core_bentley_1.compareNumbers)(lhs.terrainHeightOriginMode, rhs.terrainHeightOriginMode);
-                                                            if (0 === cmp)
+                                                            if (0 === cmp) {
                                                                 cmp = (0, core_bentley_1.compareNumbers)(lhs.terrainExaggeration, rhs.terrainExaggeration);
+                                                                if (0 === cmp)
+                                                                    cmp = (0, core_bentley_1.compareBooleansOrUndefined)(lhs.produceGeometry, rhs.produceGeometry);
+                                                            }
                                                         }
                                                     }
                                                 }
@@ -404,7 +419,7 @@ const mapTreeSupplier = new MapTreeSupplier();
  */
 class MapTileTreeReference extends internal_1.TileTreeReference {
     constructor(settings, _baseLayerSettings, _layerSettings, iModel, tileUserId, isOverlay, _isDrape, _overrideTerrainDisplay) {
-        var _a;
+        var _a, _b;
         super();
         this._baseLayerSettings = _baseLayerSettings;
         this._layerSettings = _layerSettings;
@@ -412,7 +427,7 @@ class MapTileTreeReference extends internal_1.TileTreeReference {
         this._isDrape = _isDrape;
         this._overrideTerrainDisplay = _overrideTerrainDisplay;
         this._baseImageryLayerIncluded = false;
-        this._imageryTrees = new Array();
+        this._layerTrees = new Array();
         this._baseTransparent = false;
         this._tileUserId = tileUserId;
         this._settings = settings;
@@ -420,7 +435,7 @@ class MapTileTreeReference extends internal_1.TileTreeReference {
         let tree;
         if (!isOverlay && this._baseLayerSettings !== undefined) {
             if (this._baseLayerSettings instanceof core_common_1.MapLayerSettings) {
-                tree = IModelApp_1.IModelApp.mapLayerFormatRegistry.createImageryMapLayerTree(this._baseLayerSettings, 0, iModel);
+                tree = (0, internal_1.createMapLayerTreeReference)(this._baseLayerSettings, 0, iModel);
                 this._baseTransparent = this._baseLayerSettings.transparency > 0;
             }
             else {
@@ -429,16 +444,25 @@ class MapTileTreeReference extends internal_1.TileTreeReference {
             }
         }
         if (this._baseImageryLayerIncluded = (undefined !== tree))
-            this._imageryTrees.push(tree);
+            this._layerTrees.push(tree);
         for (let i = 0; i < this._layerSettings.length; i++)
-            if (undefined !== (tree = IModelApp_1.IModelApp.mapLayerFormatRegistry.createImageryMapLayerTree(this._layerSettings[i], i + 1, iModel)))
-                this._imageryTrees.push(tree);
+            if (undefined !== (tree = (0, internal_1.createMapLayerTreeReference)(this._layerSettings[i], i + 1, iModel)))
+                this._layerTrees.push(tree);
         if (this._settings.planarClipMask && this._settings.planarClipMask.isValid)
             this._planarClipMask = PlanarClipMaskState_1.PlanarClipMaskState.create(this._settings.planarClipMask);
+        if (this._overrideTerrainDisplay && ((_b = this._overrideTerrainDisplay()) === null || _b === void 0 ? void 0 : _b.produceGeometry))
+            this.collectTileGeometry = (collector) => this._collectTileGeometry(collector);
     }
     get isGlobal() { return true; }
     get baseColor() { return this._baseColor; }
     get planarclipMaskPriority() { return core_common_1.PlanarClipMaskPriority.BackgroundMap; }
+    _createGeometryTreeReference() {
+        if (!this._settings.applyTerrain || this._isDrape)
+            return undefined; // Don't bother generating non-terrain (flat) geometry.
+        const ref = new MapTileTreeReference(this._settings, undefined, [], this._iModel, this._tileUserId, false, false, () => { return { produceGeometry: true }; });
+        (0, core_bentley_1.assert)(undefined !== ref.collectTileGeometry);
+        return ref;
+    }
     /** Terrain  tiles do not contribute to the range used by "fit view". */
     unionFitRange(_range) { }
     get settings() { return this._settings; }
@@ -451,7 +475,7 @@ class MapTileTreeReference extends internal_1.TileTreeReference {
         let tree;
         this._baseLayerSettings = baseLayerSettings;
         if (baseLayerSettings instanceof core_common_1.MapLayerSettings) {
-            tree = IModelApp_1.IModelApp.mapLayerFormatRegistry.createImageryMapLayerTree(baseLayerSettings, 0, this._iModel);
+            tree = (0, internal_1.createMapLayerTreeReference)(baseLayerSettings, 0, this._iModel);
             this._baseColor = undefined;
             this._baseTransparent = baseLayerSettings.transparency > 0;
         }
@@ -461,13 +485,13 @@ class MapTileTreeReference extends internal_1.TileTreeReference {
         }
         if (tree) {
             if (this._baseImageryLayerIncluded)
-                this._imageryTrees[0] = tree;
+                this._layerTrees[0] = tree;
             else
-                this._imageryTrees.splice(0, 0, tree);
+                this._layerTrees.splice(0, 0, tree);
         }
         else {
             if (this._baseImageryLayerIncluded)
-                this._imageryTrees.shift();
+                this._layerTrees.shift();
         }
         this._baseImageryLayerIncluded = tree !== undefined;
         this.clearLayers();
@@ -478,11 +502,11 @@ class MapTileTreeReference extends internal_1.TileTreeReference {
     setLayerSettings(layerSettings) {
         this._layerSettings = layerSettings;
         const baseLayerIndex = this._baseImageryLayerIncluded ? 1 : 0;
-        this._imageryTrees.length = Math.min(layerSettings.length + baseLayerIndex, this._imageryTrees.length); // Truncate if number of layers reduced.
+        this._layerTrees.length = Math.min(layerSettings.length + baseLayerIndex, this._layerTrees.length); // Truncate if number of layers reduced.
         for (let i = 0; i < layerSettings.length; i++) {
             const treeIndex = i + baseLayerIndex;
-            if (treeIndex >= this._imageryTrees.length || !this._imageryTrees[treeIndex].layerSettings.displayMatches(layerSettings[i]))
-                this._imageryTrees[treeIndex] = IModelApp_1.IModelApp.mapLayerFormatRegistry.createImageryMapLayerTree(layerSettings[i], treeIndex, this._iModel);
+            if (treeIndex >= this._layerTrees.length || !this._layerTrees[treeIndex].layerSettings.displayMatches(layerSettings[i]))
+                this._layerTrees[treeIndex] = (0, internal_1.createMapLayerTreeReference)(layerSettings[i], treeIndex, this._iModel);
         }
         this.clearLayers();
     }
@@ -496,7 +520,7 @@ class MapTileTreeReference extends internal_1.TileTreeReference {
     }
     get _isLoadingComplete() {
         // Wait until drape tree is fully loaded too.
-        for (const drapeTree of this._imageryTrees)
+        for (const drapeTree of this._layerTrees)
             if (!drapeTree.isLoadingComplete)
                 return false;
         return super._isLoadingComplete;
@@ -513,7 +537,7 @@ class MapTileTreeReference extends internal_1.TileTreeReference {
         }
         const id = {
             tileUserId: this._tileUserId,
-            applyTerrain: this.settings.applyTerrain && !this.isOverlay && !this._isDrape,
+            applyTerrain: this.settings.applyTerrain && !this._isDrape,
             terrainProviderName: this.settings.terrainSettings.providerName,
             terrainHeightOrigin: this.settings.terrainSettings.heightOrigin,
             terrainHeightOriginMode: this.settings.terrainSettings.heightOriginMode,
@@ -529,12 +553,14 @@ class MapTileTreeReference extends internal_1.TileTreeReference {
             baseTransparent: this._baseTransparent,
             mapTransparent: this.settings.transparency > 0,
             maskModelIds: (_b = this._planarClipMask) === null || _b === void 0 ? void 0 : _b.settings.compressedModelIds,
+            produceGeometry: false,
         };
         if (undefined !== this._overrideTerrainDisplay) {
             const ovr = this._overrideTerrainDisplay();
             if (undefined !== ovr) {
                 id.wantSkirts = (_c = ovr.wantSkirts) !== null && _c !== void 0 ? _c : id.wantSkirts;
                 id.wantNormals = (_d = ovr.wantNormals) !== null && _d !== void 0 ? _d : id.wantNormals;
+                id.produceGeometry = ovr.produceGeometry === true;
             }
         }
         return this._iModel.tiles.getTileTreeOwner(id, mapTreeSupplier);
@@ -542,30 +568,33 @@ class MapTileTreeReference extends internal_1.TileTreeReference {
     getLayerImageryTreeRef(index) {
         const baseLayerIndex = this._baseImageryLayerIncluded ? 1 : 0;
         const treeIndex = index + baseLayerIndex;
-        return index < 0 || treeIndex >= this._imageryTrees.length ? undefined : this._imageryTrees[treeIndex];
+        return index < 0 || treeIndex >= this._layerTrees.length ? undefined : this._layerTrees[treeIndex];
     }
-    initializeImagery() {
+    initializeLayers(context) {
         const tree = this.treeOwner.load();
         if (undefined === tree)
             return false; // Not loaded yet.
         tree.imageryTrees.length = 0;
-        if (0 === this._imageryTrees.length)
+        if (0 === this._layerTrees.length)
             return !this.isOverlay;
-        let treeIndex = this._imageryTrees.length - 1;
+        let treeIndex = this._layerTrees.length - 1;
         // Start displaying at the highest completely opaque layer...
         for (; treeIndex >= 1; treeIndex--) {
-            const imageryTreeRef = this._imageryTrees[treeIndex];
-            const layerSettings = imageryTreeRef.layerSettings;
-            if (layerSettings.visible && !imageryTreeRef.layerSettings.allSubLayersInvisible && !layerSettings.transparentBackground && 0 === layerSettings.transparency)
+            const layerTreeRef = this._layerTrees[treeIndex];
+            if (layerTreeRef.isOpaque)
                 break; // This layer is completely opaque and will obscure all others so ignore lower ones.
         }
-        for (; treeIndex < this._imageryTrees.length; treeIndex++) {
-            const imageryTreeRef = this._imageryTrees[treeIndex];
-            if (internal_1.TileTreeLoadStatus.NotFound !== imageryTreeRef.treeOwner.loadStatus && imageryTreeRef.layerSettings.visible && !imageryTreeRef.layerSettings.allSubLayersInvisible) {
-                const imageryTree = imageryTreeRef.treeOwner.load();
-                if (undefined === imageryTree)
+        for (; treeIndex < this._layerTrees.length; treeIndex++) {
+            const layerTreeRef = this._layerTrees[treeIndex];
+            if (internal_1.TileTreeLoadStatus.NotFound !== layerTreeRef.treeOwner.loadStatus && layerTreeRef.layerSettings.visible && !layerTreeRef.layerSettings.allSubLayersInvisible) {
+                const layerTree = layerTreeRef.treeOwner.load();
+                if (undefined === layerTree)
                     return false; // Not loaded yet.
-                tree.addImageryLayer(imageryTree, imageryTreeRef.layerSettings);
+                if (layerTree instanceof internal_1.ImageryMapTileTree) {
+                    tree.addImageryLayer(layerTree, layerTreeRef.layerSettings, treeIndex);
+                }
+                else if (layerTreeRef instanceof internal_1.ModelMapLayerTileTreeReference)
+                    tree.addModelLayer(layerTreeRef, context);
             }
         }
         return true;
@@ -575,7 +604,7 @@ class MapTileTreeReference extends internal_1.TileTreeReference {
         if (!context.viewFlags.backgroundMap)
             return;
         const tree = this.treeOwner.load();
-        if (undefined === tree || !this.initializeImagery())
+        if (undefined === tree || !this.initializeLayers(context))
             return; // Not loaded yet.
         if (this._planarClipMask && this._planarClipMask.settings.isValid)
             context.addPlanarClassifier(tree.modelId, undefined, this._planarClipMask);
@@ -591,13 +620,14 @@ class MapTileTreeReference extends internal_1.TileTreeReference {
         const args = this.createDrawArgs(context);
         if (undefined !== args)
             tree.draw(args);
-        tree.clearImageryLayers();
+        tree.clearImageryTreesAndClassifiers();
     }
     createDrawArgs(context) {
         const args = super.createDrawArgs(context);
         if (undefined === args)
             return undefined;
-        return new internal_1.RealityTileDrawArgs(args, args.worldToViewMap, args.frustumPlanes);
+        const tree = this.treeOwner.load();
+        return new internal_1.RealityTileDrawArgs(args, args.worldToViewMap, args.frustumPlanes, undefined, tree === null || tree === void 0 ? void 0 : tree.layerClassifiers);
     }
     getViewFlagOverrides(_tree) {
         return createViewFlagOverrides(false, this._settings.applyTerrain ? undefined : false);
@@ -607,7 +637,7 @@ class MapTileTreeReference extends internal_1.TileTreeReference {
     }
     discloseTileTrees(trees) {
         super.discloseTileTrees(trees);
-        this._imageryTrees.forEach((imageryTree) => trees.disclose(imageryTree));
+        this._layerTrees.forEach((imageryTree) => trees.disclose(imageryTree));
         if (this._planarClipMask)
             this._planarClipMask.discloseTileTrees(trees);
     }
@@ -615,7 +645,7 @@ class MapTileTreeReference extends internal_1.TileTreeReference {
         const tree = this.treeOwner.tileTree;
         if (undefined === tree || tree.modelId !== mapTreeModelId)
             return undefined;
-        for (const imageryTree of this._imageryTrees)
+        for (const imageryTree of this._layerTrees)
             if (imageryTree.treeOwner.tileTree && imageryTree.treeOwner.tileTree.modelId === layerTreeModelId)
                 return imageryTree;
         return undefined;
@@ -624,16 +654,24 @@ class MapTileTreeReference extends internal_1.TileTreeReference {
         const imageryTree = this.imageryTreeFromTreeModelIds(mapTreeModelId, layerTreeModelId);
         return imageryTree === undefined ? imageryTree : imageryTree.layerSettings;
     }
-    async getToolTip(hit) {
+    // Utility method that execute the provided function for every *imagery* tiles under a given HotDetail object.
+    async forEachImageryTileHit(hit, func) {
         const tree = this.treeOwner.tileTree;
-        // eslint-disable-next-line @typescript-eslint/unbound-method
         if (undefined === tree || hit.iModel !== tree.iModel || tree.modelId !== hit.modelId || !hit.viewport || !hit.viewport.view.is3d)
             return undefined;
         const backgroundMapGeometry = hit.viewport.displayStyle.getBackgroundMapGeometry();
         if (undefined === backgroundMapGeometry)
             return undefined;
         const worldPoint = hit.hitPoint.clone();
-        const cartoGraphic = await backgroundMapGeometry.dbToCartographicFromGcs(worldPoint);
+        let cartoGraphic;
+        try {
+            cartoGraphic = await backgroundMapGeometry.dbToCartographicFromGcs(worldPoint);
+        }
+        catch {
+        }
+        if (!cartoGraphic) {
+            return undefined;
+        }
         const strings = [];
         const imageryTreeRef = this.imageryTreeFromTreeModelIds(hit.modelId, hit.sourceId);
         if (imageryTreeRef !== undefined) {
@@ -645,23 +683,72 @@ class MapTileTreeReference extends internal_1.TileTreeReference {
                     const imageryTree = imageryTreeRef.treeOwner.tileTree;
                     if (imageryTree) {
                         for (const imageryTile of terrainTile.imageryTiles) {
-                            if (imageryTree === imageryTile.imageryTree && imageryTile.rectangle.containsCartographic(cartoGraphic))
-                                await imageryTree.imageryLoader.getToolTip(strings, imageryTile.quadId, cartoGraphic, imageryTree);
+                            if (imageryTree === imageryTile.imageryTree && imageryTile.rectangle.containsCartographic(cartoGraphic)) {
+                                try {
+                                    await func(imageryTreeRef, imageryTile.quadId, cartoGraphic, imageryTree);
+                                }
+                                catch {
+                                    // continue iterating even though we got a failure.
+                                }
+                            }
                         }
                     }
                 }
             }
         }
-        strings.push(`Latitude: ${cartoGraphic.latitudeDegrees.toFixed(4)}`);
-        strings.push(`Longitude: ${cartoGraphic.longitudeDegrees.toFixed(4)}`);
-        if (this.settings.applyTerrain) {
-            const geodeticHeight = (cartoGraphic.height - tree.bimElevationBias) / tree.terrainExaggeration;
-            strings.push(`Height (Meters) Geodetic: ${geodeticHeight.toFixed(1)} Sea Level: ${(geodeticHeight - tree.geodeticOffset).toFixed(1)}`);
+    }
+    async getToolTip(hit) {
+        const tree = this.treeOwner.tileTree;
+        if (tree.modelId !== hit.modelId)
+            return undefined;
+        let carto;
+        const strings = [];
+        const getTooltipFunc = async (imageryTreeRef, quadId, cartoGraphic, imageryTree) => {
+            strings.push(`Imagery Layer: ${imageryTreeRef.layerSettings.name}`);
+            carto = cartoGraphic;
+            await imageryTree.imageryLoader.getToolTip(strings, quadId, cartoGraphic, imageryTree);
+        };
+        try {
+            await this.forEachImageryTileHit(hit, getTooltipFunc);
+        }
+        catch {
+            // No results added
+        }
+        if (carto) {
+            strings.push(`Latitude: ${carto.latitudeDegrees.toFixed(4)}`);
+            strings.push(`Longitude: ${carto.longitudeDegrees.toFixed(4)}`);
+            if (this.settings.applyTerrain && tree.terrainExaggeration !== 0.0) {
+                const geodeticHeight = (carto.height - tree.bimElevationBias) / tree.terrainExaggeration;
+                strings.push(`Height (Meters) Geodetic: ${geodeticHeight.toFixed(1)} Sea Level: ${(geodeticHeight - tree.geodeticOffset).toFixed(1)}`);
+            }
         }
         const div = document.createElement("div");
         div.innerHTML = strings.join("<br>");
         return div;
     }
+    async getMapFeatureInfo(hit) {
+        const tree = this.treeOwner.tileTree;
+        if (undefined === tree || hit.iModel !== tree.iModel || tree.modelId !== hit.modelId || !hit.viewport || !hit.viewport.view.is3d)
+            return undefined;
+        const info = [];
+        const imageryTreeRef = this.imageryTreeFromTreeModelIds(hit.modelId, hit.sourceId);
+        if (imageryTreeRef !== undefined) {
+            const getFeatureInfoFunc = async (_imageryTreeRef, quadId, cartoGraphic, imageryTree) => {
+                try {
+                    await imageryTree.imageryLoader.getMapFeatureInfo(info, quadId, cartoGraphic, imageryTree);
+                }
+                catch {
+                }
+            };
+            try {
+                await this.forEachImageryTileHit(hit, getFeatureInfoFunc);
+            }
+            catch {
+                // No results added
+            }
+        }
+        return info;
+    }
     /** Add logo cards to logo div. */
     addLogoCards(cards, vp) {
         const tree = this.treeOwner.tileTree;
@@ -669,7 +756,7 @@ class MapTileTreeReference extends internal_1.TileTreeReference {
         if (tree) {
             if (undefined !== (logo = tree.mapLoader.terrainProvider.getLogo()))
                 cards.appendChild(logo);
-            for (const imageryTreeRef of this._imageryTrees) {
+            for (const imageryTreeRef of this._layerTrees) {
                 if (imageryTreeRef.layerSettings.visible) {
                     const imageryTree = imageryTreeRef.treeOwner.tileTree;
                     if (imageryTree && (undefined !== (logo = imageryTree.getLogo(vp))))