bruce-cesium 7.7.3 → 7.7.5

package/dist/bruce-cesium.es5.js

@@ -1,6 +1,6 @@
 import * as Cesium from 'cesium';
-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, PixelDatatype, VertexArray, BufferUsage, ShaderProgram, RenderState, BlendingState, DrawCommand, Pass, ConstantPositionProperty, HeightReference, DistanceDisplayCondition, JulianDate, Quaternion, HeadingPitchRoll, ColorBlendMode, ShadowMode, ClassificationType, Model, HorizontalOrigin, VerticalOrigin, ArcType, CornerType, ImageMaterialProperty, PolygonHierarchy, PolylineGraphics, Rectangle, SceneMode, IntersectionTests, Ray, SceneTransforms, FeatureDetection, Matrix3, NearFarScalar, KmlDataSource, 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, EllipsoidGeodesic, sampleTerrainMostDetailed, defined, CustomDataSource, GeometryInstance, PolygonPipeline, CesiumInspector, ClockRange, DynamicEnvironmentMapManager, ScreenSpaceEventHandler, ScreenSpaceEventType, Fullscreen, CzmlDataSource } from 'cesium';
-import { Cartes, LRUCache, Carto, ProjectViewTile, EntityHistoricData, BruceEvent, DelayQueue, Entity as Entity$1, EntityTag, ClientFile, ENVIRONMENT, EntityAttachmentType, EntityRelationType, EntityType, Tileset, Calculator, DataLab, Style, ObjectUtils, MenuItem, AccountConcept, RecordChangeFeed, EntityLod, UrlUtils, Api, Geometry as Geometry$1, Bounds, ClientFileValueMap, Color as Color$1, ProjectView, ProjectViewBookmark, ZoomControl, Assembly, EntityCoords, BruceApi, EntityRelation, EntitySource, Camera, ProgramKey, ProjectViewLegacyTile, Account, AccountLimits, Session, EntityAttachment, EntityAttribute, MathUtils, ProjectViewBookmarkGroup } from 'bruce-models';
+import { Cartographic, Entity, ConstantPositionProperty, HeightReference, Color, DistanceDisplayCondition, ColorMaterialProperty, ConstantProperty, CallbackProperty, Primitive, Cesium3DTileFeature, ColorBlendMode, HeadingPitchRoll, Math as Math$1, Transforms, ShadowMode, Cartesian3, Model, ClassificationType, Matrix4, JulianDate, Quaternion, ArcType, CornerType, ShaderSource, Ellipsoid, Geometry, GeometryAttribute, ComponentDatatype, PrimitiveType, BoundingSphere, GeometryPipeline, Cartesian2, Cartesian4, sampleTerrain, Texture, PixelFormat, Sampler, TextureWrap, TextureMinificationFilter, TextureMagnificationFilter, PixelDatatype, VertexArray, BufferUsage, ShaderProgram, RenderState, BlendingState, DrawCommand, Pass, HorizontalOrigin, VerticalOrigin, SceneMode, IntersectionTests, Ray, SceneTransforms, ImageMaterialProperty, PolygonHierarchy, PolylineGraphics, Rectangle, NearFarScalar, Matrix3, KmlDataSource, GeoJsonDataSource, FeatureDetection, Cesium3DTileStyle, HeadingPitchRange, Ion, IonResource, Cesium3DTileColorBlendMode, EllipsoidTerrainProvider, IonImageryProvider, createWorldImagery, createWorldImageryAsync, BingMapsImageryProvider, BingMapsStyle, MapboxImageryProvider, MapboxStyleImageryProvider, ArcGisMapServerImageryProvider, OpenStreetMapImageryProvider, UrlTemplateImageryProvider, GridImageryProvider, GeographicTilingScheme, ImageryLayer, TileMapServiceImageryProvider, CesiumTerrainProvider, Cesium3DTileset, OrthographicFrustum, EasingFunction, ModelGraphics, PolygonGraphics, CorridorGraphics, PointGraphics, BillboardGraphics, EllipseGraphics, PolylineDashMaterialProperty, EllipsoidGeodesic, sampleTerrainMostDetailed, defined, WebGLConstants, Intersect, PolygonPipeline, CustomDataSource, CesiumInspector, ClockRange, DynamicEnvironmentMapManager, GeometryInstance, ScreenSpaceEventHandler, ScreenSpaceEventType, Fullscreen, CzmlDataSource } from 'cesium';
+import { Cartes, LRUCache, Carto, ProjectViewTile, EntityHistoricData, BruceEvent, DelayQueue, Entity as Entity$1, EntityTag, ClientFile, ENVIRONMENT, EntityAttachmentType, EntityRelationType, EntityType, Tileset, Calculator, DataLab, Style, ObjectUtils, MenuItem, AccountConcept, RecordChangeFeed, EntityLod, UrlUtils, Geometry as Geometry$1, Api, ClientFileValueMap, Color as Color$1, Bounds, ZoomControl, Assembly, EntityCoords, ProjectView, ProjectViewBookmark, EntityRelation, BruceApi, EntitySource, ProgramKey, ProjectViewLegacyTile, Camera, Account, AccountLimits, Session, EntityAttachment, EntityAttribute, MathUtils, ProjectViewBookmarkGroup } from 'bruce-models';
 
 /**
  * Ensures a number is returned from a given value.
@@ -28178,10 +28178,13 @@ var DataSourceStaticKmlManager;
  */
 var XGridsRenderEngine;
 (function (XGridsRenderEngine) {
+    /*
+     * Loads a scan with optional SDK tuning and per-viewer budget control.
+     */
     function Render(params) {
-        var _a, _b, _c;
+        var _a, _b, _c, _d;
         const { api, viewer, tileset } = params;
-        if (!LCCRender) {
+        if (typeof LCCRender === "undefined" || typeof (LCCRender === null || LCCRender === void 0 ? void 0 : LCCRender.load) !== "function") {
             console.warn("[XGridsRenderEngine] Render() LCCRender library not available.");
             return null;
         }
@@ -28224,6 +28227,46 @@ var XGridsRenderEngine;
         if (loadUrl.indexOf("?") !== -1) {
             loadUrl = loadUrl.split("?")[0];
         }
+        let maxSplats = 6000000;
+        /*
+         * Configures optional LOD capabilities once metadata or initial geometry is ready.
+         */
+        const configure = (object, ready) => {
+            var _a, _b, _c;
+            if (!object || object["_nextspaceLodRemoved"] || object["_nextspaceLodConfigured"] || ((_a = viewer.isDestroyed) === null || _a === void 0 ? void 0 : _a.call(viewer))) {
+                return;
+            }
+            try {
+                if (typeof object.setMaxSplats !== "function") {
+                    return;
+                }
+                const lods = typeof object.getLodInfos === "function" ? object.getLodInfos() : undefined;
+                const adaptive = (LCCRender.nextspaceAdaptiveLod === 1 &&
+                    typeof object.setNextspaceMetadataCallback === "function" &&
+                    Array.isArray(lods) &&
+                    typeof object.setVisible === "function" &&
+                    typeof object.setLodAutoLevelUp === "function");
+                // Unpatched SDKs still need the legacy clamp to avoid their fixed LOD shortcut.
+                const budget = !adaptive && (lods === null || lods === void 0 ? void 0 : lods[0]) > maxSplats && (lods === null || lods === void 0 ? void 0 : lods[1]) > 0
+                    ? Math.min(maxSplats, lods[1]) : maxSplats;
+                object.setMaxSplats(budget);
+                // A requested fly-to needs its initial data before off-screen culling can take over.
+                if (adaptive &&
+                    (!params.flyTo || ready) &&
+                    ((_b = viewer.scene.preUpdate) === null || _b === void 0 ? void 0 : _b.addEventListener) &&
+                    ((_c = viewer.scene.postRender) === null || _c === void 0 ? void 0 : _c.addEventListener)) {
+                    const controller = viewer["_nextspaceXGridsLod"] ||
+                        (viewer["_nextspaceXGridsLod"] = new AdaptiveLod(viewer));
+                    controller.Add(object, maxSplats);
+                    controller.Update();
+                }
+                object["_nextspaceLodConfigured"] = !params.flyTo || ready;
+            }
+            catch (error) {
+                // Optional SDK tuning must not abort its metadata parsing or the Cesium render loop.
+                console.warn("[XGridsRenderEngine] Optional LOD setup unavailable.", error);
+            }
+        };
         const obj = LCCRender.load({
             camera: viewer.camera,
             scene: viewer.scene,
@@ -28237,24 +28280,19 @@ var XGridsRenderEngine;
             // When true it makes the new pieces fade-in.
             // The look is similar to sectioning in cesium. Might be a nice setting.
             useLoadingEffect: false
-        }, async () => {
-            var _a, _b;
-            // Array index is the LOD level, ie: index 0 = LOD 0.
-            const lods = obj.getLodInfos();
-            //console.log("xgrids-getLodInfos()", lods);
-            const HARD_MIN = 1000000;
-            const HARD_MAX = 20000000;
-            const maxSplats = Math.max(lods ? lods[0] || 0 : 0, HARD_MIN);
-            obj.setMaxSplats(Math.min(HARD_MAX, maxSplats));
-            if (maxSplats >= HARD_MAX) {
-                console.warn("Reduced splat quality due to the number of splats being too large. Was: \"" + maxSplats + "\", now is: \"" + HARD_MAX + "\".");
+        }, async (loaded) => {
+            var _a, _b, _c;
+            const object = loaded || obj;
+            if (!object || object["_nextspaceLodRemoved"] || ((_a = viewer.isDestroyed) === null || _a === void 0 ? void 0 : _a.call(viewer))) {
+                return;
             }
+            configure(object, true);
             // Auto fly to.
             if (params.flyTo) {
-                const pos3d = (_b = (_a = obj === null || obj === void 0 ? void 0 : obj.getBounds) === null || _a === void 0 ? void 0 : _a.call(obj)) === null || _b === void 0 ? void 0 : _b.origin;
+                const pos3d = typeof object.getBounds === "function" ? (_b = object.getBounds()) === null || _b === void 0 ? void 0 : _b.origin : undefined;
                 if (pos3d && Cartes.ValidateCartes3(pos3d)) {
                     const altered = await DrawingUtils.RaisePos3d(viewer, pos3d, 300);
-                    if (altered && Cartes.ValidateCartes3(altered)) {
+                    if (!object["_nextspaceLodRemoved"] && !((_c = viewer.isDestroyed) === null || _c === void 0 ? void 0 : _c.call(viewer)) && altered && Cartes.ValidateCartes3(altered)) {
                         viewer.scene.camera.flyTo({
                             destination: altered,
                             orientation: {
@@ -28269,14 +28307,46 @@ var XGridsRenderEngine;
                 }
             }
         });
+        if (!obj) {
+            return null;
+        }
+        try {
+            const sdkBudget = typeof obj.getCurrentConfig === "function" ? (_d = obj.getCurrentConfig()) === null || _d === void 0 ? void 0 : _d.maxLoadSplatCount : undefined;
+            // Preserve the SDK's mobile and weak-GPU limits before applying any temporary startup cap.
+            maxSplats = Number.isFinite(sdkBudget) && sdkBudget > 0 && sdkBudget <= 2000000 ? sdkBudget : 6000000;
+            if (LCCRender.nextspaceMetadataReady === 1 &&
+                typeof obj.setNextspaceMetadataCallback === "function" &&
+                typeof obj.setMaxSplats === "function") {
+                obj.setNextspaceMetadataCallback((object) => configure(object, false));
+                obj.setMaxSplats(Math.min(maxSplats, 1000000));
+            }
+        }
+        catch (error) {
+            console.warn("[XGridsRenderEngine] Optional startup LOD setup unavailable.", error);
+        }
+        if (typeof (obj === null || obj === void 0 ? void 0 : obj.setRenderState) === "function") {
+            // Splats must respect nearer meshes already drawn in the same Cesium pass.
+            obj.setRenderState({
+                depthTest: {
+                    enabled: true,
+                    func: WebGLConstants.LEQUAL
+                },
+                // Transparent Gaussian edges must not occlude the splats blended behind them.
+                depthMask: false
+            });
+        }
         if (typeof (obj === null || obj === void 0 ? void 0 : obj.setVisible) === "function") {
             obj.setVisible(true);
         }
         TilesetRenderEngine.WatchDateRange(viewer, obj, tileset);
         // Highest LOD.
-        obj.setStartLod(0);
+        if (typeof obj.setStartLod === "function") {
+            obj.setStartLod(0);
+        }
         // Max distance for rendering.
-        obj.setMaxDistance(800);
+        if (typeof obj.setMaxDistance === "function") {
+            obj.setMaxDistance(800);
+        }
         // Adjust LODs based on camera distance.
         if (typeof obj.setLodAutoLevelUp === "function") {
             obj.setLodAutoLevelUp(true);
@@ -28284,18 +28354,299 @@ var XGridsRenderEngine;
         return obj;
     }
     XGridsRenderEngine.Render = Render;
+    /*
+     * Detaches optional tuning before unloading the scan.
+     */
     function Remove(viewer, renderObject) {
+        var _a;
         if (!renderObject) {
             return;
         }
-        if (!LCCRender) {
+        renderObject["_nextspaceLodRemoved"] = true;
+        delete renderObject.nextspaceOnMetadata;
+        (_a = viewer === null || viewer === void 0 ? void 0 : viewer["_nextspaceXGridsLod"]) === null || _a === void 0 ? void 0 : _a.Remove(renderObject);
+        TilesetRenderEngine.UnwatchDateRange(viewer, renderObject);
+        if (typeof LCCRender === "undefined" || typeof (LCCRender === null || LCCRender === void 0 ? void 0 : LCCRender.unload) !== "function") {
             console.warn("[XGridsRenderEngine] Remove() LCCRender library not available.");
             return;
         }
-        TilesetRenderEngine.UnwatchDateRange(viewer, renderObject);
         LCCRender.unload(renderObject);
     }
     XGridsRenderEngine.Remove = Remove;
+    /*
+     * Shares a bounded splat budget across visible scans without overriding layer or timeline visibility.
+     */
+    class AdaptiveLod {
+        /*
+         * Observes scene updates and rendered frames for this viewer only.
+         */
+        constructor(viewer) {
+            this.viewer = viewer;
+            this.entries = [];
+            this.removals = [];
+            this.lastUpdate = -Infinity;
+            this.lastAllocation = -Infinity;
+            this.lastFrame = 0;
+            this.lastMove = 0;
+            this.slowSince = 0;
+            this.fastSince = 0;
+            this.lastChange = -Infinity;
+            this.scale = 1;
+            this.position = new Cartesian3();
+            this.direction = new Cartesian3();
+            this.havePose = false;
+            this.removals.push(viewer.scene.preUpdate.addEventListener(() => {
+                try {
+                    this.Update();
+                }
+                catch (error) {
+                    console.warn("[XGridsRenderEngine] Optional LOD controller disabled.", error);
+                    this.Dispose();
+                }
+            }));
+            this.removals.push(viewer.scene.postRender.addEventListener(() => {
+                const camera = viewer.scene.camera;
+                const moving = this.havePose && (Cartesian3.distanceSquared(camera.positionWC, this.position) > 0.000001 ||
+                    Cartesian3.distanceSquared(camera.directionWC, this.direction) > 0.00000001);
+                Cartesian3.clone(camera.positionWC, this.position);
+                Cartesian3.clone(camera.directionWC, this.direction);
+                this.havePose = true;
+                this.ObserveFrame(performance.now(), moving);
+            }));
+        }
+        /*
+         * Registers a scan while preserving the caller's visibility intent.
+         */
+        Add(object, maxBudget) {
+            var _a, _b, _c, _d;
+            if (this.entries.some(entry => entry.object === object)) {
+                return;
+            }
+            if (typeof object.setMaxSplats !== "function") {
+                return;
+            }
+            const lods = typeof object.getLodInfos === "function" ? object.getLodInfos() : undefined;
+            const finest = lods === null || lods === void 0 ? void 0 : lods[0];
+            const coarsest = (lods === null || lods === void 0 ? void 0 : lods.length) > 1 ? lods[lods.length - 1] : 0;
+            const entry = {
+                object, maxBudget,
+                capacity: Number.isFinite(finest) && finest > 0 ? Math.min(maxBudget, finest) : maxBudget,
+                minimum: Number.isFinite(coarsest) && coarsest > 0 ? Math.min(maxBudget, coarsest) : 0,
+                wantedVisible: ((_b = (_a = object.getCurrentConfig) === null || _a === void 0 ? void 0 : _a.call(object)) === null || _b === void 0 ? void 0 : _b.visible) !== false,
+                visible: ((_d = (_c = object.getCurrentConfig) === null || _c === void 0 ? void 0 : _c.call(object)) === null || _d === void 0 ? void 0 : _d.visible) !== false,
+                culled: false, setVisible: object.setVisible, budget: -1, nodeBudget: -1,
+                radiusPixels: Infinity, surfaceDistance: Infinity, weight: 1, near: false
+            };
+            if (typeof entry.setVisible === "function") {
+                object.setVisible = (visible) => {
+                    entry.wantedVisible = !!visible;
+                    this.applyVisibility(entry);
+                    this.lastUpdate = -Infinity;
+                    this.lastAllocation = -Infinity;
+                };
+            }
+            this.entries.push(entry);
+            this.lastMove = performance.now();
+            this.lastUpdate = -Infinity;
+            this.lastAllocation = -Infinity;
+        }
+        /*
+         * Combines explicit visibility with temporary camera culling.
+         */
+        applyVisibility(entry) {
+            const visible = entry.wantedVisible && !entry.culled;
+            if (entry.visible !== visible && typeof entry.setVisible === "function") {
+                entry.visible = visible;
+                entry.setVisible.call(entry.object, visible);
+                this.viewer.scene.requestRender();
+            }
+        }
+        /*
+         * Render pressure uses elapsed wall time because a paused timeline must still adapt.
+         */
+        ObserveFrame(now, moving) {
+            const gap = now - this.lastFrame;
+            this.lastFrame = now;
+            if (moving) {
+                this.lastMove = now;
+            }
+            if (!moving || gap <= 0 || gap > 1000) {
+                this.slowSince = this.fastSince = 0;
+                return;
+            }
+            this.slowSince = gap > 40 ? this.slowSince || now : 0;
+            this.fastSince = gap < 22 ? this.fastSince || now : 0;
+            if (now - this.lastChange < 4000) {
+                return;
+            }
+            if (this.slowSince && now - this.slowSince >= 1500 && this.scale > 0.25) {
+                this.scale = Math.max(0.25, this.scale * 0.75);
+                this.lastChange = now;
+                this.slowSince = this.fastSince = 0;
+                this.lastUpdate = -Infinity;
+            }
+            else if (this.fastSince && now - this.fastSince >= 6000 && this.scale < 1) {
+                this.scale = Math.min(1, this.scale + 0.125);
+                this.lastChange = now;
+                this.slowSince = this.fastSince = 0;
+                this.lastUpdate = -Infinity;
+            }
+        }
+        /*
+         * Estimates visible screen coverage and distance, failing open for unknown bounds.
+         */
+        measure(entry) {
+            var _a;
+            entry.weight = 1;
+            entry.radiusPixels = entry.surfaceDistance = Infinity;
+            try {
+                const object = entry.object;
+                const bounds = (_a = object.getBounds) === null || _a === void 0 ? void 0 : _a.call(object);
+                const matrix = object.modelMatrix;
+                const camera = this.viewer.scene.camera;
+                const width = this.viewer.scene.drawingBufferWidth;
+                const height = this.viewer.scene.drawingBufferHeight;
+                if (!(bounds === null || bounds === void 0 ? void 0 : bounds.min) || !(bounds === null || bounds === void 0 ? void 0 : bounds.max) || !matrix || !(width > 0 && height > 0)) {
+                    entry.culled = false;
+                    return;
+                }
+                const center = Cartesian3.midpoint(bounds.min, bounds.max, new Cartesian3());
+                Matrix4.multiplyByPoint(matrix, center, center);
+                const scale = Matrix4.getMaximumScale(matrix);
+                const radius = Cartesian3.distance(bounds.min, bounds.max) * scale * 0.55 + 1;
+                const distance = Cartesian3.distance(camera.positionWC, center);
+                const pixel = camera.frustum.getPixelDimensions(width, height, Math.max(1, distance), 1, new Cartesian2());
+                const pixels = radius / Math.max(pixel.x, pixel.y);
+                if (!Number.isFinite(pixels) || !(radius > 0)) {
+                    entry.culled = false;
+                    return;
+                }
+                const sphere = new BoundingSphere(center, radius);
+                const frustum = camera.frustum.computeCullingVolume(camera.positionWC, camera.directionWC, camera.upWC);
+                const outside = frustum.computeVisibility(sphere) === Intersect.OUTSIDE;
+                entry.culled = outside || pixels < (entry.culled ? 1.5 : 0.75);
+                entry.radiusPixels = pixels;
+                entry.weight = Math.pow(Math.min(1, Math.max(0.05, pixels / height)), 2);
+                const local = Matrix4.multiplyByPoint(Matrix4.inverse(matrix, new Matrix4()), camera.positionWC, new Cartesian3());
+                const nearest = new Cartesian3(Math$1.clamp(local.x, bounds.min.x, bounds.max.x), Math$1.clamp(local.y, bounds.min.y, bounds.max.y), Math$1.clamp(local.z, bounds.min.z, bounds.max.z));
+                entry.surfaceDistance = Cartesian3.distance(local, nearest) * scale;
+            }
+            catch {
+                // Unknown bounds or a changed optional SDK must fail open instead of hiding the scan.
+                entry.culled = false;
+            }
+        }
+        /*
+         * Allocates the shared hardware budget across visible scans with hysteresis.
+         */
+        Update(now = performance.now()) {
+            var _a, _b;
+            if ((_b = (_a = this.viewer).isDestroyed) === null || _b === void 0 ? void 0 : _b.call(_a)) {
+                this.Dispose();
+                return;
+            }
+            if (now - this.lastUpdate < 250) {
+                return;
+            }
+            this.lastUpdate = now;
+            // A still view can recover detail gradually without treating missing frames as a slow GPU.
+            if (now - this.lastMove > 3000 && now - this.lastChange > 6000 && this.scale < 1) {
+                this.scale = Math.min(1, this.scale + 0.125);
+                this.lastChange = now;
+            }
+            for (const entry of this.entries) {
+                this.measure(entry);
+                this.applyVisibility(entry);
+            }
+            const visible = this.entries.filter(entry => entry.wantedVisible && !entry.culled);
+            if (!visible.length || now - this.lastAllocation < 2000) {
+                return;
+            }
+            this.lastAllocation = now;
+            const maximum = Math.max(...visible.map(entry => entry.maxBudget));
+            const minimum = visible.reduce((sum, entry) => sum + Math.min(entry.capacity, entry.minimum), 0);
+            // Preserve authored coarse coverage when it fits; dropping below a whole tile can erase a scan.
+            const reserve = minimum <= maximum;
+            let remaining = Math.max(maximum * this.scale, reserve ? minimum : 0);
+            const allocations = new Map();
+            visible.forEach(entry => {
+                const floor = reserve ? Math.min(entry.capacity, entry.minimum) : 0;
+                allocations.set(entry, floor);
+                remaining -= floor;
+            });
+            let pending = visible.filter(entry => allocations.get(entry) < entry.capacity);
+            while (pending.length) {
+                const totalWeight = pending.reduce((sum, entry) => sum + entry.weight, 0);
+                const capped = pending.filter(entry => remaining * entry.weight / totalWeight >= entry.capacity - allocations.get(entry));
+                if (!capped.length) {
+                    pending.forEach(entry => allocations.set(entry, allocations.get(entry) + remaining * entry.weight / totalWeight));
+                    break;
+                }
+                capped.forEach(entry => {
+                    remaining -= entry.capacity - allocations.get(entry);
+                    allocations.set(entry, entry.capacity);
+                });
+                pending = pending.filter(entry => allocations.get(entry) < entry.capacity);
+            }
+            for (const entry of visible) {
+                const allocation = allocations.get(entry);
+                const step = allocation < 250000 ? 10000 : 250000;
+                const budget = allocation >= entry.capacity ? entry.capacity : Math.max(1, reserve ? entry.minimum : 0, Math.floor(allocation / step) * step);
+                const near = entry.surfaceDistance < (entry.near ? 20 : 12) && entry.radiusPixels > (entry.near ? 80 : 120);
+                entry.near = near;
+                const ceiling = entry.maxBudget <= 2000000 ? entry.maxBudget / 2 : near ? 4000000 : 2000000;
+                const nodeBudget = Math.max(1, Math.min(ceiling, entry.capacity <= ceiling ? budget : budget * (near ? 2 / 3 : 1 / 3)));
+                if (entry.budget !== budget) {
+                    entry.object.setMaxSplats(budget);
+                    entry.budget = budget;
+                    this.viewer.scene.requestRender();
+                }
+                if (entry.nodeBudget !== nodeBudget && typeof entry.object.setMaxNodeSplats === "function") {
+                    entry.object.setMaxNodeSplats(nodeBudget);
+                    entry.nodeBudget = nodeBudget;
+                    this.viewer.scene.requestRender();
+                }
+            }
+        }
+        /*
+         * Restores the scan's visibility method and releases unused listeners.
+         */
+        Remove(object) {
+            const entry = this.entries.find(entry => entry.object === object);
+            if (entry) {
+                object.setVisible = entry.setVisible;
+                this.entries = this.entries.filter(other => other !== entry);
+                this.lastUpdate = -Infinity;
+                this.lastAllocation = -Infinity;
+            }
+            if (!this.entries.length) {
+                this.Dispose();
+            }
+        }
+        /*
+         * Restores visibility intent and releases all controller listeners.
+         */
+        Dispose() {
+            this.removals.forEach(remove => remove());
+            this.removals = [];
+            this.entries.forEach(entry => {
+                entry.object.setVisible = entry.setVisible;
+                try {
+                    if (entry.visible !== entry.wantedVisible && typeof entry.setVisible === "function") {
+                        entry.setVisible.call(entry.object, entry.wantedVisible);
+                    }
+                }
+                catch {
+                    // A disposed or replaced optional SDK must not break viewer cleanup.
+                }
+            });
+            this.entries = [];
+            if (this.viewer["_nextspaceXGridsLod"] === this) {
+                delete this.viewer["_nextspaceXGridsLod"];
+            }
+        }
+    }
+    XGridsRenderEngine.AdaptiveLod = AdaptiveLod;
     /**
      * Applies position, rotation, and scale to a live XGrids render object.
      */
@@ -49596,88 +49947,103 @@ var EntityRenderEngineModel3d;
             });
             cEntity.show = true;
         }
-        const fileRadiusKey = `model3d_${UrlUtils.RemoveSignature(params.lodUrl)}_${scale * styleScale}_radius`;
-        let heightProm = _fileRadiusCache.Get(fileRadiusKey);
-        if (!heightProm) {
-            heightProm = new Promise(async (res) => {
-                try {
-                    // We'll have an async secondary model created for calculating boundaries.
-                    // Once calculated we remove it.
-                    const modelPrim = await getModelEntity(params.lodUrl, scale * styleScale);
-                    const onReady = () => {
-                        readyEventRemoval === null || readyEventRemoval === void 0 ? void 0 : readyEventRemoval();
-                        readyEventRemoval = null;
-                        const kill = () => {
-                            if (params.viewer && !params.viewer.isDestroyed() && params.viewer.scene.primitives.contains(modelPrim)) {
-                                params.viewer.scene.primitives.remove(modelPrim);
+        const model = cEntity.model;
+        model._radiusLoaded = false;
+        /*
+         * Retains bounds measurement for hosts that cannot expose the displayed model.
+         */
+        const measureTemporaryModelBounds = () => {
+            const fileRadiusKey = `model3d_${UrlUtils.RemoveSignature(params.lodUrl)}_${scale * styleScale}_radius`;
+            let heightProm = _fileRadiusCache.Get(fileRadiusKey);
+            if (!heightProm) {
+                heightProm = new Promise(async (res) => {
+                    try {
+                        // The fallback needs a temporary primitive until its bounds become available.
+                        const modelPrim = await getModelEntity(params.lodUrl, scale * styleScale);
+                        /*
+                         * Copies bounds before releasing the temporary primitive.
+                         */
+                        const onReady = () => {
+                            readyEventRemoval === null || readyEventRemoval === void 0 ? void 0 : readyEventRemoval();
+                            readyEventRemoval = null;
+                            /*
+                             * Releases the temporary primitive even if the viewer was destroyed.
+                             */
+                            const kill = () => {
+                                if (params.viewer && !params.viewer.isDestroyed() && params.viewer.scene.primitives.contains(modelPrim)) {
+                                    params.viewer.scene.primitives.remove(modelPrim);
+                                }
+                                if (!modelPrim.isDestroyed()) {
+                                    modelPrim.destroy();
+                                }
+                            };
+                            if (!cEntity || !(modelPrim === null || modelPrim === void 0 ? void 0 : modelPrim.boundingSphere)) {
+                                kill();
+                                res(null);
+                                return;
                             }
-                            if (!modelPrim.isDestroyed()) {
-                                modelPrim.destroy();
+                            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) {
+                                // Include the offset so origin-based culling contains the full model.
+                                const magnitude = Cartesian3.magnitude(centerOffset);
+                                radius += magnitude;
+                                // Preserve extra culling padding for models with large origin offsets.
+                                if (magnitude > 100) {
+                                    radius += 100;
+                                }
                             }
-                        };
-                        if (!cEntity || !(modelPrim === null || modelPrim === void 0 ? void 0 : modelPrim.boundingSphere)) {
                             kill();
-                            res(null);
-                            return;
-                        }
-                        let radius = modelPrim.boundingSphere.radius;
-                        let centerOffset = modelPrim.boundingSphere.center;
-                        const bounds = {
-                            center: centerOffset ? Cartesian3.clone(centerOffset) : Cartesian3.ZERO.clone(),
-                            radius: modelPrim.boundingSphere.radius
+                            res({ radius, bounds });
                         };
-                        if (centerOffset) {
-                            // Add the center offset to the radius because I am not good at math.
-                            const magnitude = Cartesian3.magnitude(centerOffset);
-                            radius += magnitude;
-                            // Extra padding if the model is super not centered.
-                            // I saw some strange boundaries for some bad models.
-                            if (magnitude > 100) {
-                                radius += 100;
-                            }
+                        let readyEventRemoval = null;
+                        // Prefer the ready event when the host exposes it.
+                        if (modelPrim["readyEvent"]) {
+                            modelPrim["readyEvent"].addEventListener(onReady);
+                        }
+                        // Retain compatibility with promise-based hosts.
+                        else if (modelPrim["readyPromise"]) {
+                            modelPrim["readyPromise"].then(() => {
+                                onReady();
+                            }).catch((e) => {
+                                console.error(e);
+                                res(null);
+                            });
                         }
-                        kill();
-                        res({ radius, bounds });
-                    };
-                    let readyEventRemoval = null;
-                    // Newer Cesium versions have readyEvent. They don't use readyPromise.
-                    if (modelPrim["readyEvent"]) {
-                        modelPrim["readyEvent"].addEventListener(onReady);
-                    }
-                    // Older Cesium versions don't have readyEvent, they use readyPromise.
-                    else if (modelPrim["readyPromise"]) {
-                        modelPrim["readyPromise"].then(() => {
-                            onReady();
-                        }).catch((e) => {
-                            console.error(e);
-                            res(null);
-                        });
+                        params.viewer.scene.primitives.add(modelPrim);
+                    }
+                    catch (e) {
+                        console.error(e);
+                        res(null);
+                    }
+                });
+                _fileRadiusCache.Set(fileRadiusKey, heightProm);
+            }
+            heightProm.then((measured) => {
+                if (model) {
+                    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);
                     }
-                    params.viewer.scene.primitives.add(modelPrim);
                 }
-                catch (e) {
-                    console.error(e);
-                    res(null);
+                // Rough estimate on when the model is ready in the scene.
+                if (animateScale) {
+                    animateScale.Play();
                 }
             });
-            _fileRadiusCache.Set(fileRadiusKey, heightProm);
+        };
+        if (Model.fromGltfAsync) {
+            trackRenderedModelBounds(params.viewer, cEntity, model, scale * styleScale, measureTemporaryModelBounds, animateScale);
+        }
+        else {
+            measureTemporaryModelBounds();
         }
-        heightProm.then((measured) => {
-            if (model) {
-                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);
-                }
-            }
-            // Rough estimate on when the model is ready in the scene.
-            if (animateScale) {
-                animateScale.Play();
-            }
-        });
-        const model = cEntity.model;
-        model._radiusLoaded = false;
         model._clientFileId = params.lodClientFileId;
         model._entityScale = {
             record: scale,
@@ -49885,6 +50251,88 @@ var EntityRenderEngineModel3d;
     }
     EntityRenderEngineModel3d.RenderGroup = RenderGroup;
 })(EntityRenderEngineModel3d || (EntityRenderEngineModel3d = {}));
+/*
+ * Measures bounds from Cesium's displayed model so loading a visual does not also load a temporary model.
+ */
+function trackRenderedModelBounds(viewer, entity, model, targetScale, fallback, animateScale) {
+    const key = "_nextspaceRenderedModelBoundsMonitor";
+    let monitor = viewer[key];
+    if (!monitor) {
+        monitor = { pending: new Map() };
+        viewer[key] = monitor;
+    }
+    monitor.pending.set(entity.id, { entity, model, targetScale, fallback, animateScale });
+    if (monitor.removeListener) {
+        return;
+    }
+    monitor.removeListener = viewer.scene.postRender.addEventListener(() => {
+        var _a, _b, _c, _d, _e, _f;
+        if (viewer.isDestroyed()) {
+            monitor.pending.clear();
+        }
+        else {
+            const primitives = viewer.scene.primitives;
+            for (let i = 0; i < primitives.length && monitor.pending.size; i++) {
+                const primitive = primitives.get(i);
+                if (!(primitive instanceof Model) || !primitive.ready) {
+                    continue;
+                }
+                const task = monitor.pending.get((_a = primitive.id) === null || _a === void 0 ? void 0 : _a.id);
+                if (!task || primitive.id !== task.entity || task.entity.model !== task.model) {
+                    continue;
+                }
+                try {
+                    const sphere = primitive.boundingSphere;
+                    const matrix = primitive.heightReference == null || primitive.heightReference === HeightReference.NONE
+                        ? primitive.modelMatrix
+                        : primitive._clampedModelMatrix;
+                    if (!sphere || !matrix ||
+                        !Number.isFinite(sphere.radius) || sphere.radius < 0 ||
+                        !Number.isFinite((_b = sphere.center) === null || _b === void 0 ? void 0 : _b.x) ||
+                        !Number.isFinite((_c = sphere.center) === null || _c === void 0 ? void 0 : _c.y) ||
+                        !Number.isFinite((_d = sphere.center) === null || _d === void 0 ? void 0 : _d.z)) {
+                        throw new Error("Displayed model bounds unavailable");
+                    }
+                    const inverse = Matrix4.inverseTransformation(matrix, new Matrix4());
+                    const center = Matrix4.multiplyByPoint(inverse, sphere.center, new Cartesian3());
+                    const scaleRatio = task.targetScale / primitive.scale;
+                    Cartesian3.multiplyByScalar(center, scaleRatio, center);
+                    const radius = sphere.radius * scaleRatio;
+                    const magnitude = Cartesian3.magnitude(center);
+                    if (!Number.isFinite(scaleRatio) || scaleRatio <= 0 || !Number.isFinite(magnitude) || !Number.isFinite(radius)) {
+                        throw new Error("Displayed model bounds transform invalid");
+                    }
+                    task.model._bounds = { center, radius };
+                    task.model._radius = radius + magnitude + (magnitude > 100 ? 100 : 0);
+                    task.model._radiusLoaded = true;
+                    (_e = task.animateScale) === null || _e === void 0 ? void 0 : _e.Play();
+                    VisualRegisterCuller.MarkShouldRecheck(viewer);
+                }
+                catch (e) {
+                    task.fallback();
+                }
+                monitor.pending.delete(task.entity.id);
+            }
+            for (const [id, task] of monitor.pending) {
+                const modelShown = GetCValue(viewer, task.model.show) !== false;
+                if (!task.entity.isShowing || !modelShown) {
+                    task.visibleAt = null;
+                }
+                else if (task.visibleAt == null) {
+                    task.visibleAt = performance.now();
+                }
+                else if (performance.now() - task.visibleAt > 60000) {
+                    task.fallback();
+                    monitor.pending.delete(id);
+                }
+            }
+        }
+        if (!monitor.pending.size) {
+            (_f = monitor.removeListener) === null || _f === void 0 ? void 0 : _f.call(monitor);
+            monitor.removeListener = null;
+        }
+    });
+}
 async function getName$1(api, entity, offline) {
     var _a;
     const ownName = GetUsableEntityName(entity);
@@ -57267,7 +57715,7 @@ var StyleUtils;
     StyleUtils.ApplyTypeStyle = ApplyTypeStyle;
 })(StyleUtils || (StyleUtils = {}));
 
-const VERSION = "7.7.3";
+const VERSION = "7.7.5";
 /**
  * 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.