bruce-cesium 7.5.2 → 7.5.4

package/dist/bruce-cesium.es5.js

@@ -1,6 +1,6 @@
 import * as Cesium from 'cesium';
-import { Cartographic, ColorMaterialProperty, Entity, Color, ConstantProperty, CallbackProperty, Primitive, Cesium3DTileFeature, ConstantPositionProperty, HeightReference, DistanceDisplayCondition, HorizontalOrigin, VerticalOrigin, Cartesian3, ClassificationType, Math as Math$1, JulianDate, Quaternion, Transforms, HeadingPitchRoll, Matrix4, ArcType, CornerType, ShadowMode, ColorBlendMode, Model, ImageMaterialProperty, Ellipsoid, Cartesian2, SceneTransforms, ShaderSource, Geometry, GeometryAttribute, ComponentDatatype, PrimitiveType, BoundingSphere, GeometryPipeline, Cartesian4, sampleTerrain, Texture, PixelFormat, Sampler, TextureWrap, TextureMinificationFilter, TextureMagnificationFilter, VertexArray, BufferUsage, ShaderProgram, RenderState, BlendingState, DrawCommand, Pass, PolygonHierarchy, PolylineGraphics, Rectangle, FeatureDetection, SceneMode, NearFarScalar, KmlDataSource, Matrix3, GeoJsonDataSource, Cesium3DTileStyle, HeadingPitchRange, Ion, IonResource, Cesium3DTileColorBlendMode, EllipsoidTerrainProvider, IonImageryProvider, createWorldImagery, createWorldImageryAsync, BingMapsImageryProvider, BingMapsStyle, MapboxImageryProvider, MapboxStyleImageryProvider, ArcGisMapServerImageryProvider, OpenStreetMapImageryProvider, UrlTemplateImageryProvider, GridImageryProvider, GeographicTilingScheme, ImageryLayer, TileMapServiceImageryProvider, CesiumTerrainProvider, Cesium3DTileset, Intersect, OrthographicFrustum, EasingFunction, PolygonPipeline, ModelGraphics, PolygonGraphics, CorridorGraphics, PointGraphics, BillboardGraphics, EllipseGraphics, PolylineDashMaterialProperty, CesiumInspector, defined, ClockRange, DynamicEnvironmentMapManager, GeometryInstance, EllipsoidGeodesic, sampleTerrainMostDetailed, CustomDataSource, ScreenSpaceEventHandler, ScreenSpaceEventType, Fullscreen, CzmlDataSource } from 'cesium';
-import { Cartes, LRUCache, ProjectViewTile, ENVIRONMENT, Api, Calculator, ClientFile, Entity as Entity$1, EntityTag, EntityType, ObjectUtils, Style, Carto, Geometry as Geometry$1, EntityLod, ClientFileValueMap, Color as Color$1, MenuItem, ProjectView, ProjectViewBookmark, Tileset, ZoomControl, Bounds, BruceEvent, EntityCoords, DataLab, DelayQueue, BruceApi, EntityRelation, AccountConcept, RecordChangeFeed, EntitySource, ProgramKey, ProjectViewLegacyTile, Camera, Account, AccountLimits, Session, UrlUtils, ProjectViewBookmarkGroup, EntityAttachment, EntityAttachmentType, EntityAttribute, MathUtils, EntityRelationType, EntityHistoricData } from 'bruce-models';
+import { Cartographic, ColorMaterialProperty, Entity, Color, ConstantProperty, CallbackProperty, Primitive, Cesium3DTileFeature, HeightReference, ColorBlendMode, HeadingPitchRoll, Math as Math$1, Transforms, ShadowMode, Cartesian3, ClassificationType, Model, ShaderSource, Ellipsoid, Matrix4, Geometry, GeometryAttribute, ComponentDatatype, PrimitiveType, BoundingSphere, GeometryPipeline, Cartesian2, Cartesian4, sampleTerrain, Texture, PixelFormat, Sampler, TextureWrap, TextureMinificationFilter, TextureMagnificationFilter, VertexArray, BufferUsage, ShaderProgram, RenderState, BlendingState, DrawCommand, Pass, JulianDate, Quaternion, ArcType, CornerType, ConstantPositionProperty, DistanceDisplayCondition, HorizontalOrigin, VerticalOrigin, ImageMaterialProperty, PolygonHierarchy, PolylineGraphics, Rectangle, SceneTransforms, NearFarScalar, Matrix3, KmlDataSource, FeatureDetection, SceneMode, GeoJsonDataSource, Cesium3DTileStyle, HeadingPitchRange, Cesium3DTileColorBlendMode, Ion, IonResource, Cesium3DTileset, OrthographicFrustum, EasingFunction, EllipsoidTerrainProvider, IonImageryProvider, createWorldImagery, createWorldImageryAsync, BingMapsImageryProvider, BingMapsStyle, MapboxImageryProvider, MapboxStyleImageryProvider, ArcGisMapServerImageryProvider, OpenStreetMapImageryProvider, UrlTemplateImageryProvider, GridImageryProvider, GeographicTilingScheme, ImageryLayer, TileMapServiceImageryProvider, CesiumTerrainProvider, Intersect, ModelGraphics, PolygonGraphics, CorridorGraphics, PointGraphics, BillboardGraphics, EllipseGraphics, PolylineDashMaterialProperty, PolygonPipeline, EllipsoidGeodesic, sampleTerrainMostDetailed, defined, CustomDataSource, CesiumInspector, ClockRange, DynamicEnvironmentMapManager, ScreenSpaceEventHandler, ScreenSpaceEventType, GeometryInstance, Fullscreen, CzmlDataSource } from 'cesium';
+import { Cartes, LRUCache, ProjectViewTile, ENVIRONMENT, Calculator, ClientFile, Entity as Entity$1, EntityLod, EntityTag, EntityType, ObjectUtils, Style, Carto, Geometry as Geometry$1, Api, ClientFileValueMap, Color as Color$1, BruceEvent, EntityCoords, MenuItem, Tileset, ProjectView, ProjectViewBookmark, ZoomControl, Bounds, DataLab, DelayQueue, AccountConcept, BruceApi, EntityRelation, RecordChangeFeed, EntitySource, Camera, ProgramKey, ProjectViewLegacyTile, Account, AccountLimits, Session, UrlUtils, EntityAttachment, EntityAttachmentType, EntityAttribute, MathUtils, ProjectViewBookmarkGroup, EntityRelationType, EntityHistoricData } from 'bruce-models';
 
 /**
  * Ensures a number is returned from a given value.
@@ -3028,6 +3028,7 @@ function isAlive(viewer, visual) {
 }
 let _selectColor = Color.fromAlpha(Color.YELLOW, 0.5);
 let _highlightColor = Color.fromCssColorString("#33b1ff").withAlpha(0.5);
+const DIMMING_REGISTERS_KEY = "_nextspaceDimmingRegisters";
 const STORE_COLOR_PREFIX = "_storeColor_";
 function getStoreKey(key) {
     return STORE_COLOR_PREFIX + key;
@@ -3184,6 +3185,10 @@ function refreshColor(viewer, graphic, opacity) {
         getColor$1(viewer, "default", graphic);
     }
     let color = (_a = getColor$1(viewer, key, graphic)) !== null && _a !== void 0 ? _a : 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) && 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;
@@ -3359,6 +3364,50 @@ function getKeyState(graphic, key) {
  */
 var CesiumEntityStyler;
 (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 Entity) {
+            return Boolean(graphic.model);
+        }
+        return graphic instanceof Cesium3DTileFeature || graphic instanceof 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();
@@ -9858,6 +9907,8 @@ var VisualsRegister;
             // 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.
@@ -10126,6 +10177,7 @@ var VisualsRegister;
                         this.updateQueueInterval = null;
                         return;
                     }
+                    this.syncDimming();
                     const batch = this.updateQueue.splice(0, BATCH_SIZE);
                     const cache = {};
                     for (let i = 0; i < batch.length; i++) {
@@ -10360,6 +10412,9 @@ var VisualsRegister;
                 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;
@@ -10791,8 +10846,36 @@ var VisualsRegister;
             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 (!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 (CesiumEntityStyler.IsModel(rego.visual)) {
+                        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;
+            CesiumEntityStyler.SetDimming(this.viewer, this.id, false);
             this.ClearLabelHover();
             clearTimeout(this.hoverRingReset);
             this.hoverRingState = {};
@@ -11419,6 +11502,7 @@ var VisualsRegister;
                 // 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({
@@ -12155,6 +12239,7 @@ var VisualsRegister;
             }
         }
         async updateAllEntities(params) {
+            this.syncDimming();
             const ids = Object.keys(this.rego);
             const interval = setInterval(() => {
                 const batch = ids.splice(0, 3000);
@@ -12249,6 +12334,7 @@ var VisualsRegister;
             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,
@@ -17211,6 +17297,9 @@ class EntityGatherer {
             }
         };
     }
+    HasEntityDataOverride(eId) {
+        return this.entityDataOverrides.has(eId);
+    }
     SetEntityDataOverride(eId, entity) {
         if (this.disposed) {
             return;
@@ -17907,6 +17996,24 @@ function correctStyle(style) {
     }
     return style;
 }
+/**
+ * Reads the baked attribute declaration from a loaded tileset, keyed by path.
+ * @param cTileset
+ */
+function getBakedAttributes(cTileset) {
+    var _a, _b;
+    const result = new Map();
+    const declared = (_b = (_a = cTileset === null || cTileset === void 0 ? void 0 : cTileset.extras) === null || _a === void 0 ? void 0 : _a.bruce) === null || _b === void 0 ? void 0 : _b.bakedAttributes;
+    if (!Array.isArray(declared)) {
+        return result;
+    }
+    for (const baked of declared) {
+        if (Array.isArray(baked === null || baked === void 0 ? void 0 : baked.path) && baked.path.length && typeof baked.property == "string") {
+            result.set(JSON.stringify(baked.path), baked);
+        }
+    }
+    return result;
+}
 function colorToCColor$3(color) {
     return new Color(color.red ? color.red / 255 : 0, color.green ? color.green / 255 : 0, color.blue ? color.blue / 255 : 0, color.alpha);
 }
@@ -17977,6 +18084,10 @@ class TilesetStyler {
         // When false the Entity data is still gathered and the regos still updated, but no colour is
         // applied. A historic item that did not ask for styling needs the first without the second.
         this.applyStyles = true;
+        // Attribute values the tiles carry per feature, keyed by JSON path. Empty for a tileset without them.
+        this.bakedAttributes = new Map();
+        // Entities changed since the tileset was generated, so their baked values can no longer be trusted.
+        this.bakedStaleIds = new Set();
         this.reRenderState = new EntityReRenderMaintainState();
         // More expensive process.
         // When an Entity is styled, the rego is reviewed and updated if needed.
@@ -18018,6 +18129,7 @@ class TilesetStyler {
         this.viewer = viewer;
         this.api = api;
         this.cTileset = cTileset;
+        this.bakedAttributes = getBakedAttributes(cTileset);
         this.register = register;
         this.menuItemId = menuItemId;
         this.historic = Boolean(historic);
@@ -18096,6 +18208,7 @@ class TilesetStyler {
                 for (const [internalId, entityId] of this.styledByInternalId) {
                     if (RecordChangeFeed.isEntityInternalIdInRangeString(rangeStr, internalId)) {
                         this.feedPendingRestyleIds.add(entityId);
+                        this.bakedStaleIds.add(entityId);
                     }
                 }
                 if (this.feedPendingRestyleIds.size && !this.feedRestyleThrottleTimer) {
@@ -18335,8 +18448,6 @@ class TilesetStyler {
             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) {
@@ -18402,23 +18513,7 @@ class TilesetStyler {
             }
             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) {
@@ -18434,22 +18529,63 @@ class TilesetStyler {
             for (const key of pendingKeys) {
                 const relatedIds = this.stylePendingEntityIds.get(key);
                 if (relatedIds) {
-                    if (this.getTilesetFeatureNeedsFullData(key)) {
-                        this.entityGatherer.Queue(Array.from(relatedIds));
-                    }
-                    else {
-                        relatedIds.forEach(id => {
-                            const rego = this.getEntityRego(id);
-                            if (rego) {
-                                this.styleTilesetFeature(rego);
-                            }
-                        });
-                    }
+                    this.styleOrGatherIds(key, relatedIds);
                 }
             }
             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;
+        }
+        this.styleOrGatherIds(entityTypeId, relatedIds);
+        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 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 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);
@@ -18488,21 +18624,15 @@ class TilesetStyler {
                 this.overrideFeatureColor.set(rego.entityId, false);
             }
             const typeId = rego.entityTypeId || "";
-            if (this.styleMappingLoaded || this.styleMappingsLoaded.get(typeId)) {
-                if (this.getTilesetFeatureNeedsFullData(typeId)) {
-                    needsDataIds.push(rego.entityId);
-                }
-                else {
-                    this.styleTilesetFeature(rego);
-                }
+            // 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))) {
+                this.styleOrCollect(rego, typeId, needsDataIds);
             }
             else if (!this.styleMappingsLoaded.has(typeId) && this.styleFallbackLoaded) {
-                if (this.getTilesetFeatureNeedsFullData(typeId)) {
-                    needsDataIds.push(rego.entityId);
-                }
-                else {
-                    this.styleTilesetFeature(rego);
-                }
+                this.styleOrCollect(rego, typeId, needsDataIds);
             }
             else {
                 if (!this.stylePendingEntityIds.has(typeId)) {
@@ -18515,6 +18645,96 @@ class TilesetStyler {
             this.entityGatherer.Queue(needsDataIds, highPriority);
         }
     }
+    /**
+     * Styles each Entity waiting on a type's style, gathering the records of those that need one.
+     * @param entityTypeId
+     * @param entityIds
+     */
+    styleOrGatherIds(entityTypeId, entityIds) {
+        const gatherIds = [];
+        for (const id of entityIds) {
+            const rego = this.getEntityRego(id);
+            if (rego) {
+                this.styleOrCollect(rego, entityTypeId, gatherIds);
+            }
+        }
+        if (gatherIds.length) {
+            this.entityGatherer.Queue(gatherIds);
+        }
+    }
+    /**
+     * Styles a feature now when its style reads no record, or reads only values its tile carries, and otherwise collects it for gathering.
+     * @param rego
+     * @param entityTypeId
+     * @param gatherIds Receives the Entity ID when its record is needed.
+     */
+    styleOrCollect(rego, entityTypeId, gatherIds) {
+        if (!this.getTilesetFeatureNeedsFullData(entityTypeId)) {
+            this.styleTilesetFeature(rego);
+            return;
+        }
+        const record = this.canStyleFromBaked(rego.entityId, entityTypeId) ? this.readBakedRecord(rego.visual) : null;
+        if (!record) {
+            gatherIds.push(rego.entityId);
+            return;
+        }
+        this.styleTilesetFeatureFullData(rego, record, []);
+        // A later edit has to reach the record path, and the change feed finds Entities by Internal ID.
+        if (rego.internalId != null) {
+            this.styledByInternalId.set(rego.internalId, rego.entityId);
+        }
+    }
+    /**
+     * Returns if the tile's baked values hold everything this Entity's style would read from its record.
+     * @param entityId
+     * @param entityTypeId
+     */
+    canStyleFromBaked(entityId, entityTypeId) {
+        var _a, _b, _c;
+        // Baked values are the base record at generation time, which a scenario, a point in time or merged sources all differ from.
+        if (!this.bakedAttributes.size || this.historic || !!this.scenario || this.expandSources) {
+            return false;
+        }
+        if (this.bakedStaleIds.has(entityId) || ((_a = this.entityGatherer) === null || _a === void 0 ? void 0 : _a.HasEntityDataOverride(entityId))) {
+            return false;
+        }
+        const paths = Calculator.GetFieldPaths((_c = (_b = this.getTilesetFeatureStyle(entityTypeId)) === null || _b === void 0 ? void 0 : _b.modelStyle) === null || _c === void 0 ? void 0 : _c.fillColor);
+        return paths != null && paths.every(path => this.bakedAttributes.has(JSON.stringify(path)));
+    }
+    /**
+     * Builds a stand-in record from a feature's baked values, holding only the attributes that have one.
+     * Returns null when the feature's tile lacks a declared column, so the record is gathered instead.
+     * @param visual
+     */
+    readBakedRecord(visual) {
+        if (!(visual instanceof Cesium3DTileFeature)) {
+            return null;
+        }
+        const record = {};
+        for (const baked of this.bakedAttributes.values()) {
+            if (!visual.hasProperty(baked.property)) {
+                return null;
+            }
+            let value = visual.getProperty(baked.property);
+            if (value == null) {
+                continue;
+            }
+            // Booleans travel as 0/1 because a boolean column has no way to say "no value".
+            if (baked.type == "BOOLEAN") {
+                value = value != 0;
+            }
+            let target = record;
+            for (let i = 0; i < baked.path.length - 1; i++) {
+                const segment = baked.path[i];
+                if (target[segment] == null || typeof target[segment] != "object") {
+                    target[segment] = {};
+                }
+                target = target[segment];
+            }
+            target[baked.path[baked.path.length - 1]] = value;
+        }
+        return record;
+    }
     styleTilesetFeature(rego) {
         this.styleTilesetFeatureFullData(rego, null, []);
     }
@@ -40591,6 +40811,47 @@ function calcEntityLocation(entity, modelSpace) {
     }
     return Matrix4.multiplyByPoint(enuFrame, new Cartesian3(tx, ty, tz), new 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(Entity$1.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
+        ? Matrix3.fromQuaternion(orientation, new Matrix3())
+        : Matrix4.getMatrix3(Transforms.eastNorthUpToFixedFrame(pos3d), new Matrix3());
+    const offset = Matrix3.multiplyByVector(rotation, bounds.center, new Cartesian3());
+    return Cartesian3.add(pos3d, offset, new Cartesian3());
+}
 // +90° rotation around Z: aligns GLTF Y-up forward with Cesium ENU North.
 const _assemblyAxisShift = new Quaternion(0, 0, -Math.SQRT1_2, Math.SQRT1_2);
 var EntityUtils;
@@ -40642,6 +40903,9 @@ var EntityUtils;
             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)) {
@@ -40719,7 +40983,7 @@ var EntityUtils;
              * 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
@@ -40851,9 +41115,14 @@ var EntityUtils;
                                 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 BoundingSphere(getModelBoundsCenter(viewer, part, pos3d, bounds), bounds.radius));
+                                    }
+                                    else if (modelExt._radius && modelExt._radius > -1) {
                                         const sphere = BoundingSphere.fromPoints([pos3d]);
                                         sphere.radius = modelExt._radius;
+                                        spheres.push(sphere);
                                     }
                                 }
                                 else if (part.ellipse) {
@@ -40872,6 +41141,7 @@ var EntityUtils;
                                     const radius = Math.max(semiMajorAxis, semiMinorAxis, height);
                                     if (radius && radius > 0) {
                                         const sphere = new BoundingSphere(pos3d, radius);
+                                        spheres.push(sphere);
                                     }
                                 }
                             }
@@ -40890,6 +41160,14 @@ var EntityUtils;
                             posses.push(pos3d);
                             if (data.radius != null && !isNaN(data.radius)) {
                                 const sphere = new 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(BoundingSphere.clone(tileSphere));
                             }
                         }
                     }
@@ -40969,7 +41247,7 @@ var EntityUtils;
                 }
                 const boundaries = Entity$1.GetValue({
                     entity: entity,
-                    path: ["Bruce, Boundaries"]
+                    path: ["Bruce", "Boundaries"]
                 });
                 if (boundaries && typeof boundaries == "object") {
                     const point = {
@@ -41022,16 +41300,9 @@ var EntityUtils;
                                 const transformedOffset = Matrix3.multiplyByVector(transformHpr, offset, new Cartesian3());
                                 pos3d = Matrix4.multiplyByPoint(m1, transformedOffset, new Cartesian3());
                                 pos3d = await processPosHeight(pos3d, HeightReference.NONE);
-                                const geometryRadius = Entity$1.GetValue({
-                                    entity: entity,
-                                    path: ["Bruce", "GeometryRadius"]
-                                });
+                                const geometryRadius = getTrustedGeometryRadius(entity);
                                 if (geometryRadius && (pos3d === null || pos3d === void 0 ? void 0 : pos3d.x)) {
-                                    const sphere = 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 BoundingSphere(pos3d, geometryRadius));
                                 }
                                 return [pos3d];
                             }
@@ -41039,16 +41310,9 @@ var EntityUtils;
                                 if (location) {
                                     let pos3d = Cartesian3.fromDegrees(longitude, latitude, EnsureNumber(location.altitude));
                                     pos3d = await processPosHeight(pos3d, HeightReference.NONE);
-                                    const geometryRadius = Entity$1.GetValue({
-                                        entity: entity,
-                                        path: ["Bruce", "GeometryRadius"]
-                                    });
+                                    const geometryRadius = getTrustedGeometryRadius(entity);
                                     if (geometryRadius && (pos3d === null || pos3d === void 0 ? void 0 : pos3d.x)) {
-                                        const sphere = 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 BoundingSphere(pos3d, geometryRadius));
                                     }
                                     return [pos3d];
                                 }
@@ -41071,16 +41335,9 @@ var EntityUtils;
                 }
                 if (pos3d) {
                     pos3d = await processPosHeight(pos3d, HeightReference.NONE);
-                    const geometryRadius = Entity$1.GetValue({
-                        entity: entity,
-                        path: ["Bruce", "GeometryRadius"]
-                    });
+                    const geometryRadius = getTrustedGeometryRadius(entity);
                     if (geometryRadius && (pos3d === null || pos3d === void 0 ? void 0 : pos3d.x)) {
-                        const sphere = 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 BoundingSphere(pos3d, geometryRadius));
                     }
                     return [pos3d];
                 }
@@ -41100,16 +41357,9 @@ var EntityUtils;
                             if (pos3d === null || pos3d === void 0 ? void 0 : pos3d.x) {
                                 pos3d = await processPosHeight(pos3d, HeightReference.NONE);
                             }
-                            const geometryRadius = Entity$1.GetValue({
-                                entity: entity,
-                                path: ["Bruce", "GeometryRadius"]
-                            });
+                            const geometryRadius = getTrustedGeometryRadius(entity);
                             if (geometryRadius && (pos3d === null || pos3d === void 0 ? void 0 : pos3d.x)) {
-                                const sphere = 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 BoundingSphere(pos3d, geometryRadius));
                             }
                         }
                     }
@@ -41344,6 +41594,7 @@ var EntityUtils;
                     radius /= 2;
                 }
                 const sphere = new BoundingSphere(data.pos3d, radius);
+                spheres.push(sphere);
                 data.sphere = sphere;
             }
             else {
@@ -41353,23 +41604,24 @@ var EntityUtils;
         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 = 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 = BoundingSphere.fromBoundingSpheres(tileSpheres);
+            data.pos3d = data.sphere.center;
+        }
         return data;
     }
     EntityUtils.GetLocation = GetLocation;
@@ -43937,6 +44189,10 @@ var EntityRenderEngineModel3d;
                         }
                         let radius = modelPrim.boundingSphere.radius;
                         let centerOffset = modelPrim.boundingSphere.center;
+                        const bounds = {
+                            center: centerOffset ? Cartesian3.clone(centerOffset) : 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 = Cartesian3.magnitude(centerOffset);
@@ -43948,7 +44204,7 @@ var EntityRenderEngineModel3d;
                             }
                         }
                         kill();
-                        res(radius);
+                        res({ radius, bounds });
                     };
                     let readyEventRemoval = null;
                     // Newer Cesium versions have readyEvent. They don't use readyPromise.
@@ -43973,9 +44229,10 @@ var EntityRenderEngineModel3d;
             });
             _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()) {
                     VisualRegisterCuller.MarkShouldRecheck(params.viewer);
@@ -49785,9 +50042,6 @@ var StyleEffective;
     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) {
@@ -51056,7 +51310,7 @@ var StyleUtils;
     StyleUtils.ApplyTypeStyle = ApplyTypeStyle;
 })(StyleUtils || (StyleUtils = {}));
 
-const VERSION = "7.5.2";
+const VERSION = "7.5.4";
 /**
  * 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.