@itwin/core-frontend 3.1.0-dev.25 → 3.1.0-dev.29

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

@@ -6,13 +6,12 @@
  * @module Tiles
  */
 import { assert, compareBooleans, compareBooleansOrUndefined, compareNumbers, compareStrings, compareStringsOrUndefined, CompressedId64Set } from "@itwin/core-bentley";
-import { Angle, AngleSweep, Constant, Ellipsoid, EllipsoidPatch, Point3d, Range1d, Range3d, Ray3d, Transform, Vector3d, } from "@itwin/core-geometry";
 import { Cartographic, FeatureAppearance, GeoCoordStatus, GlobeMode, MapLayerSettings, PlanarClipMaskPriority, TerrainHeightOriginMode, } from "@itwin/core-common";
+import { Angle, AngleSweep, Constant, Ellipsoid, EllipsoidPatch, Point3d, Range1d, Range3d, Ray3d, Transform, Vector3d, } from "@itwin/core-geometry";
 import { ApproximateTerrainHeights } from "../../ApproximateTerrainHeights";
-import { IModelApp } from "../../IModelApp";
 import { PlanarClipMaskState } from "../../PlanarClipMaskState";
 import { FeatureSymbology } from "../../render/FeatureSymbology";
-import { BingElevationProvider, createDefaultViewFlagOverrides, EllipsoidTerrainProvider, getCesiumTerrainProvider, MapCartoRectangle, MapTile, MapTileLoader, PlanarTilePatch, QuadId, RealityTileDrawArgs, RealityTileTree, TileTreeLoadStatus, TileTreeReference, UpsampledMapTile, WebMercatorTilingScheme, } from "../internal";
+import { BingElevationProvider, createDefaultViewFlagOverrides, createMapLayerTreeReference, EllipsoidTerrainProvider, getCesiumTerrainProvider, GraphicsCollectorDrawArgs, ImageryMapTileTree, MapCartoRectangle, MapTile, MapTileLoader, ModelMapLayerTileTreeReference, PlanarTilePatch, QuadId, RealityTileDrawArgs, RealityTileTree, TileTreeLoadStatus, TileTreeReference, UpsampledMapTile, WebMercatorTilingScheme, } from "../internal";
 const scratchPoint = Point3d.create();
 const scratchCorners = [Point3d.createZero(), Point3d.createZero(), Point3d.createZero(), Point3d.createZero(), Point3d.createZero(), Point3d.createZero(), Point3d.createZero(), Point3d.createZero()];
 const scratchCorner = Point3d.createZero();
@@ -27,6 +26,8 @@ export class MapTileTree extends RealityTileTree {
         this.sourceTilingScheme = sourceTilingScheme;
         this.imageryTrees = [];
         this._layerSettings = new Map();
+        this._modelIdToIndex = new Map();
+        this.layerClassifiers = new Map();
         this._mercatorTilingScheme = new WebMercatorTilingScheme();
         this._mercatorFractionToDb = this._mercatorTilingScheme.computeMercatorFractionToDb(ecefToDb, bimElevationBias, params.iModel, applyTerrain);
         const quadId = new QuadId(sourceTilingScheme.rootLevel, 0, 0);
@@ -67,19 +68,28 @@ export class MapTileTree extends RealityTileTree {
     tileFromQuadId(quadId) {
         return this._rootTile.tileFromQuadId(quadId);
     }
-    addImageryLayer(tree, settings) {
-        const maxLayers = 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);
     }
-    clearImageryLayers() {
+    addModelLayer(layerTreeRef, context) {
+        const classifier = context.addPlanarClassifier(`MapLayer ${this.modelId}-${layerTreeRef.layerIndex}`, layerTreeRef);
+        if (classifier)
+            this.layerClassifiers.set(layerTreeRef.layerIndex, classifier);
+    }
+    collectClassifierGraphics(args, selectedTiles) {
+        super.collectClassifierGraphics(args, selectedTiles);
+        this.layerClassifiers.forEach((layerClassifier) => {
+            if (!(args instanceof 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;
@@ -271,10 +281,8 @@ export class MapTileTree extends 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);
@@ -415,7 +423,7 @@ export class MapTileTreeReference extends 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;
@@ -423,7 +431,7 @@ export class MapTileTreeReference extends TileTreeReference {
         let tree;
         if (!isOverlay && this._baseLayerSettings !== undefined) {
             if (this._baseLayerSettings instanceof MapLayerSettings) {
-                tree = IModelApp.mapLayerFormatRegistry.createImageryMapLayerTree(this._baseLayerSettings, 0, iModel);
+                tree = createMapLayerTreeReference(this._baseLayerSettings, 0, iModel);
                 this._baseTransparent = this._baseLayerSettings.transparency > 0;
             }
             else {
@@ -432,10 +440,10 @@ export class MapTileTreeReference extends 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.mapLayerFormatRegistry.createImageryMapLayerTree(this._layerSettings[i], i + 1, iModel)))
-                this._imageryTrees.push(tree);
+            if (undefined !== (tree = createMapLayerTreeReference(this._layerSettings[i], i + 1, iModel)))
+                this._layerTrees.push(tree);
         if (this._settings.planarClipMask && this._settings.planarClipMask.isValid)
             this._planarClipMask = PlanarClipMaskState.create(this._settings.planarClipMask);
         if (this._overrideTerrainDisplay && ((_b = this._overrideTerrainDisplay()) === null || _b === void 0 ? void 0 : _b.produceGeometry))
@@ -463,7 +471,7 @@ export class MapTileTreeReference extends TileTreeReference {
         let tree;
         this._baseLayerSettings = baseLayerSettings;
         if (baseLayerSettings instanceof MapLayerSettings) {
-            tree = IModelApp.mapLayerFormatRegistry.createImageryMapLayerTree(baseLayerSettings, 0, this._iModel);
+            tree = createMapLayerTreeReference(baseLayerSettings, 0, this._iModel);
             this._baseColor = undefined;
             this._baseTransparent = baseLayerSettings.transparency > 0;
         }
@@ -473,13 +481,13 @@ export class MapTileTreeReference extends 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();
@@ -490,11 +498,11 @@ export class MapTileTreeReference extends 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.mapLayerFormatRegistry.createImageryMapLayerTree(layerSettings[i], treeIndex, this._iModel);
+            if (treeIndex >= this._layerTrees.length || !this._layerTrees[treeIndex].layerSettings.displayMatches(layerSettings[i]))
+                this._layerTrees[treeIndex] = createMapLayerTreeReference(layerSettings[i], treeIndex, this._iModel);
         }
         this.clearLayers();
     }
@@ -508,7 +516,7 @@ export class MapTileTreeReference extends 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;
@@ -556,30 +564,33 @@ export class MapTileTreeReference extends 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 (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 (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 ImageryMapTileTree) {
+                    tree.addImageryLayer(layerTree, layerTreeRef.layerSettings, treeIndex);
+                }
+                else if (layerTreeRef instanceof ModelMapLayerTileTreeReference)
+                    tree.addModelLayer(layerTreeRef, context);
             }
         }
         return true;
@@ -589,7 +600,7 @@ export class MapTileTreeReference extends 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);
@@ -605,13 +616,14 @@ export class MapTileTreeReference extends 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 RealityTileDrawArgs(args, args.worldToViewMap, args.frustumPlanes);
+        const tree = this.treeOwner.load();
+        return new 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);
@@ -621,7 +633,7 @@ export class MapTileTreeReference extends 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);
     }
@@ -629,7 +641,7 @@ export class MapTileTreeReference extends 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;
@@ -683,7 +695,7 @@ export class MapTileTreeReference extends 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))))