bruce-cesium 7.0.9 → 7.1.0

package/dist/bruce-cesium.umd.js

@@ -6454,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++) {
@@ -6502,6 +6504,12 @@
                                 (!isIsolatedAny || state.isolated)) {
                                 toAdd.push(part);
                             }
+                            else if (part.show === false &&
+                                rego.overrideShow != false &&
+                                !state.hidden &&
+                                (!isIsolatedAny || state.isolated)) {
+                                toRefresh.add(entityId);
+                            }
                         }
                     }
                 }
@@ -6512,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;
@@ -6733,7 +6746,11 @@
                 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;
         }
@@ -34701,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
@@ -34891,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),
@@ -34902,7 +34969,7 @@
                 visualRegister: manager.VisualsRegister,
                 minimumAlt: params.minimumAlt,
                 api: manager.Getters.GetBruceApi()
-            });
+            }) : null;
             if (params.isCancelled && params.isCancelled()) {
                 return;
             }
@@ -40379,7 +40446,7 @@
         StyleUtils.ApplyTypeStyle = ApplyTypeStyle;
     })(exports.StyleUtils || (exports.StyleUtils = {}));
 
-    const VERSION = "7.0.9";
+    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.