bruce-cesium 7.0.1 → 7.0.3

package/dist/lib/rendering/visuals-register.js

@@ -4,6 +4,8 @@ exports.VisualsRegister = void 0;
 const bruce_models_1 = require("bruce-models");
 const Cesium = require("cesium");
 const js_utils_1 = require("../internal/js-utils");
+const cesium_show_gate_1 = require("../internal/cesium-show-gate");
+const cesium_utils_1 = require("../internal/cesium-utils");
 const entity_label_1 = require("../rendering/render-managers/common/entity-label");
 const cesium_entity_styler_1 = require("../utils/cesium-entity-styler");
 const entity_render_engine_1 = require("./entity-render-engine");
@@ -35,7 +37,7 @@ function isAlive(viewer, visual) {
         return false;
     }
     if (visual instanceof Cesium.Entity) {
-        return viewer.entities.contains(visual);
+        return (0, cesium_utils_1.IsCEntityInScene)(viewer, visual);
     }
     else if (visual instanceof Cesium.Primitive) {
         return viewer.scene.primitives.contains(visual);
@@ -62,6 +64,32 @@ function removeEntity(viewer, visual) {
         viewer
     });
 }
+/**
+ * Returns the highest zIndex across a graphic and its siblings, or null when none of them set one.
+ * @param viewer
+ * @param visual
+ */
+function getHighestZIndex(viewer, visual) {
+    if (!(visual instanceof Cesium.Entity)) {
+        return null;
+    }
+    let highest = null;
+    const parts = entity_utils_1.EntityUtils.GatherEntity({
+        entity: visual
+    });
+    for (const part of parts) {
+        if (!(part instanceof Cesium.Entity)) {
+            continue;
+        }
+        for (const graphic of [part.polygon, part.polyline, part.corridor, part.ellipse, part.rectangle]) {
+            const zIndex = graphic ? (0, cesium_utils_1.GetCValue)(viewer, graphic.zIndex) : null;
+            if (zIndex != null && !isNaN(zIndex) && (highest == null || zIndex > highest)) {
+                highest = zIndex;
+            }
+        }
+    }
+    return highest;
+}
 const MAX_SHOW_DEPTH = 10;
 function updateCEntityShow(viewer, visual, rego, show, ignoreParent, depth = 0) {
     if (depth > MAX_SHOW_DEPTH) {
@@ -80,26 +108,24 @@ function updateCEntityShow(viewer, visual, rego, show, ignoreParent, depth = 0)
             updateCEntityShow(viewer, sibling, rego, show, true, depth + 1);
         }
     }
-    /**
-     * Do NOT use ".show" as it causes crashes in Cesium polylines that are clamped to ground.
-     * We could target them specifically here but we may be getting overall performance gain by just removing stuff from the scene.
-     */
-    if (rego.collection) {
-        if (!show && rego.collection.contains(visual)) {
-            rego.collection.remove(visual);
-        }
-        else if (show && !rego.collection.contains(visual)) {
-            rego.collection.add(visual);
+    if (show) {
+        // Always restore membership on the way back in. Something else may have evicted this graphic while it
+        // was hidden (the culler removes outright), and `show` alone would leave it invisible.
+        (0, cesium_utils_1.AddCEntityToScene)(viewer, visual, rego.collection);
+        if (visual.show !== true) {
+            visual.show = true;
         }
+        return;
     }
-    else {
-        if (!show && viewer.entities.contains(visual)) {
-            viewer.entities.remove(visual);
-        }
-        else if (show && !viewer.entities.contains(visual)) {
-            viewer.entities.add(visual);
+    // Hiding via `show` only updates a per-instance attribute, where leaving the collection rebuilds the whole
+    // geometry batch. But it is not safe for every graphic, see CanToggleShowSafely for exactly why.
+    if ((0, cesium_utils_1.CanToggleShowSafely)([visual])) {
+        if (visual.show !== false) {
+            visual.show = false;
         }
+        return;
     }
+    (0, cesium_utils_1.RemoveCEntityFromScene)(viewer, visual);
 }
 function updateEntityShow(viewer, rego, show) {
     const visual = rego.visual;
@@ -412,12 +438,128 @@ var VisualsRegister;
             // This lets us modify the update without re-adding the item to the queue if it's already in it.
             this.updateQueueSettings = {};
             this.updateQueueInterval = null;
+            // Per menu item collections so we can refresh sets of Entities without affecting others.
+            this.menuItemSources = new Map();
+            // Set when the data source order no longer matches the zIndexes seen, so it is re-applied once.
+            this.sourceOrderDirty = false;
+            /*
+             * Tilesets in the scene, keyed by the tileset itself.
+             */
+            this.tilesets = new Map();
             this.viewer = params.viewer;
             this.apiGetters = params.apiGetters;
             this.cameraCullerDispose = visual_register_culler_1.VisualRegisterCuller.Monitor({
                 register: this
             });
         }
+        /**
+         * Returns the collection a menu item's visuals belong in, creating its data source on first use.
+         * Returns null when there is nothing to key off, leaving the caller on the viewer's own collection.
+         * @param menuItemId
+         */
+        ensureMenuItemCollection(menuItemId) {
+            var _a;
+            if (!menuItemId || this.disposed || !((_a = this.viewer) === null || _a === void 0 ? void 0 : _a.dataSources)) {
+                return null;
+            }
+            const existing = this.menuItemSources.get(menuItemId);
+            if (existing) {
+                return existing.source.entities;
+            }
+            const source = new Cesium.CustomDataSource(`menu-item-${menuItemId}`);
+            const record = {
+                source,
+                maxZIndex: 0,
+                added: false
+            };
+            (0, cesium_utils_1.MarkCCollectionOwned)(source.entities);
+            this.menuItemSources.set(menuItemId, record);
+            // Adding is asynchronous, so ordering has to wait until it is actually in the collection.
+            Promise.resolve(this.viewer.dataSources.add(source))
+                .then(() => {
+                record.added = true;
+                this.applySourceOrder();
+            })
+                .catch((e) => {
+                console.error(e);
+            });
+            return source.entities;
+        }
+        /**
+         * Notes the highest zIndex seen for a menu item, since that is what its data source has to sort by.
+         * zIndex orders geometry within a data source but not between them, so a whole layer stacks by the
+         * highest value anything in it asked for.
+         * @param menuItemId
+         * @param visual
+         */
+        trackSourceZIndex(menuItemId, visual) {
+            const record = this.menuItemSources.get(menuItemId);
+            if (!record) {
+                return;
+            }
+            const zIndex = getHighestZIndex(this.viewer, visual);
+            if (zIndex == null || zIndex <= record.maxZIndex) {
+                return;
+            }
+            record.maxZIndex = zIndex;
+            this.sourceOrderDirty = true;
+            this.applySourceOrder();
+        }
+        /**
+         * Re-stacks the menu item data sources so a higher zIndex sits above a lower one.
+         */
+        applySourceOrder() {
+            var _a;
+            if (this.disposed || !this.sourceOrderDirty || !((_a = this.viewer) === null || _a === void 0 ? void 0 : _a.dataSources)) {
+                return;
+            }
+            const records = Array.from(this.menuItemSources.values()).filter(x => x.added);
+            if (records.length < 2) {
+                // Nothing to order against yet, so leave the flag set for when there is.
+                return;
+            }
+            this.sourceOrderDirty = false;
+            // Raising each in ascending order leaves the highest on top.
+            records.sort((a, b) => a.maxZIndex - b.maxZIndex);
+            for (const record of records) {
+                try {
+                    this.viewer.dataSources.raiseToTop(record.source);
+                }
+                catch (e) {
+                    console.error(e);
+                }
+            }
+        }
+        /**
+         * Drops a menu item's data source once nothing is registered under it any more.
+         * @param menuItemId
+         */
+        releaseMenuItemCollection(menuItemId) {
+            var _a, _b, _c;
+            const record = this.menuItemSources.get(menuItemId);
+            if (!record) {
+                return;
+            }
+            if ((_a = this.entityIdsByMenuItem[menuItemId]) === null || _a === void 0 ? void 0 : _a.size) {
+                return;
+            }
+            this.menuItemSources.delete(menuItemId);
+            try {
+                (_c = (_b = this.viewer) === null || _b === void 0 ? void 0 : _b.dataSources) === null || _c === void 0 ? void 0 : _c.remove(record.source, true);
+            }
+            catch (e) {
+                console.error(e);
+            }
+        }
+        /** Every collection a bulk pass over this register's visuals could mutate. */
+        allSceneCollections() {
+            var _a;
+            const collections = [(_a = this.viewer) === null || _a === void 0 ? void 0 : _a.entities];
+            for (const record of Array.from(this.menuItemSources.values())) {
+                collections.push(record.source.entities);
+            }
+            return collections;
+        }
         indexMenuItemEntity(menuItemId, entityId) {
             if (!menuItemId) {
                 return;
@@ -1007,9 +1149,11 @@ var VisualsRegister;
                     return;
                 }
                 const end = Math.min(index + BATCH_SIZE, items.length);
-                for (; index < end; index++) {
-                    perItem(items[index]);
-                }
+                (0, cesium_utils_1.WithSuspendedCCollections)(this.allSceneCollections(), () => {
+                    for (; index < end; index++) {
+                        perItem(items[index]);
+                    }
+                });
                 this.viewer.scene.requestRender();
                 if (index >= items.length) {
                     clearInterval(interval);
@@ -1166,7 +1310,7 @@ var VisualsRegister;
             markEntity(this, rego, rego.visual, false);
         }
         Dispose() {
-            var _a;
+            var _a, _b, _c, _d;
             (_a = this.cameraCullerDispose) === null || _a === void 0 ? void 0 : _a.call(this, {
                 uncull: false
             });
@@ -1181,6 +1325,20 @@ var VisualsRegister;
             }
             this.activeChunkedIntervals.clear();
             this.disposed = true;
+            for (const record of Array.from(this.menuItemSources.values())) {
+                try {
+                    (_c = (_b = this.viewer) === null || _b === void 0 ? void 0 : _b.dataSources) === null || _c === void 0 ? void 0 : _c.remove(record.source, true);
+                }
+                catch (e) {
+                    console.error(e);
+                }
+            }
+            this.menuItemSources.clear();
+            // Hand every tileset's show flag back to its owner, holding whatever the owner last asked for.
+            for (const rego of Array.from(this.tilesets.values())) {
+                (_d = rego.gate) === null || _d === void 0 ? void 0 : _d.Release();
+            }
+            this.tilesets.clear();
         }
         ForceUpdate(params) {
             var _a;
@@ -1778,6 +1936,14 @@ var VisualsRegister;
                 });
             }
             const entityId = rego.entityId;
+            // Scope this visual to its menu item's own data source, so a rebuild of it cannot re-tessellate
+            // other layers. A caller that already picked a collection (eg. geojson) keeps its own.
+            if (!rego.collection && rego.menuItemId) {
+                const collection = this.ensureMenuItemCollection(rego.menuItemId);
+                if (collection) {
+                    rego.collection = collection;
+                }
+            }
             // Add the new visual to the register.
             const entityRegos = (_a = this.rego[entityId]) !== null && _a !== void 0 ? _a : [];
             entityRegos.push(rego);
@@ -1785,6 +1951,7 @@ var VisualsRegister;
             this.indexMenuItemEntity(rego.menuItemId, entityId);
             // Mark the visual as part of this register so selection works.
             markEntity(this, rego, rego.visual, false);
+            this.trackSourceZIndex(rego.menuItemId, rego.visual);
             // Run any updates on the visual based on the calculated state.
             // Eg: visibility, opacity, selection, etc.
             this.queueUpdate({
@@ -2089,9 +2256,13 @@ var VisualsRegister;
                     this.startLazyRemoval(entityIds, removeOne, onComplete);
                     return;
                 }
-                for (const entityId of entityIds) {
-                    removeOne(entityId);
-                }
+                (0, cesium_utils_1.WithSuspendedCCollections)(this.allSceneCollections(), () => {
+                    for (const entityId of entityIds) {
+                        removeOne(entityId);
+                    }
+                });
+                this.releaseMenuItemCollection(menuItemId);
+                this.RemoveTilesetsByMenuItem(menuItemId);
             }
             else if (entityId) {
                 const entityRegos = this.rego[entityId];
@@ -2274,8 +2445,75 @@ var VisualsRegister;
             };
         }
         /**
-         * Returns all registered entity ids.
+         * Registers a tileset so the register can decide when it is worth drawing.
+         * @param params
+         */
+        AddTileset(params) {
+            const { tileset, menuItemId } = params;
+            if (!tileset || this.disposed) {
+                return;
+            }
+            const existing = this.tilesets.get(tileset);
+            if (existing) {
+                existing.menuItemId = menuItemId !== null && menuItemId !== void 0 ? menuItemId : existing.menuItemId;
+                return;
+            }
+            this.tilesets.set(tileset, {
+                tileset,
+                menuItemId,
+                // Null when the property could not be intercepted, in which case this tileset simply never gets
+                // culled rather than us fighting its owner over the same field.
+                gate: (0, cesium_show_gate_1.InstallShowGate)(tileset),
+                culled: false
+            });
+        }
+        /**
+         * Stops tracking a tileset and hands its show flag back to its owner.
+         * @param tileset
          */
+        RemoveTileset(tileset) {
+            var _a;
+            const rego = this.tilesets.get(tileset);
+            if (!rego) {
+                return;
+            }
+            this.tilesets.delete(tileset);
+            (_a = rego.gate) === null || _a === void 0 ? void 0 : _a.Release();
+        }
+        /**
+         * Stops tracking every tileset belonging to a menu item.
+         * @param menuItemId
+         */
+        RemoveTilesetsByMenuItem(menuItemId) {
+            if (!menuItemId) {
+                return;
+            }
+            for (const rego of Array.from(this.tilesets.values())) {
+                if (rego.menuItemId === menuItemId) {
+                    this.RemoveTileset(rego.tileset);
+                }
+            }
+        }
+        /**
+         * Every tileset currently tracked.
+         */
+        GetTilesets() {
+            return Array.from(this.tilesets.values());
+        }
+        /**
+         * Suppresses or restores a tileset.
+         * Returns whether its effective visibility changed, so a caller can skip requesting a render when nothing did.
+         * @param tileset
+         * @param culled
+         */
+        SetTilesetCulled(tileset, culled) {
+            const rego = this.tilesets.get(tileset);
+            if (!(rego === null || rego === void 0 ? void 0 : rego.gate)) {
+                return false;
+            }
+            rego.culled = Boolean(culled);
+            return rego.gate.SetSuppressed(rego.culled);
+        }
         GetEntityIds() {
             const ids = [];
             for (const entityId in this.rego) {