bruce-cesium 7.3.7 → 7.3.9

package/dist/bruce-cesium.es5.js

@@ -1,6 +1,6 @@
 import * as Cesium from 'cesium';
-import { Cartographic, ColorMaterialProperty, Entity, Color, ConstantProperty, CallbackProperty, Primitive, Cesium3DTileFeature, HeightReference, ColorBlendMode, HeadingPitchRoll, Math as Math$1, Transforms, ShadowMode, Cartesian3, ClassificationType, Model, JulianDate, Quaternion, Matrix4, ArcType, CornerType, ConstantPositionProperty, HorizontalOrigin, VerticalOrigin, ShaderSource, Ellipsoid, Geometry, GeometryAttribute, ComponentDatatype, PrimitiveType, BoundingSphere, GeometryPipeline, Cartesian2, sampleTerrain, Texture, PixelFormat, Sampler, TextureWrap, TextureMinificationFilter, TextureMagnificationFilter, Cartesian4, VertexArray, BufferUsage, ShaderProgram, RenderState, BlendingState, DrawCommand, Pass, DistanceDisplayCondition, ImageMaterialProperty, SceneTransforms, PolygonHierarchy, PolylineGraphics, Rectangle, NearFarScalar, Matrix3, KmlDataSource, GeoJsonDataSource, SceneMode, Cesium3DTileStyle, Cesium3DTileColorBlendMode, HeadingPitchRange, Ion, IonResource, OrthographicFrustum, EasingFunction, Cesium3DTileset, EllipsoidTerrainProvider, IonImageryProvider, createWorldImagery, createWorldImageryAsync, BingMapsImageryProvider, BingMapsStyle, MapboxImageryProvider, MapboxStyleImageryProvider, ArcGisMapServerImageryProvider, OpenStreetMapImageryProvider, UrlTemplateImageryProvider, GridImageryProvider, GeographicTilingScheme, ImageryLayer, TileMapServiceImageryProvider, CesiumTerrainProvider, ModelGraphics, PolygonGraphics, CorridorGraphics, PointGraphics, BillboardGraphics, EllipseGraphics, PolylineDashMaterialProperty, Intersect, PolygonPipeline, EllipsoidGeodesic, sampleTerrainMostDetailed, defined, CesiumInspector, ClockRange, DynamicEnvironmentMapManager, GeometryInstance, CustomDataSource, ScreenSpaceEventHandler, ScreenSpaceEventType, 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, Bounds, MenuItem, ProjectView, ProjectViewBookmark, Tileset, ZoomControl, BruceEvent, EntityCoords, DataLab, DelayQueue, AccountConcept, BruceApi, EntityRelation, EntitySource, RecordChangeFeed, Camera, ProgramKey, ProjectViewLegacyTile, Account, AccountLimits, Session, UrlUtils, ProjectViewBookmarkGroup, EntityAttachment, EntityAttachmentType, EntityAttribute, MathUtils, EntityRelationType, EntityHistoricData } from 'bruce-models';
+import { Cartographic, ColorMaterialProperty, Entity, Color, ConstantProperty, CallbackProperty, Primitive, Cesium3DTileFeature, ShaderSource, Cartesian3, Math as Math$1, Ellipsoid, Transforms, 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, HeadingPitchRoll, HeightReference, ColorBlendMode, ShadowMode, ClassificationType, Model, HorizontalOrigin, VerticalOrigin, ConstantPositionProperty, ArcType, CornerType, DistanceDisplayCondition, SceneTransforms, ImageMaterialProperty, PolygonHierarchy, PolylineGraphics, Rectangle, NearFarScalar, Matrix3, KmlDataSource, GeoJsonDataSource, SceneMode, Cesium3DTileStyle, HeadingPitchRange, Ion, IonResource, Cesium3DTileColorBlendMode, Cesium3DTileset, EllipsoidTerrainProvider, IonImageryProvider, createWorldImagery, createWorldImageryAsync, BingMapsImageryProvider, BingMapsStyle, MapboxImageryProvider, MapboxStyleImageryProvider, ArcGisMapServerImageryProvider, OpenStreetMapImageryProvider, UrlTemplateImageryProvider, GridImageryProvider, GeographicTilingScheme, ImageryLayer, TileMapServiceImageryProvider, CesiumTerrainProvider, OrthographicFrustum, EasingFunction, Intersect, ModelGraphics, PolygonGraphics, CorridorGraphics, PointGraphics, BillboardGraphics, EllipseGraphics, PolylineDashMaterialProperty, PolygonPipeline, CustomDataSource, EllipsoidGeodesic, sampleTerrainMostDetailed, defined, 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, Api, Carto, Geometry as Geometry$1, Bounds, ClientFileValueMap, Color as Color$1, MenuItem, ProjectView, ProjectViewBookmark, Tileset, ZoomControl, BruceEvent, EntityCoords, DataLab, DelayQueue, AccountConcept, EntityRelation, BruceApi, RecordChangeFeed, EntitySource, ProgramKey, ProjectViewLegacyTile, Camera, Account, AccountLimits, Session, UrlUtils, ProjectViewBookmarkGroup, EntityAttachment, EntityAttachmentType, EntityAttribute, MathUtils, EntityRelationType, EntityHistoricData } from 'bruce-models';
 
 /**
  * Ensures a number is returned from a given value.
@@ -9514,6 +9514,14 @@ var VisualsRegister;
                 }
             };
         }
+        /**
+         * Whether this register is holding a record of a visual.
+         * @param visual
+         */
+        HasRego(visual) {
+            const vis = visual;
+            return Boolean(vis && vis._register === this && vis._rego);
+        }
         /**
          * Locates a visual corresponding to a given entity id.
          * If no menu item id is provided, then it will pick the "best" one.
@@ -11040,10 +11048,6 @@ class PointClustering {
 
 /**
  * How often a historic refresh is worth running, and which Entities it should ask about first.
- *
- * A handful of tracked vehicles can afford to re-read on almost every clock tick. Thousands of
- * parcels cannot, and refreshing them that often was never buying anything since the answer barely
- * changes between ticks.
  */
 var HistoricFetchOrder;
 (function (HistoricFetchOrder) {
@@ -11088,6 +11092,13 @@ var HistoricFetchOrder;
     HistoricFetchOrder.IntervalForClock = IntervalForClock;
     // Upper bounds in metres for the distance bands, nearest first.
     HistoricFetchOrder.DEFAULT_BANDS = [500, 2000, 10000, 50000];
+    // How far outside the visible rectangle something still counts as worth re-reading, share of the view itself.
+    HistoricFetchOrder.REFRESH_MARGIN_FRACTION = 0.5;
+    // A close view still gets a usable buffer, and a distant one does not reach half the account.
+    HistoricFetchOrder.MIN_REFRESH_MARGIN_METRES = 250;
+    HistoricFetchOrder.MAX_REFRESH_MARGIN_METRES = 2000;
+    const METRES_PER_DEGREE_LAT = 111320;
+    const MIN_LAT_COSINE = 0.01;
     /**
      * Resolves what to order by from the view monitor, falling back to the camera itself.
      */
@@ -11168,6 +11179,55 @@ var HistoricFetchOrder;
         return grouped.filter(group => group.length > 0);
     }
     HistoricFetchOrder.ByCameraDistanceOf = ByCameraDistanceOf;
+    /**
+     * Returns how far past a visible rectangle a refresh should still reach, in metres.
+     */
+    function RefreshMarginFor(bounds) {
+        if (!bounds) {
+            return HistoricFetchOrder.MIN_REFRESH_MARGIN_METRES;
+        }
+        const latSpan = Math.abs(bounds.north - bounds.south) * METRES_PER_DEGREE_LAT;
+        const cosine = Math.max(MIN_LAT_COSINE, Math.cos(Math$1.toRadians((bounds.north + bounds.south) / 2)));
+        const lonDegrees = bounds.west > bounds.east
+            ? (bounds.east + 360) - bounds.west
+            : bounds.east - bounds.west;
+        const lonSpan = Math.abs(lonDegrees) * METRES_PER_DEGREE_LAT * cosine;
+        const span = Math.min(latSpan, lonSpan);
+        if (!(span > 0)) {
+            return HistoricFetchOrder.MIN_REFRESH_MARGIN_METRES;
+        }
+        return Math.min(HistoricFetchOrder.MAX_REFRESH_MARGIN_METRES, Math.max(HistoricFetchOrder.MIN_REFRESH_MARGIN_METRES, span * HistoricFetchOrder.REFRESH_MARGIN_FRACTION));
+    }
+    HistoricFetchOrder.RefreshMarginFor = RefreshMarginFor;
+    /**
+     * Returns the rectangle grown outwards by a margin in metres.
+     */
+    function GrowBounds(bounds, metres) {
+        if (!bounds || !(metres > 0)) {
+            return bounds;
+        }
+        const dLat = metres / METRES_PER_DEGREE_LAT;
+        const north = Math.min(90, bounds.north + dLat);
+        const south = Math.max(-90, bounds.south - dLat);
+        const cosine = Math.cos(Math$1.toRadians((bounds.north + bounds.south) / 2));
+        if (cosine < MIN_LAT_COSINE) {
+            return { north, south, west: -180, east: 180 };
+        }
+        const dLon = metres / (METRES_PER_DEGREE_LAT * cosine);
+        const straddles = bounds.west > bounds.east;
+        const gap = straddles ? bounds.west - bounds.east : 360 - (bounds.east - bounds.west);
+        if (gap <= dLon * 2) {
+            return { north, south, west: -180, east: 180 };
+        }
+        return { north, south, west: wrapLongitude(bounds.west - dLon), east: wrapLongitude(bounds.east + dLon) };
+    }
+    HistoricFetchOrder.GrowBounds = GrowBounds;
+    /*
+     * Returns a longitude folded back into the range the bounds are expressed in.
+     */
+    function wrapLongitude(lon) {
+        return (((lon + 180) % 360) + 360) % 360 - 180;
+    }
     /*
      * Returns whether a world position sits inside a ground rectangle given in degrees.
      */
@@ -11176,17 +11236,22 @@ var HistoricFetchOrder;
         if (!degrees) {
             return false;
         }
-        const { lat, lon } = degrees;
+        return InDegreeBounds(degrees.lat, degrees.lon, bounds);
+    }
+    HistoricFetchOrder.InBounds = InBounds;
+    /*
+     * The same test for a caller that already holds the degrees and should not pay to resolve them from a world position again.
+     */
+    function InDegreeBounds(lat, lon, bounds) {
         if (lat < bounds.south || lat > bounds.north) {
             return false;
         }
-        // A view straddling the antimeridian reports west east of east, so the span is the outside.
         if (bounds.west > bounds.east) {
             return lon >= bounds.west || lon <= bounds.east;
         }
         return lon >= bounds.west && lon <= bounds.east;
     }
-    HistoricFetchOrder.InBounds = InBounds;
+    HistoricFetchOrder.InDegreeBounds = InDegreeBounds;
     /*
      * Returns an Entity's world position, or null when it has none to place it by.
      */
@@ -12685,6 +12750,11 @@ var EntitiesRenderManager;
                 optimizeTolerance: this.item.optimizeTolerance,
             });
             if (this.disposed) {
+                EntityRenderEngine.RemoveAll({
+                    viewer: this.viewer,
+                    entities: cEntities,
+                    register: this.visualsManager
+                });
                 this.doDispose();
                 return;
             }
@@ -13692,6 +13762,11 @@ var EntitiesLoadedRenderManager;
                 force
             });
             if (this.disposed) {
+                EntityRenderEngine.RemoveAll({
+                    viewer: this.viewer,
+                    entities: cEntities,
+                    register: this.visualsManager
+                });
                 this.visualsManager.RemoveRegos({
                     menuItemId: this.item.id
                 });
@@ -14136,10 +14211,15 @@ var EntitiesIdsRenderManager;
                 zoomControl: this.item.CameraZoomSettings,
                 force: force || changed
             });
+            if (this.disposed) {
+                EntityRenderEngine.RemoveAll({
+                    viewer: this.viewer,
+                    entities: cEntities,
+                    register: this.visualsManager
+                });
+                return;
+            }
             for (let i = 0; i < entities.length; i++) {
-                if (this.disposed) {
-                    break;
-                }
                 const entity = entities[i];
                 const id = entity.Bruce.ID;
                 const cEntity = cEntities.get(id);
@@ -14577,6 +14657,19 @@ class EntityGatherer {
         // All IDs that have ever been queued.
         // When nothing is in queue, we'll re-request the existing IDs based on timeline changes.
         this.allEIds = new Set();
+        // IDs a historic read has actually answered with a record, rather than falling back to a stub.
+        // A refresh serves these before the ones that have never produced anything.
+        this.everFound = new Set();
+        // Every known Entity bucketed by the ground cell its position falls in, so a refresh can ask
+        // what the view reaches instead of walking the whole set. Built as IDs arrive.
+        this.cells = new Map();
+        // IDs the position source could not place yet. They are always refreshed.
+        this.unplaced = new Set();
+        // The IDs the last decision found inside the view, so a camera move can queue the difference
+        // rather than re-requesting everything it already asked about.
+        this.lastInView = new Set();
+        // Unsubscribes the view monitor listener that queues what the camera has moved onto.
+        this.monitorRemoval = null;
         // Indicates a tick is active.
         // When true, we won't bother calling onTick again.
         this.runningTick = false;
@@ -14627,6 +14720,16 @@ class EntityGatherer {
         }
         this.historic = historic;
         this.expandSources = expandSources;
+        if (this.historic) {
+            // Anything already known was taken in before the index was being built, so it is filed
+            // a bounded number at a time from here rather than in one pass now.
+            for (const entityId of this.allEIds) {
+                this.unplaced.add(entityId);
+            }
+        }
+        else {
+            this.clearIndex();
+        }
         if (this.historic) {
             // 4 ticks per second.
             // The fastest data we are working with is 5 times per second.
@@ -14678,6 +14781,8 @@ class EntityGatherer {
         this.lastOrderFocus = null;
         this.allEIds.clear();
         this.lastFoundDateTimes.clear();
+        this.everFound.clear();
+        this.clearIndex();
         this.lastDateTime = null;
     }
     ReQueueAll() {
@@ -14688,22 +14793,193 @@ class EntityGatherer {
         this.eIdQueued = new Set(this.eIdQueue);
         this.priorityCount = 0;
         this.lastOrderFocus = null;
+        this.clearIndex();
     }
     /**
-     * Supplies a lookup from Entity ID to world position, letting the queue resolve what the camera
-     * is nearest first. Sources that cannot answer should not call this, and are served in order.
+     * Supplies a lookup from Entity ID to world position, letting the queue resolve what the camera is nearest first.
+     * Sources that cannot answer should not call this, and are served in order.
      */
     SetPositionSource(positionOf) {
         this.positionOf = positionOf;
         this.lastOrderFocus = null;
+        this.cells.clear();
+        this.lastInView.clear();
+        for (const entityId of this.allEIds) {
+            this.unplaced.add(entityId);
+        }
     }
     /**
-     * Supplies the view monitor, so the order follows the ground the camera is aimed at and prefers
-     * what is on screen. Without one the ordering falls back to distance from the camera itself.
+     * Supplies the view monitor, so the order follows the ground the camera is aimed at and prefers what is on screen.
+     * Without one the ordering falls back to distance from the camera itself.
      */
     SetViewMonitor(monitor) {
+        var _a;
+        (_a = this.monitorRemoval) === null || _a === void 0 ? void 0 : _a.call(this);
+        this.monitorRemoval = null;
         this.monitor = monitor;
         this.lastOrderFocus = null;
+        if (!monitor) {
+            return;
+        }
+        this.monitorRemoval = monitor.Updated().Subscribe(() => {
+            this.admitNewlyInView();
+        });
+    }
+    /*
+     * Queues whatever the camera has moved onto since the last decision.
+     */
+    admitNewlyInView() {
+        if (this.disposed || !this.historic) {
+            return;
+        }
+        const inView = this.decideInView();
+        if (!inView) {
+            return;
+        }
+        const admit = [];
+        for (const entityId of inView) {
+            if (!this.lastInView.has(entityId)) {
+                admit.push(entityId);
+            }
+        }
+        this.lastInView = new Set(inView);
+        if (admit.length) {
+            this.Queue(admit);
+        }
+    }
+    /*
+     * Returns the IDs a refresh should ask about, or null when the view cannot say and the answer has to be everything.
+     */
+    decideInView() {
+        if (!this.historic || !this.positionOf || !this.monitor) {
+            return null;
+        }
+        const area = this.refreshArea();
+        if (!area) {
+            return null;
+        }
+        const inView = [];
+        for (const key of this.candidateCellKeys(area)) {
+            const cell = this.cells.get(key);
+            if (!cell) {
+                continue;
+            }
+            for (let i = 0; i < cell.ids.length; i++) {
+                if (HistoricFetchOrder.InDegreeBounds(cell.lats[i], cell.lons[i], area)) {
+                    inView.push(cell.ids[i]);
+                }
+            }
+        }
+        // Anything the source cannot place yet is asked about rather than quietly dropped.
+        for (const entityId of this.unplaced) {
+            inView.push(entityId);
+        }
+        return inView;
+    }
+    /*
+     * Returns the cell keys a rectangle can reach.
+     */
+    candidateCellKeys(area) {
+        const size = EntityGatherer.CELL_DEGREES;
+        const southCell = Math.floor(area.south / size);
+        const northCell = Math.floor(area.north / size);
+        const spans = (area.west > area.east ? [
+            {
+                from: Math.floor(area.west / size),
+                to: Math.floor(180 / size)
+            },
+            {
+                from: Math.floor(-180 / size),
+                to: Math.floor(area.east / size)
+            }
+        ] :
+            [{
+                    from: Math.floor(area.west / size),
+                    to: Math.floor(area.east / size)
+                }]);
+        let width = 0;
+        for (const span of spans) {
+            width += (span.to - span.from) + 1;
+        }
+        const wanted = ((northCell - southCell) + 1) * width;
+        if (!(wanted > 0) || wanted > this.cells.size) {
+            return Array.from(this.cells.keys());
+        }
+        const keys = [];
+        for (let lat = southCell; lat <= northCell; lat++) {
+            for (const span of spans) {
+                for (let lon = span.from; lon <= span.to; lon++) {
+                    keys.push(lat + ":" + lon);
+                }
+            }
+        }
+        return keys;
+    }
+    /*
+     * Files an Entity in the cell its position falls in.
+     */
+    place(entityId) {
+        const degrees = this.degreesOf(entityId);
+        if (!degrees) {
+            this.unplaced.add(entityId);
+            return;
+        }
+        const size = EntityGatherer.CELL_DEGREES;
+        const key = Math.floor(degrees.lat / size) + ":" + Math.floor(degrees.lon / size);
+        let cell = this.cells.get(key);
+        if (!cell) {
+            cell = { ids: [], lats: [], lons: [] };
+            this.cells.set(key, cell);
+        }
+        cell.ids.push(entityId);
+        cell.lats.push(degrees.lat);
+        cell.lons.push(degrees.lon);
+        this.unplaced.delete(entityId);
+    }
+    /*
+     * Retries a bounded number of the Entities the source could not place before, so a late baked
+     * position joins the index without any one tick paying for all of them.
+     */
+    placeStragglers() {
+        if (!this.unplaced.size || !this.positionOf) {
+            return;
+        }
+        let budget = EntityGatherer.PLACE_BATCH;
+        for (const entityId of this.unplaced) {
+            if (budget-- <= 0) {
+                return;
+            }
+            this.place(entityId);
+        }
+    }
+    clearIndex() {
+        this.cells.clear();
+        this.unplaced.clear();
+        this.lastInView.clear();
+    }
+    /*
+     * Returns where an Entity sits in degrees, or null when the source cannot place it.
+     */
+    degreesOf(entityId) {
+        let pos = null;
+        try {
+            pos = this.positionOf ? this.positionOf(entityId) : null;
+        }
+        catch {
+            pos = null;
+        }
+        return pos ? CartesianToDegrees(pos) : null;
+    }
+    /*
+     * Returns the visible rectangle plus the margin a refresh still reaches into,
+     * or null when the view cannot say, which is what leaves every Entity in.
+     */
+    refreshArea() {
+        const focus = HistoricFetchOrder.FocusFrom({ viewer: this.viewer, monitor: this.monitor });
+        if (!(focus === null || focus === void 0 ? void 0 : focus.bounds)) {
+            return null;
+        }
+        return HistoricFetchOrder.GrowBounds(focus.bounds, HistoricFetchOrder.RefreshMarginFor(focus.bounds));
     }
     /**
      * Re-bands the pending queue so the nearest Entities are requested first.
@@ -14716,8 +14992,6 @@ class EntityGatherer {
         if (!focus) {
             return;
         }
-        // Re-banding on every batch would cost a full pass per request for no change in the answer.
-        // Measured on the focus, so panning across the ground counts even when the eye barely moves.
         if (this.lastOrderFocus && !EntityGatherer.boundsChanged(this.lastOrderFocus, focus) &&
             Cartesian3.distance(this.lastOrderFocus.origin, focus.origin) < EntityGatherer.REORDER_MOVE_METRES) {
             return;
@@ -14764,26 +15038,47 @@ class EntityGatherer {
         });
         const ordered = [];
         for (const band of banded) {
+            // Within a band, the ones a read has answered for go first.
+            // A building that has never produced a record is the one least likely to start now, so it waits.
+            const withData = [];
+            const withoutData = [];
             for (const entityId of band) {
+                (this.everFound.has(entityId) ? withData : withoutData).push(entityId);
+            }
+            for (const entityId of withData) {
+                ordered.push(entityId);
+            }
+            for (const entityId of withoutData) {
                 ordered.push(entityId);
             }
         }
         return ordered;
     }
+    /*
+     * Takes an ID into the known set, filing it in the index the first time it is seen.
+     */
+    remember(entityId) {
+        if (this.allEIds.has(entityId)) {
+            return;
+        }
+        this.allEIds.add(entityId);
+        // Only a historic refresh reads the index, so nothing else pays to build it.
+        if (this.historic) {
+            this.place(entityId);
+        }
+    }
     Queue(entityIds, topOfQueue = false) {
         if (this.disposed || !(entityIds === null || entityIds === void 0 ? void 0 : entityIds.length)) {
             return;
         }
         let changes = 0;
         if (topOfQueue) {
-            // Walked back to front so a repeated ID keeps the position of its last occurrence, then
-            // laid down in that order, which is where inserting one at a time leaves them.
             const toFront = [];
             const promoting = new Set();
             let anyAlreadyQueued = false;
             for (let i = entityIds.length - 1; i >= 0; i--) {
                 const eId = entityIds[i];
-                this.allEIds.add(eId);
+                this.remember(eId);
                 if (promoting.has(eId)) {
                     continue;
                 }
@@ -14819,7 +15114,7 @@ class EntityGatherer {
         else {
             for (let i = 0; i < entityIds.length; i++) {
                 const eId = entityIds[i];
-                this.allEIds.add(eId);
+                this.remember(eId);
                 if (this.eIdQueued.has(eId)) {
                     continue;
                 }
@@ -14834,19 +15129,22 @@ class EntityGatherer {
         this.onTick(false);
     }
     Dispose() {
+        var _a;
         if (this.disposed) {
             return;
         }
         this.disposed = true;
+        (_a = this.monitorRemoval) === null || _a === void 0 ? void 0 : _a.call(this);
+        this.monitorRemoval = null;
         this.hDisposals.forEach((d) => d());
         this.hDisposals = [];
-        // A tick still awaiting a response resumes after this, and anything left here would have it
-        // ask for the whole set again on the way out.
         this.eIdQueue = [];
         this.eIdQueued.clear();
         this.priorityCount = 0;
         this.allEIds.clear();
         this.lastFoundDateTimes.clear();
+        this.everFound.clear();
+        this.clearIndex();
         this.entityDataOverrides.clear();
     }
     checkRange(force) {
@@ -14870,6 +15168,7 @@ class EntityGatherer {
         this.lastDateTime = rTime;
         (async () => {
             this.runningTick = true;
+            this.placeStragglers();
             let rerun = false;
             try {
                 const handleResponse = async (requestedBatch, entities) => {
@@ -14882,6 +15181,13 @@ class EntityGatherer {
                             foundById.set(entityId, entity);
                         }
                     }
+                    if (this.historic) {
+                        for (const entityId of requestedBatch || []) {
+                            if (foundById.has(entityId)) {
+                                this.everFound.add(entityId);
+                            }
+                        }
+                    }
                     for (const entityId of requestedBatch || []) {
                         const override = this.entityDataOverrides.get(entityId);
                         if (override) {
@@ -15010,15 +15316,16 @@ class EntityGatherer {
                         this._onQueueProgress.Trigger(100);
                     }
                 }
-                // Now run through all IDs that we've seen and request them.
+                // Now run through the IDs we've seen that the view still reaches, and request them.
                 // We'll skip those that we just requested.
-                let allEIds = Array.from(this.allEIds);
+                const inView = this.decideInView();
+                this.lastInView = inView ? new Set(inView) : new Set();
+                let allEIds = inView || Array.from(this.allEIds);
                 if (requestedIds.size) {
                     allEIds = allEIds.filter((eId) => !requestedIds.has(eId));
                 }
                 if (allEIds.length) {
-                    // A historic tick re-reads the whole set, so the near ones are worth resolving
-                    // first here even more than in the queue above.
+                    // The near ones are resolved first out of whatever the view still reaches.
                     allEIds = this.bandIds(allEIds);
                     while (allEIds.length && !this.disposed && !this.eIdQueue.length) {
                         if (this.historic && this.lastDateTime !== rTime) {
@@ -15057,6 +15364,11 @@ class EntityGatherer {
 }
 // Below this the whole queue clears in one or two requests, so ordering it buys nothing.
 EntityGatherer.MIN_ORDER_QUEUE = 500;
+// Side of the ground cells Entities are bucketed into, in degrees.
+// About a kilometre, so a view covers a handful of them rather than hundreds.
+EntityGatherer.CELL_DEGREES = 0.01;
+// How many Entities one tick will try to place in the index.
+EntityGatherer.PLACE_BATCH = 20000;
 // How far the point being looked at has to move before the queue is worth re-banding, in metres.
 // Under the nearest band's width, so a move that could change what is nearest still triggers one.
 EntityGatherer.REORDER_MOVE_METRES = 250;
@@ -19520,6 +19832,11 @@ var DataLabRenderManager;
                     force
                 });
                 if (this.disposed) {
+                    EntityRenderEngine.RemoveAll({
+                        viewer: this.viewer,
+                        entities: cEntities,
+                        register: this.visualsManager
+                    });
                     return;
                 }
                 for (let i = 0; i < entities.length; i++) {
@@ -43668,17 +43985,21 @@ uniform vec2 u_maskGroundSize;
 uniform vec4 u_extentDegrees;
 uniform vec4 u_maskGroundDegrees;
 uniform float u_coverageCutoffVertex;
+//#water
 uniform vec2 u_extentMetres;
 uniform vec2 u_waveOrigin;
+//#endwater
 
 out vec2 v_st;
 out float v_value;
 out float v_coverage;
+//#water
 out vec3 v_positionEC;
 out vec3 v_eastEC;
 out vec3 v_northEC;
 out vec3 v_upEC;
 out vec2 v_waveMetres;
+//#endwater
 
 float decodeGround(vec2 uv) {
     // Channels arrive normalised to 0..1, so they go back to bytes before being reassembled.
@@ -43798,6 +44119,7 @@ void main() {
     // would be lost to float32 rounding at an earth radius.
     vec4 p = czm_translateRelativeToEye(position3DHigh, position3DLow + normal * displacement);
 
+//#water
     // The local frame at this vertex so a shading normal built in east/north/up meters can be turned into something usable.
     v_upEC = czm_normal * normal;
     vec3 east = normalize(cross(vec3(0.0, 0.0, 1.0), normal));
@@ -43805,16 +44127,9 @@ void main() {
     v_northEC = czm_normal * cross(normal, east);
     v_positionEC = (czm_modelViewRelativeToEye * p).xyz;
 
-    /*
-     * Where this vertex sits in the ripple field, in metres from an origin that follows the camera.
-     *
-     * Subtracted here rather than in the fragment shader because the position it is subtracted from
-     * spans the whole archive, which over a sound is tens of kilometres. A wave number times that
-     * is thousands of radians, and no fragment shader that may only have mediump can step through a
-     * cosine at that magnitude: the ripples come out as a flat surface, which is what a first cut of
-     * this did. What crosses into the fragment shader is a small number the camera is standing in.
-     */
+    // Where this vertex sits in the ripple field, in metres from an origin that follows the camera.
     v_waveMetres = st * u_extentMetres - u_waveOrigin;
+//#endwater
 
     gl_Position = czm_modelViewProjectionRelativeToEye * p;
 }
@@ -43828,7 +44143,7 @@ uniform float u_valuePacked;
 uniform float u_valueRange;
 uniform float u_exaggeration;
 uniform float u_metresPerTexel;
-uniform float u_waterOn;
+//#water
 uniform float u_waterWavelength;
 uniform float u_waterAmplitude;
 uniform float u_waterReflectivity;
@@ -43840,15 +44155,18 @@ uniform vec4 u_wavePhase;
 uniform vec4 u_wavePhaseB;
 // Metres the whole ripple field repeats over.
 uniform float u_wavePeriod;
+//#endwater
 
 in vec2 v_st;
 in float v_value;
 in float v_coverage;
+//#water
 in vec3 v_positionEC;
 in vec3 v_eastEC;
 in vec3 v_northEC;
 in vec3 v_upEC;
 in vec2 v_waveMetres;
+//#endwater
 
 /*
  * Scaled per channel for the same reason the vertex shader's decode is: reassembling the pair reaches
@@ -43860,6 +44178,7 @@ float valueAt(vec2 uv) {
     return mix(texel.r, packed16, u_valuePacked);
 }
 
+//#water
 /*
  * Slope of the ripple field at a point, in metres of rise per metre travelled.
  */
@@ -43935,6 +44254,7 @@ vec4 water(vec3 relief, vec4 color) {
     alpha = clamp(alpha + (1.0 - alpha) * (fresnel * 0.55 + glint), 0.0, 1.0);
     return vec4(lit, alpha);
 }
+//#endwater
 
 void main() {
     if (v_coverage < u_coverageCutoff) {
@@ -43957,10 +44277,10 @@ void main() {
     float scale = u_valueRange * u_exaggeration;
     vec3 n = normalize(vec3((left - right) * scale, (down - up) * scale, 2.0 * u_metresPerTexel));
 
-    if (u_waterOn > 0.5) {
-        out_FragColor = water(n, color);
-        return;
-    }
+//#water
+    out_FragColor = water(n, color);
+    return;
+//#endwater
 
     float lambert = clamp(dot(n, normalize(vec3(-0.5, -0.6, 0.62))), 0.0, 1.0);
     color.rgb *= 0.45 + 0.9 * lambert;
@@ -43968,6 +44288,15 @@ void main() {
     out_FragColor = vec4(color.rgb, color.a * v_coverage);
 }
 `;
+    /*
+     * Strips the water-only regions out of a shader source unless this surface is drawing water.
+     */
+    function withWater(source, water) {
+        if (water) {
+            return source.replace(/^\/\/#(end)?water\n/gm, "");
+        }
+        return source.replace(/^\/\/#water\n[\s\S]*?^\/\/#endwater\n/gm, "");
+    }
     /*
      * Rewrites a GLSL 300 es source into the GLSL 100 dialect older Cesium builds author in.
      */
@@ -44296,6 +44625,7 @@ void main() {
             this.texture = null;
             this.textureDirty = true;
             this.shaderProgram = null;
+            this.shaderProgramWater = false;
             this.renderState = null;
             this.destroyed = false;
             this.lastEyePosition = null;
@@ -44315,6 +44645,10 @@ void main() {
             this.water = null;
             this.waterStartMs = now();
             this.waveOrigin = new Cartesian2(0, 0);
+            this.extentMetresCache = null;
+            // Written in place each frame rather than reallocated, since they are read per tile.
+            this.wavePhaseScratch = [new Cartesian4(), new Cartesian4()];
+            this.waterSkyScratch = new Cartesian3();
             this.followGround = Boolean(options.followGround);
             this.terrainProvider = options.terrainProvider || null;
             this.extent = options.extent;
@@ -44739,32 +45073,45 @@ void main() {
          * 0..1 surface coordinate into the real distance the ripple wavelength is measured in.
          */
         extentMetres() {
+            // The extent never moves, and this is read once per tile per frame.
+            if (this.extentMetresCache) {
+                return this.extentMetresCache;
+            }
             const southWest = Cartesian3.fromDegrees(this.extent.West, this.extent.South, 0);
             const southEast = Cartesian3.fromDegrees(this.extent.East, this.extent.South, 0);
             const northWest = Cartesian3.fromDegrees(this.extent.West, this.extent.North, 0);
-            return new Cartesian2(Math.max(1, Cartesian3.distance(southWest, southEast)), Math.max(1, Cartesian3.distance(southWest, northWest)));
+            this.extentMetresCache = new Cartesian2(Math.max(1, Cartesian3.distance(southWest, southEast)), Math.max(1, Cartesian3.distance(southWest, northWest)));
+            return this.extentMetresCache;
         }
         /*
          * Where each ripple layer has scrolled to, wrapped into one turn.
          */
         wavePhase(from) {
             var _a;
+            const into = this.wavePhaseScratch[from / 4];
             const water = this.water;
             if (!water) {
-                return new Cartesian4(0, 0, 0, 0);
+                return Cartesian4.clone(Cartesian4.ZERO, into);
             }
             const speed = (_a = water.speed) !== null && _a !== void 0 ? _a : DEFAULT_WATER_SPEED_METRES_PER_SECOND;
             const period = this.wavePeriod();
             const seconds = (now() - this.waterStartMs) / 1000;
             const base = waveCycles(WATER_WAVES[WATER_BASE_WAVE]);
-            const phases = WATER_WAVES.slice(from, from + 4).map((wave) => {
+            const phaseAt = (index) => {
+                const wave = WATER_WAVES[from + index];
+                if (!wave) {
+                    return 0;
+                }
                 const cycles = waveCycles(wave);
                 const waveNumber = 2 * Math.PI * cycles / period;
                 const travels = Math.sqrt(base / cycles);
-                const travelled = seconds * speed * travels * waveNumber;
-                return travelled % (2 * Math.PI);
-            });
-            return new Cartesian4(phases[0] || 0, phases[1] || 0, phases[2] || 0, phases[3] || 0);
+                return (seconds * speed * travels * waveNumber) % (2 * Math.PI);
+            };
+            into.x = phaseAt(0);
+            into.y = phaseAt(1);
+            into.z = phaseAt(2);
+            into.w = phaseAt(3);
+            return into;
         }
         wavePeriod() {
             const wavelength = (this.water && this.water.wavelength) || DEFAULT_WATER_WAVELENGTH_METRES;
@@ -44951,14 +45298,22 @@ void main() {
             return isFinite(nearest) ? Math.max(1, nearest) : 1;
         }
         commandFor(context, tile, mesh) {
+            // Rebuilt when the effect is switched, since which program is wanted is part of it.
+            const wantsWater = Boolean(this.water);
+            if (this.shaderProgram && this.shaderProgramWater !== wantsWater) {
+                this.shaderProgram = null;
+            }
             if (!this.shaderProgram) {
                 const glsl300 = usesGlsl300(context);
+                const vertex = withWater(VERTEX_SHADER_GLSL300, wantsWater);
+                const fragment = withWater(FRAGMENT_SHADER_GLSL300, wantsWater);
                 this.shaderProgram = ShaderProgram.fromCache({
                     context,
-                    vertexShaderSource: glsl300 ? VERTEX_SHADER_GLSL300 : toGlsl100(VERTEX_SHADER_GLSL300, false),
-                    fragmentShaderSource: glsl300 ? FRAGMENT_SHADER_GLSL300 : toGlsl100(FRAGMENT_SHADER_GLSL300, true),
+                    vertexShaderSource: glsl300 ? vertex : toGlsl100(vertex, false),
+                    fragmentShaderSource: glsl300 ? fragment : toGlsl100(fragment, true),
                     attributeLocations: mesh.attributeLocations
                 });
+                this.shaderProgramWater = wantsWater;
                 this.renderState = RenderState.fromCache({
                     depthTest: { enabled: true },
                     // Translucent ramp: blend, and leave the depth buffer to the opaque world.
@@ -45034,7 +45389,7 @@ void main() {
                         },
                         u_waterSky: () => {
                             const sky = (self.water && self.water.skyColor) || DEFAULT_WATER_SKY_COLOR;
-                            return new Cartesian3(sky.red / 255, sky.green / 255, sky.blue / 255);
+                            return Cartesian3.fromElements(sky.red / 255, sky.green / 255, sky.blue / 255, self.waterSkyScratch);
                         },
                         u_wavePhase: () => self.wavePhase(0),
                         u_wavePhaseB: () => self.wavePhase(4),
@@ -45045,6 +45400,7 @@ void main() {
                 });
             }
             // Bounding volume belongs to the mesh, so it follows whichever tier is drawing.
+            tile.command.shaderProgram = this.shaderProgram;
             tile.command.vertexArray = mesh.vertexArray;
             tile.command.boundingVolume = mesh.boundingSphere;
             return tile.command;
@@ -47006,6 +47362,28 @@ var EntityRenderEngine;
         };
     }
     EntityRenderEngine.Render = Render;
+    /**
+     * Removes what a render produced that nothing has a record of, for a render whose caller has gone away.
+     * @param params
+     */
+    function RemoveAll(params) {
+        const { viewer, entities, register } = params;
+        if (!entities || viewer.isDestroyed()) {
+            return;
+        }
+        entities.forEach((entity) => {
+            if (!entity || (register === null || register === void 0 ? void 0 : register.HasRego(entity))) {
+                return;
+            }
+            try {
+                Remove({ viewer, entity });
+            }
+            catch (e) {
+                console.error("EntityRenderEngine.RemoveAll: failed to remove a visual:", e);
+            }
+        });
+    }
+    EntityRenderEngine.RemoveAll = RemoveAll;
     function Remove(params) {
         function doRemove(params) {
             const { viewer, entity, ignoreParent } = params;
@@ -47834,7 +48212,7 @@ var StyleUtils;
     StyleUtils.ApplyTypeStyle = ApplyTypeStyle;
 })(StyleUtils || (StyleUtils = {}));
 
-const VERSION = "7.3.7";
+const VERSION = "7.3.9";
 /**
  * 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.