bruce-cesium 7.0.8 → 7.1.0

package/dist/bruce-cesium.umd.js

@@ -6307,6 +6307,7 @@
     // Attached to a cesium viewer to indicate a re-check should be done.
     // This is to override the cache that avoids re-checking when the camera hasn't moved.
     const SHOULD_RECHECK_KEY = Symbol("SHOULD_RECHECK_KEY");
+    const RECHECK_KICK_KEY = Symbol("RECHECK_KICK_KEY");
     /**
      * We will recheck if the camera has turned or moved enough.
      * @param viewer
@@ -6453,6 +6454,8 @@
             }
             const toRemove = [];
             const toAdd = [];
+            // Entities the register has to re-evaluate, because the culler cannot restore a `show` it did not set.
+            const toRefresh = new Set();
             const isIsolatedAny = register.GetIsIsolatedAny();
             const slice = entityIds.splice(0, CHECK_BATCH);
             for (let i = 0; i < slice.length; i++) {
@@ -6490,17 +6493,23 @@
                         }
                         const shouldCull = shouldCullEntity(viewer, part);
                         if (shouldCull) {
-                            part[VisualRegisterCuller.VISUAL_CULL_KEY] = true;
+                            part[exports.VisualRegisterCuller.VISUAL_CULL_KEY] = true;
                             toRemove.push(part);
                         }
                         else {
-                            delete part[VisualRegisterCuller.VISUAL_CULL_KEY];
+                            delete part[exports.VisualRegisterCuller.VISUAL_CULL_KEY];
                             if (rego.overrideShow != false &&
                                 !IsCEntityInScene(viewer, part) &&
                                 !state.hidden &&
                                 (!isIsolatedAny || state.isolated)) {
                                 toAdd.push(part);
                             }
+                            else if (part.show === false &&
+                                rego.overrideShow != false &&
+                                !state.hidden &&
+                                (!isIsolatedAny || state.isolated)) {
+                                toRefresh.add(entityId);
+                            }
                         }
                     }
                 }
@@ -6511,6 +6520,11 @@
             if (toAdd.length > 0) {
                 addEntities(viewer, toAdd);
             }
+            if (toRefresh.size > 0) {
+                register.ForceUpdate({
+                    entityIds: Array.from(toRefresh)
+                });
+            }
             if (entityIds.length <= 0) {
                 clearInterval(checkInterval);
                 checkInterval = null;
@@ -6574,7 +6588,6 @@
             });
         });
     }
-    var VisualRegisterCuller;
     (function (VisualRegisterCuller) {
         VisualRegisterCuller.VISUAL_CULL_KEY = Symbol("VISUAL_CULL_KEY");
         /**
@@ -6597,6 +6610,7 @@
                 runCullChecker(register);
                 lastCullCheck = new Date();
             }, 1000);
+            register.Viewer[RECHECK_KICK_KEY] = () => { var _a; return (_a = checkQueue === null || checkQueue === void 0 ? void 0 : checkQueue.Call) === null || _a === void 0 ? void 0 : _a.call(checkQueue); };
             let moveStartRemoval = register.Viewer.camera.moveStart.addEventListener(() => {
                 var _a;
                 (_a = checkQueue.Call) === null || _a === void 0 ? void 0 : _a.call(checkQueue);
@@ -6639,6 +6653,9 @@
                 checkWaiting = false;
                 checkQueue === null || checkQueue === void 0 ? void 0 : checkQueue.Dispose();
                 checkQueue = null;
+                if (register.Viewer) {
+                    delete register.Viewer[RECHECK_KICK_KEY];
+                }
             };
         }
         VisualRegisterCuller.Monitor = Monitor;
@@ -6729,16 +6746,28 @@
                 return false;
             }
             if (visual instanceof Cesium.Entity) {
-                return visual[VisualRegisterCuller.VISUAL_CULL_KEY] == true;
+                if (visual[VisualRegisterCuller.VISUAL_CULL_KEY] != true) {
+                    return false;
+                }
+                // Invalidated, so the decision above was measured from geometry that no longer describes this.
+                return boundingSphereCache.Get(visual.id) != null;
             }
             return false;
         }
         VisualRegisterCuller.IsCulled = IsCulled;
+        /**
+         * Asks for the next cull pass to actually re-measure, and brings that pass forward.
+         */
         function MarkShouldRecheck(viewer) {
+            var _a, _b;
+            if (!viewer || ((_a = viewer.isDestroyed) === null || _a === void 0 ? void 0 : _a.call(viewer))) {
+                return;
+            }
             viewer[SHOULD_RECHECK_KEY] = true;
+            (_b = viewer[RECHECK_KICK_KEY]) === null || _b === void 0 ? void 0 : _b.call(viewer);
         }
         VisualRegisterCuller.MarkShouldRecheck = MarkShouldRecheck;
-    })(VisualRegisterCuller || (VisualRegisterCuller = {}));
+    })(exports.VisualRegisterCuller || (exports.VisualRegisterCuller = {}));
 
     function isTilesetFeatureAlive(visual) {
         const cTileset = visual === null || visual === void 0 ? void 0 : visual.tileset;
@@ -6825,7 +6854,7 @@
         }
         // A sub-object can be culled while the siblings are not.
         // We only cull things that give us some benefit. For example clamped to ground graphics are expensive to keep rendered.
-        show = show ? !VisualRegisterCuller.IsCulled(viewer, rego, visual) : false;
+        show = show ? !exports.VisualRegisterCuller.IsCulled(viewer, rego, visual) : false;
         if (visual._parentEntity && !ignoreParent) {
             updateCEntityShow(viewer, visual._parentEntity, rego, show, false, depth + 1);
         }
@@ -7178,7 +7207,7 @@
                 this.tilesets = new Map();
                 this.viewer = params.viewer;
                 this.apiGetters = params.apiGetters;
-                this.cameraCullerDispose = VisualRegisterCuller.Monitor({
+                this.cameraCullerDispose = exports.VisualRegisterCuller.Monitor({
                     register: this
                 });
             }
@@ -8190,6 +8219,26 @@
                     exports.CesiumEntityStyler.UpdateColorSetting("highlight", color);
                 }
             }
+            /**
+             * Whether any rego for this entity is currently held as being edited.
+             */
+            IsEditing(params) {
+                const { entityId, menuItemId } = params;
+                const regos = this.rego[entityId];
+                if (!(regos === null || regos === void 0 ? void 0 : regos.length)) {
+                    return false;
+                }
+                for (let i = 0; i < regos.length; i++) {
+                    const rego = regos[i];
+                    if (menuItemId && rego.menuItemId !== menuItemId) {
+                        continue;
+                    }
+                    if (rego.editing) {
+                        return true;
+                    }
+                }
+                return false;
+            }
             /**
              * Marks visuals as being actively edited, which exempts them from culling until it is turned back off.
              */
@@ -8210,12 +8259,15 @@
                         if (menuItemId && rego.menuItemId !== menuItemId) {
                             continue;
                         }
-                        if (Boolean(rego.editing) == Boolean(editing)) {
+                        const wasEditing = Boolean(rego.editing);
+                        if (wasEditing == Boolean(editing) && 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 (wasEditing != Boolean(editing)) {
+                            changed = true;
+                        }
                         if (editing) {
                             const parts = exports.EntityUtils.GatherEntity({
                                 entity: rego.visual
@@ -8225,18 +8277,17 @@
                                 if (!(part instanceof Cesium.Entity)) {
                                     continue;
                                 }
-                                const removalPending = VisualRegisterCuller.CancelQueuedSceneChange(part);
-                                const wasCulled = part[VisualRegisterCuller.VISUAL_CULL_KEY] == true || removalPending;
-                                delete part[VisualRegisterCuller.VISUAL_CULL_KEY];
+                                const removalPending = exports.VisualRegisterCuller.CancelQueuedSceneChange(part);
+                                const wasCulled = part[exports.VisualRegisterCuller.VISUAL_CULL_KEY] == true || removalPending;
+                                delete part[exports.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);
-                            VisualRegisterCuller.MarkShouldRecheck(this.viewer);
+                            exports.VisualRegisterCuller.InvalidateBounds(rego.visual);
+                            exports.VisualRegisterCuller.MarkShouldRecheck(this.viewer);
                         }
                     }
                 }
@@ -8710,6 +8761,9 @@
                 // Tilesets will often add -> remove -> add because of how tiles load in and out of the scene.
                 // To avoid flickering, we'll just replace rather than remove -> add.
                 if (!rego.tilesetId && params.removePrior != false) {
+                    if (!rego.editing && this.IsEditing({ entityId: rego.entityId, menuItemId: rego.menuItemId })) {
+                        rego.editing = true;
+                    }
                     this.RemoveRegos({
                         entityId: rego.entityId,
                         menuItemId: rego.menuItemId,
@@ -34664,6 +34718,54 @@
             });
         }
         EntityUtils.GetPosAsync = GetPosAsync;
+        // Graphics that take a heightReference, and so get a cached terrain offset from Cesium.
+        const GROUND_REFERENCED_GRAPHICS = ["ellipse", "polygon", "corridor", "rectangle", "box", "cylinder", "ellipsoid"];
+        const HEIGHT_REFERENCE_KEYS = ["heightReference", "extrudedHeightReference"];
+        /**
+         * Makes a moved graphic sample the ground again at where it now is.
+         *
+         * Reassigning the height references touches an observed property, so the updater discards the stale offset
+         * and builds a new one against the current position.
+         * @returns whether anything was refreshed.
+         */
+        function RefreshGroundClamping(params) {
+            var _a, _b;
+            const { viewer, visual } = params;
+            if (!viewer || ((_a = viewer.isDestroyed) === null || _a === void 0 ? void 0 : _a.call(viewer)) || !(visual instanceof Cesium.Entity)) {
+                return false;
+            }
+            const parts = GatherEntity({ entity: visual });
+            let refreshed = false;
+            for (let i = 0; i < parts.length; i++) {
+                const part = parts[i];
+                if (!(part instanceof Cesium.Entity)) {
+                    continue;
+                }
+                for (let j = 0; j < GROUND_REFERENCED_GRAPHICS.length; j++) {
+                    const graphic = part[GROUND_REFERENCED_GRAPHICS[j]];
+                    if (!graphic) {
+                        continue;
+                    }
+                    for (let k = 0; k < HEIGHT_REFERENCE_KEYS.length; k++) {
+                        const key = HEIGHT_REFERENCE_KEYS[k];
+                        const current = GetValue$1(viewer, graphic[key]);
+                        // Nothing to resample for a graphic that does not follow the ground.
+                        if (current == null || current === Cesium.HeightReference.NONE) {
+                            continue;
+                        }
+                        // A new property instance rather than the same value written back, since an equal value would
+                        // be dropped as a no-op and the updater would never hear about it.
+                        graphic[key] = new Cesium.ConstantProperty(current);
+                        refreshed = true;
+                    }
+                }
+            }
+            if (refreshed) {
+                (_b = viewer.scene) === null || _b === void 0 ? void 0 : _b.requestRender();
+            }
+            return refreshed;
+        }
+        EntityUtils.RefreshGroundClamping = RefreshGroundClamping;
         /**
          * Returns entity and any associated parent/sibling entities as a flat array.
          * @param entity
@@ -34854,7 +34956,9 @@
                 viewer: params.viewer,
                 createIfMissing: true
             });
-            const location = await EntityUtils.GetLocation({
+            // A tileset-only fly-to has no entities to sample from, so there's nothing to resolve here.
+            // The tileset's own bounding sphere is used further down instead.
+            const location = (entityIds === null || entityIds === void 0 ? void 0 : entityIds.length) ? await EntityUtils.GetLocation({
                 samples: entityIds.map((id) => ({
                     entityId: id,
                     entity: entityLookup.get(id),
@@ -34865,7 +34969,7 @@
                 visualRegister: manager.VisualsRegister,
                 minimumAlt: params.minimumAlt,
                 api: manager.Getters.GetBruceApi()
-            });
+            }) : null;
             if (params.isCancelled && params.isCancelled()) {
                 return;
             }
@@ -36969,7 +37073,7 @@
                     model._radius = radius;
                     model._radiusLoaded = true;
                     if (params.viewer && params.viewer.scene && !params.viewer.isDestroyed()) {
-                        VisualRegisterCuller.MarkShouldRecheck(params.viewer);
+                        exports.VisualRegisterCuller.MarkShouldRecheck(params.viewer);
                     }
                 }
                 // Rough estimate on when the model is ready in the scene.
@@ -39574,8 +39678,9 @@
                 if (bandCheck) {
                     cEntity._bandCheck = bandCheck;
                 }
-                VisualRegisterCuller.InvalidateBounds(cEntity);
+                exports.VisualRegisterCuller.InvalidateBounds(cEntity);
             });
+            exports.VisualRegisterCuller.MarkShouldRecheck(params.viewer);
             return {
                 entities: cEntities,
                 updated
@@ -40341,7 +40446,7 @@
         StyleUtils.ApplyTypeStyle = ApplyTypeStyle;
     })(exports.StyleUtils || (exports.StyleUtils = {}));
 
-    const VERSION = "7.0.8";
+    const VERSION = "7.1.0";
     /**
      * 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.