bruce-cesium 7.0.4 → 7.0.5

package/dist/bruce-cesium.umd.js

@@ -6073,7 +6073,17 @@
      * Cesium's own flat ellipsoid. Deliberately not FlatTerrain, see shouldCullEntity.
      */
     const UNRECOGNISED_TERRAIN_ID = "unrecognised-terrain";
+    // Keyed by entity id alone. A cached sphere is only as good as the geometry it was measured from, so anything
+    // changing that geometry has to call InvalidateBounds, see it for why nothing can be inferred instead.
     const boundingSphereCache = new BModels.LRUCache(100000);
+    /*
+     * Forgets what is known about an entity's extent, so the next check measures it again.
+     */
+    function invalidateBounds(entityIds) {
+        for (let i = 0; i < entityIds.length; i++) {
+            boundingSphereCache.Delete(entityIds[i]);
+        }
+    }
     function getPositionsFromEntity(viewer, entity) {
         let positions = [];
         let heightRef;
@@ -6191,9 +6201,10 @@
         const terrainId = (_c = (_b = (_a = exports.ViewUtils.GatherTerrainTile({
             viewer
         })) === null || _a === void 0 ? void 0 : _a.terrain) === null || _b === void 0 ? void 0 : _b.tilesetId) !== null && _c !== void 0 ? _c : UNRECOGNISED_TERRAIN_ID;
-        const cacheKey = terrainId + cEntity.id;
+        const cacheKey = cEntity.id;
         const cacheData = boundingSphereCache.Get(cacheKey);
-        if (cacheData) {
+        // A sphere measured under different terrain cannot be reused, since the height treatment differs.
+        if (cacheData && (cacheData == -1 || cacheData.terrainId == terrainId)) {
             boundingSphere = cacheData;
         }
         else {
@@ -6249,7 +6260,8 @@
                 }
                 boundingSphere = {
                     heightRef: positions.heightRef,
-                    sphere: sphere
+                    sphere: sphere,
+                    terrainId: terrainId
                 };
                 if (!doNotCache) {
                     boundingSphereCache.Set(cacheKey, boundingSphere);
@@ -6344,6 +6356,8 @@
             rego.relation != null ||
             // Explicitly being either shown or hidden.
             rego.overrideShow != null ||
+            // Being dragged around right now, so its extent is changing faster than we could measure it.
+            rego.editing == true ||
             // Part of a collection we did not create, eg. a geojson data source, which may have its own rules for
             // what is in the scene. Our own per-menu-item data sources are fair game.
             (rego.collection && !IsCCollectionOwned(rego.collection)) ||
@@ -6632,6 +6646,38 @@
             return isCullingIgnored(viewer, rego);
         }
         VisualRegisterCuller.IsCullingIgnored = IsCullingIgnored;
+        /**
+         * Discards what the culler knows about an entity's extent, so its next check measures the geometry again.
+         * @param visuals an entity, an entity id, or an array of either.
+         */
+        function InvalidateBounds(visuals) {
+            const list = Array.isArray(visuals) ? visuals : [visuals];
+            const ids = [];
+            for (let i = 0; i < list.length; i++) {
+                const item = list[i];
+                if (!item) {
+                    continue;
+                }
+                if (typeof item == "string") {
+                    ids.push(item);
+                    continue;
+                }
+                const parts = exports.EntityUtils.GatherEntity({
+                    entity: item
+                });
+                for (let j = 0; j < parts.length; j++) {
+                    const part = parts[j];
+                    if (!(part instanceof Cesium.Entity)) {
+                        continue;
+                    }
+                    ids.push(part.id);
+                    // The per-entity answer is derived from the sphere, so it goes stale with it.
+                    delete part[VisualRegisterCuller.VISUAL_CULL_KEY];
+                }
+            }
+            invalidateBounds(ids);
+        }
+        VisualRegisterCuller.InvalidateBounds = InvalidateBounds;
         function IsCulled(viewer, rego, visual) {
             if (isCullingIgnored(viewer, rego)) {
                 return false;
@@ -8098,6 +8144,58 @@
                     exports.CesiumEntityStyler.UpdateColorSetting("highlight", color);
                 }
             }
+            /**
+             * Marks visuals as being actively edited, which exempts them from culling until it is turned back off.
+             */
+            SetEditing(params) {
+                var _a, _b;
+                const { entityIds, editing, menuItemId, requestRender } = params;
+                if (!(entityIds === null || entityIds === void 0 ? void 0 : entityIds.length)) {
+                    return;
+                }
+                let changed = false;
+                for (let i = 0; i < entityIds.length; i++) {
+                    const regos = this.rego[entityIds[i]];
+                    if (!regos) {
+                        continue;
+                    }
+                    for (let j = 0; j < regos.length; j++) {
+                        const rego = regos[j];
+                        if (menuItemId && rego.menuItemId !== menuItemId) {
+                            continue;
+                        }
+                        if (Boolean(rego.editing) == Boolean(editing)) {
+                            continue;
+                        }
+                        // Null rather than false, so the rego does not carry a key for every visual ever edited.
+                        rego.editing = editing ? true : null;
+                        changed = true;
+                        if (editing) {
+                            const parts = exports.EntityUtils.GatherEntity({
+                                entity: rego.visual
+                            });
+                            for (let k = 0; k < parts.length; k++) {
+                                const part = parts[k];
+                                if (!(part instanceof Cesium.Entity)) {
+                                    continue;
+                                }
+                                const wasCulled = part[VisualRegisterCuller.VISUAL_CULL_KEY];
+                                delete part[VisualRegisterCuller.VISUAL_CULL_KEY];
+                                if (wasCulled && !IsCEntityInScene(this.viewer, part)) {
+                                    AddCEntityToScene(this.viewer, part, rego.collection);
+                                }
+                            }
+                        }
+                        else {
+                            // The geometry almost certainly moved, so what was measured before is worthless.
+                            VisualRegisterCuller.InvalidateBounds(rego.visual);
+                        }
+                    }
+                }
+                if (changed && requestRender != false) {
+                    (_b = (_a = this.viewer) === null || _a === void 0 ? void 0 : _a.scene) === null || _b === void 0 ? void 0 : _b.requestRender();
+                }
+            }
             SetSelected(params) {
                 var _a;
                 let { entityIds, selected, refreshIfSelected, requestRender, menuItemId, source } = params;
@@ -39428,6 +39526,7 @@
                 if (bandCheck) {
                     cEntity._bandCheck = bandCheck;
                 }
+                VisualRegisterCuller.InvalidateBounds(cEntity);
             });
             return {
                 entities: cEntities,
@@ -40194,7 +40293,7 @@
         StyleUtils.ApplyTypeStyle = ApplyTypeStyle;
     })(exports.StyleUtils || (exports.StyleUtils = {}));
 
-    const VERSION = "7.0.4";
+    const VERSION = "7.0.5";
     /**
      * Updates the environment instance used by bruce-cesium to one specified.
      * This can be used to ensure that the instance a parent is referencing is shared between bruce-cesium, bruce-models, and the parent app.