bruce-cesium 7.5.1 → 7.5.3

package/dist/bruce-cesium.umd.js

@@ -3026,6 +3026,7 @@
     }
     let _selectColor = Cesium.Color.fromAlpha(Cesium.Color.YELLOW, 0.5);
     let _highlightColor = Cesium.Color.fromCssColorString("#33b1ff").withAlpha(0.5);
+    const DIMMING_REGISTERS_KEY = "_nextspaceDimmingRegisters";
     const STORE_COLOR_PREFIX = "_storeColor_";
     function getStoreKey(key) {
         return STORE_COLOR_PREFIX + key;
@@ -3182,6 +3183,10 @@
             getColor$1(viewer, "default", graphic);
         }
         let color = (_a = getColor$1(viewer, key, graphic)) !== null && _a !== void 0 ? _a : Cesium.Color.WHITE;
+        // A model that is itself dimmed stays see-through. Only the ones standing out from dimmed surroundings go opaque.
+        if (key != "default" && (opacity == null || opacity >= 1) && exports.CesiumEntityStyler.IsSelectionOpaque(viewer, graphic)) {
+            color = color.withAlpha(1);
+        }
         // If we're selecting and it's highlighted, don't change the color.
         if (key != "select" || getKeyState(graphic, "highlight") == false) {
             let animateMs = key == "highlight" ? ANIMATE_COLOR_HIGHLIGHT_MS : ANIMATE_COLOR_MS;
@@ -3352,6 +3357,50 @@
         return value == null ? false : value;
     }
     (function (CesiumEntityStyler) {
+        /**
+         * Whether a graphic or visual is a 3D model, ie: a tileset feature from a CAD or assembly import, or a model Entity.
+         * @param graphic
+         */
+        function IsModel(graphic) {
+            if (graphic instanceof Cesium.Entity) {
+                return Boolean(graphic.model);
+            }
+            return graphic instanceof Cesium.Cesium3DTileFeature || graphic instanceof Cesium.ModelGraphics;
+        }
+        CesiumEntityStyler.IsModel = IsModel;
+        /**
+         * Whether a graphic is drawn with an opaque selection and highlight because something on its viewer is dimmed.
+         * Only 3D models are. GIS graphics keep the colour's own alpha.
+         * @param viewer
+         * @param graphic
+         */
+        function IsSelectionOpaque(viewer, graphic) {
+            var _a;
+            return Boolean((_a = viewer === null || viewer === void 0 ? void 0 : viewer[DIMMING_REGISTERS_KEY]) === null || _a === void 0 ? void 0 : _a.size) && IsModel(graphic);
+        }
+        CesiumEntityStyler.IsSelectionOpaque = IsSelectionOpaque;
+        /**
+         * Records whether a register dims anything on a viewer, by isolation or by opacity.
+         * @param viewer
+         * @param registerId
+         * @param dimming
+         * @returns Whether the viewer went into or out of dimming, so selected models can be recoloured.
+         */
+        function SetDimming(viewer, registerId, dimming) {
+            let ids = viewer[DIMMING_REGISTERS_KEY];
+            const before = Boolean(ids === null || ids === void 0 ? void 0 : ids.size);
+            if (dimming) {
+                if (!ids) {
+                    ids = viewer[DIMMING_REGISTERS_KEY] = new Set();
+                }
+                ids.add(registerId);
+            }
+            else {
+                ids === null || ids === void 0 ? void 0 : ids.delete(registerId);
+            }
+            return before !== Boolean(ids === null || ids === void 0 ? void 0 : ids.size);
+        }
+        CesiumEntityStyler.SetDimming = SetDimming;
         function UpdateColorSetting(key, color) {
             if (key == "highlight") {
                 _highlightColor = color.clone();
@@ -9836,6 +9885,8 @@
                 // Caches GetIsIsolatedAny(). `null` means "unknown, recompute".
                 // Invalidated on any write that could affect isolation.
                 this.isolatedAnyCache = null;
+                // Set when isolation or opacity changes, so the next update checks whether anything is still dimmed.
+                this.dimmingDirty = false;
                 // Caches GetIsolationOpacity(). `undefined` means "unknown, recompute", `null` means
                 // "isolation (if any) is the legacy boolean/full-hide kind, not a numeric dim".
                 // Invalidated alongside isolatedAnyCache.
@@ -10104,6 +10155,7 @@
                             this.updateQueueInterval = null;
                             return;
                         }
+                        this.syncDimming();
                         const batch = this.updateQueue.splice(0, BATCH_SIZE);
                         const cache = {};
                         for (let i = 0; i < batch.length; i++) {
@@ -10338,6 +10390,9 @@
                     this.isolatedAnyCache = null;
                     this.isolationOpacityCache = undefined;
                 }
+                if (keys.includes("isolated") || keys.includes("opacity")) {
+                    this.dimmingDirty = true;
+                }
                 let changed = false;
                 const eStates = this.states[entityId] || {};
                 this.states[entityId] = eStates;
@@ -10769,8 +10824,36 @@
                 const { rego } = params;
                 markEntity(this, rego, rego.visual, false);
             }
+            /**
+             * Tells the styler whether this register dims anything, by isolation or opacity.
+             */
+            syncDimming() {
+                var _a, _b;
+                if (!this.dimmingDirty) {
+                    return;
+                }
+                this.dimmingDirty = false;
+                const dimming = Object.values(this.states).some(states => Object.values(states).some(state => state.isolated || (state.opacity != null && state.opacity < 1)));
+                if (!exports.CesiumEntityStyler.SetDimming(this.viewer, this.id, dimming)) {
+                    return;
+                }
+                const entityIds = new Set([...this.GetSelected(), ...this.GetHighlighted()]);
+                for (const entityId of entityIds) {
+                    for (const rego of (_a = this.rego[entityId]) !== null && _a !== void 0 ? _a : []) {
+                        if (exports.CesiumEntityStyler.IsModel(rego.visual)) {
+                            exports.CesiumEntityStyler.Refresh({
+                                viewer: this.viewer,
+                                entity: rego.visual,
+                                requestRender: false
+                            });
+                        }
+                    }
+                }
+                (_b = this.viewer.scene) === null || _b === void 0 ? void 0 : _b.requestRender();
+            }
             Dispose() {
                 var _a, _b, _c, _d, _e;
+                exports.CesiumEntityStyler.SetDimming(this.viewer, this.id, false);
                 this.ClearLabelHover();
                 clearTimeout(this.hoverRingReset);
                 this.hoverRingState = {};
@@ -11397,6 +11480,7 @@
                     // Mutated `isolated` directly rather than through setStateValues().
                     this.isolatedAnyCache = false;
                     this.isolationOpacityCache = null;
+                    this.dimmingDirty = true;
                 }
                 if (changed && (params === null || params === void 0 ? void 0 : params.doUpdate) !== false) {
                     this.updateAllEntities({
@@ -12133,6 +12217,7 @@
                 }
             }
             async updateAllEntities(params) {
+                this.syncDimming();
                 const ids = Object.keys(this.rego);
                 const interval = setInterval(() => {
                     const batch = ids.splice(0, 3000);
@@ -12227,6 +12312,7 @@
                 const clearedIds = new Set();
                 this.ForEachState((state) => {
                     if (!clearedIds.has(state.entityId) && state.opacity != null) {
+                        this.dimmingDirty = true;
                         this.markLazyExclusion(state.entityId);
                         this.queueUpdate({
                             entityId: state.entityId,
@@ -18293,8 +18379,6 @@
                 console.error(e);
             }
             // Before we start the loop we'll do a single request for the needed Entity Types.
-            // This will be aimed at rows that don't specify a Style and if the default fallback-
-            //is set to 0 (using the default of the Entity Type).
             const typeMap = new Map();
             const typeIds = styleMapping.map(x => x.StyleID == -1 || Boolean(x.style) ? null : x.EntityTypeID).filter(x => !!x);
             if (typeIds.length) {
@@ -18360,23 +18444,7 @@
                 }
                 this.styleMappingsLoaded.set(styleMap.EntityTypeID, true);
                 if (this.loaded) {
-                    // If we have a bunch of Entities that were waiting for the style to load,
-                    // then we can pass them to the gatherer now.
-                    const relatedIds = this.stylePendingEntityIds.get(styleMap.EntityTypeID);
-                    if (relatedIds) {
-                        if (this.getTilesetFeatureNeedsFullData(styleMap.EntityTypeID)) {
-                            this.entityGatherer.Queue(Array.from(relatedIds));
-                        }
-                        else {
-                            relatedIds.forEach(id => {
-                                const rego = this.getEntityRego(id);
-                                if (rego) {
-                                    this.styleTilesetFeature(rego);
-                                }
-                            });
-                        }
-                        this.stylePendingEntityIds.delete(styleMap.EntityTypeID);
-                    }
+                    this.flushPendingForType(styleMap.EntityTypeID);
                 }
             }
             if (this.loadingCounter != counter) {
@@ -18408,6 +18476,67 @@
                 this.stylePendingEntityIds.clear();
             }
         }
+        /**
+         * Passes the Entities waiting on an Entity Type's style on to be styled, now that the style is known.
+         * @param entityTypeId
+         */
+        flushPendingForType(entityTypeId) {
+            const relatedIds = this.stylePendingEntityIds.get(entityTypeId);
+            if (!relatedIds) {
+                return;
+            }
+            if (this.getTilesetFeatureNeedsFullData(entityTypeId)) {
+                this.entityGatherer.Queue(Array.from(relatedIds));
+            }
+            else {
+                relatedIds.forEach(id => {
+                    const rego = this.getEntityRego(id);
+                    if (rego) {
+                        this.styleTilesetFeature(rego);
+                    }
+                });
+            }
+            this.stylePendingEntityIds.delete(entityTypeId);
+        }
+        hasMappingRow(entityTypeId) {
+            var _a;
+            return Boolean((_a = this.styleMapping) === null || _a === void 0 ? void 0 : _a.some(x => x.EntityTypeID == entityTypeId));
+        }
+        /**
+         * Loads the default style of an Entity Type that the style mapping does not list.
+         * @param entityTypeId
+         */
+        async loadEntityTypeDefaultStyle(entityTypeId) {
+            const counter = this.loadingCounter;
+            const styleMap = { EntityTypeID: entityTypeId, StyleID: 0, style: null };
+            this.styleMapping.push(styleMap);
+            try {
+                const { entityType } = await BModels.EntityType.Get({
+                    api: this.api,
+                    entityTypeId
+                });
+                const styleId = entityType === null || entityType === void 0 ? void 0 : entityType["DisplaySetting.ID"];
+                if (styleId && styleId != -1) {
+                    const { style } = await BModels.Style.Get({
+                        api: this.api,
+                        styleId
+                    });
+                    if (style) {
+                        styleMap.style = style;
+                        styleMap.StyleID = styleId;
+                    }
+                }
+            }
+            catch (e) {
+                console.error(e);
+            }
+            // A reload in the meantime resolves the row itself, or replaces the mapping and re-queues everything.
+            if (this.disposed || this.loadingCounter != counter) {
+                return;
+            }
+            this.styleMappingsLoaded.set(entityTypeId, true);
+            this.flushPendingForType(entityTypeId);
+        }
         disposeGatherer() {
             if (this.feedRestyleThrottleTimer) {
                 clearTimeout(this.feedRestyleThrottleTimer);
@@ -18446,7 +18575,11 @@
                     this.overrideFeatureColor.set(rego.entityId, false);
                 }
                 const typeId = rego.entityTypeId || "";
-                if (this.styleMappingLoaded || this.styleMappingsLoaded.get(typeId)) {
+                // With no fallback style to use instead, a type the mapping does not list falls back to its own default.
+                if (this.styleMappingLoaded && typeId && !this.fallbackStyle && !this.hasMappingRow(typeId)) {
+                    this.loadEntityTypeDefaultStyle(typeId);
+                }
+                if (this.styleMappingsLoaded.get(typeId) || (this.styleMappingLoaded && !this.hasMappingRow(typeId))) {
                     if (this.getTilesetFeatureNeedsFullData(typeId)) {
                         needsDataIds.push(rego.entityId);
                     }
@@ -40491,6 +40624,47 @@
         }
         return Cesium.Matrix4.multiplyByPoint(enuFrame, new Cesium.Cartesian3(tx, ty, tz), new Cesium.Cartesian3());
     }
+    // Records created within about this long ago are the ones the oversized GeometryRadius bug could have written.
+    const GEOMETRY_RADIUS_SUSPECT_AGE_MS = 1000 * 60 * 60 * 24 * 183;
+    // Above this a recent record's radius is treated as that bug rather than a real size.
+    const GEOMETRY_RADIUS_SUSPECT_ABOVE = 500;
+    /**
+     * Returns an entity's Bruce.GeometryRadius, or null when there is none or it looks like the oversized-radius bug.
+     * The size cap only applies to records created recently; older ones and ones with no known date are taken as they are.
+     * @param entity
+     */
+    function getTrustedGeometryRadius(entity) {
+        var _a;
+        const radius = EnsureNumber(BModels.Entity.GetValue({
+            entity: entity,
+            path: ["Bruce", "GeometryRadius"]
+        }));
+        if (!(radius > 0)) {
+            return null;
+        }
+        const created = Date.parse((_a = entity === null || entity === void 0 ? void 0 : entity.Bruce) === null || _a === void 0 ? void 0 : _a.Created);
+        const recent = !isNaN(created) && Date.now() - created < GEOMETRY_RADIUS_SUSPECT_AGE_MS;
+        if (recent && radius >= GEOMETRY_RADIUS_SUSPECT_ABOVE) {
+            return null;
+        }
+        return radius;
+    }
+    /**
+     * Returns the world centre of a model's own bounds, applying the entity's orientation to the offset.
+     * The position is the one GetLocation already resolved, so height references are honoured.
+     * @param viewer
+     * @param part
+     * @param pos3d
+     * @param bounds
+     */
+    function getModelBoundsCenter(viewer, part, pos3d, bounds) {
+        const orientation = GetValue$1(viewer, part.orientation);
+        const rotation = orientation
+            ? Cesium.Matrix3.fromQuaternion(orientation, new Cesium.Matrix3())
+            : Cesium.Matrix4.getMatrix3(Cesium.Transforms.eastNorthUpToFixedFrame(pos3d), new Cesium.Matrix3());
+        const offset = Cesium.Matrix3.multiplyByVector(rotation, bounds.center, new Cesium.Cartesian3());
+        return Cesium.Cartesian3.add(pos3d, offset, new Cesium.Cartesian3());
+    }
     // +90° rotation around Z: aligns GLTF Y-up forward with Cesium ENU North.
     const _assemblyAxisShift = new Cesium.Quaternion(0, 0, -Math.SQRT1_2, Math.SQRT1_2);
     (function (EntityUtils) {
@@ -40541,6 +40715,9 @@
                 rectangle: null,
                 sphere: null
             };
+            const spheres = [];
+            // The tile holding a rendered feature that says nothing of where it is, used only when nothing better turns up.
+            const tileSpheres = [];
             const processPosHeight = async (pos3d, heightRef) => {
                 // Raise to minimumAlt if needed.
                 if ((!isNaN(minimumAlt) && minimumAlt != null)) {
@@ -40618,7 +40795,7 @@
                  * Returns an array of positions from the entity's currently rendered graphics.
                  */
                 const evaluateRendered = async () => {
-                    var _a, _b;
+                    var _a, _b, _c, _d;
                     const rego = visualRegister ? visualRegister.GetRego({
                         entityId: sample.entityId,
                         menuItemId: sample.menuItemId
@@ -40750,9 +40927,14 @@
                                     posses.push(pos3d);
                                     if (part.model) {
                                         const modelExt = part.model;
-                                        if (modelExt._radius && modelExt._radius > -1) {
+                                        const bounds = modelExt._bounds;
+                                        if ((bounds === null || bounds === void 0 ? void 0 : bounds.radius) > 0) {
+                                            spheres.push(new Cesium.BoundingSphere(getModelBoundsCenter(viewer, part, pos3d, bounds), bounds.radius));
+                                        }
+                                        else if (modelExt._radius && modelExt._radius > -1) {
                                             const sphere = Cesium.BoundingSphere.fromPoints([pos3d]);
                                             sphere.radius = modelExt._radius;
+                                            spheres.push(sphere);
                                         }
                                     }
                                     else if (part.ellipse) {
@@ -40771,6 +40953,7 @@
                                         const radius = Math.max(semiMajorAxis, semiMinorAxis, height);
                                         if (radius && radius > 0) {
                                             const sphere = new Cesium.BoundingSphere(pos3d, radius);
+                                            spheres.push(sphere);
                                         }
                                     }
                                 }
@@ -40789,6 +40972,14 @@
                                 posses.push(pos3d);
                                 if (data.radius != null && !isNaN(data.radius)) {
                                     const sphere = new Cesium.BoundingSphere(pos3d, data.radius);
+                                    spheres.push(sphere);
+                                }
+                            }
+                            else {
+                                // Missing from the typings this library builds against, but there at runtime.
+                                const tileSphere = (_d = (_c = part.content) === null || _c === void 0 ? void 0 : _c.tile) === null || _d === void 0 ? void 0 : _d.boundingSphere;
+                                if ((tileSphere === null || tileSphere === void 0 ? void 0 : tileSphere.radius) > 0) {
+                                    tileSpheres.push(Cesium.BoundingSphere.clone(tileSphere));
                                 }
                             }
                         }
@@ -40868,7 +41059,7 @@
                     }
                     const boundaries = BModels.Entity.GetValue({
                         entity: entity,
-                        path: ["Bruce, Boundaries"]
+                        path: ["Bruce", "Boundaries"]
                     });
                     if (boundaries && typeof boundaries == "object") {
                         const point = {
@@ -40921,16 +41112,9 @@
                                     const transformedOffset = Cesium.Matrix3.multiplyByVector(transformHpr, offset, new Cesium.Cartesian3());
                                     pos3d = Cesium.Matrix4.multiplyByPoint(m1, transformedOffset, new Cesium.Cartesian3());
                                     pos3d = await processPosHeight(pos3d, Cesium.HeightReference.NONE);
-                                    const geometryRadius = BModels.Entity.GetValue({
-                                        entity: entity,
-                                        path: ["Bruce", "GeometryRadius"]
-                                    });
+                                    const geometryRadius = getTrustedGeometryRadius(entity);
                                     if (geometryRadius && (pos3d === null || pos3d === void 0 ? void 0 : pos3d.x)) {
-                                        const sphere = Cesium.BoundingSphere.fromPoints([pos3d]);
-                                        // For now making sure it's less than x amount because we had a bug which made it huge.
-                                        if (geometryRadius && geometryRadius < 500 && geometryRadius > 0.1) {
-                                            sphere.radius = geometryRadius;
-                                        }
+                                        spheres.push(new Cesium.BoundingSphere(pos3d, geometryRadius));
                                     }
                                     return [pos3d];
                                 }
@@ -40938,16 +41122,9 @@
                                     if (location) {
                                         let pos3d = Cesium.Cartesian3.fromDegrees(longitude, latitude, EnsureNumber(location.altitude));
                                         pos3d = await processPosHeight(pos3d, Cesium.HeightReference.NONE);
-                                        const geometryRadius = BModels.Entity.GetValue({
-                                            entity: entity,
-                                            path: ["Bruce", "GeometryRadius"]
-                                        });
+                                        const geometryRadius = getTrustedGeometryRadius(entity);
                                         if (geometryRadius && (pos3d === null || pos3d === void 0 ? void 0 : pos3d.x)) {
-                                            const sphere = Cesium.BoundingSphere.fromPoints([pos3d]);
-                                            // For now making sure it's less than x amount because we had a bug which made it huge.
-                                            if (geometryRadius && geometryRadius < 500 && geometryRadius > 0.1) {
-                                                sphere.radius = geometryRadius;
-                                            }
+                                            spheres.push(new Cesium.BoundingSphere(pos3d, geometryRadius));
                                         }
                                         return [pos3d];
                                     }
@@ -40970,16 +41147,9 @@
                     }
                     if (pos3d) {
                         pos3d = await processPosHeight(pos3d, Cesium.HeightReference.NONE);
-                        const geometryRadius = BModels.Entity.GetValue({
-                            entity: entity,
-                            path: ["Bruce", "GeometryRadius"]
-                        });
+                        const geometryRadius = getTrustedGeometryRadius(entity);
                         if (geometryRadius && (pos3d === null || pos3d === void 0 ? void 0 : pos3d.x)) {
-                            const sphere = Cesium.BoundingSphere.fromPoints([pos3d]);
-                            // For now making sure it's less than x amount because we had a bug which made it huge.
-                            if (geometryRadius && geometryRadius < 500 && geometryRadius > 0.1) {
-                                sphere.radius = geometryRadius;
-                            }
+                            spheres.push(new Cesium.BoundingSphere(pos3d, geometryRadius));
                         }
                         return [pos3d];
                     }
@@ -40999,16 +41169,9 @@
                                 if (pos3d === null || pos3d === void 0 ? void 0 : pos3d.x) {
                                     pos3d = await processPosHeight(pos3d, Cesium.HeightReference.NONE);
                                 }
-                                const geometryRadius = BModels.Entity.GetValue({
-                                    entity: entity,
-                                    path: ["Bruce", "GeometryRadius"]
-                                });
+                                const geometryRadius = getTrustedGeometryRadius(entity);
                                 if (geometryRadius && (pos3d === null || pos3d === void 0 ? void 0 : pos3d.x)) {
-                                    const sphere = Cesium.BoundingSphere.fromPoints([pos3d]);
-                                    // For now making sure it's less than x amount because we had a bug which made it huge.
-                                    if (geometryRadius && geometryRadius < 500 && geometryRadius > 0.1) {
-                                        sphere.radius = geometryRadius;
-                                    }
+                                    spheres.push(new Cesium.BoundingSphere(pos3d, geometryRadius));
                                 }
                             }
                         }
@@ -41243,6 +41406,7 @@
                         radius /= 2;
                     }
                     const sphere = new Cesium.BoundingSphere(data.pos3d, radius);
+                    spheres.push(sphere);
                     data.sphere = sphere;
                 }
                 else {
@@ -41252,23 +41416,24 @@
             else if (allPosses.length == 1) {
                 data.pos3d = allPosses[0];
             }
-            /*
-            Was used to clean up bad radius data but now seems to do more harm than good.
-            TODO: re-review edge cases.
-            if ((data.rectangle && spheres.length > 1) || (!data.rectangle && spheres.length > 0)) {
-                const allPointSphere = Cesium.BoundingSphere.fromPoints(allPosses);
-                spheres.push(allPointSphere);
-                if (data.rectangle) {
-                    const rectSphere = Cesium.BoundingSphere.fromRectangle3D(data.rectangle);
-                    spheres.push(rectSphere);
-                }
-                const combinedSphere = Cesium.BoundingSphere.fromBoundingSpheres(spheres);
-                data.sphere = combinedSphere;
+            // The entities' own sizes, so a large piece is framed whole and a small one is not left far away.
+            // The rectangle sphere above only spans the sampled points, which for one entity is its pivot alone.
+            const sizeSpheres = spheres.filter(x => x !== data.sphere && x.radius > 0);
+            if (sizeSpheres.length) {
+                data.sphere = Cesium.BoundingSphere.fromBoundingSpheres(data.sphere ? [data.sphere, ...sizeSpheres] : sizeSpheres);
+                if (allPosses.length <= 1) {
+                    data.pos3d = data.sphere.center;
+                }
             }
-            */
             if (data.sphere && data.sphere.radius <= 0) {
                 data.sphere = null;
             }
+            // An Assembly part's record can come back without a location while the API has yet to resolve its model's
+            // bounds, and its feature carries no position of its own. The tile it is drawn in still says roughly where.
+            if (!data.pos3d && tileSpheres.length) {
+                data.sphere = Cesium.BoundingSphere.fromBoundingSpheres(tileSpheres);
+                data.pos3d = data.sphere.center;
+            }
             return data;
         }
         EntityUtils.GetLocation = GetLocation;
@@ -43827,6 +43992,10 @@
                             }
                             let radius = modelPrim.boundingSphere.radius;
                             let centerOffset = modelPrim.boundingSphere.center;
+                            const bounds = {
+                                center: centerOffset ? Cesium.Cartesian3.clone(centerOffset) : Cesium.Cartesian3.ZERO.clone(),
+                                radius: modelPrim.boundingSphere.radius
+                            };
                             if (centerOffset) {
                                 // Add the center offset to the radius because I am not good at math.
                                 const magnitude = Cesium.Cartesian3.magnitude(centerOffset);
@@ -43838,7 +44007,7 @@
                                 }
                             }
                             kill();
-                            res(radius);
+                            res({ radius, bounds });
                         };
                         let readyEventRemoval = null;
                         // Newer Cesium versions have readyEvent. They don't use readyPromise.
@@ -43863,9 +44032,10 @@
                 });
                 _fileRadiusCache.Set(fileRadiusKey, heightProm);
             }
-            heightProm.then((radius) => {
+            heightProm.then((measured) => {
                 if (model) {
-                    model._radius = radius;
+                    model._radius = measured ? measured.radius : null;
+                    model._bounds = measured ? measured.bounds : null;
                     model._radiusLoaded = true;
                     if (params.viewer && params.viewer.scene && !params.viewer.isDestroyed()) {
                         exports.VisualRegisterCuller.MarkShouldRecheck(params.viewer);
@@ -48088,11 +48258,32 @@ void main() {
         }
     })(exports.DisplacedSurfacePrimitive || (exports.DisplacedSurfacePrimitive = {}));
 
+    // Vertex heights within this many metres of zero count as no height at all.
+    const FLAT_HEIGHT_EPSILON = 1e-3;
     const TEXTURE_FRAME_SERIES_ANIMATOR_KEY = "TextureFrameSeriesAnimator.Animator";
     const EXTRUSION_ANIMATOR_KEY = "TextureFrameSeriesAnimator.ExtrusionAnimator";
     const TEXTURE_VALUE_LABELS_KEY = "TextureValueLabels.Overlay";
     const DISPLACED_SURFACE_KEY = "DisplacedSurfacePrimitive.Surface";
     (function (EntityRenderEnginePolygon) {
+        /**
+         * The height reference a polygon is actually drawn with.
+         * @param params
+         */
+        function FlatHeightRef(params) {
+            const { heightRef, extruded, textured, altitudes } = params;
+            if (extruded || heightRef === Cesium.HeightReference.CLAMP_TO_GROUND) {
+                return heightRef;
+            }
+            const hasHeights = altitudes.some((altitude) => Math.abs(EnsureNumber(altitude)) > FLAT_HEIGHT_EPSILON);
+            if (hasHeights) {
+                return heightRef;
+            }
+            if (heightRef === Cesium.HeightReference.RELATIVE_TO_GROUND || textured) {
+                return Cesium.HeightReference.CLAMP_TO_GROUND;
+            }
+            return heightRef;
+        }
+        EntityRenderEnginePolygon.FlatHeightRef = FlatHeightRef;
         async function Render(params) {
             var _a, _b, _c, _d, _e;
             const entity = params.entity;
@@ -48193,6 +48384,14 @@ void main() {
                 ? { posses, value: undefined, exHeightRef: Cesium.HeightReference.NONE }
                 : getPolygonExtrusion(entity, params.tags, outerRing, posses, heightRef, style);
             posses = extrusion.posses;
+            heightRef = FlatHeightRef({
+                heightRef,
+                extruded: drawsDisplacedSurface || extrusion.value != undefined,
+                textured: fillType === BModels.Style.EPolygonFillType.Texture,
+                altitudes: pRings.flatMap((ring) => (ring === null || ring === void 0 ? void 0 : ring.LinearRing)
+                    ? BModels.Geometry.ParsePoints(ring.LinearRing).map((point) => point.altitude)
+                    : [])
+            });
             posses = CullDuplicateCPosses(posses);
             if (posses.length < 4) {
                 return null;
@@ -48232,6 +48431,14 @@ void main() {
                 }
             };
             const hasOutline = width > 0 && cLineColor;
+            // Cesium draws nothing for a ground polygon with an image material once it carries a distance display condition.
+            const drapesImage = (!drawsDisplacedSurface &&
+                heightRef === Cesium.HeightReference.CLAMP_TO_GROUND &&
+                extrusion.value == undefined &&
+                (fillMaterial instanceof Cesium.ImageMaterialProperty || Boolean(frameArchive || keepsAnimator)));
+            const polygonDisplayCondition = drapesImage
+                ? undefined
+                : exports.EntityRenderEngine.GetDisplayCondition(params.minDistance, params.maxDistance, width <= 0 || !cLineColor || units == "m" ? size : null, true, size);
             let cEntity = null;
             const isExistingGraphic = Boolean(params.rendered && params.rendered.polygon);
             if (!isExistingGraphic) {
@@ -48248,7 +48455,7 @@ void main() {
                         classificationType: classification,
                         perPositionHeight: heightRef == Cesium.HeightReference.CLAMP_TO_GROUND ? false : true,
                         zIndex: zIndex,
-                        distanceDisplayCondition: exports.EntityRenderEngine.GetDisplayCondition(params.minDistance, params.maxDistance, width <= 0 || !cLineColor || units == "m" ? size : null, true, size)
+                        distanceDisplayCondition: polygonDisplayCondition
                     },
                     position: exports.EntityUtils.GetPos({
                         viewer: params.viewer,
@@ -48308,12 +48515,17 @@ void main() {
                 if (oldZIndex != zIndex) {
                     cEntity.polygon.zIndex = new Cesium.ConstantProperty(zIndex);
                 }
-                SetCPropIfChanged({
-                    viewer: params.viewer,
-                    graphic: cEntity.polygon,
-                    property: "distanceDisplayCondition",
-                    value: exports.EntityRenderEngine.GetDisplayCondition(params.minDistance, params.maxDistance, width <= 0 || !cLineColor || units == "m" ? size : null, true, size)
-                });
+                if (polygonDisplayCondition) {
+                    SetCPropIfChanged({
+                        viewer: params.viewer,
+                        graphic: cEntity.polygon,
+                        property: "distanceDisplayCondition",
+                        value: polygonDisplayCondition
+                    });
+                }
+                else if (cEntity.polygon.distanceDisplayCondition) {
+                    cEntity.polygon.distanceDisplayCondition = undefined;
+                }
                 SetCPropIfChanged({
                     viewer: params.viewer,
                     graphic: cEntity.polygon,
@@ -49607,9 +49819,6 @@ void main() {
         StyleEffective.Combine = Combine;
         /**
          * Returns true if every segment in the filter string appears in the subject effective string.
-         * A filter segment matches if the subject contains a segment starting with the same key,
-         * and either no value filter is given or the value matches exactly.
-         * Passing a partial effective value (e.g. just "f0:gradient") also matches.
          */
         function MatchesFilter(effective, filter) {
             if (!filter) {
@@ -50874,7 +51083,7 @@ void main() {
         StyleUtils.ApplyTypeStyle = ApplyTypeStyle;
     })(exports.StyleUtils || (exports.StyleUtils = {}));
 
-    const VERSION = "7.5.1";
+    const VERSION = "7.5.3";
     /**
      * 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.