@itwin/core-frontend 5.0.0-dev.90 → 5.0.0-dev.93

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

@@ -6,13 +6,13 @@
  * @module Tiles
  */
 import { assert, compareBooleans, compareBooleansOrUndefined, compareNumbers, compareStrings, compareStringsOrUndefined, CompressedId64Set } from "@itwin/core-bentley";
-import { Cartographic, FeatureAppearance, GeoCoordStatus, GlobeMode, MapLayerSettings, PlanarClipMaskPriority, TerrainHeightOriginMode, } from "@itwin/core-common";
+import { Cartographic, FeatureAppearance, GeoCoordStatus, GlobeMode, ModelMapLayerDrapeTarget, ModelMapLayerSettings, 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, createMapLayerTreeReference, EllipsoidTerrainProvider, GraphicsCollectorDrawArgs, ImageryMapLayerTreeReference, ImageryMapTileTree, ImageryTileTreeState, MapCartoRectangle, MapLayerTileTreeReference, MapTile, MapTileLoader, ModelMapLayerTileTreeReference, PlanarTilePatch, QuadId, RealityTileDrawArgs, RealityTileTree, TileTreeLoadStatus, TileTreeReference, UpsampledMapTile, WebMercatorTilingScheme, } from "../internal";
+import { BingElevationProvider, createDefaultViewFlagOverrides, EllipsoidTerrainProvider, ImageryMapTileTree, LayerTileTreeHandler, LayerTileTreeReferenceHandler, MapCartoRectangle, MapLayerTileTreeReference, MapTile, MapTileLoader, PlanarTilePatch, QuadId, RealityTileDrawArgs, RealityTileTree, 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();
@@ -78,11 +78,9 @@ export class MapTileTree extends RealityTileTree {
     produceGeometry;
     /** @internal */
     layerImageryTrees = [];
-    _layerSettings = new Map();
-    _imageryTreeState = new Map();
-    _modelIdToIndex = new Map();
+    _layerHandler;
     /** @internal */
-    layerClassifiers = new Map();
+    get layerHandler() { return this._layerHandler; }
     /** @internal */
     constructor(params, ecefToDb, bimElevationBias, geodeticOffset, sourceTilingScheme, id, applyTerrain) {
         super(params);
@@ -124,6 +122,7 @@ export class MapTileTree extends RealityTileTree {
             range = Range3d.createArray(MapTile.computeRangeCorners(corners, Vector3d.create(0, 0, 1), 0, scratchCorners, globalHeightRange));
         }
         this._rootTile = this.createGlobeChild({ contentId: quadId.contentId, maximumSize: 0, range }, quadId, range.corners(), globalRectangle, rootPatch, undefined);
+        this._layerHandler = new LayerTileTreeHandler(this);
     }
     /** @internal */
     get parentsAndChildrenExclusive() {
@@ -135,14 +134,14 @@ export class MapTileTree extends RealityTileTree {
      * @internal
      */
     getImageryTreeState(imageryTreeId) {
-        return this._imageryTreeState.get(imageryTreeId);
+        return this._layerHandler.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) {
+        for (const [treeId, state] of this._layerHandler.imageryTreeState) {
             clone.set(treeId, state.clone());
         }
         return clone;
@@ -151,36 +150,16 @@ export class MapTileTree extends RealityTileTree {
     tileFromQuadId(quadId) {
         return this._rootTile.tileFromQuadId(quadId);
     }
-    /** Add a new imagery tile tree / map-layer settings pair and initialize the imagery tile tree state.
-     * @internal
-     */
-    addImageryLayer(tree, settings, index, baseImageryLayer) {
-        this.layerImageryTrees.push({ tree, settings, baseImageryLayer });
-        this._layerSettings.set(tree.modelId, settings);
-        if (!this._imageryTreeState.has(tree.modelId))
-            this._imageryTreeState.set(tree.modelId, new ImageryTileTreeState());
-        this._modelIdToIndex.set(tree.modelId, index);
-    }
-    /** @internal */
-    addModelLayer(layerTreeRef, context) {
-        const classifier = context.addPlanarClassifier(`MapLayer ${this.modelId}-${layerTreeRef.layerIndex}`, layerTreeRef);
-        if (classifier)
-            this.layerClassifiers.set(layerTreeRef.layerIndex, classifier);
-    }
-    /** @internal */
     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 });
-        });
+        this._layerHandler.collectClassifierGraphics(args, selectedTiles);
     }
     /** @internal */
     clearImageryTreesAndClassifiers() {
-        this.layerImageryTrees.length = 0;
-        this._layerSettings.clear();
-        this._modelIdToIndex.clear();
-        this.layerClassifiers.clear();
+        this._layerHandler.layerImageryTrees.length = 0;
+        this._layerHandler.layerSettings.clear();
+        this._layerHandler.modelIdToIndex.clear();
+        this._layerHandler.layerClassifiers.clear();
     }
     /** @internal */
     get isTransparent() {
@@ -189,6 +168,7 @@ export class MapTileTree extends RealityTileTree {
     /** @internal */
     get maxDepth() {
         let maxDepth = this.loader.maxDepth;
+        /** NB: need to use local layerImageTrees because of the order super() is called (before layerHandler exists on this class)! */
         this.layerImageryTrees?.forEach((layerImageryTree) => maxDepth = Math.max(maxDepth, layerImageryTree.tree.maxDepth));
         return maxDepth;
     }
@@ -216,10 +196,6 @@ export class MapTileTree extends RealityTileTree {
     getChildHeightRange(quadId, rectangle, parent) {
         return this.mapLoader.getChildHeightRange(quadId, rectangle, parent);
     }
-    /** @internal */
-    clearLayers() {
-        this._rootTile.clearLayers();
-    }
     /** Reprojection does not work with very large tiles so just do linear transform.
      * @internal
      */
@@ -472,12 +448,12 @@ export class MapTileTree extends RealityTileTree {
     }
     /** @internal */
     getLayerIndex(imageryTreeId) {
-        const index = this._modelIdToIndex.get(imageryTreeId);
+        const index = this._layerHandler.modelIdToIndex.get(imageryTreeId);
         return index === undefined ? -1 : index;
     }
     /** @internal */
     getLayerTransparency(imageryTreeId) {
-        const layerSettings = this._layerSettings.get(imageryTreeId);
+        const layerSettings = this._layerHandler.layerSettings.get(imageryTreeId);
         assert(undefined !== layerSettings);
         return undefined === layerSettings || !layerSettings.transparency ? 0.0 : layerSettings.transparency;
     }
@@ -616,64 +592,47 @@ const mapTreeSupplier = new MapTreeSupplier();
  * @internal
  */
 export class MapTileTreeReference extends TileTreeReference {
-    _baseLayerSettings;
-    _layerSettings;
-    isOverlay;
     _isDrape;
     _overrideTerrainDisplay;
     _tileUserId;
     _settings;
-    _iModel;
-    _baseImageryLayerIncluded = false;
-    _baseColor;
-    _layerTrees = new Array();
-    _baseTransparent = false;
     _symbologyOverrides;
     _planarClipMask;
-    constructor(settings, _baseLayerSettings, _layerSettings, iModel, tileUserId, isOverlay, _isDrape, _overrideTerrainDisplay) {
+    _layerRefHandler;
+    iModel;
+    get layerRefHandler() { return this._layerRefHandler; }
+    shouldDrapeLayer(layerTreeRef) {
+        const mapLayerSettings = layerTreeRef?.layerSettings;
+        if (mapLayerSettings && mapLayerSettings instanceof ModelMapLayerSettings)
+            return ModelMapLayerDrapeTarget.Globe === mapLayerSettings.drapeTarget;
+        return true; // catch-all for other cases (skip reality models, though).
+    }
+    constructor(settings, baseLayerSettings, layerSettings, iModel, tileUserId, isOverlay, _isDrape, _overrideTerrainDisplay) {
         super();
-        this._baseLayerSettings = _baseLayerSettings;
-        this._layerSettings = _layerSettings;
-        this.isOverlay = isOverlay;
         this._isDrape = _isDrape;
         this._overrideTerrainDisplay = _overrideTerrainDisplay;
+        this.iModel = iModel;
         this._tileUserId = tileUserId;
         this._settings = settings;
-        this._iModel = iModel;
-        let tree;
-        if (!isOverlay && this._baseLayerSettings !== undefined) {
-            if (this._baseLayerSettings instanceof MapLayerSettings) {
-                tree = createMapLayerTreeReference(this._baseLayerSettings, 0, iModel);
-                this._baseTransparent = this._baseLayerSettings.transparency > 0;
-            }
-            else {
-                this._baseColor = this._baseLayerSettings;
-                this._baseTransparent = this._baseColor?.getTransparency() > 0;
-            }
-        }
-        if (this._baseImageryLayerIncluded = (undefined !== tree))
-            this._layerTrees.push(tree);
-        for (let i = 0; i < this._layerSettings.length; i++)
-            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 && this._overrideTerrainDisplay()?.produceGeometry)
             this.collectTileGeometry = (collector) => this._collectTileGeometry(collector);
+        this._layerRefHandler = new LayerTileTreeReferenceHandler(this, isOverlay, baseLayerSettings, layerSettings);
     }
     forEachLayerTileTreeRef(func) {
-        for (const layerTree of this._layerTrees) {
+        for (const layerTree of this._layerRefHandler.layerTrees) {
             assert(layerTree instanceof MapLayerTileTreeReference);
             func(layerTree);
         }
     }
     get isGlobal() { return true; }
-    get baseColor() { return this._baseColor; }
+    get baseColor() { return this.baseColor; }
     get planarClipMaskPriority() { return 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, () => {
+        const ref = new MapTileTreeReference(this._settings, undefined, [], this.iModel, this._tileUserId, false, false, () => {
             return { produceGeometry: true };
         });
         assert(undefined !== ref.collectTileGeometry);
@@ -686,66 +645,24 @@ export class MapTileTreeReference extends TileTreeReference {
         this._settings = settings;
         this._planarClipMask = settings.planarClipMask ? PlanarClipMaskState.create(settings.planarClipMask) : undefined;
     }
-    setBaseLayerSettings(baseLayerSettings) {
-        assert(!this.isOverlay);
-        let tree;
-        this._baseLayerSettings = baseLayerSettings;
-        if (baseLayerSettings instanceof MapLayerSettings) {
-            tree = createMapLayerTreeReference(baseLayerSettings, 0, this._iModel);
-            this._baseColor = undefined;
-            this._baseTransparent = baseLayerSettings.transparency > 0;
-        }
-        else {
-            this._baseColor = baseLayerSettings;
-            this._baseTransparent = this._baseColor.getTransparency() > 0;
-        }
-        if (tree) {
-            if (this._baseImageryLayerIncluded)
-                this._layerTrees[0] = tree;
-            else
-                this._layerTrees.splice(0, 0, tree);
-        }
-        else {
-            if (this._baseImageryLayerIncluded)
-                this._layerTrees.shift();
-        }
-        this._baseImageryLayerIncluded = tree !== undefined;
-        this.clearLayers();
-    }
     get layerSettings() {
-        return this._layerSettings;
-    }
-    setLayerSettings(layerSettings) {
-        this._layerSettings = layerSettings;
-        const baseLayerIndex = this._baseImageryLayerIncluded ? 1 : 0;
-        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._layerTrees.length || !this._layerTrees[treeIndex]?.layerSettings.displayMatches(layerSettings[i]))
-                this._layerTrees[treeIndex] = createMapLayerTreeReference(layerSettings[i], treeIndex, this._iModel);
-        }
-        this.clearLayers();
-    }
-    clearLayers() {
-        const tree = this.treeOwner.tileTree;
-        if (undefined !== tree)
-            tree.clearLayers();
+        return this.layerRefHandler.layerSettings;
     }
     get castsShadows() {
         return false;
     }
     get _isLoadingComplete() {
         // Wait until drape tree is fully loaded too.
-        for (const drapeTree of this._layerTrees)
+        for (const drapeTree of this._layerRefHandler.layerTrees)
             if (drapeTree && !drapeTree.isLoadingComplete)
                 return false;
         return super._isLoadingComplete;
     }
     get useDepthBuffer() {
-        return !this.isOverlay && (this.settings.applyTerrain || this.settings.useDepthBuffer);
+        return !this._layerRefHandler.isOverlay && (this.settings.applyTerrain || this.settings.useDepthBuffer);
     }
     get treeOwner() {
-        let wantSkirts = (this.settings.applyTerrain || this.useDepthBuffer) && !this.settings.transparency && !this._baseTransparent;
+        let wantSkirts = (this.settings.applyTerrain || this.useDepthBuffer) && !this.settings.transparency && !this._layerRefHandler.baseTransparent;
         if (wantSkirts) {
             const maskTrans = this._planarClipMask?.settings.transparency;
             wantSkirts = (undefined === maskTrans || maskTrans <= 0);
@@ -763,10 +680,10 @@ export class MapTileTreeReference extends TileTreeReference {
             // Can set to this.settings.terrainSettings.applyLighting if we want to ever apply lighting to terrain again so that normals are retrieved when lighting is on.
             wantNormals: false,
             globeMode: this._isDrape ? GlobeMode.Plane : this.settings.globeMode,
-            isOverlay: this.isOverlay,
+            isOverlay: this._layerRefHandler.isOverlay,
             useDepthBuffer: this.useDepthBuffer,
-            baseColor: this._baseColor,
-            baseTransparent: this._baseTransparent,
+            baseColor: this._layerRefHandler.baseColor,
+            baseTransparent: this._layerRefHandler.baseTransparent,
             mapTransparent: Number(this.settings.transparency) > 0,
             maskModelIds: this._planarClipMask?.settings.compressedModelIds,
             produceGeometry: false,
@@ -779,12 +696,12 @@ export class MapTileTreeReference extends TileTreeReference {
                 id.produceGeometry = ovr.produceGeometry === true;
             }
         }
-        return this._iModel.tiles.getTileTreeOwner(id, mapTreeSupplier);
+        return this.iModel.tiles.getTileTreeOwner(id, mapTreeSupplier);
     }
     getLayerImageryTreeRef(index) {
-        const baseLayerIndex = this._baseImageryLayerIncluded ? 1 : 0;
+        const baseLayerIndex = this._layerRefHandler.baseImageryLayerIncluded ? 1 : 0;
         const treeIndex = index + baseLayerIndex;
-        return index < 0 || treeIndex >= this._layerTrees.length ? undefined : this._layerTrees[treeIndex];
+        return index < 0 || treeIndex >= this._layerRefHandler.layerTrees.length ? undefined : this._layerRefHandler.layerTrees[treeIndex];
     }
     /** Return the map-layer scale range visibility for the provided map-layer index.
    * @internal
@@ -802,58 +719,12 @@ export class MapTileTreeReference extends TileTreeReference {
         }
         return MapTileTreeScaleRangeVisibility.Unknown;
     }
-    initializeLayers(context) {
-        let hasLoadedTileTree = false;
-        const tree = this.treeOwner.load();
-        if (undefined === tree) {
-            return hasLoadedTileTree; // Not loaded yet.
-        }
-        tree.layerImageryTrees.length = 0;
-        if (0 === this._layerTrees.length) {
-            return !this.isOverlay;
-        }
-        let treeIndex = this._layerTrees.length - 1;
-        // Start displaying at the highest completely opaque layer...
-        for (; treeIndex >= 1; treeIndex--) {
-            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._layerTrees.length; treeIndex++) {
-            const layerTreeRef = this._layerTrees[treeIndex];
-            const hasValidTileTree = layerTreeRef && TileTreeLoadStatus.NotFound !== layerTreeRef.treeOwner.loadStatus;
-            const isImageryMapLayer = layerTreeRef instanceof ImageryMapLayerTreeReference;
-            const isLayerVisible = (isImageryMapLayer || (!isImageryMapLayer && layerTreeRef?.layerSettings.visible));
-            // Load tile tree for each configured layer.
-            // Note: Non-visible imagery layer are always added to allow proper tile tree scale range visibility reporting.
-            if (hasValidTileTree
-                && isLayerVisible
-                && !layerTreeRef.layerSettings.allSubLayersInvisible) {
-                const layerTree = layerTreeRef.treeOwner.load();
-                if (layerTree !== undefined) {
-                    hasLoadedTileTree = true;
-                }
-                else {
-                    // Let's continue, there might be loaded tile tree in the list
-                    continue;
-                }
-                // Add loaded TileTree
-                const baseImageryLayer = this._baseImageryLayerIncluded && (treeIndex === 0);
-                if (layerTree instanceof ImageryMapTileTree) {
-                    tree.addImageryLayer(layerTree, layerTreeRef.layerSettings, treeIndex, baseImageryLayer);
-                }
-                else if (layerTreeRef instanceof ModelMapLayerTileTreeReference)
-                    tree.addModelLayer(layerTreeRef, context);
-            }
-        }
-        return hasLoadedTileTree;
-    }
     /** Adds this reference's graphics to the scene. By default this invokes [[TileTree.drawScene]] on the referenced TileTree, if it is loaded. */
     addToScene(context) {
         if (!context.viewFlags.backgroundMap)
             return;
         const tree = this.treeOwner.load();
-        if (undefined === tree || !this.initializeLayers(context))
+        if (undefined === tree || !this._layerRefHandler.initializeLayers(context))
             return; // Not loaded yet.
         if (this._planarClipMask && this._planarClipMask.settings.isValid)
             context.addPlanarClassifier(tree.modelId, undefined, this._planarClipMask);
@@ -876,7 +747,7 @@ export class MapTileTreeReference extends TileTreeReference {
         if (undefined === args)
             return undefined;
         const tree = this.treeOwner.load();
-        return new RealityTileDrawArgs(args, args.worldToViewMap, args.frustumPlanes, undefined, tree?.layerClassifiers);
+        return new RealityTileDrawArgs(args, args.worldToViewMap, args.frustumPlanes, undefined, tree?.layerHandler.layerClassifiers);
     }
     getViewFlagOverrides(_tree) {
         return createViewFlagOverrides(false, this._settings.applyTerrain ? undefined : false);
@@ -886,7 +757,7 @@ export class MapTileTreeReference extends TileTreeReference {
     }
     discloseTileTrees(trees) {
         super.discloseTileTrees(trees);
-        for (const imageryTree of this._layerTrees)
+        for (const imageryTree of this._layerRefHandler.layerTrees)
             if (imageryTree)
                 trees.disclose(imageryTree);
         if (this._planarClipMask)
@@ -897,7 +768,7 @@ export class MapTileTreeReference extends TileTreeReference {
         const tree = this.treeOwner.tileTree;
         if (undefined === tree || tree.modelId !== mapTreeModelId)
             return imageryTrees;
-        for (const imageryTree of this._layerTrees)
+        for (const imageryTree of this._layerRefHandler.layerTrees)
             if (imageryTree && imageryTree.treeOwner.tileTree && imageryTree.treeOwner.tileTree.modelId === layerTreeModelId)
                 imageryTrees.push(imageryTree);
         return imageryTrees;
@@ -905,10 +776,10 @@ export class MapTileTreeReference extends TileTreeReference {
     layerFromTreeModelIds(mapTreeModelId, layerTreeModelId) {
         const imageryTree = this.imageryTreeFromTreeModelIds(mapTreeModelId, layerTreeModelId);
         return imageryTree.map((tree) => {
-            const isBaseLayer = (this._baseImageryLayerIncluded && tree.layerIndex === 0);
+            const isBaseLayer = (this._layerRefHandler.baseImageryLayerIncluded && tree.layerIndex === 0);
             return {
                 isBaseLayer,
-                index: isBaseLayer ? undefined : { isOverlay: this.isOverlay, index: this._baseImageryLayerIncluded ? tree.layerIndex - 1 : tree.layerIndex },
+                index: isBaseLayer ? undefined : { isOverlay: this._layerRefHandler.isOverlay, index: this._layerRefHandler.baseImageryLayerIncluded ? tree.layerIndex - 1 : tree.layerIndex },
                 settings: tree.layerSettings, provider: tree.imageryProvider,
             };
         });
@@ -1022,7 +893,7 @@ export class MapTileTreeReference extends TileTreeReference {
         if (tree) {
             // eslint-disable-next-line @typescript-eslint/no-deprecated
             tree.mapLoader.terrainProvider.addLogoCards(cards, vp);
-            for (const imageryTreeRef of this._layerTrees) {
+            for (const imageryTreeRef of this._layerRefHandler.layerTrees) {
                 if (imageryTreeRef?.layerSettings.visible) {
                     const imageryTree = imageryTreeRef.treeOwner.tileTree;
                     if (imageryTree instanceof ImageryMapTileTree)
@@ -1037,7 +908,7 @@ export class MapTileTreeReference extends TileTreeReference {
         const tree = this.treeOwner.tileTree;
         if (tree) {
             const promises = [tree.mapLoader.terrainProvider.addAttributions(cards, vp)];
-            for (const imageryTreeRef of this._layerTrees) {
+            for (const imageryTreeRef of this._layerRefHandler.layerTrees) {
                 if (imageryTreeRef?.layerSettings.visible) {
                     const imageryTree = imageryTreeRef.treeOwner.tileTree;
                     if (imageryTree instanceof ImageryMapTileTree)
@@ -1048,7 +919,7 @@ export class MapTileTreeReference extends TileTreeReference {
         }
     }
     decorate(context) {
-        for (const layerTree of this._layerTrees) {
+        for (const layerTree of this._layerRefHandler.layerTrees) {
             if (layerTree)
                 layerTree.decorate(context);
         }