bruce-cesium 7.7.3 → 7.7.5

package/dist/bruce-cesium.umd.js

@@ -28110,10 +28110,13 @@
     })(exports.DataSourceStaticKmlManager || (exports.DataSourceStaticKmlManager = {}));
 
     (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;
             }
@@ -28156,6 +28159,46 @@
             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,
@@ -28169,24 +28212,19 @@
                 // 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 && BModels.Cartes.ValidateCartes3(pos3d)) {
                         const altered = await exports.DrawingUtils.RaisePos3d(viewer, pos3d, 300);
-                        if (altered && BModels.Cartes.ValidateCartes3(altered)) {
+                        if (!object["_nextspaceLodRemoved"] && !((_c = viewer.isDestroyed) === null || _c === void 0 ? void 0 : _c.call(viewer)) && altered && BModels.Cartes.ValidateCartes3(altered)) {
                             viewer.scene.camera.flyTo({
                                 destination: altered,
                                 orientation: {
@@ -28201,14 +28239,46 @@
                     }
                 }
             });
+            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: Cesium.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);
             }
             exports.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);
@@ -28216,18 +28286,299 @@
             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);
+            exports.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;
             }
-            exports.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 Cesium.Cartesian3();
+                this.direction = new Cesium.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 && (Cesium.Cartesian3.distanceSquared(camera.positionWC, this.position) > 0.000001 ||
+                        Cesium.Cartesian3.distanceSquared(camera.directionWC, this.direction) > 0.00000001);
+                    Cesium.Cartesian3.clone(camera.positionWC, this.position);
+                    Cesium.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 = Cesium.Cartesian3.midpoint(bounds.min, bounds.max, new Cesium.Cartesian3());
+                    Cesium.Matrix4.multiplyByPoint(matrix, center, center);
+                    const scale = Cesium.Matrix4.getMaximumScale(matrix);
+                    const radius = Cesium.Cartesian3.distance(bounds.min, bounds.max) * scale * 0.55 + 1;
+                    const distance = Cesium.Cartesian3.distance(camera.positionWC, center);
+                    const pixel = camera.frustum.getPixelDimensions(width, height, Math.max(1, distance), 1, new Cesium.Cartesian2());
+                    const pixels = radius / Math.max(pixel.x, pixel.y);
+                    if (!Number.isFinite(pixels) || !(radius > 0)) {
+                        entry.culled = false;
+                        return;
+                    }
+                    const sphere = new Cesium.BoundingSphere(center, radius);
+                    const frustum = camera.frustum.computeCullingVolume(camera.positionWC, camera.directionWC, camera.upWC);
+                    const outside = frustum.computeVisibility(sphere) === Cesium.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 = Cesium.Matrix4.multiplyByPoint(Cesium.Matrix4.inverse(matrix, new Cesium.Matrix4()), camera.positionWC, new Cesium.Cartesian3());
+                    const nearest = new Cesium.Cartesian3(Cesium.Math.clamp(local.x, bounds.min.x, bounds.max.x), Cesium.Math.clamp(local.y, bounds.min.y, bounds.max.y), Cesium.Math.clamp(local.z, bounds.min.z, bounds.max.z));
+                    entry.surfaceDistance = Cesium.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.
          */
@@ -49474,88 +49825,103 @@
                 });
                 cEntity.show = true;
             }
-            const fileRadiusKey = `model3d_${BModels.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_${BModels.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 ? Cesium.Cartesian3.clone(centerOffset) : Cesium.Cartesian3.ZERO.clone(),
+                                    radius: modelPrim.boundingSphere.radius
+                                };
+                                if (centerOffset) {
+                                    // Include the offset so origin-based culling contains the full model.
+                                    const magnitude = Cesium.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 ? Cesium.Cartesian3.clone(centerOffset) : Cesium.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 = Cesium.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()) {
+                            exports.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 (Cesium.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()) {
-                        exports.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,
@@ -49763,6 +50129,88 @@
         }
         EntityRenderEngineModel3d.RenderGroup = RenderGroup;
     })(exports.EntityRenderEngineModel3d || (exports.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 Cesium.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 === Cesium.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 = Cesium.Matrix4.inverseTransformation(matrix, new Cesium.Matrix4());
+                        const center = Cesium.Matrix4.multiplyByPoint(inverse, sphere.center, new Cesium.Cartesian3());
+                        const scaleRatio = task.targetScale / primitive.scale;
+                        Cesium.Cartesian3.multiplyByScalar(center, scaleRatio, center);
+                        const radius = sphere.radius * scaleRatio;
+                        const magnitude = Cesium.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();
+                        exports.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);
@@ -57115,7 +57563,7 @@ void main() {
         StyleUtils.ApplyTypeStyle = ApplyTypeStyle;
     })(exports.StyleUtils || (exports.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.