bruce-cesium 7.7.6 → 7.7.8

package/dist/bruce-cesium.umd.js

@@ -907,6 +907,542 @@
         return true;
     }
 
+    const CESIUM_CAMERA_CONTROLS_KEY = "_nextspace_camera_controls";
+    // How far a wheel notch or its drag equivalent moves the camera, as a share of the distance to what it points at.
+    const ZOOM_SHARE = 0.18;
+    // The distance a zoom step treats anything closer as, so the camera keeps moving through a surface instead of stalling.
+    const MIN_ZOOM_DISTANCE = 4;
+    // How far from the origin zooming out may take a model-space camera, beyond which the scene is a dot on a planet.
+    const MODEL_SPACE_MAX_RANGE = 250000;
+    // Above this height a geospatial scene is a planet, which CesiumJS's own controller navigates better.
+    const GEO_HANDOFF_HEIGHT = 15000;
+    // The furthest a depth pick is trusted from a camera close to the ground; further up the limit grows with height.
+    const PLAUSIBLE_PICK_FLOOR = 1000;
+    // Pixels of right drag that make one wheel notch.
+    const DRAG_PIXELS_PER_NOTCH = 40;
+    // Share of the outstanding wheel movement applied each animation frame.
+    const ZOOM_EASE = 0.35;
+    // A pan plane seen closer to edge on than this (sine of the angle) is swapped for one facing the camera.
+    const GRAZING_SINE = 0.12;
+    // Closest the view may get to straight up or down while orbiting, in radians, so the camera never flips over.
+    const ORBIT_POLE_MARGIN = Cesium.Math.toRadians(1);
+    var EDrag;
+    (function (EDrag) {
+        EDrag["Pan"] = "pan";
+        EDrag["Orbit"] = "orbit";
+        EDrag["Zoom"] = "zoom";
+    })(EDrag || (EDrag = {}));
+    (function (CameraControls) {
+        /**
+         * Takes over mouse drag and wheel navigation close to the ground; CesiumJS keeps planet scale, pinch and look.
+         */
+        function Attach(viewer) {
+            var _a, _b, _c;
+            if (!viewer || viewer.isDestroyed() || viewer[CESIUM_CAMERA_CONTROLS_KEY]) {
+                return;
+            }
+            const scene = viewer.scene;
+            const controller = scene === null || scene === void 0 ? void 0 : scene.screenSpaceCameraController;
+            if (!controller || !scene.canvas || !scene.preUpdate) {
+                return;
+            }
+            const state = {
+                viewer,
+                getModelSpaceFrame: null,
+                drag: null,
+                touches: new Set(),
+                pendingZoom: new Cesium.Cartesian3(),
+                zoomFrame: null,
+                zoomPosition: null,
+                lastDistance: 100,
+                saved: {
+                    rotateEventTypes: controller.rotateEventTypes,
+                    zoomEventTypes: controller.zoomEventTypes,
+                    tiltEventTypes: controller.tiltEventTypes,
+                    enableCollisionDetection: controller.enableCollisionDetection,
+                    backFaceAlpha: (_b = (_a = scene.globe) === null || _a === void 0 ? void 0 : _a.translucency) === null || _b === void 0 ? void 0 : _b.backFaceAlpha,
+                    showSkirts: (_c = scene.globe) === null || _c === void 0 ? void 0 : _c.showSkirts
+                },
+                ours: false,
+                removals: []
+            };
+            viewer[CESIUM_CAMERA_CONTROLS_KEY] = state;
+            // The camera may go below the ground; zooming slows near a surface, so it takes a deliberate push.
+            controller.enableCollisionDetection = false;
+            const canvas = scene.canvas;
+            const listen = (target, type, handler, options) => {
+                target.addEventListener(type, handler, options);
+                state.removals.push(() => target.removeEventListener(type, handler, options));
+            };
+            listen(canvas, "pointerdown", (e) => onPointerDown(state, e));
+            listen(window, "pointermove", (e) => onPointerMove(state, e));
+            listen(window, "pointerup", (e) => onPointerUp(state, e));
+            listen(window, "pointercancel", (e) => onPointerUp(state, e));
+            listen(canvas, "wheel", (e) => onWheel(state, e), { passive: true });
+            state.removals.push(scene.preUpdate.addEventListener(() => syncController(state)));
+            syncController(state);
+            scene.requestRender();
+        }
+        CameraControls.Attach = Attach;
+        /**
+         * Hands navigation back to CesiumJS's own camera controller, as it was before Attach.
+         */
+        function Detach(viewer) {
+            const state = viewer === null || viewer === void 0 ? void 0 : viewer[CESIUM_CAMERA_CONTROLS_KEY];
+            if (!state) {
+                return;
+            }
+            SetModelSpace(viewer, null);
+            viewer[CESIUM_CAMERA_CONTROLS_KEY] = null;
+            state.removals.forEach((removal) => removal());
+            state.removals = [];
+            if (state.zoomFrame != null) {
+                cancelAnimationFrame(state.zoomFrame);
+            }
+            if (viewer.isDestroyed()) {
+                return;
+            }
+            restoreCesiumGestures(state);
+            viewer.scene.screenSpaceCameraController.enableCollisionDetection = state.saved.enableCollisionDetection;
+            viewer.scene.requestRender();
+        }
+        CameraControls.Detach = Detach;
+        function IsAttached(viewer) {
+            return Boolean(viewer === null || viewer === void 0 ? void 0 : viewer[CESIUM_CAMERA_CONTROLS_KEY]);
+        }
+        CameraControls.IsAttached = IsAttached;
+        /**
+         * Switches to navigating model-space measured from the frame getFrame returns, or back to geospatial with null.
+         */
+        function SetModelSpace(viewer, getFrame) {
+            const state = viewer === null || viewer === void 0 ? void 0 : viewer[CESIUM_CAMERA_CONTROLS_KEY];
+            if (!state || viewer.isDestroyed()) {
+                return;
+            }
+            const wasModelSpace = Boolean(state.getModelSpaceFrame);
+            state.getModelSpaceFrame = getFrame !== null && getFrame !== void 0 ? getFrame : null;
+            syncController(state);
+            if (wasModelSpace === Boolean(getFrame)) {
+                return;
+            }
+            const globe = viewer.scene.globe;
+            const translucency = globe === null || globe === void 0 ? void 0 : globe.translucency;
+            if (getFrame) {
+                // The ground is see-through from below, so what stands on it stays in view underground.
+                if (translucency && typeof translucency.backFaceAlpha === "number") {
+                    translucency.backFaceAlpha = 0.5;
+                }
+                // Skirts hide seams flat model-space ground never has, and below it they are walls.
+                if (typeof state.saved.showSkirts === "boolean") {
+                    globe.showSkirts = false;
+                }
+            }
+            else {
+                if (translucency && typeof state.saved.backFaceAlpha === "number") {
+                    translucency.backFaceAlpha = state.saved.backFaceAlpha;
+                }
+                if (typeof state.saved.showSkirts === "boolean") {
+                    globe.showSkirts = state.saved.showSkirts;
+                }
+            }
+            viewer.scene.requestRender();
+        }
+        CameraControls.SetModelSpace = SetModelSpace;
+    })(exports.CameraControls || (exports.CameraControls = {}));
+    function restoreCesiumGestures(state) {
+        const controller = state.viewer.scene.screenSpaceCameraController;
+        controller.rotateEventTypes = state.saved.rotateEventTypes;
+        controller.zoomEventTypes = state.saved.zoomEventTypes;
+        controller.tiltEventTypes = state.saved.tiltEventTypes;
+    }
+    /*
+     * Decides each frame who has the mouse: these controls near the ground, CesiumJS for planets, orthographic and tracking.
+     */
+    function syncController(state) {
+        const viewer = state.viewer;
+        if (viewer.isDestroyed() || state.drag) {
+            return;
+        }
+        const ours = shouldControl(state);
+        if (ours === state.ours) {
+            return;
+        }
+        state.ours = ours;
+        if (ours) {
+            const controller = viewer.scene.screenSpaceCameraController;
+            controller.rotateEventTypes = [];
+            controller.zoomEventTypes = [Cesium.CameraEventType.PINCH];
+            controller.tiltEventTypes = [Cesium.CameraEventType.PINCH];
+        }
+        else {
+            restoreCesiumGestures(state);
+        }
+    }
+    function shouldControl(state) {
+        const viewer = state.viewer;
+        const camera = viewer.camera;
+        if (viewer.scene.mode !== Cesium.SceneMode.SCENE3D || camera.frustum instanceof Cesium.OrthographicFrustum) {
+            return false;
+        }
+        // A camera following something is CesiumJS's to move.
+        if (!Cesium.Matrix4.equals(camera.transform, Cesium.Matrix4.IDENTITY)) {
+            return false;
+        }
+        if (state.getModelSpaceFrame) {
+            return true;
+        }
+        return heightOf(state, camera.positionWC) < GEO_HANDOFF_HEIGHT;
+    }
+    function ellipsoidOf(state) {
+        var _a, _b;
+        return (_b = (_a = state.viewer.scene.globe) === null || _a === void 0 ? void 0 : _a.ellipsoid) !== null && _b !== void 0 ? _b : Cesium.Ellipsoid.WGS84;
+    }
+    function heightOf(state, position) {
+        const carto = ellipsoidOf(state).cartesianToCartographic(position);
+        return carto ? carto.height : Number.POSITIVE_INFINITY;
+    }
+    function canvasPosition(viewer, e) {
+        const rect = viewer.scene.canvas.getBoundingClientRect();
+        return new Cesium.Cartesian2(e.clientX - rect.left, e.clientY - rect.top);
+    }
+    /*
+     * Up at a point: the model-space frame's up in model-space, else the ellipsoid's surface normal there.
+     */
+    function upAt(state, position) {
+        if (state.getModelSpaceFrame) {
+            const up = Cesium.Matrix4.multiplyByPointAsVector(state.getModelSpaceFrame(), Cesium.Cartesian3.UNIT_Z, new Cesium.Cartesian3());
+            return Cesium.Cartesian3.normalize(up, up);
+        }
+        return ellipsoidOf(state).geodeticSurfaceNormal(position, new Cesium.Cartesian3());
+    }
+    /*
+     * The level plane standing in for the ground when nothing is drawn under the cursor.
+     */
+    function groundPlane(state) {
+        if (state.getModelSpaceFrame) {
+            const frame = state.getModelSpaceFrame();
+            return Cesium.Plane.fromPointNormal(Cesium.Matrix4.getTranslation(frame, new Cesium.Cartesian3()), upAt(state, null));
+        }
+        const camera = state.viewer.camera;
+        const ellipsoid = ellipsoidOf(state);
+        const surface = ellipsoid.scaleToGeodeticSurface(camera.positionWC, new Cesium.Cartesian3());
+        if (!surface) {
+            return null;
+        }
+        return Cesium.Plane.fromPointNormal(surface, ellipsoid.geodeticSurfaceNormal(surface, new Cesium.Cartesian3()));
+    }
+    /*
+     * How far away a depth pick is believable, since below ground the depth buffer can hold the globe's inside.
+     */
+    function plausibleDistance(state) {
+        const camera = state.viewer.camera;
+        if (state.getModelSpaceFrame) {
+            const origin = Cesium.Matrix4.getTranslation(state.getModelSpaceFrame(), new Cesium.Cartesian3());
+            return Math.max(PLAUSIBLE_PICK_FLOOR, Cesium.Cartesian3.distance(camera.positionWC, origin) * 10);
+        }
+        const height = Math.abs(heightOf(state, camera.positionWC) - (Number(state.viewer.scene.globeHeight) || 0));
+        const horizon = Math.sqrt(2 * ellipsoidOf(state).maximumRadius * Math.max(height, 0));
+        return Math.max(PLAUSIBLE_PICK_FLOOR, height * 10, horizon * 1.5);
+    }
+    /*
+     * The point under a screen position: what is drawn there, else the ground plane, else a point at the last distance.
+     */
+    function pickTarget(state, position) {
+        const viewer = state.viewer;
+        const scene = viewer.scene;
+        const camera = viewer.camera;
+        const ray = camera.getPickRay(position);
+        if (!ray) {
+            return null;
+        }
+        let picked;
+        if (scene.pickPositionSupported) {
+            try {
+                picked = scene.pickPosition(position);
+            }
+            catch (e) {
+                picked = null;
+            }
+        }
+        const plausible = plausibleDistance(state);
+        if (isAhead(camera, picked) && Cesium.Cartesian3.distance(picked, camera.positionWC) < plausible) {
+            return picked;
+        }
+        const ground = groundPlane(state);
+        const onGround = ground ? Cesium.IntersectionTests.rayPlane(ray, ground) : null;
+        if (isAhead(camera, onGround) && Cesium.Cartesian3.distance(onGround, camera.positionWC) < plausible) {
+            return onGround;
+        }
+        return Cesium.Ray.getPoint(ray, state.lastDistance);
+    }
+    function isAhead(camera, point) {
+        if (!point || !Number.isFinite(point.x) || !Number.isFinite(point.y) || !Number.isFinite(point.z)) {
+            return false;
+        }
+        const toPoint = Cesium.Cartesian3.subtract(point, camera.positionWC, new Cesium.Cartesian3());
+        return Cesium.Cartesian3.dot(toPoint, camera.directionWC) > 0;
+    }
+    /*
+     * Picks which gesture a button and its modifiers start, matching CesiumJS's own mapping.
+     */
+    function dragKind(e) {
+        if (e.shiftKey) {
+            // Shift drag looks around, which CesiumJS still handles.
+            return null;
+        }
+        if (e.button === 1 || (e.ctrlKey && (e.button === 0 || e.button === 2))) {
+            return EDrag.Orbit;
+        }
+        if (e.button === 0) {
+            return EDrag.Pan;
+        }
+        if (e.button === 2) {
+            return EDrag.Zoom;
+        }
+        return null;
+    }
+    function allows(state, kind) {
+        const controller = state.viewer.scene.screenSpaceCameraController;
+        if (!controller.enableInputs) {
+            return false;
+        }
+        switch (kind) {
+            case EDrag.Pan:
+                return controller.enableRotate;
+            case EDrag.Orbit:
+                return controller.enableTilt;
+            case EDrag.Zoom:
+                return controller.enableZoom;
+        }
+        return false;
+    }
+    function onPointerDown(state, e) {
+        const viewer = state.viewer;
+        if (viewer.isDestroyed() || !state.ours) {
+            return;
+        }
+        if (e.pointerType === "touch") {
+            state.touches.add(e.pointerId);
+            // A second finger makes it a pinch, which CesiumJS handles.
+            if (state.touches.size > 1) {
+                endDrag(state);
+                return;
+            }
+        }
+        const kind = dragKind(e);
+        if (!kind || !allows(state, kind)) {
+            return;
+        }
+        const position = canvasPosition(viewer, e);
+        const target = pickTarget(state, position);
+        if (!target) {
+            return;
+        }
+        const camera = viewer.camera;
+        const distance = Cesium.Cartesian3.distance(camera.positionWC, target);
+        state.lastDistance = Math.max(distance, MIN_ZOOM_DISTANCE);
+        const drag = { kind, pointerId: e.pointerId, last: position, target, up: upAt(state, target), distance };
+        if (kind === EDrag.Pan) {
+            drag.plane = panPlane(camera, target, drag.up);
+        }
+        else if (kind === EDrag.Zoom) {
+            drag.direction = Cesium.Cartesian3.normalize(Cesium.Cartesian3.subtract(target, camera.positionWC, new Cesium.Cartesian3()), new Cesium.Cartesian3());
+        }
+        state.drag = drag;
+    }
+    /*
+     * A level plane through the grabbed point, or one facing the camera when the level one is seen edge on.
+     */
+    function panPlane(camera, target, up) {
+        if (Math.abs(Cesium.Cartesian3.dot(camera.directionWC, up)) > GRAZING_SINE) {
+            return Cesium.Plane.fromPointNormal(target, up);
+        }
+        return Cesium.Plane.fromPointNormal(target, Cesium.Cartesian3.negate(camera.directionWC, new Cesium.Cartesian3()));
+    }
+    function onPointerMove(state, e) {
+        const drag = state.drag;
+        const viewer = state.viewer;
+        if (!drag || drag.pointerId !== e.pointerId || viewer.isDestroyed()) {
+            return;
+        }
+        if (!allows(state, drag.kind)) {
+            endDrag(state);
+            return;
+        }
+        const position = canvasPosition(viewer, e);
+        const dx = position.x - drag.last.x;
+        const dy = position.y - drag.last.y;
+        if (dx === 0 && dy === 0) {
+            return;
+        }
+        switch (drag.kind) {
+            case EDrag.Pan:
+                pan(state, drag, position);
+                break;
+            case EDrag.Orbit:
+                orbit(state, drag, dx, dy);
+                break;
+            case EDrag.Zoom:
+                // Dragging down zooms in, as it does in CesiumJS.
+                moveAlong(state, drag.direction, drag.target, dy / DRAG_PIXELS_PER_NOTCH);
+                break;
+        }
+        drag.last = position;
+        viewer.scene.requestRender();
+    }
+    function onPointerUp(state, e) {
+        var _a;
+        state.touches.delete(e.pointerId);
+        if (((_a = state.drag) === null || _a === void 0 ? void 0 : _a.pointerId) === e.pointerId) {
+            endDrag(state);
+        }
+    }
+    function endDrag(state) {
+        state.drag = null;
+    }
+    /*
+     * Slides the camera so the grabbed point stays under the cursor.
+     */
+    function pan(state, drag, position) {
+        const camera = state.viewer.camera;
+        const ray = camera.getPickRay(position);
+        const hit = ray ? Cesium.IntersectionTests.rayPlane(ray, drag.plane) : null;
+        if (!isAhead(camera, hit)) {
+            return;
+        }
+        const delta = Cesium.Cartesian3.subtract(drag.target, hit, new Cesium.Cartesian3());
+        // Near the horizon a pixel covers kilometres, so one move is capped at a few times the grab distance.
+        const limit = Math.max(drag.distance, MIN_ZOOM_DISTANCE) * 3;
+        const length = Cesium.Cartesian3.magnitude(delta);
+        if (length > limit) {
+            Cesium.Cartesian3.multiplyByScalar(delta, limit / length, delta);
+        }
+        Cesium.Cartesian3.add(camera.position, delta, camera.position);
+    }
+    /*
+     * Turns the camera around the grabbed point: sideways about up there, and up or down about the camera's right.
+     */
+    function orbit(state, drag, dx, dy) {
+        const viewer = state.viewer;
+        const camera = viewer.camera;
+        const canvas = viewer.scene.canvas;
+        const up = drag.up;
+        const heading = -dx / Math.max(canvas.clientWidth, 1) * Math.PI * 2;
+        // Dragging down looks further down, as CesiumJS's own tilt does.
+        let pitch = -dy / Math.max(canvas.clientHeight, 1) * Math.PI;
+        // Keeps the view from tipping past straight up or down, where it would flip over.
+        const elevation = Math.asin(Cesium.Math.clamp(Cesium.Cartesian3.dot(camera.direction, up), -1, 1));
+        const limit = Math.PI / 2 - ORBIT_POLE_MARGIN;
+        pitch = Cesium.Math.clamp(elevation + pitch, -limit, limit) - elevation;
+        rotateAbout(camera, drag.target, up, heading);
+        const right = Cesium.Cartesian3.cross(camera.direction, up, new Cesium.Cartesian3());
+        if (Cesium.Cartesian3.magnitude(right) > Cesium.Math.EPSILON6) {
+            Cesium.Cartesian3.normalize(right, right);
+            rotateAbout(camera, drag.target, right, pitch);
+        }
+        levelCamera(camera, upAt(state, camera.position));
+    }
+    function rotateAbout(camera, pivot, axis, angle) {
+        if (!angle) {
+            return;
+        }
+        const rotation = Cesium.Matrix3.fromQuaternion(Cesium.Quaternion.fromAxisAngle(axis, angle));
+        const offset = Cesium.Cartesian3.subtract(camera.position, pivot, new Cesium.Cartesian3());
+        Cesium.Matrix3.multiplyByVector(rotation, offset, offset);
+        Cesium.Cartesian3.add(pivot, offset, camera.position);
+        Cesium.Matrix3.multiplyByVector(rotation, camera.direction, camera.direction);
+        Cesium.Matrix3.multiplyByVector(rotation, camera.up, camera.up);
+        Cesium.Matrix3.multiplyByVector(rotation, camera.right, camera.right);
+    }
+    /*
+     * Takes any roll out, so the horizon stays level however the camera has turned.
+     */
+    function levelCamera(camera, up) {
+        const direction = Cesium.Cartesian3.normalize(camera.direction, camera.direction);
+        const right = Cesium.Cartesian3.cross(direction, up, new Cesium.Cartesian3());
+        if (Cesium.Cartesian3.magnitude(right) < Cesium.Math.EPSILON6) {
+            return;
+        }
+        Cesium.Cartesian3.normalize(right, camera.right);
+        Cesium.Cartesian3.cross(camera.right, direction, camera.up);
+        Cesium.Cartesian3.normalize(camera.up, camera.up);
+    }
+    function onWheel(state, e) {
+        const viewer = state.viewer;
+        if (viewer.isDestroyed() || !state.ours || !allows(state, EDrag.Zoom)) {
+            return;
+        }
+        let notches = e.deltaMode === 1 ? e.deltaY / 3 : e.deltaMode === 2 ? e.deltaY : e.deltaY / 100;
+        notches = Cesium.Math.clamp(-notches, -3, 3);
+        if (!notches) {
+            return;
+        }
+        const position = canvasPosition(viewer, e);
+        const camera = viewer.camera;
+        const target = pickTarget(state, position);
+        const ray = camera.getPickRay(position);
+        if (!target || !ray) {
+            return;
+        }
+        const step = zoomStep(state, ray.direction, target, notches);
+        Cesium.Cartesian3.add(state.pendingZoom, step, state.pendingZoom);
+        state.zoomPosition = Cesium.Cartesian3.clone(camera.position);
+        if (state.zoomFrame == null) {
+            state.zoomFrame = requestAnimationFrame(() => easeZoom(state));
+        }
+    }
+    /*
+     * Applies part of the outstanding wheel movement each frame, so a notch glides rather than jumps.
+     */
+    function easeZoom(state) {
+        state.zoomFrame = null;
+        const viewer = state.viewer;
+        if (viewer.isDestroyed() || !viewer[CESIUM_CAMERA_CONTROLS_KEY]) {
+            return;
+        }
+        // A tool locking the camera mid glide (walkthrough, a camera lock) owns it from then on.
+        if (!allows(state, EDrag.Zoom) ||
+            !state.zoomPosition ||
+            !Cesium.Cartesian3.equalsEpsilon(viewer.camera.position, state.zoomPosition, 0, 1e-3)) {
+            state.pendingZoom = new Cesium.Cartesian3();
+            return;
+        }
+        const remaining = Cesium.Cartesian3.magnitude(state.pendingZoom);
+        const share = remaining < 0.01 ? 1 : ZOOM_EASE;
+        const step = Cesium.Cartesian3.multiplyByScalar(state.pendingZoom, share, new Cesium.Cartesian3());
+        Cesium.Cartesian3.subtract(state.pendingZoom, step, state.pendingZoom);
+        Cesium.Cartesian3.add(viewer.camera.position, step, viewer.camera.position);
+        state.zoomPosition = Cesium.Cartesian3.clone(viewer.camera.position);
+        viewer.scene.requestRender();
+        if (share < 1) {
+            state.zoomFrame = requestAnimationFrame(() => easeZoom(state));
+        }
+    }
+    function moveAlong(state, direction, target, notches) {
+        const step = zoomStep(state, direction, target, notches);
+        Cesium.Cartesian3.add(state.viewer.camera.position, step, state.viewer.camera.position);
+    }
+    /*
+     * The move for some notches toward a target along a direction, a share of the distance with a floor so it never stalls.
+     */
+    function zoomStep(state, direction, target, notches) {
+        const camera = state.viewer.camera;
+        const distance = Math.max(Cesium.Cartesian3.distance(camera.positionWC, target), MIN_ZOOM_DISTANCE);
+        state.lastDistance = distance;
+        let length = distance * ZOOM_SHARE * notches;
+        // A geospatial camera zooming out hands over to CesiumJS once it is high enough, so only model-space is capped.
+        if (length < 0 && state.getModelSpaceFrame) {
+            const origin = Cesium.Matrix4.getTranslation(state.getModelSpaceFrame(), new Cesium.Cartesian3());
+            const pending = Cesium.Cartesian3.add(camera.positionWC, state.pendingZoom, new Cesium.Cartesian3());
+            const range = Cesium.Cartesian3.distance(pending, origin);
+            length = Math.max(length, range - MODEL_SPACE_MAX_RANGE);
+            if (length >= 0) {
+                return new Cesium.Cartesian3();
+            }
+        }
+        return Cesium.Cartesian3.multiplyByScalar(Cesium.Cartesian3.normalize(direction, new Cesium.Cartesian3()), length, new Cesium.Cartesian3());
+    }
+
     const CESIUM_INSPECTOR_KEY = "_nextspace_inspector";
     const CESIUM_TIMELINE_KEY = "_nextspace_timeline";
     const CESIUM_TIMELINE_LIVE_KEY = "_nextspace_timeline_live";
@@ -1383,6 +1919,13 @@
             return overriddenImageBasedLighting || null;
         }
         ViewUtils.GetDefaultImageBasedLighting = GetDefaultImageBasedLighting;
+        /**
+         * Shadow mode for the Entity graphics this library draws, following the scene's shadow switch.
+         */
+        function GetEntityShadowMode(viewer) {
+            return (viewer === null || viewer === void 0 ? void 0 : viewer.shadows) ? Cesium.ShadowMode.ENABLED : Cesium.ShadowMode.DISABLED;
+        }
+        ViewUtils.GetEntityShadowMode = GetEntityShadowMode;
         function EngineShadesModelsDarker() {
             return typeof Cesium.DynamicEnvironmentMapManager !== "undefined";
         }
@@ -1454,6 +1997,7 @@
             viewer[CESIUM_MODEL_SPACE_KEY] = modelSpace;
             // Reload globe since we display it differently between the two modes.
             SetGlobeDetails({ viewer });
+            exports.CameraControls.SetModelSpace(viewer, modelSpace ? () => GetModelSpaceFrame(viewer) : null);
         }
         ViewUtils.SetModelSpace = SetModelSpace;
         function GetModelSpace(viewer) {
@@ -6166,7 +6710,7 @@
                 const byTime = new Map();
                 for (const set of this.sets.values()) {
                     for (const [ms, record] of set.records.get(entityId) || []) {
-                        if (attrKey && record.attrKey && record.attrKey !== attrKey) {
+                        if (attrKey && record.attrKey && !BModels.PathUtils.Equals(record.attrKey, attrKey)) {
                             continue;
                         }
                         const held = byTime.get(ms);
@@ -11965,6 +12509,28 @@
         return highest;
     }
     const MAX_SHOW_DEPTH = 10;
+    // Entity graphics whose shadows follow the scene's shadow switch.
+    const SHADOWED_GRAPHICS = ["model", "polygon", "polyline", "corridor"];
+    /*
+     * Points a registered Entity graphic, and the graphics drawn beside it, at the given shadow mode.
+     */
+    function updateCEntityShadows(viewer, visual, mode, depth = 0) {
+        if (!visual || depth > MAX_SHOW_DEPTH) {
+            return;
+        }
+        for (const key of SHADOWED_GRAPHICS) {
+            const graphic = visual[key];
+            // Only graphics drawn with a mode; one left at Cesium's default was never meant to shadow.
+            if ((graphic === null || graphic === void 0 ? void 0 : graphic.shadows) != null) {
+                SetCPropIfChanged({ viewer, graphic, property: "shadows", value: mode });
+            }
+        }
+        if (visual._siblingGraphics) {
+            for (let i = 0; i < visual._siblingGraphics.length; i++) {
+                updateCEntityShadows(viewer, visual._siblingGraphics[i], mode, depth + 1);
+            }
+        }
+    }
     function updateCEntityShow(viewer, visual, rego, show, ignoreParent, depth = 0) {
         if (depth > MAX_SHOW_DEPTH) {
             console.warn("updateCEntityShow(): Max show depth reached. EntityId = " + rego.entityId);
@@ -12297,7 +12863,7 @@
             }
             get OnLabelGroupsChanged() { return this.labelGroupsChanged; }
             constructor(params) {
-                var _a, _b;
+                var _a, _b, _c, _d, _e, _f, _g;
                 this.id = BModels.ObjectUtils.UId();
                 this.disposed = false;
                 this.rego = {};
@@ -12347,6 +12913,7 @@
                 this.sourceOrderDirty = false;
                 // Stops following what is simulated, so labels can read it again when it changes.
                 this.simulationRemoval = null;
+                this.shadowsRemoval = null;
                 this.labelGroupsChanged = new BModels.BruceEvent();
                 this.hoverRingState = {};
                 this.retiringHoverLabels = new Map();
@@ -12382,6 +12949,27 @@
                     register: this
                 });
                 this.simulationRemoval = (_b = (_a = exports.EntitySimulation.Get(this.viewer)) === null || _a === void 0 ? void 0 : _a.OnChanged.Subscribe((change) => this.reloadLabels(change.entityIds))) !== null && _b !== void 0 ? _b : null;
+                this.entityShadows = Boolean((_c = this.viewer) === null || _c === void 0 ? void 0 : _c.shadows);
+                this.shadowsRemoval = (_g = (_f = (_e = (_d = this.viewer) === null || _d === void 0 ? void 0 : _d.scene) === null || _e === void 0 ? void 0 : _e.preUpdate) === null || _f === void 0 ? void 0 : _f.addEventListener(() => this.syncEntityShadows())) !== null && _g !== void 0 ? _g : null;
+            }
+            /*
+             * Follows the scene's shadow switch on every registered Entity, whichever app or bookmark flipped it.
+             */
+            syncEntityShadows() {
+                const viewer = this.viewer;
+                const enabled = Boolean(viewer === null || viewer === void 0 ? void 0 : viewer.shadows);
+                if (enabled === this.entityShadows || this.disposed || !viewer || viewer.isDestroyed()) {
+                    return;
+                }
+                this.entityShadows = enabled;
+                const mode = enabled ? Cesium.ShadowMode.ENABLED : Cesium.ShadowMode.DISABLED;
+                for (const regos of Object.values(this.rego)) {
+                    for (const rego of regos) {
+                        if (rego.visual instanceof Cesium.Entity) {
+                            updateCEntityShadows(viewer, rego.visual, mode);
+                        }
+                    }
+                }
             }
             /*
              * Tells labels to read their Entity again, since they keep what they read when drawn.
@@ -13310,9 +13898,11 @@
                 (_b = this.viewer.scene) === null || _b === void 0 ? void 0 : _b.requestRender();
             }
             Dispose() {
-                var _a, _b, _c, _d, _e, _f;
+                var _a, _b, _c, _d, _e, _f, _g;
                 (_a = this.simulationRemoval) === null || _a === void 0 ? void 0 : _a.call(this);
                 this.simulationRemoval = null;
+                (_b = this.shadowsRemoval) === null || _b === void 0 ? void 0 : _b.call(this);
+                this.shadowsRemoval = null;
                 exports.CesiumEntityStyler.SetDimming(this.viewer, this.id, false);
                 this.ClearLabelHover();
                 clearTimeout(this.hoverRingReset);
@@ -13322,14 +13912,14 @@
                     exports.EntityLabel.Detatch({ label });
                 }
                 this.retiringHoverLabels.clear();
-                (_b = this.labelGroups) === null || _b === void 0 ? void 0 : _b.Dispose();
+                (_c = this.labelGroups) === null || _c === void 0 ? void 0 : _c.Dispose();
                 this.labelGroupsChanged.Clear();
                 for (const regos of Object.values(this.rego)) {
                     for (const rego of regos)
                         exports.EntityLabel.Detatch({ rego, force: true });
                 }
                 exports.EntityLabel.SetContainer(this.viewer);
-                (_c = this.cameraCullerDispose) === null || _c === void 0 ? void 0 : _c.call(this, {
+                (_d = this.cameraCullerDispose) === null || _d === void 0 ? void 0 : _d.call(this, {
                     uncull: false
                 });
                 this.cameraCullerDispose = null;
@@ -13346,7 +13936,7 @@
                 this.disposed = true;
                 for (const record of Array.from(this.menuItemSources.values())) {
                     try {
-                        (_e = (_d = this.viewer) === null || _d === void 0 ? void 0 : _d.dataSources) === null || _e === void 0 ? void 0 : _e.remove(record.source, true);
+                        (_f = (_e = this.viewer) === null || _e === void 0 ? void 0 : _e.dataSources) === null || _f === void 0 ? void 0 : _f.remove(record.source, true);
                     }
                     catch (e) {
                         console.error(e);
@@ -13355,7 +13945,7 @@
                 this.menuItemSources.clear();
                 // Hand every tileset's show flag back to its owner, holding whatever the owner last asked for.
                 for (const rego of Array.from(this.tilesets.values())) {
-                    (_f = rego.gate) === null || _f === void 0 ? void 0 : _f.Release();
+                    (_g = rego.gate) === null || _g === void 0 ? void 0 : _g.Release();
                 }
                 this.tilesets.clear();
             }
@@ -14079,8 +14669,11 @@
                     }
                 }
                 // Add the new visual to the register.
+                // Tileset managers add the same rego again for each tile holding more of the Entity.
                 const entityRegos = (_a = this.rego[entityId]) !== null && _a !== void 0 ? _a : [];
-                entityRegos.push(rego);
+                if (!entityRegos.includes(rego)) {
+                    entityRegos.push(rego);
+                }
                 this.rego[entityId] = entityRegos;
                 this.indexMenuItemEntity(rego.menuItemId, entityId);
                 // Mark the visual as part of this register so selection works.
@@ -14514,6 +15107,28 @@
                     }
                 }
             }
+            /*
+             * Hands a tile feature rego to a sibling feature from another tile when its own tile unloads.
+             * An Entity split across tiles keeps drawing from those, so it must stay registered for them.
+             */
+            promoteTileSibling(rego, removing) {
+                var _a;
+                const departing = rego.visual;
+                if (!(departing instanceof Cesium.Cesium3DTileFeature) || !((_a = departing._siblingGraphics) === null || _a === void 0 ? void 0 : _a.length)) {
+                    return false;
+                }
+                const remaining = departing._siblingGraphics.filter(s => !removing.has(s));
+                if (!remaining.length) {
+                    return false;
+                }
+                departing._siblingGraphics = undefined;
+                unmarkEntity(departing, true);
+                const promoted = remaining[0];
+                promoted._siblingGraphics = remaining.slice(1);
+                rego.visual = promoted;
+                markEntity(this, rego, promoted, false);
+                return true;
+            }
             /**
              * Removes regos matching given visuals.
              * This is used when we cannot unpack properties from the visual any longer to determine its ID.
@@ -14524,6 +15139,7 @@
                 var _a, _b, _c;
                 const { doRemove = true, requestRender = true, source, doUpdate, menuItemId } = params;
                 const removedEntityIds = new Set();
+                const removing = new Set(params.visuals);
                 for (const visual of params.visuals) {
                     const visExt = visual;
                     const rego = (visExt === null || visExt === void 0 ? void 0 : visExt._register) === this ? visExt._rego : null;
@@ -14535,7 +15151,20 @@
                     if (!entityRegos) {
                         continue;
                     }
-                    if (rego.visual === visual) {
+                    if (rego.visual === visual && this.promoteTileSibling(rego, removing)) {
+                        if (doRemove != false) {
+                            removeEntity(this.viewer, visual);
+                        }
+                        // The label was placed against the departing feature, the refresh attaches it again.
+                        exports.EntityLabel.Detatch({
+                            rego, force: true
+                        });
+                        this.queueUpdate({
+                            entityId: entityId,
+                            refresh: true
+                        });
+                    }
+                    else if (rego.visual === visual) {
                         exports.EntityLabel.Detatch({
                             rego, force: true
                         });
@@ -16187,6 +16816,300 @@
         }
     }
 
+    // viewer[VIEWER_WATCH_KEY] is true once the viewer's canvas reports context loss to DeviceProfile.
+    const VIEWER_WATCH_KEY = "_bruceDeviceProfileWatch";
+    // localStorage[DEMOTION_KEY] holds an IDemotion written after this browser lost a WebGL context.
+    const DEMOTION_KEY = "bruce-cesium-device-demotion";
+    // A lost context demotes for this long, so one driver reset does not cap a strong device forever.
+    // Measured on the wall clock, not the viewer's: it spans sessions, and a scene clock can be historic.
+    const DEMOTION_MS = 14 * 24 * 60 * 60 * 1000;
+    // Each loss demotes one more tier, up to this many.
+    const DEMOTION_MAX = 2;
+    /*
+     * Reads the demotion left by earlier context losses, ignoring an expired or unreadable one.
+     */
+    function readDemotion(now) {
+        try {
+            const value = JSON.parse(window.localStorage.getItem(DEMOTION_KEY));
+            if (value &&
+                Number.isFinite(value.count) &&
+                Number.isFinite(value.at) &&
+                now - value.at < DEMOTION_MS) {
+                return value;
+            }
+        }
+        catch (e) {
+            // Storage is blocked (private mode, sandboxed frame) or holds junk; treat as no demotion.
+        }
+        return null;
+    }
+    /*
+     * Stores or clears the demotion, carrying on without it where storage is blocked.
+     */
+    function writeDemotion(value) {
+        try {
+            if (value) {
+                window.localStorage.setItem(DEMOTION_KEY, JSON.stringify(value));
+            }
+            else {
+                window.localStorage.removeItem(DEMOTION_KEY);
+            }
+        }
+        catch (e) {
+            // Without storage the demotion lasts only for this page.
+        }
+    }
+    /*
+     * Reads the GPU name, preferring the unmasked one, which browsers that hide it simply do not offer.
+     */
+    function readRenderer(gl) {
+        try {
+            const ext = gl.getExtension("WEBGL_debug_renderer_info");
+            const name = ext ? gl.getParameter(ext.UNMASKED_RENDERER_WEBGL) : gl.getParameter(gl.RENDERER);
+            return typeof name === "string" && name ? name : undefined;
+        }
+        catch (e) {
+            return undefined;
+        }
+    }
+    (function (DeviceProfile) {
+        let ETier;
+        (function (ETier) {
+            ETier["Low"] = "LOW";
+            ETier["Mid"] = "MID";
+            ETier["High"] = "HIGH";
+        })(ETier = DeviceProfile.ETier || (DeviceProfile.ETier = {}));
+        DeviceProfile.BUDGETS = {
+            [ETier.Low]: { tilesetMb: 384, splats: 1000000 },
+            [ETier.Mid]: { tilesetMb: 1024, splats: 3000000 },
+            [ETier.High]: { tilesetMb: 2048, splats: 6000000 }
+        };
+        const ORDER = [ETier.Low, ETier.Mid, ETier.High];
+        /**
+         * Raised after the override or a demotion changes the tier, so live budgets can be redistributed.
+         */
+        DeviceProfile.Changed = new Cesium.Event();
+        let override = null;
+        let detected = null;
+        let logged = false;
+        /*
+         * Sorts a GPU name into a class. Order matters: Intel Arc is discrete, SwiftShader names any vendor.
+         */
+        function ClassifyGpu(renderer) {
+            const name = (renderer || "").toLowerCase();
+            if (!name) {
+                return "unknown";
+            }
+            if (/swiftshader|llvmpipe|softpipe|lavapipe|software|basic render/.test(name)) {
+                return "software";
+            }
+            if (/mali|adreno|powervr|apple gpu|videocore|immortalis|xclipse|tegra/.test(name)) {
+                return "mobile";
+            }
+            if (/apple m\d+ (pro|max|ultra)/.test(name)) {
+                return "discrete";
+            }
+            if (/nvidia|geforce|quadro|rtx|radeon (rx|pro|r9|vii)|firepro|arc(\(tm\))? a\d/.test(name)) {
+                return "discrete";
+            }
+            if (/intel|apple m\d|radeon(\(tm\))? graphics|vega \d/.test(name)) {
+                return "integrated";
+            }
+            return "unknown";
+        }
+        DeviceProfile.ClassifyGpu = ClassifyGpu;
+        /**
+         * Guesses a tier from the hardware alone. Unknown hardware stays mid; only clear evidence moves it.
+         */
+        function Classify(env) {
+            const ua = (env.userAgent || "").toLowerCase();
+            const mobile = /android|iphone|ipad|ipod|mobile/.test(ua) || (/macintosh/.test(ua) && env.maxTouchPoints > 1);
+            const gpuClass = ClassifyGpu(env.gpuRenderer);
+            const memory = env.deviceMemory;
+            const reasons = [];
+            let tier = ETier.Mid;
+            if (gpuClass === "software") {
+                reasons.push("software renderer");
+                tier = ETier.Low;
+            }
+            if (mobile) {
+                reasons.push("mobile device");
+                tier = ETier.Low;
+            }
+            if (Number.isFinite(memory) && memory < 4) {
+                reasons.push(`${memory} GB device memory`);
+                tier = ETier.Low;
+            }
+            if (Number.isFinite(env.maxTextureSize) && env.maxTextureSize < 8192) {
+                reasons.push(`max texture ${env.maxTextureSize}`);
+                tier = ETier.Low;
+            }
+            if (tier === ETier.Mid && gpuClass === "discrete") {
+                if (!Number.isFinite(memory) || memory >= 8) {
+                    reasons.push("discrete GPU");
+                    tier = ETier.High;
+                }
+                else {
+                    reasons.push(`discrete GPU held to mid by ${memory} GB device memory`);
+                }
+            }
+            if (!reasons.length) {
+                reasons.push(`${gpuClass} GPU`);
+            }
+            return { tier, gpuClass, mobile, reasons };
+        }
+        DeviceProfile.Classify = Classify;
+        /*
+         * Reads the browser environment, from the viewer's GL context when given rather than a spare one.
+         */
+        function readEnvironment(viewer) {
+            var _a, _b, _c;
+            const nav = typeof navigator !== "undefined" ? navigator : {};
+            const env = {
+                userAgent: nav.userAgent,
+                maxTouchPoints: nav.maxTouchPoints,
+                deviceMemory: nav.deviceMemory,
+                hardwareConcurrency: nav.hardwareConcurrency
+            };
+            let gl = (_b = (_a = viewer === null || viewer === void 0 ? void 0 : viewer.scene) === null || _a === void 0 ? void 0 : _a.context) === null || _b === void 0 ? void 0 : _b._gl;
+            let spare = false;
+            if (!gl && typeof document !== "undefined") {
+                try {
+                    gl = document.createElement("canvas").getContext("webgl");
+                    spare = Boolean(gl);
+                }
+                catch (e) {
+                    gl = null;
+                }
+            }
+            // Detection must never stop a scene loading, so anything odd leaves the GPU unknown.
+            if (gl &&
+                typeof gl.getParameter === "function" &&
+                typeof gl.getExtension === "function") {
+                env.gpuRenderer = readRenderer(gl);
+                try {
+                    env.maxTextureSize = gl.getParameter(gl.MAX_TEXTURE_SIZE) || undefined;
+                    if (spare) {
+                        // Browsers cap live contexts per page; give this one back now rather than at GC.
+                        (_c = gl.getExtension("WEBGL_lose_context")) === null || _c === void 0 ? void 0 : _c.loseContext();
+                    }
+                }
+                catch (e) {
+                    // Leave it unknown.
+                }
+            }
+            return env;
+        }
+        /**
+         * Returns this device's profile, detecting it once per page. Pass the viewer to read its GL context.
+         */
+        function Get(viewer) {
+            var _a, _b;
+            if (!detected) {
+                const environment = readEnvironment(viewer);
+                detected = { ...Classify(environment), environment };
+            }
+            const demotion = readDemotion(Date.now());
+            const demoted = Math.min((_a = demotion === null || demotion === void 0 ? void 0 : demotion.count) !== null && _a !== void 0 ? _a : 0, DEMOTION_MAX);
+            let tier = ORDER[Math.max(0, ORDER.indexOf(detected.tier) - demoted)];
+            if (override) {
+                tier = override;
+            }
+            const profile = {
+                tier,
+                detectedTier: detected.tier,
+                gpuClass: detected.gpuClass,
+                mobile: detected.mobile,
+                demoted,
+                overridden: Boolean(override),
+                reasons: [...detected.reasons],
+                environment: { ...detected.environment }
+            };
+            if (!logged) {
+                logged = true;
+                console.info(`[DeviceProfile] tier ${profile.tier} (${profile.reasons.join(", ")}` +
+                    `${demoted ? `, demoted ${demoted} after lost WebGL context` : ""}` +
+                    `${override ? ", overridden" : ""}). GPU: ${(_b = profile.environment.gpuRenderer) !== null && _b !== void 0 ? _b : "unknown"}.`);
+            }
+            return profile;
+        }
+        DeviceProfile.Get = Get;
+        /**
+         * Returns the memory budgets for this device's tier, or for a given tier.
+         */
+        function GetBudget(tier) {
+            return DeviceProfile.BUDGETS[tier !== null && tier !== void 0 ? tier : Get().tier];
+        }
+        DeviceProfile.GetBudget = GetBudget;
+        /**
+         * Forces a tier, for a user who knows better than the guess. Null returns to detection.
+         */
+        function SetOverride(tier) {
+            const next = tier && ORDER.includes(tier) ? tier : null;
+            if (next === override) {
+                return;
+            }
+            override = next;
+            DeviceProfile.Changed.raiseEvent();
+        }
+        DeviceProfile.SetOverride = SetOverride;
+        /**
+         * Returns the forced tier, or null while detection decides.
+         */
+        function GetOverride() {
+            return override;
+        }
+        DeviceProfile.GetOverride = GetOverride;
+        /**
+         * Records that a WebGL context was lost, so this and later sessions start a tier lower.
+         */
+        function RecordContextLost() {
+            var _a, _b;
+            const now = Date.now();
+            const count = Math.min(((_b = (_a = readDemotion(now)) === null || _a === void 0 ? void 0 : _a.count) !== null && _b !== void 0 ? _b : 0) + 1, DEMOTION_MAX);
+            writeDemotion({ count, at: now });
+            console.warn(`[DeviceProfile] WebGL context lost; demoting the memory tier by ${count}.`);
+            DeviceProfile.Changed.raiseEvent();
+        }
+        DeviceProfile.RecordContextLost = RecordContextLost;
+        /**
+         * Forgets earlier context losses, for a host that offers a reset.
+         */
+        function ClearDemotion() {
+            writeDemotion(null);
+            DeviceProfile.Changed.raiseEvent();
+        }
+        DeviceProfile.ClearDemotion = ClearDemotion;
+        /**
+         * Reports the viewer's context losses. Safe to call repeatedly.
+         */
+        function WatchViewer(viewer) {
+            const canvas = viewer === null || viewer === void 0 ? void 0 : viewer.canvas;
+            if (!canvas ||
+                viewer[VIEWER_WATCH_KEY] ||
+                typeof canvas.addEventListener !== "function") {
+                return;
+            }
+            viewer[VIEWER_WATCH_KEY] = true;
+            canvas.addEventListener("webglcontextlost", () => {
+                // Ignore a loss caused by tearing the viewer down.
+                if (!viewer.isDestroyed()) {
+                    RecordContextLost();
+                }
+            });
+        }
+        DeviceProfile.WatchViewer = WatchViewer;
+        /**
+         * Forgets the detected hardware and override, for tests.
+         */
+        function Reset() {
+            detected = null;
+            override = null;
+            logged = false;
+        }
+        DeviceProfile.Reset = Reset;
+    })(exports.DeviceProfile || (exports.DeviceProfile = {}));
+
     /**
      * Returns if a given tileset is alive and in the scene.
      * @param viewer
@@ -16205,7 +17128,7 @@
         }
         return viewer.scene.primitives.contains(cTileset);
     }
-    const VIEWER_WATCH_KEY = "bruce-viewer-watch";
+    const VIEWER_WATCH_KEY$1 = "bruce-viewer-watch";
     const WATCH_KEY = "bruce-tileset-watch";
     const VIEWER_DATE_RANGE_WATCH_KEY = "bruce-viewer-date-range-watch";
     const DATE_RANGE_WATCH_KEY = "bruce-tileset-date-range-watch";
@@ -16267,6 +17190,22 @@
         }
         renderObject._bruceDateRangeVisible = visible;
     }
+    // A tileset may pass its cache share by this fraction before Cesium coarsens it to fit.
+    const TILESET_OVERFLOW_RATIO = 0.25;
+    /*
+     * Returns the options capping a tileset's tile cache at the given MB, in the form the running Cesium reads.
+     */
+    function getTilesetMemoryProps(mb) {
+        const prototype = Cesium.Cesium3DTileset.prototype;
+        if ("cacheBytes" in prototype) {
+            const props = { cacheBytes: Math.round(mb * 1024 * 1024) };
+            if ("maximumCacheOverflowBytes" in prototype) {
+                props.maximumCacheOverflowBytes = Math.round(mb * TILESET_OVERFLOW_RATIO * 1024 * 1024);
+            }
+            return props;
+        }
+        return { maximumMemoryUsage: mb };
+    }
     /**
      * Creates and returns a tileset instance from a given url.
      * This is made to handle the difference between old and new cesium versions.
@@ -16283,8 +17222,8 @@
         };
         Object.assign(defaultProps, exports.ViewUtils.DefaultLightingProps());
         if (noMemoryLimit != true) {
-            // "The maximum amount of memory in MB that can be used by the tileset.".
-            defaultProps.maximumMemoryUsage = 512;
+            // The memory watcher narrows this to a share once the tileset joins it.
+            Object.assign(defaultProps, getTilesetMemoryProps(exports.TilesetRenderEngine.GetTilesetMemoryBudget()));
         }
         const C3DT = Cesium.Cesium3DTileset;
         if (C3DT.fromUrl) {
@@ -16835,10 +17774,23 @@
         }
         TilesetRenderEngine.UnwatchDateRange = UnwatchDateRange;
         /**
-         * The maximum memory in MB that can be used by all tilesets.
-         * This is distributed evenly between all loaded tilesets.
+         * Total MB all tilesets may use, split evenly; null leaves it to the DeviceProfile tier.
+         */
+        TilesetRenderEngine.MAX_TILESET_MEMORY = null;
+        /**
+         * Smallest MB share a tileset gets; small, since Cesium coarsens one that needs more.
          */
-        TilesetRenderEngine.MAX_TILESET_MEMORY = 1024;
+        TilesetRenderEngine.MIN_TILESET_MEMORY = 32;
+        /**
+         * Returns the total MB all tilesets may use, from MAX_TILESET_MEMORY or else the device tier.
+         */
+        function GetTilesetMemoryBudget() {
+            if (Number.isFinite(TilesetRenderEngine.MAX_TILESET_MEMORY) && TilesetRenderEngine.MAX_TILESET_MEMORY > 0) {
+                return TilesetRenderEngine.MAX_TILESET_MEMORY;
+            }
+            return exports.DeviceProfile.GetBudget().tilesetMb;
+        }
+        TilesetRenderEngine.GetTilesetMemoryBudget = GetTilesetMemoryBudget;
         /**
          * Watches tileset date cutoffs and toggles their primitive visibility based on the viewer clock.
          */
@@ -16929,23 +17881,26 @@
             constructor(viewer) {
                 this.watched = [];
                 this.viewer = viewer;
+                exports.DeviceProfile.Get(viewer);
+                exports.DeviceProfile.WatchViewer(viewer);
+                this.removeChanged = exports.DeviceProfile.Changed.addEventListener(() => this.distributeMemory());
             }
             distributeMemory() {
                 this.clean();
-                // Total 1gb as default.
-                // We'll need to allow user to change this somehow.
-                const maxMemory = TilesetRenderEngine.MAX_TILESET_MEMORY;
-                // Minimum memory in MB per tileset.
-                const minMemory = 80;
-                const totalPerTileset = Math.max(this.watched.length ? maxMemory / this.watched.length : maxMemory, minMemory);
+                if (!this.watched.length) {
+                    return;
+                }
+                const share = Math.max(GetTilesetMemoryBudget() / this.watched.length, TilesetRenderEngine.MIN_TILESET_MEMORY);
+                const props = getTilesetMemoryProps(share);
                 this.watched.forEach(x => {
-                    // Newer Cesium killed this property.
-                    // TODO: Check if it's needed then.
-                    x["maximumMemoryUsage"] = totalPerTileset;
+                    Object.assign(x, props);
                 });
             }
             destroy() {
+                var _a;
                 this.watched = [];
+                (_a = this.removeChanged) === null || _a === void 0 ? void 0 : _a.call(this);
+                this.removeChanged = null;
             }
             /**
              * Remove all dead tilesets.
@@ -16994,10 +17949,10 @@
             if (!viewer || viewer.isDestroyed()) {
                 return null;
             }
-            if (!viewer[VIEWER_WATCH_KEY]) {
-                viewer[VIEWER_WATCH_KEY] = new MemoryWatcher(viewer);
+            if (!viewer[VIEWER_WATCH_KEY$1]) {
+                viewer[VIEWER_WATCH_KEY$1] = new MemoryWatcher(viewer);
             }
-            return viewer[VIEWER_WATCH_KEY];
+            return viewer[VIEWER_WATCH_KEY$1];
         }
         TilesetRenderEngine.GetMemoryWatcher = GetMemoryWatcher;
         function GetDateRangeWatcher(viewer) {
@@ -28159,7 +29114,9 @@
             if (loadUrl.indexOf("?") !== -1) {
                 loadUrl = loadUrl.split("?")[0];
             }
-            let maxSplats = 6000000;
+            const profile = exports.DeviceProfile.Get(viewer);
+            exports.DeviceProfile.WatchViewer(viewer);
+            let maxSplats = exports.DeviceProfile.GetBudget(profile.tier).splats;
             /*
              * Configures optional LOD capabilities once metadata or initial geometry is ready.
              */
@@ -28244,8 +29201,7 @@
             }
             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;
+                maxSplats = GetSplatBudget(sdkBudget, profile);
                 if (LCCRender.nextspaceMetadataReady === 1 &&
                     typeof obj.setNextspaceMetadataCallback === "function" &&
                     typeof obj.setMaxSplats === "function") {
@@ -28286,6 +29242,21 @@
             return obj;
         }
         XGridsRenderEngine.Render = Render;
+        /*
+         * The most splats a scan may load: the tier's, lowered by the SDK's GPU limit unless overridden.
+         */
+        function GetSplatBudget(sdkBudget, profile) {
+            const budget = exports.DeviceProfile.GetBudget(profile.tier).splats;
+            // Above 2M the SDK is reporting its flat default, not a limit it chose for this GPU.
+            if (!profile.overridden &&
+                Number.isFinite(sdkBudget) &&
+                sdkBudget > 0 &&
+                sdkBudget <= 2000000) {
+                return Math.min(sdkBudget, budget);
+            }
+            return budget;
+        }
+        XGridsRenderEngine.GetSplatBudget = GetSplatBudget;
         /*
          * Detaches optional tuning before unloading the scan.
          */
@@ -38712,6 +39683,1228 @@
         })(Terrain = TileRenderEngine.Terrain || (TileRenderEngine.Terrain = {}));
     })(exports.TileRenderEngine || (exports.TileRenderEngine = {}));
 
+    // Builds simple meshes into binary glTF in code. Nothing here imports Cesium, so it can move to bruce-models as is.
+    const GLB_MAGIC = 0x46546C67;
+    const GLB_CHUNK_JSON = 0x4E4F534A;
+    const GLB_CHUNK_BIN = 0x004E4942;
+    const GL_ARRAY_BUFFER = 34962;
+    const GL_ELEMENT_ARRAY_BUFFER = 34963;
+    const GL_UNSIGNED_SHORT = 5123;
+    const GL_UNSIGNED_INT = 5125;
+    const GL_FLOAT = 5126;
+    const GL_TRIANGLES = 4;
+    (function (GltfGenerator) {
+        /**
+         * Vertices and triangles collected by the shape functions, one material's worth.
+         */
+        class Mesh {
+            constructor() {
+                this.positions = [];
+                this.normals = [];
+                this.indices = [];
+            }
+            AddVertex(position, normal) {
+                this.positions.push(position[0], position[1], position[2]);
+                this.normals.push(normal[0], normal[1], normal[2]);
+                return this.positions.length / 3 - 1;
+            }
+            /**
+             * Adds a triangle wound so its front faces along normal, whichever order the corners come in.
+             * Per corner normals smooth it; without them every corner takes the face normal.
+             */
+            AddTriangle(a, b, c, normal, corners) {
+                var _a, _b, _c;
+                const ia = this.AddVertex(a, (_a = corners === null || corners === void 0 ? void 0 : corners[0]) !== null && _a !== void 0 ? _a : normal);
+                const ib = this.AddVertex(b, (_b = corners === null || corners === void 0 ? void 0 : corners[1]) !== null && _b !== void 0 ? _b : normal);
+                const ic = this.AddVertex(c, (_c = corners === null || corners === void 0 ? void 0 : corners[2]) !== null && _c !== void 0 ? _c : normal);
+                if (Dot(Cross(Sub(b, a), Sub(c, a)), normal) >= 0) {
+                    this.indices.push(ia, ib, ic);
+                }
+                else {
+                    this.indices.push(ia, ic, ib);
+                }
+            }
+            /**
+             * Joins three added vertices into a triangle facing along normal, so shapes can share corners.
+             */
+            AddIndexedTriangle(ia, ib, ic, normal) {
+                const at = (i) => [this.positions[i * 3], this.positions[i * 3 + 1], this.positions[i * 3 + 2]];
+                const a = at(ia);
+                if (Dot(Cross(Sub(at(ib), a), Sub(at(ic), a)), normal) >= 0) {
+                    this.indices.push(ia, ib, ic);
+                }
+                else {
+                    this.indices.push(ia, ic, ib);
+                }
+            }
+            get VertexCount() {
+                return this.positions.length / 3;
+            }
+        }
+        GltfGenerator.Mesh = Mesh;
+        function Add(a, b) {
+            return [a[0] + b[0], a[1] + b[1], a[2] + b[2]];
+        }
+        GltfGenerator.Add = Add;
+        function Sub(a, b) {
+            return [a[0] - b[0], a[1] - b[1], a[2] - b[2]];
+        }
+        GltfGenerator.Sub = Sub;
+        function Scale(a, s) {
+            return [a[0] * s, a[1] * s, a[2] * s];
+        }
+        GltfGenerator.Scale = Scale;
+        function Dot(a, b) {
+            return a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
+        }
+        GltfGenerator.Dot = Dot;
+        function Cross(a, b) {
+            return [a[1] * b[2] - a[2] * b[1], a[2] * b[0] - a[0] * b[2], a[0] * b[1] - a[1] * b[0]];
+        }
+        GltfGenerator.Cross = Cross;
+        function Normalize(a) {
+            const length = Math.hypot(a[0], a[1], a[2]);
+            return length ? Scale(a, 1 / length) : [0, 0, 0];
+        }
+        GltfGenerator.Normalize = Normalize;
+        /*
+         * Two unit vectors at right angles to an axis and each other, the first along start where one is given.
+         */
+        function perpendiculars(axis, start) {
+            const n = Normalize(axis);
+            let u = start ? Sub(start, Scale(n, Dot(start, n))) : null;
+            if (!u || Math.hypot(u[0], u[1], u[2]) < 1e-9) {
+                u = Math.abs(n[0]) < 0.9 ? Cross(n, [1, 0, 0]) : Cross(n, [0, 1, 0]);
+            }
+            u = Normalize(u);
+            return [u, Cross(n, u)];
+        }
+        /*
+         * The point on a circle around centre at a given turn, in the plane the two perpendiculars span.
+         */
+        function onCircle(centre, u, v, radius, angle) {
+            return Add(centre, Add(Scale(u, Math.cos(angle) * radius), Scale(v, Math.sin(angle) * radius)));
+        }
+        /**
+         * Adds a flat disc facing along normal.
+         */
+        function AddDisc(mesh, params) {
+            const { centre, radius, sides } = params;
+            const normal = Normalize(params.normal);
+            const [u, v] = perpendiculars(normal, params.start);
+            for (let i = 0; i < sides; i++) {
+                const a = onCircle(centre, u, v, radius, i / sides * Math.PI * 2);
+                const b = onCircle(centre, u, v, radius, (i + 1) / sides * Math.PI * 2);
+                mesh.AddTriangle(centre, a, b, normal);
+            }
+        }
+        GltfGenerator.AddDisc = AddDisc;
+        /**
+         * Adds a smooth sided cylinder between two points, closed at the start by default.
+         */
+        function AddCylinder(mesh, params) {
+            const { start, end, radius, sides } = params;
+            const axis = Normalize(Sub(end, start));
+            const [u, v] = perpendiculars(axis);
+            for (let i = 0; i < sides; i++) {
+                const angleA = i / sides * Math.PI * 2;
+                const angleB = (i + 1) / sides * Math.PI * 2;
+                const outA = onCircle([0, 0, 0], u, v, 1, angleA);
+                const outB = onCircle([0, 0, 0], u, v, 1, angleB);
+                const a0 = onCircle(start, u, v, radius, angleA);
+                const b0 = onCircle(start, u, v, radius, angleB);
+                const a1 = onCircle(end, u, v, radius, angleA);
+                const b1 = onCircle(end, u, v, radius, angleB);
+                const face = Normalize(Add(outA, outB));
+                mesh.AddTriangle(a0, b0, b1, face, [outA, outB, outB]);
+                mesh.AddTriangle(a0, b1, a1, face, [outA, outB, outA]);
+            }
+            if (params.capStart != false) {
+                AddDisc(mesh, { centre: start, normal: Scale(axis, -1), radius, sides });
+            }
+            if (params.capEnd) {
+                AddDisc(mesh, { centre: end, normal: axis, radius, sides });
+            }
+        }
+        GltfGenerator.AddCylinder = AddCylinder;
+        /**
+         * Adds a cone from a base circle to a tip, closed at the base by default.
+         */
+        function AddCone(mesh, params) {
+            const { base, tip, radius, sides } = params;
+            const toTip = Sub(tip, base);
+            const height = Math.hypot(toTip[0], toTip[1], toTip[2]);
+            const axis = Normalize(toTip);
+            const [u, v] = perpendiculars(axis, params.start);
+            // A side normal leans toward the tip by the slope of the side.
+            const sideNormal = (angle) => Normalize(Add(Scale(onCircle([0, 0, 0], u, v, 1, angle), height), Scale(axis, radius)));
+            for (let i = 0; i < sides; i++) {
+                const angleA = i / sides * Math.PI * 2;
+                const angleB = (i + 1) / sides * Math.PI * 2;
+                const a = onCircle(base, u, v, radius, angleA);
+                const b = onCircle(base, u, v, radius, angleB);
+                const face = sideNormal((angleA + angleB) / 2);
+                mesh.AddTriangle(a, b, tip, face, params.faceted ? undefined : [sideNormal(angleA), sideNormal(angleB), face]);
+            }
+            if (params.cap != false) {
+                AddDisc(mesh, { centre: base, normal: Scale(axis, -1), radius, sides, start: params.start });
+            }
+        }
+        GltfGenerator.AddCone = AddCone;
+        /**
+         * Adds a smooth ring of tube around an axis through centre.
+         */
+        function AddTorus(mesh, params) {
+            const { centre, radius, tube, segments, sides } = params;
+            const axis = Normalize(params.axis);
+            const [u, v] = perpendiculars(axis);
+            // A grid of shared corners, wrapping round both ways.
+            const first = mesh.VertexCount;
+            for (let i = 0; i < segments; i++) {
+                const out = onCircle([0, 0, 0], u, v, 1, i / segments * Math.PI * 2);
+                for (let j = 0; j < sides; j++) {
+                    const turn = j / sides * Math.PI * 2;
+                    const normal = Add(Scale(out, Math.cos(turn)), Scale(axis, Math.sin(turn)));
+                    mesh.AddVertex(Add(Add(centre, Scale(out, radius)), Scale(normal, tube)), normal);
+                }
+            }
+            const at = (i, j) => first + (i % segments) * sides + (j % sides);
+            const normalAt = (i) => [mesh.normals[i * 3], mesh.normals[i * 3 + 1], mesh.normals[i * 3 + 2]];
+            for (let i = 0; i < segments; i++) {
+                for (let j = 0; j < sides; j++) {
+                    const quad = [at(i, j), at(i + 1, j), at(i + 1, j + 1), at(i, j + 1)];
+                    const normal = Normalize(Add(normalAt(quad[0]), normalAt(quad[2])));
+                    mesh.AddIndexedTriangle(quad[0], quad[1], quad[2], normal);
+                    mesh.AddIndexedTriangle(quad[0], quad[2], quad[3], normal);
+                }
+            }
+        }
+        GltfGenerator.AddTorus = AddTorus;
+        /**
+         * Adds a flat convex outline, given in a plane's own across and up coordinates, facing along normal.
+         */
+        function AddConvexOutline(mesh, params) {
+            const { points, origin, across, up } = params;
+            const normal = Normalize(params.normal);
+            const at = ([x, y]) => Add(origin, Add(Scale(across, x), Scale(up, y)));
+            for (let i = 1; i < points.length - 1; i++) {
+                mesh.AddTriangle(at(points[0]), at(points[i]), at(points[i + 1]), normal);
+            }
+        }
+        GltfGenerator.AddConvexOutline = AddConvexOutline;
+        function align4(length) {
+            return Math.ceil(length / 4) * 4;
+        }
+        function bounds(positions) {
+            const min = [Infinity, Infinity, Infinity];
+            const max = [-Infinity, -Infinity, -Infinity];
+            for (let i = 0; i < positions.length; i++) {
+                const k = i % 3;
+                min[k] = Math.min(min[k], positions[i]);
+                max[k] = Math.max(max[k], positions[i]);
+            }
+            return { min, max };
+        }
+        /**
+         * Packs a mesh into GLB bytes, under a chain of node matrices (outermost first) when given.
+         */
+        function ToGlb(params) {
+            var _a, _b, _c;
+            const { mesh, material } = params;
+            const count = mesh.VertexCount;
+            const wide = count > 0xFFFF;
+            const IndexArray = wide ? Uint32Array : Uint16Array;
+            const indexLength = mesh.indices.length * IndexArray.BYTES_PER_ELEMENT;
+            const indexBytes = align4(indexLength);
+            const vertexBytes = count * 12;
+            const bin = new ArrayBuffer(indexBytes + vertexBytes * 2);
+            new IndexArray(bin, 0, mesh.indices.length).set(mesh.indices);
+            new Float32Array(bin, indexBytes, count * 3).set(mesh.positions);
+            new Float32Array(bin, indexBytes + vertexBytes, count * 3).set(mesh.normals);
+            // The mesh node is last, each matrix node holding the next.
+            const matrices = (_a = params.matrices) !== null && _a !== void 0 ? _a : [];
+            const nodes = matrices.map((matrix, i) => ({ matrix, children: [i + 1] }));
+            nodes.push({ mesh: 0 });
+            const json = {
+                asset: { version: "2.0", generator: "bruce-cesium GltfGenerator" },
+                scene: 0,
+                scenes: [{ nodes: [0] }],
+                nodes,
+                meshes: [{ primitives: [{ attributes: { POSITION: 1, NORMAL: 2 }, indices: 0, material: 0, mode: GL_TRIANGLES }] }],
+                materials: [{
+                        pbrMetallicRoughness: {
+                            baseColorFactor: material.color,
+                            metallicFactor: (_b = material.metallic) !== null && _b !== void 0 ? _b : 0,
+                            roughnessFactor: (_c = material.roughness) !== null && _c !== void 0 ? _c : 1
+                        },
+                        doubleSided: Boolean(material.doubleSided)
+                    }],
+                buffers: [{ byteLength: bin.byteLength }],
+                bufferViews: [
+                    { buffer: 0, byteOffset: 0, byteLength: indexLength, target: GL_ELEMENT_ARRAY_BUFFER },
+                    { buffer: 0, byteOffset: indexBytes, byteLength: vertexBytes, target: GL_ARRAY_BUFFER },
+                    { buffer: 0, byteOffset: indexBytes + vertexBytes, byteLength: vertexBytes, target: GL_ARRAY_BUFFER }
+                ],
+                accessors: [
+                    { bufferView: 0, componentType: wide ? GL_UNSIGNED_INT : GL_UNSIGNED_SHORT, count: mesh.indices.length, type: "SCALAR" },
+                    { bufferView: 1, componentType: GL_FLOAT, count, type: "VEC3", ...bounds(mesh.positions) },
+                    { bufferView: 2, componentType: GL_FLOAT, count, type: "VEC3" }
+                ]
+            };
+            let text = JSON.stringify(json);
+            text += " ".repeat(align4(text.length) - text.length);
+            const jsonBytes = new TextEncoder().encode(text);
+            const glb = new Uint8Array(20 + jsonBytes.length + 8 + bin.byteLength);
+            const view = new DataView(glb.buffer);
+            view.setUint32(0, GLB_MAGIC, true);
+            view.setUint32(4, 2, true);
+            view.setUint32(8, glb.length, true);
+            view.setUint32(12, jsonBytes.length, true);
+            view.setUint32(16, GLB_CHUNK_JSON, true);
+            glb.set(jsonBytes, 20);
+            const binStart = 20 + jsonBytes.length;
+            view.setUint32(binStart, bin.byteLength, true);
+            view.setUint32(binStart + 4, GLB_CHUNK_BIN, true);
+            glb.set(new Uint8Array(bin), binStart + 8);
+            return glb;
+        }
+        GltfGenerator.ToGlb = ToGlb;
+        /**
+         * Packs a mesh into a GLB data URI, which loads as a model url with nothing to fetch.
+         */
+        function ToDataUri(params) {
+            const glb = ToGlb(params);
+            let binary = "";
+            for (let i = 0; i < glb.length; i += 0x8000) {
+                binary += String.fromCharCode.apply(null, glb.subarray(i, i + 0x8000));
+            }
+            return "data:model/gltf-binary;base64," + btoa(binary);
+        }
+        GltfGenerator.ToDataUri = ToDataUri;
+    })(exports.GltfGenerator || (exports.GltfGenerator = {}));
+
+    // Sides on an arrow's shaft and cone.
+    const ARROW_SIDES = 16;
+    const SHAFT_RADIUS = 2.4;
+    const SHAFT_LENGTH = 265;
+    const CONE_RADIUS = 10;
+    const CONE_BASE = 264.6;
+    const CONE_TIP = 306.3;
+    const RING_RADIUS = 210;
+    const RING_TUBE = 1;
+    const RING_SEGMENTS = 60;
+    const RING_SIDES = 10;
+    // The ring's two arrowheads sit either side of its 45 degree mark, each pointing back toward it.
+    const RING_MARK_ANGLES = [137.64, -47.64];
+    const RING_MARK_LENGTH = 5.82;
+    const RING_MARK_CENTRE = 209.8;
+    const RING_MARK_RADIUS = 8.5;
+    const RING_MARK_SIDES = 8;
+    // Turns the original models' Y up node into the Z up frame the pieces were drawn in.
+    const ROOT_MATRIX = [1, 0, 0, 0, 0, 0, -1, 0, 0, 1, 0, 0, 0, 0, 0, 1];
+    // Points a piece drawn along +Z down another axis, as the original models' mesh nodes did.
+    const TO_X_MATRIX = [0, 0, -1, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1];
+    const TO_Y_ARROW_MATRIX = [0, 0, -1, 0, -1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1];
+    const TO_Y_RING_MATRIX = [1, 0, 0, 0, 0, 0, 1, 0, 0, -1, 0, 0, 0, 0, 0, 1];
+    const RED = { color: [1, 0, 0, 1] };
+    const GREEN = { color: [0.2196, 0.5216, 0.1647, 1] };
+    const BLUE = { color: [0.1608, 0.3843, 0.698, 1] };
+    const LETTER_X = {
+        across: [0, 1, 0],
+        facing: [-1, 0, 0],
+        strokes: [
+            [[16.4, 318.6], [16.4, 324.2], [-19.4, 349.8], [-19.4, 343.9]],
+            [[-19.4, 316.9], [-19.4, 322.6], [16.4, 348.8], [16.4, 343.6]]
+        ]
+    };
+    const LETTER_Y = {
+        across: [0, 1, 0],
+        facing: [-1, 0, 0],
+        strokes: [
+            [[-1.9, 320.1], [2.8, 320.1], [2.8, 337.7], [-1.9, 337.7]],
+            [[-1.9, 335.3], [2.8, 335.3], [-10.7, 355.9], [-16.2, 355.9]],
+            [[-1.9, 335.3], [2.8, 335.3], [16.6, 355.9], [10.9, 355.9]]
+        ]
+    };
+    const LETTER_Z = {
+        across: [1, 0, 0],
+        facing: [0, -1, 0],
+        strokes: [
+            [[-14.6, 319], [13.7, 319], [13.7, 323.3], [-14.6, 323.3]],
+            [[-14.6, 323.3], [-9.1, 323.3], [13.1, 350.6], [7.5, 350.6]],
+            [[-12.5, 350.6], [13.1, 350.6], [13.1, 354.8], [-12.5, 354.8]]
+        ]
+    };
+    /*
+     * An axis arrow along +Z: shaft, cone and the axis letter past the tip.
+     */
+    function arrowMesh(letter) {
+        const mesh = new exports.GltfGenerator.Mesh();
+        exports.GltfGenerator.AddCylinder(mesh, { start: [0, 0, 0], end: [0, 0, SHAFT_LENGTH], radius: SHAFT_RADIUS, sides: ARROW_SIDES });
+        exports.GltfGenerator.AddCone(mesh, { base: [0, 0, CONE_BASE], tip: [0, 0, CONE_TIP], radius: CONE_RADIUS, sides: ARROW_SIDES });
+        for (const stroke of letter.strokes) {
+            exports.GltfGenerator.AddConvexOutline(mesh, { points: stroke, origin: [0, 0, 0], across: letter.across, up: [0, 0, 1], normal: letter.facing });
+        }
+        return mesh;
+    }
+    function onRing(degrees, radius) {
+        const angle = degrees * Math.PI / 180;
+        return [Math.cos(angle) * radius, Math.sin(angle) * radius, 0];
+    }
+    /*
+     * A rotation ring about +Z with its two arrowheads.
+     */
+    function ringMesh() {
+        const mesh = new exports.GltfGenerator.Mesh();
+        exports.GltfGenerator.AddTorus(mesh, {
+            centre: [0, 0, 0],
+            axis: [0, 0, 1],
+            radius: RING_RADIUS,
+            tube: RING_TUBE,
+            segments: RING_SEGMENTS,
+            sides: RING_SIDES
+        });
+        for (const degrees of RING_MARK_ANGLES) {
+            const toward = degrees > 45 ? -RING_MARK_LENGTH : RING_MARK_LENGTH;
+            exports.GltfGenerator.AddCone(mesh, {
+                base: onRing(degrees, RING_MARK_CENTRE),
+                tip: onRing(degrees + toward, RING_MARK_CENTRE),
+                radius: RING_MARK_RADIUS,
+                sides: RING_MARK_SIDES,
+                faceted: true,
+                // A rim corner points at the ring's centre, as the original arrowheads' did.
+                start: onRing(degrees, 1)
+            });
+        }
+        return mesh;
+    }
+    (function (GltfGizmo) {
+        let EPiece;
+        (function (EPiece) {
+            EPiece["X"] = "x";
+            EPiece["Y"] = "y";
+            EPiece["Z"] = "z";
+            EPiece["XRotation"] = "x-rot";
+            EPiece["YRotation"] = "y-rot";
+            EPiece["ZRotation"] = "z-rot";
+        })(EPiece = GltfGizmo.EPiece || (GltfGizmo.EPiece = {}));
+        const BUILDERS = {
+            [EPiece.X]: () => exports.GltfGenerator.ToDataUri({ mesh: arrowMesh(LETTER_X), material: RED, matrices: [ROOT_MATRIX, TO_X_MATRIX] }),
+            [EPiece.Y]: () => exports.GltfGenerator.ToDataUri({ mesh: arrowMesh(LETTER_Y), material: GREEN, matrices: [ROOT_MATRIX, TO_Y_ARROW_MATRIX] }),
+            [EPiece.Z]: () => exports.GltfGenerator.ToDataUri({ mesh: arrowMesh(LETTER_Z), material: BLUE, matrices: [ROOT_MATRIX] }),
+            [EPiece.XRotation]: () => exports.GltfGenerator.ToDataUri({ mesh: ringMesh(), material: RED, matrices: [ROOT_MATRIX, TO_X_MATRIX] }),
+            [EPiece.YRotation]: () => exports.GltfGenerator.ToDataUri({ mesh: ringMesh(), material: GREEN, matrices: [ROOT_MATRIX, TO_Y_RING_MATRIX] }),
+            [EPiece.ZRotation]: () => exports.GltfGenerator.ToDataUri({ mesh: ringMesh(), material: BLUE, matrices: [ROOT_MATRIX] })
+        };
+        // Built pieces, so every gizmo shares one string per piece and CesiumJS's model cache sees the same url.
+        const built = {};
+        /**
+         * Returns a piece's model as a data URI, to pass wherever a model url is taken.
+         */
+        function GetUri(piece) {
+            if (!built[piece]) {
+                built[piece] = BUILDERS[piece]();
+            }
+            return built[piece];
+        }
+        GltfGizmo.GetUri = GetUri;
+    })(exports.GltfGizmo || (exports.GltfGizmo = {}));
+
+    // viewer[CLASS_INSTANCE_KEY] will point at an instance of MapGridHandler.
+    const CLASS_INSTANCE_KEY = "nextspace-navigator-grid-handler";
+    // viewer[UPDATE_MARKER_KEY] will point at a number that is incremented every time the grid is updated.
+    // This is used to determine if the grid is still valid or if it needs to be redrawn.
+    const UPDATE_MARKER_KEY = "nextspace-marker-grid";
+    // viewer[LAST_SETTINGS_KEY] will point at the last settings used for the grid.
+    const LAST_SETTINGS_KEY = "nextspace-navigator-last-settings-grid";
+    /*
+     * The point a distance in metres along a heading in degrees from another, over a spherical earth.
+     */
+    function offsetPoint$1(point, distance, heading) {
+        // Radius of earth.
+        const radius = 6371e3;
+        const δ = distance / radius;
+        const θ = Cesium.Math.toRadians(heading);
+        const φ1 = Cesium.Math.toRadians(point.latitude);
+        const λ1 = Cesium.Math.toRadians(point.longitude);
+        const sinφ2 = Math.sin(φ1) * Math.cos(δ) + Math.cos(φ1) * Math.sin(δ) * Math.cos(θ);
+        const φ2 = Math.asin(sinφ2);
+        const y = Math.sin(θ) * Math.sin(δ) * Math.cos(φ1);
+        const x = Math.cos(δ) - Math.sin(φ1) * sinφ2;
+        const λ2 = λ1 + Math.atan2(y, x);
+        return {
+            altitude: point.altitude,
+            latitude: Cesium.Math.toDegrees(φ2),
+            longitude: Cesium.Math.toDegrees(λ2)
+        };
+    }
+    /**
+     * Handler for drawing a grid of lines on the map with a specified spacing.
+     * Initially this grid is for model-space viewing which means we start at 0,0 lat/lon and have it expand from there.
+     * However, it should be a general-use tool for drawing a grid anywhere.
+     *
+     * It reacts to camera changes and draws the grid within view with padding.
+     * This helps avoid performance issues around drawing too many lines.
+     */
+    class MapGridHandler {
+        constructor(viewer, spacingInMeters = 100, modelSpace = false) {
+            this.gridCenterGizmoPieces = [];
+            this.maxCacheSize = 1000;
+            // === Thresholds for grid stability.
+            // As a fraction of current grid extent.
+            this.CAMERA_MOVE_THRESHOLD = 0.5;
+            // 40% change in camera height triggers redraw.
+            this.HEIGHT_CHANGE_THRESHOLD = 0.4;
+            // 40% change in grid extent triggers redraw.
+            this.GRID_EXTENT_CHANGE_THRESHOLD = 0.4;
+            // 5km - distance that triggers origin reset.
+            this.EXTREME_DISTANCE_THRESHOLD = 5000;
+            // Grid limits to prevent drawing too many lines.
+            this.MAX_LINES = 500;
+            // 50% padding around visible area.
+            this.VIEW_PADDING_FACTOR = 0.5;
+            // Minimum pixels between grid lines to show them.
+            this.MIN_GRID_PIXEL_SIZE = 20;
+            // Base ratio - will be adjusted dynamically based on spacing size and camera height.
+            this.BASE_MAX_VISIBILITY_RATIO = 30;
+            // Height to spacing ratio.
+            this.HEIGHT_TO_SPACING_RATIO = 100;
+            // === Label settings
+            // Label every nth intersection.
+            this.LABEL_INTERVAL = 2;
+            // Maximum number of labels to show.
+            this.MAX_LABELS = 100;
+            // Spacing levels to use for adaptive spacing.
+            this.SPACING_LEVELS = [
+                1, 2, 5, 10, 20, 25, 50, 100, 200, 250, 300, 400, 500, 1000, 2000, 2500, 5000, 10000, 20000, 25000, 50000, 100000
+            ];
+            // Minimum zoom distance to prevent precision issues.
+            this.MINIMUM_ZOOM_DISTANCE = 40;
+            // Base spacing to use for adaptive spacing.
+            this.BASE_SPACING = 1;
+            // Maximum number of attempts to find a suitable spacing.
+            this.MAX_ADAPTIVE_ATTEMPTS = 5;
+            this.viewer = viewer;
+            this.spacingInMeters = spacingInMeters;
+            this.isUpdating = false;
+            this.modelSpace = modelSpace;
+            this.lastCameraPosition = null;
+            this.fixedGridOrigin = null;
+            this.lastGridExtent = 0;
+            this.offsetCache = new Map();
+            this.gridPrimitives = new Cesium.PrimitiveCollection();
+            this.viewer.scene.primitives.add(this.gridPrimitives);
+            this.currentMarker = viewer[UPDATE_MARKER_KEY] || 1;
+            const isMac = typeof navigator !== "undefined" && (navigator.platform.toUpperCase().indexOf("MAC") !== -1 ||
+                navigator.userAgent.toUpperCase().indexOf("MAC") !== -1);
+            if (modelSpace && isMac) {
+                console.log("[MAC-FIX] Applying camera distance limits for Mac");
+                viewer.scene.screenSpaceCameraController.minimumZoomDistance = this.MINIMUM_ZOOM_DISTANCE;
+            }
+            const manager = exports.ViewerUtils.GetManager({
+                viewer: this.viewer,
+                createIfMissing: false
+            });
+            if (manager) {
+                this.cameraChangeRemoval = manager.Monitor.Updated().Subscribe(() => {
+                    this.onCameraChanged();
+                });
+            }
+            // Initial grid draw.
+            this.onCameraChanged();
+        }
+        Update(spacingInMeters, modelSpace) {
+            this.currentMarker = this.viewer[UPDATE_MARKER_KEY] || 1;
+            let needsUpdate = false;
+            if (this.spacingInMeters !== spacingInMeters) {
+                this.spacingInMeters = spacingInMeters;
+                needsUpdate = true;
+            }
+            if (modelSpace !== undefined && this.modelSpace !== modelSpace) {
+                this.modelSpace = modelSpace;
+                needsUpdate = true;
+            }
+            if (needsUpdate) {
+                this.clearGrid();
+                // When spacing or model space changes, clear the cached origin to force recalculation
+                // This ensures grid alignment at the new spacing.
+                this.fixedGridOrigin = null;
+                this.offsetCache.clear();
+                this.onCameraChanged();
+            }
+        }
+        Dispose() {
+            this.clearGrid();
+            this.clearGizmoPieces();
+            if (this.cameraChangeRemoval) {
+                this.cameraChangeRemoval();
+                this.cameraChangeRemoval = null;
+            }
+            if (this.gridPrimitives) {
+                this.viewer.scene.primitives.remove(this.gridPrimitives);
+                this.gridPrimitives = null;
+            }
+            if (this.viewer) {
+                this.viewer = null;
+            }
+            this.offsetCache.clear();
+            this.fixedGridOrigin = null;
+        }
+        clearGrid() {
+            if (this.gridPrimitives) {
+                this.gridPrimitives.removeAll();
+                this.gridLines = null;
+                this.gridLabels = null;
+            }
+        }
+        calculateAdaptiveSpacing(cameraHeight, baseSpacing) {
+            // Define spacing levels that look good (powers of 2, 5, and 10)
+            const spacingLevels = this.SPACING_LEVELS;
+            // Ensure base spacing is at least 1m
+            const adjustedBaseSpacing = Math.max(this.BASE_SPACING, baseSpacing);
+            // For very close cameras, use much smaller spacing regardless of base
+            if (cameraHeight < 10) {
+                // Find the smallest reasonable spacing for this height
+                // Rule: spacing should be roughly 1/20th to 1/50th of camera height, but at least 1m
+                const targetSpacing = Math.max(this.BASE_SPACING, cameraHeight / 30);
+                // Find the closest spacing level to our target
+                let bestSpacing = this.BASE_SPACING; // Start with minimum
+                let bestDifference = Math.abs(1 - targetSpacing);
+                for (const spacing of spacingLevels) {
+                    if (spacing >= this.BASE_SPACING) { // Only consider valid spacings
+                        const difference = Math.abs(spacing - targetSpacing);
+                        if (difference < bestDifference) {
+                            bestSpacing = spacing;
+                            bestDifference = difference;
+                        }
+                    }
+                }
+                return bestSpacing;
+            }
+            // For medium distances (10m - 200m), scale more gradually
+            if (cameraHeight < 200) {
+                const targetSpacing = cameraHeight / 10; // More conservative scaling// Find closest spacing level, but prefer going up from base spacing
+                let bestSpacing = adjustedBaseSpacing;
+                let bestDifference = Math.abs(adjustedBaseSpacing - targetSpacing);
+                for (const spacing of spacingLevels) {
+                    if (spacing >= Math.min(adjustedBaseSpacing, targetSpacing)) {
+                        const difference = Math.abs(spacing - targetSpacing);
+                        if (difference < bestDifference) {
+                            bestSpacing = spacing;
+                            bestDifference = difference;
+                        }
+                    }
+                }
+                return bestSpacing;
+            }
+            // For far distances (100m+), scale up aggressively
+            const targetSpacing = cameraHeight / 20;
+            // Find the spacing level that's closest to target but not smaller than base
+            let bestSpacing = adjustedBaseSpacing;
+            let bestDifference = Math.abs(adjustedBaseSpacing - targetSpacing);
+            for (const spacing of spacingLevels) {
+                if (spacing >= adjustedBaseSpacing) {
+                    const difference = Math.abs(spacing - targetSpacing);
+                    if (difference < bestDifference) {
+                        bestSpacing = spacing;
+                        bestDifference = difference;
+                    }
+                }
+            }
+            return bestSpacing;
+        }
+        /*
+         * The point model-space treats as 0,0,0: the UCS in UCS placement, otherwise 0,0 lat/lon at sea level.
+         */
+        modelSpaceOrigin() {
+            const origin = exports.ViewUtils.IsModelSpaceUcs(this.viewer) ? exports.ViewUtils.GetModelSpaceOrigin(this.viewer) : null;
+            return origin !== null && origin !== void 0 ? origin : { latitude: 0, longitude: 0, altitude: 0 };
+        }
+        /*
+         * The origin as a scene position, where the axis gizmo sits.
+         */
+        modelSpaceOriginPos3d() {
+            const origin = this.modelSpaceOrigin();
+            return Cesium.Cartesian3.fromDegrees(origin.longitude, origin.latitude, origin.altitude);
+        }
+        drawGizmoPieces() {
+            if (this.gridCenterGizmoPieces.length) {
+                return;
+            }
+            // X.
+            {
+                const pos3d = this.modelSpaceOriginPos3d();
+                const scale = new Cesium.CallbackProperty(() => Cesium.Cartesian3.distance(this.viewer.camera.position, pos3d) * 0.0002, false);
+                const orientation = Cesium.Transforms.headingPitchRollQuaternion(pos3d, new Cesium.HeadingPitchRoll(Cesium.Math.toRadians(90), 0, 0));
+                const entity = this.viewer.entities.add(new Cesium.Entity({
+                    model: {
+                        uri: exports.GltfGizmo.GetUri(exports.GltfGizmo.EPiece.X),
+                        heightReference: Cesium.HeightReference.NONE,
+                        shadows: Cesium.ShadowMode.DISABLED,
+                        distanceDisplayCondition: new Cesium.DistanceDisplayCondition(0, Number.MAX_VALUE),
+                        scale
+                    },
+                    position: pos3d,
+                    orientation: new Cesium.ConstantProperty(orientation)
+                }));
+                this.gridCenterGizmoPieces.push(entity);
+            }
+            // Y.
+            {
+                const pos3d = this.modelSpaceOriginPos3d();
+                const scale = new Cesium.CallbackProperty(() => Cesium.Cartesian3.distance(this.viewer.camera.position, pos3d) * 0.0002, false);
+                const orientation = Cesium.Transforms.headingPitchRollQuaternion(pos3d, new Cesium.HeadingPitchRoll(Cesium.Math.toRadians(90), 0, 0));
+                const entity = this.viewer.entities.add(new Cesium.Entity({
+                    model: {
+                        uri: exports.GltfGizmo.GetUri(exports.GltfGizmo.EPiece.Y),
+                        heightReference: Cesium.HeightReference.NONE,
+                        shadows: Cesium.ShadowMode.DISABLED,
+                        distanceDisplayCondition: new Cesium.DistanceDisplayCondition(0, Number.MAX_VALUE),
+                        scale
+                    },
+                    position: pos3d,
+                    orientation: new Cesium.ConstantProperty(orientation)
+                }));
+                this.gridCenterGizmoPieces.push(entity);
+            }
+            // Z.
+            {
+                const pos3d = this.modelSpaceOriginPos3d();
+                const scale = new Cesium.CallbackProperty(() => Cesium.Cartesian3.distance(this.viewer.camera.position, pos3d) * 0.0002, false);
+                const orientation = Cesium.Transforms.headingPitchRollQuaternion(pos3d, new Cesium.HeadingPitchRoll(Cesium.Math.toRadians(90), 0, 0));
+                const entity = this.viewer.entities.add(new Cesium.Entity({
+                    model: {
+                        uri: exports.GltfGizmo.GetUri(exports.GltfGizmo.EPiece.Z),
+                        heightReference: Cesium.HeightReference.NONE,
+                        shadows: Cesium.ShadowMode.DISABLED,
+                        distanceDisplayCondition: new Cesium.DistanceDisplayCondition(0, Number.MAX_VALUE),
+                        scale
+                    },
+                    position: pos3d,
+                    orientation: new Cesium.ConstantProperty(orientation)
+                }));
+                this.gridCenterGizmoPieces.push(entity);
+            }
+        }
+        clearGizmoPieces() {
+            for (const piece of this.gridCenterGizmoPieces) {
+                if (piece && this.viewer.entities.contains(piece)) {
+                    this.viewer.entities.remove(piece);
+                }
+            }
+            this.gridCenterGizmoPieces = [];
+        }
+        onCameraChanged() {
+            if (this.isUpdating) {
+                return;
+            }
+            else if (this.currentMarker !== this.viewer[UPDATE_MARKER_KEY]) {
+                return;
+            }
+            this.isUpdating = true;
+            // Small delay to avoid excessive updates during camera movement.
+            setTimeout(() => {
+                if (this.currentMarker !== this.viewer[UPDATE_MARKER_KEY]) {
+                    this.isUpdating = false;
+                    return;
+                }
+                try {
+                    // The grid goes first, since it notices when the origin has moved and the gizmo has to follow.
+                    this.updateGrid();
+                    if (this.modelSpace) {
+                        this.drawGizmoPieces();
+                    }
+                    else {
+                        this.clearGizmoPieces();
+                    }
+                }
+                catch (e) {
+                    console.error(e);
+                }
+                finally {
+                    this.isUpdating = false;
+                }
+            }, 100);
+        }
+        cachedOffsetPoint(point, distance, heading) {
+            const key = `${point.latitude.toFixed(8)},${point.longitude.toFixed(8)},${distance.toFixed(1)},${heading}`;
+            if (this.offsetCache.has(key)) {
+                return this.offsetCache.get(key);
+            }
+            const result = offsetPoint$1(point, distance, heading);
+            this.offsetCache.set(key, result);
+            if (this.offsetCache.size > this.maxCacheSize) {
+                const keys = Array.from(this.offsetCache.keys());
+                for (let i = 0; i < 100; i++) {
+                    this.offsetCache.delete(keys[i]);
+                }
+            }
+            return result;
+        }
+        /**
+         * Calculates a dynamic visibility ratio based on spacing size.
+         * For small grid spacings, we can show the grid from farther away.
+         * For large grid spacings, we need to hide it sooner to prevent performance issues.
+         */
+        getMaxVisibilityRatio() {
+            if (this.spacingInMeters <= 10) {
+                return this.BASE_MAX_VISIBILITY_RATIO;
+            }
+            if (this.spacingInMeters <= 100) {
+                const factor = 1 - ((this.spacingInMeters - 10) / 90);
+                return this.BASE_MAX_VISIBILITY_RATIO * (0.5 + (factor * 0.5));
+            }
+            const largeGridFactor = Math.min(1, 100 / this.spacingInMeters);
+            return this.BASE_MAX_VISIBILITY_RATIO * 0.5 * largeGridFactor;
+        }
+        updateGrid() {
+            const cameraPosition = this.viewer.camera.position;
+            const cameraCartographic = Cesium.Cartographic.fromCartesian(cameraPosition);
+            const cameraHeight = cameraCartographic.height;
+            let adaptiveSpacing = this.calculateAdaptiveSpacing(cameraHeight, this.spacingInMeters);
+            // Calculate visible area.
+            const visibleArea = this.calculateVisibleArea();
+            if (!visibleArea) {
+                return;
+            }
+            let densityCheckPassed = false;
+            let attempts = 0;
+            while (!densityCheckPassed && attempts < this.MAX_ADAPTIVE_ATTEMPTS) {
+                if (this.isGridDensityAcceptable(visibleArea, cameraHeight, adaptiveSpacing)) {
+                    densityCheckPassed = true;
+                }
+                else {
+                    adaptiveSpacing *= 2;
+                    attempts++;
+                }
+            }
+            // The origin follows the UCS of what is shown, so the grid moves with it when that changes.
+            if (this.modelSpace && this.fixedGridOrigin && !BModels.Carto.IsEqual(this.fixedGridOrigin, this.modelSpaceOrigin())) {
+                this.fixedGridOrigin = null;
+                this.lastCameraPosition = null;
+                this.clearGizmoPieces();
+            }
+            // Calculate grid origin if we don't have one yet.
+            if (!this.fixedGridOrigin) {
+                if (this.modelSpace) {
+                    this.fixedGridOrigin = this.modelSpaceOrigin();
+                }
+                else {
+                    const centerCartographic = Cesium.Cartographic.fromCartesian(visibleArea.centerCartesian);
+                    const centerPoint = {
+                        latitude: Cesium.Math.toDegrees(centerCartographic.latitude),
+                        longitude: Cesium.Math.toDegrees(centerCartographic.longitude),
+                        altitude: 0
+                    };
+                    // Simple attempt at snapping to the grid, should do something smarter.
+                    this.fixedGridOrigin = {
+                        latitude: Math.round(centerPoint.latitude * 100000) / 100000,
+                        longitude: Math.round(centerPoint.longitude * 100000) / 100000,
+                        altitude: 0
+                    };
+                }
+            }
+            // Calculate appropriate grid extent based on camera height.
+            // For larger grid spacings, we use a tighter extent to prevent performance issues.
+            const scaledExtentFactor = Math.max(0.5, Math.min(3, 3 - Math.log10(Math.max(1, adaptiveSpacing)) * 0.5));
+            const visibilityRadius = Math.min(cameraHeight * scaledExtentFactor, Infinity);
+            // Check if we should redraw the grid.
+            const shouldRedraw = this.shouldRedrawGrid(cameraPosition, cameraHeight, visibilityRadius, adaptiveSpacing);
+            if (!shouldRedraw) {
+                return;
+            }
+            // Remember current settings for next comparison.
+            this.lastCameraHeight = cameraHeight;
+            this.lastCameraPosition = cameraPosition.clone();
+            this.lastGridExtent = visibilityRadius;
+            // Clear existing grid and create a new one.
+            this.clearGrid();
+            this.gridLines = new Cesium.PolylineCollection();
+            this.gridLabels = new Cesium.LabelCollection({
+                scene: this.viewer.scene
+            });
+            this.gridPrimitives.add(this.gridLines);
+            this.gridPrimitives.add(this.gridLabels);
+            // Generate grid lines and labels using our fixed origin.
+            this.generateGridLines(this.fixedGridOrigin, visibilityRadius, adaptiveSpacing);
+        }
+        shouldRedrawGrid(cameraPosition, cameraHeight, gridExtent, currentSpacing) {
+            // check if the spacing has changed
+            if (this.lastUsedSpacing && this.lastUsedSpacing !== currentSpacing) {
+                return true;
+            }
+            // Always draw if we don't have a grid yet.
+            if (!this.gridLines || !this.lastCameraPosition || !this.fixedGridOrigin) {
+                return true;
+            }
+            // Check for significant height change.
+            const heightRatio = cameraHeight / this.lastCameraHeight;
+            if (heightRatio > (1 + this.HEIGHT_CHANGE_THRESHOLD) ||
+                heightRatio < (1 - this.HEIGHT_CHANGE_THRESHOLD)) {
+                return true;
+            }
+            // Check for significant position change relative to current grid extent.
+            const distance = Cesium.Cartesian3.distance(cameraPosition, this.lastCameraPosition);
+            const moveThreshold = gridExtent * this.CAMERA_MOVE_THRESHOLD;
+            if (distance > moveThreshold) {
+                return true;
+            }
+            // Check for significant grid extent change.
+            const extentRatio = gridExtent / this.lastGridExtent;
+            if (extentRatio > (1 + this.GRID_EXTENT_CHANGE_THRESHOLD) ||
+                extentRatio < (1 - this.GRID_EXTENT_CHANGE_THRESHOLD)) {
+                return true;
+            }
+            // No significant changes, keep current grid.
+            return false;
+        }
+        isGridDensityAcceptable(visibleArea, cameraHeight, spacingToCheck = this.spacingInMeters) {
+            const lonRange = visibleArea.eastLon - visibleArea.westLon;
+            const latRange = visibleArea.northLat - visibleArea.southLat;
+            // Convert to approximate meters at center
+            const centerCartographic = Cesium.Cartographic.fromCartesian(visibleArea.centerCartesian);
+            const metersPerDegreeLon = 111319.9 * Math.cos(centerCartographic.latitude);
+            const canvas = this.viewer.scene.canvas;
+            const spacingInDegrees = spacingToCheck / metersPerDegreeLon;
+            const canvasWidth = canvas.clientWidth;
+            const pixelsPerDegree = canvasWidth / lonRange;
+            const pixelsBetweenGridLines = pixelsPerDegree * spacingInDegrees;
+            const minPixelSize = 1;
+            return pixelsBetweenGridLines >= minPixelSize;
+        }
+        calculateVisibleArea() {
+            const scene = this.viewer.scene;
+            const camera = scene.camera;
+            const globe = scene.globe;
+            // Get the corners of the view frustum
+            const canvas = scene.canvas;
+            const corners = [
+                new Cesium.Cartesian2(0, 0),
+                new Cesium.Cartesian2(canvas.clientWidth, 0),
+                new Cesium.Cartesian2(0, canvas.clientHeight),
+                new Cesium.Cartesian2(canvas.clientWidth, canvas.clientHeight),
+                new Cesium.Cartesian2(canvas.clientWidth / 2, canvas.clientHeight / 2) // Center
+            ];
+            // Project corners to the globe
+            const cartographicCorners = [];
+            for (const corner of corners) {
+                const ray = camera.getPickRay(corner);
+                if (!ray) {
+                    continue;
+                }
+                const position = globe.pick(ray, scene);
+                if (!position) {
+                    continue;
+                }
+                cartographicCorners.push(Cesium.Cartographic.fromCartesian(position));
+            }
+            if (cartographicCorners.length === 0) {
+                return null;
+            }
+            // Find the bounding rectangle
+            let westLon = Number.POSITIVE_INFINITY;
+            let eastLon = Number.NEGATIVE_INFINITY;
+            let southLat = Number.POSITIVE_INFINITY;
+            let northLat = Number.NEGATIVE_INFINITY;
+            for (const corner of cartographicCorners) {
+                westLon = Math.min(westLon, corner.longitude);
+                eastLon = Math.max(eastLon, corner.longitude);
+                southLat = Math.min(southLat, corner.latitude);
+                northLat = Math.max(northLat, corner.latitude);
+            }
+            // Add some padding around the visible area
+            const lonPadding = (eastLon - westLon) * this.VIEW_PADDING_FACTOR;
+            const latPadding = (northLat - southLat) * this.VIEW_PADDING_FACTOR;
+            westLon -= lonPadding;
+            eastLon += lonPadding;
+            southLat -= latPadding;
+            northLat += latPadding;
+            // Get center position for reference
+            const centerCartographic = new Cesium.Cartographic((westLon + eastLon) / 2, (southLat + northLat) / 2);
+            const centerCartesian = Cesium.Cartesian3.fromRadians(centerCartographic.longitude, centerCartographic.latitude, 0);
+            return {
+                westLon: Cesium.Math.toDegrees(westLon),
+                eastLon: Cesium.Math.toDegrees(eastLon),
+                southLat: Cesium.Math.toDegrees(southLat),
+                northLat: Cesium.Math.toDegrees(northLat),
+                centerCartesian: centerCartesian
+            };
+        }
+        generateGridLines(originPoint, visibilityRadius, actualSpacing = this.spacingInMeters) {
+            // Number of grid cells in each direction (add 1 for edge lines).
+            const gridCellCount = Math.ceil(visibilityRadius / actualSpacing) + 1;
+            const maxCells = Math.min(gridCellCount, Math.floor(this.MAX_LINES / 2));
+            // Calculate interval to skip lines for density control.
+            const spacingFactor = actualSpacing / 100;
+            const heightFactor = this.lastCameraHeight / 500;
+            let lineSkipInterval = Math.floor(spacingFactor * heightFactor);
+            lineSkipInterval = Math.min(Math.max(lineSkipInterval, 1), 10); // Clamp between 1 and 10
+            const intersections = [];
+            // Generate north-south grid lines (longitude lines)
+            for (let i = -maxCells; i <= maxCells; i++) {
+                if (i % lineSkipInterval !== 0) {
+                    continue;
+                }
+                const positions = [];
+                // Create a vertical line at this longitude offset.
+                // East heading for longitude.
+                const startPoint = this.cachedOffsetPoint(originPoint, i * actualSpacing, 90);
+                // Draw the line from south to north
+                for (let j = -maxCells; j <= maxCells; j++) {
+                    if (j % lineSkipInterval !== 0) {
+                        continue;
+                    }
+                    // North heading for latitude.
+                    const linePoint = this.cachedOffsetPoint(startPoint, j * actualSpacing, 0);
+                    const position = Cesium.Cartesian3.fromDegrees(linePoint.longitude, linePoint.latitude, linePoint.altitude);
+                    positions.push(position);
+                    intersections.push({
+                        position: position,
+                        i: i,
+                        j: j
+                    });
+                }
+                if (positions.length >= 2) {
+                    // Check if this is the primary Y axis (i=0) in model space
+                    const isPrimaryYAxis = this.modelSpace && i === 0;
+                    this.addGridLine(positions, isPrimaryYAxis ? "y" : null);
+                }
+            }
+            // Generate east-west grid lines (latitude lines).
+            for (let j = -maxCells; j <= maxCells; j++) {
+                if (j % lineSkipInterval !== 0) {
+                    continue;
+                }
+                const positions = [];
+                // Create a horizontal line at this latitude offset
+                // North heading for latitude.
+                const startPoint = this.cachedOffsetPoint(originPoint, j * actualSpacing, 0);
+                // Draw the line from west to east.
+                for (let i = -maxCells; i <= maxCells; i++) {
+                    if (i % lineSkipInterval !== 0) {
+                        continue;
+                    }
+                    // East heading for longitude.
+                    const linePoint = this.cachedOffsetPoint(startPoint, i * actualSpacing, 90);
+                    const position = Cesium.Cartesian3.fromDegrees(linePoint.longitude, linePoint.latitude, linePoint.altitude);
+                    positions.push(position);
+                }
+                if (positions.length >= 2) {
+                    // Check if this is the primary X axis (j=0) in model space
+                    const isPrimaryXAxis = this.modelSpace && j === 0;
+                    this.addGridLine(positions, isPrimaryXAxis ? "x" : null);
+                }
+            }
+            this.addGridLabels(intersections, actualSpacing);
+        }
+        addGridLabels(intersections, actualSpacing) {
+            if (!this.gridLabels) {
+                return;
+            }
+            // Determine label interval based on number of intersections.
+            // Use higher interval for more intersections to prevent crowding.
+            const totalIntersections = intersections.length;
+            let labelInterval = this.LABEL_INTERVAL;
+            if (totalIntersections > 1000) {
+                labelInterval = 5;
+            }
+            else if (totalIntersections > 500) {
+                labelInterval = 3;
+            }
+            let labelCount = 0;
+            // Filter intersections to only those at the labelInterval.
+            const labelPoints = intersections.filter(point => {
+                // Always label the origin (0,0).
+                if (point.i === 0 && point.j === 0) {
+                    return true;
+                }
+                return (point.i % labelInterval === 0 && point.j % labelInterval === 0);
+            });
+            // Sort points by distance from origin.
+            labelPoints.sort((a, b) => {
+                const distA = Math.abs(a.i) + Math.abs(a.j);
+                const distB = Math.abs(b.i) + Math.abs(b.j);
+                return distA - distB;
+            });
+            // Add labels, prioritizing those closest to the origin.
+            for (const point of labelPoints) {
+                if (labelCount >= this.MAX_LABELS) {
+                    // Limit reached.
+                    break;
+                }
+                let labelText;
+                // Model space coordinates (meters from origin).
+                if (this.modelSpace) {
+                    const xMeters = point.i * actualSpacing;
+                    const yMeters = point.j * actualSpacing;
+                    if (point.i === 0 && point.j === 0) {
+                        labelText = "0,0,0";
+                    }
+                    else {
+                        labelText = `${xMeters},${yMeters}`;
+                    }
+                }
+                // Geographic coordinates (degrees).
+                else {
+                    const cartographic = Cesium.Cartographic.fromCartesian(point.position);
+                    const latitude = Cesium.Math.toDegrees(cartographic.latitude);
+                    const longitude = Cesium.Math.toDegrees(cartographic.longitude);
+                    const latFormatted = latitude.toFixed(5);
+                    const lonFormatted = longitude.toFixed(5);
+                    labelText = `${latFormatted}, ${lonFormatted}`;
+                }
+                this.gridLabels.add({
+                    position: point.position,
+                    text: labelText,
+                    font: this.modelSpace && point.i === 0 && point.j === 0 ? "20px sans-serif" : "14px sans-serif",
+                    fillColor: this.modelSpace && point.i === 0 && point.j === 0 ? Cesium.Color.WHITE : Cesium.Color.WHITE.withAlpha(0.5),
+                    style: Cesium.LabelStyle.FILL,
+                    horizontalOrigin: Cesium.HorizontalOrigin.CENTER,
+                    verticalOrigin: Cesium.VerticalOrigin.TOP,
+                    pixelOffset: new Cesium.Cartesian2(0, 10),
+                    // Fade out with distance.
+                    translucencyByDistance: new Cesium.NearFarScalar(1000, 1.0, 15000, 0.4)
+                });
+                labelCount++;
+            }
+        }
+        addGridLine(positions, primaryAxis = null) {
+            if (!this.gridLines || positions.length < 2) {
+                return;
+            }
+            let lineColor;
+            let lineWidth = 1.0;
+            let lineAlpha = 0.2;
+            // Red for X axis.
+            if (primaryAxis === "x") {
+                lineColor = Cesium.Color.RED;
+                lineAlpha = 0.5;
+                lineWidth = 1.5;
+            }
+            // Green for Y axis.
+            else if (primaryAxis === "y") {
+                lineColor = Cesium.Color.GREEN;
+                lineAlpha = 0.5;
+                lineWidth = 1.5;
+            }
+            // Default gray for regular grid lines.
+            else {
+                lineColor = Cesium.Color.LIGHTGRAY;
+            }
+            this.gridLines.add({
+                positions: positions,
+                width: lineWidth,
+                material: Cesium.Material.fromType("Color", {
+                    color: lineColor.withAlpha(lineAlpha)
+                })
+            });
+        }
+    }
+    // Grid square size used when settings name none, in metres.
+    const DEFAULT_SPACING = 50;
+    (function (CesiumMapGrid) {
+        function GetCurrentSpacing(viewer) {
+            if (!viewer || viewer.isDestroyed()) {
+                return 0;
+            }
+            const handler = viewer[CLASS_INSTANCE_KEY];
+            return handler ? handler.getCurrentSpacing() : 0;
+        }
+        CesiumMapGrid.GetCurrentSpacing = GetCurrentSpacing;
+        function Remove(viewer) {
+            if (!viewer || viewer.isDestroyed()) {
+                return;
+            }
+            else if (!viewer[LAST_SETTINGS_KEY]) {
+                return;
+            }
+            if (!viewer[UPDATE_MARKER_KEY]) {
+                viewer[UPDATE_MARKER_KEY] = 1;
+            }
+            else {
+                viewer[UPDATE_MARKER_KEY]++;
+            }
+            // Dispose of the handler.
+            if (viewer[CLASS_INSTANCE_KEY]) {
+                viewer[CLASS_INSTANCE_KEY].Dispose();
+                viewer[CLASS_INSTANCE_KEY] = null;
+            }
+            viewer[LAST_SETTINGS_KEY] = {
+                ...viewer[LAST_SETTINGS_KEY],
+                enabled: false
+            };
+        }
+        CesiumMapGrid.Remove = Remove;
+        function Draw(viewer, spacingInMeters, modelSpace = true) {
+            if (!viewer || viewer.isDestroyed()) {
+                return;
+            }
+            let settings = viewer[LAST_SETTINGS_KEY];
+            if (settings) {
+                // See if the settings are the same as the last time.
+                if (settings.spacing === spacingInMeters &&
+                    settings.modelSpace === modelSpace &&
+                    settings.enabled) {
+                    return;
+                }
+            }
+            if (!viewer[UPDATE_MARKER_KEY]) {
+                viewer[UPDATE_MARKER_KEY] = 1;
+            }
+            else {
+                viewer[UPDATE_MARKER_KEY]++;
+            }
+            settings = {
+                ...settings,
+                enabled: true,
+                spacing: spacingInMeters,
+                modelSpace: modelSpace
+            };
+            viewer[LAST_SETTINGS_KEY] = settings;
+            // Create or update the handler.
+            if (viewer[CLASS_INSTANCE_KEY]) {
+                viewer[CLASS_INSTANCE_KEY].Update(spacingInMeters, modelSpace);
+            }
+            else {
+                viewer[CLASS_INSTANCE_KEY] = new MapGridHandler(viewer, spacingInMeters, modelSpace);
+            }
+        }
+        CesiumMapGrid.Draw = Draw;
+        /**
+         * Draws a bookmark's grid, or removes the grid when it has none; only model-space draws one.
+         */
+        function Apply(viewer, grid, modelSpace) {
+            if ((grid === null || grid === void 0 ? void 0 : grid.enabled) && modelSpace) {
+                Draw(viewer, Number(grid.spacing) || DEFAULT_SPACING, modelSpace);
+            }
+            else {
+                Remove(viewer);
+            }
+        }
+        CesiumMapGrid.Apply = Apply;
+        function GetIsEnabled(viewer) {
+            if (!viewer || viewer.isDestroyed()) {
+                return false;
+            }
+            const settings = viewer[LAST_SETTINGS_KEY];
+            if (settings) {
+                return Boolean(settings.enabled);
+            }
+            return false;
+        }
+        CesiumMapGrid.GetIsEnabled = GetIsEnabled;
+        /**
+         * Returns the last applied grid settings.
+         */
+        function GetSettings(viewer) {
+            if (!viewer || viewer.isDestroyed()) {
+                return null;
+            }
+            return viewer[LAST_SETTINGS_KEY];
+        }
+        CesiumMapGrid.GetSettings = GetSettings;
+    })(exports.CesiumMapGrid || (exports.CesiumMapGrid = {}));
+
     // TODO: Move these to the data model.
     const MIN_SHADOW_SIZE = 2048;
     const MAX_SHADOW_SIZE = 32768;
@@ -38903,7 +41096,7 @@
      * @param view
      */
     async function renderNavigator(iteration, params, bookmark, view, getters) {
-        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z, _0, _1, _2, _3, _4, _5, _6, _7, _8;
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9;
         const viewer = params.manager.Viewer;
         const scene = viewer.scene;
         // Ion requests go through the server-side proxy (set up during viewer init or here as fallback).
@@ -39128,15 +41321,7 @@
             scene.globe.translucency.frontFaceAlphaByDistance.farValue = 1;
         }
         scene.globe.translucency.frontFaceAlphaByDistance.nearValue = EnsureNumber(globeAlpha, 1);
-        let shadows = bSettings === null || bSettings === void 0 ? void 0 : bSettings.shadows;
-        if (shadows == null) {
-            shadows = (_u = defaults === null || defaults === void 0 ? void 0 : defaults.settings) === null || _u === void 0 ? void 0 : _u.shadows;
-        }
-        if (shadows == null) {
-            shadows = {
-                enabled: false
-            };
-        }
+        const shadows = exports.ViewRenderEngine.ResolveShadows(bSettings, defaults === null || defaults === void 0 ? void 0 : defaults.settings, contentType);
         viewer.shadows = Boolean(shadows.enabled);
         viewer.shadowMap.enabled = Boolean(shadows.enabled);
         let size = EnsureNumber(shadows.pixelSize);
@@ -39149,9 +41334,11 @@
         viewer.shadowMap.size = size;
         viewer.shadowMap.softShadows = Boolean(shadows.soften);
         viewer.shadowMap.darkness = EnsureNumber(shadows.darkness, 0.3);
+        // Drawn after the model-space origin is resolved above, since the grid starts from it.
+        exports.CesiumMapGrid.Apply(viewer, (_u = bSettings.grid) !== null && _u !== void 0 ? _u : (_v = defaults === null || defaults === void 0 ? void 0 : defaults.settings) === null || _v === void 0 ? void 0 : _v.grid, contentType == BModels.ProjectViewBookmark.EContentType.WEB_3D_MODEL_SPACE);
         let ambientOcclusion = bSettings === null || bSettings === void 0 ? void 0 : bSettings.ambientOcclusion;
         if (ambientOcclusion == null) {
-            ambientOcclusion = (_v = defaults === null || defaults === void 0 ? void 0 : defaults.settings) === null || _v === void 0 ? void 0 : _v.ambientOcclusion;
+            ambientOcclusion = (_w = defaults === null || defaults === void 0 ? void 0 : defaults.settings) === null || _w === void 0 ? void 0 : _w.ambientOcclusion;
         }
         if (ambientOcclusion == null) {
             ambientOcclusion = {
@@ -39174,7 +41361,7 @@
         }
         let lighting = bSettings === null || bSettings === void 0 ? void 0 : bSettings.lighting;
         if (lighting == null) {
-            lighting = (_w = defaults === null || defaults === void 0 ? void 0 : defaults.settings) === null || _w === void 0 ? void 0 : _w.lighting;
+            lighting = (_x = defaults === null || defaults === void 0 ? void 0 : defaults.settings) === null || _x === void 0 ? void 0 : _x.lighting;
         }
         if (lighting == null) {
             lighting = {
@@ -39192,7 +41379,7 @@
         exports.ViewUtils.ApplyDefaultBrightness(viewer, EnsureNumber(lighting.brightnessShift, DEFAULT_BRIGHTNESS_SHIFT));
         let quality = bSettings === null || bSettings === void 0 ? void 0 : bSettings.quality;
         if (quality == null) {
-            quality = (_x = defaults === null || defaults === void 0 ? void 0 : defaults.settings) === null || _x === void 0 ? void 0 : _x.quality;
+            quality = (_y = defaults === null || defaults === void 0 ? void 0 : defaults.settings) === null || _y === void 0 ? void 0 : _y.quality;
         }
         if (quality == null) {
             quality = {
@@ -39203,11 +41390,11 @@
         fxaa.enabled = Boolean(quality.fxaa);
         let dateTime = bSettings === null || bSettings === void 0 ? void 0 : bSettings.dateTime;
         if (dateTime == null) {
-            dateTime = (_y = defaults === null || defaults === void 0 ? void 0 : defaults.settings) === null || _y === void 0 ? void 0 : _y.dateTime;
+            dateTime = (_z = defaults === null || defaults === void 0 ? void 0 : defaults.settings) === null || _z === void 0 ? void 0 : _z.dateTime;
         }
         let timeline = bSettings === null || bSettings === void 0 ? void 0 : bSettings.timeline;
         if (timeline == null) {
-            timeline = (_z = defaults === null || defaults === void 0 ? void 0 : defaults.settings) === null || _z === void 0 ? void 0 : _z.timeline;
+            timeline = (_0 = defaults === null || defaults === void 0 ? void 0 : defaults.settings) === null || _0 === void 0 ? void 0 : _0.timeline;
         }
         if (timeline == null) {
             timeline = {
@@ -39231,7 +41418,7 @@
         // Newer version that has states per Entity ID + Menu Item ID.
         let states = bSettings === null || bSettings === void 0 ? void 0 : bSettings.states;
         if (states == null) {
-            states = (_0 = defaults === null || defaults === void 0 ? void 0 : defaults.settings) === null || _0 === void 0 ? void 0 : _0.states;
+            states = (_1 = defaults === null || defaults === void 0 ? void 0 : defaults.settings) === null || _1 === void 0 ? void 0 : _1.states;
         }
         if (states != null) {
             params.manager.VisualsRegister.OverrideStates(states);
@@ -39240,7 +41427,7 @@
         else {
             let selectedIds = bSettings === null || bSettings === void 0 ? void 0 : bSettings.selectedEntityIds;
             if (selectedIds == null) {
-                selectedIds = (_1 = defaults === null || defaults === void 0 ? void 0 : defaults.settings) === null || _1 === void 0 ? void 0 : _1.selectedEntityIds;
+                selectedIds = (_2 = defaults === null || defaults === void 0 ? void 0 : defaults.settings) === null || _2 === void 0 ? void 0 : _2.selectedEntityIds;
             }
             if (selectedIds != null) {
                 params.manager.VisualsRegister.ClearSelected();
@@ -39254,7 +41441,7 @@
             params.manager.VisualsRegister.ClearHidden();
             let hiddenIds = bSettings === null || bSettings === void 0 ? void 0 : bSettings.hiddenEntityIds;
             if (hiddenIds == null) {
-                hiddenIds = (_2 = defaults === null || defaults === void 0 ? void 0 : defaults.settings) === null || _2 === void 0 ? void 0 : _2.hiddenEntityIds;
+                hiddenIds = (_3 = defaults === null || defaults === void 0 ? void 0 : defaults.settings) === null || _3 === void 0 ? void 0 : _3.hiddenEntityIds;
             }
             if (hiddenIds != null) {
                 params.manager.VisualsRegister.SetHidden({
@@ -39266,7 +41453,7 @@
             params.manager.VisualsRegister.ClearIsolated();
             let isolatedIds = bSettings === null || bSettings === void 0 ? void 0 : bSettings.isolatedEntityIds;
             if (isolatedIds == null) {
-                isolatedIds = (_3 = defaults === null || defaults === void 0 ? void 0 : defaults.settings) === null || _3 === void 0 ? void 0 : _3.isolatedEntityIds;
+                isolatedIds = (_4 = defaults === null || defaults === void 0 ? void 0 : defaults.settings) === null || _4 === void 0 ? void 0 : _4.isolatedEntityIds;
             }
             if (isolatedIds != null) {
                 params.manager.VisualsRegister.SetIsolated({
@@ -39277,7 +41464,7 @@
             }
             let labelledIds = bSettings === null || bSettings === void 0 ? void 0 : bSettings.labelledEntityIds;
             if (labelledIds == null) {
-                labelledIds = (_4 = defaults === null || defaults === void 0 ? void 0 : defaults.settings) === null || _4 === void 0 ? void 0 : _4.labelledEntityIds;
+                labelledIds = (_5 = defaults === null || defaults === void 0 ? void 0 : defaults.settings) === null || _5 === void 0 ? void 0 : _5.labelledEntityIds;
             }
             if (!(labelledIds === null || labelledIds === void 0 ? void 0 : labelledIds.length)) {
                 params.manager.VisualsRegister.ClearLabelled({
@@ -39301,7 +41488,7 @@
             params.manager.VisualsRegister.ClearOpacity();
             let entityOpacityMap = bSettings === null || bSettings === void 0 ? void 0 : bSettings.entityOpacityMap;
             if (entityOpacityMap == null) {
-                entityOpacityMap = (_5 = defaults === null || defaults === void 0 ? void 0 : defaults.settings) === null || _5 === void 0 ? void 0 : _5.entityOpacityMap;
+                entityOpacityMap = (_6 = defaults === null || defaults === void 0 ? void 0 : defaults.settings) === null || _6 === void 0 ? void 0 : _6.entityOpacityMap;
             }
             if (entityOpacityMap != null) {
                 for (const entityId in entityOpacityMap) {
@@ -39316,7 +41503,7 @@
                 }
             }
         }
-        let imagery = (bSettings === null || bSettings === void 0 ? void 0 : bSettings.imagery) != null ? bSettings.imagery : (_6 = defaults.settings) === null || _6 === void 0 ? void 0 : _6.imagery;
+        let imagery = (bSettings === null || bSettings === void 0 ? void 0 : bSettings.imagery) != null ? bSettings.imagery : (_7 = defaults.settings) === null || _7 === void 0 ? void 0 : _7.imagery;
         if (imagery == null) {
             // TODO: Need global default.
             imagery = [
@@ -39386,7 +41573,7 @@
         // Otherwise we cause a flicker of rendered graphics.
         // Maybe TODO to such a function for menu item manager.
         const curEnabled = params.manager.GetEnabledItemIds();
-        const newItemIds = (_7 = bSettings === null || bSettings === void 0 ? void 0 : bSettings.menuItemIds) !== null && _7 !== void 0 ? _7 : [];
+        const newItemIds = (_8 = bSettings === null || bSettings === void 0 ? void 0 : bSettings.menuItemIds) !== null && _8 !== void 0 ? _8 : [];
         for (const id of curEnabled) {
             let shouldRemove;
             if (id == RELATION_MENU_ITEM_ID) {
@@ -39460,7 +41647,7 @@
         }
         let gOcclusion = bSettings === null || bSettings === void 0 ? void 0 : bSettings.groundOcclusion;
         if (gOcclusion == null) {
-            gOcclusion = (_8 = defaults === null || defaults === void 0 ? void 0 : defaults.settings) === null || _8 === void 0 ? void 0 : _8.groundOcclusion;
+            gOcclusion = (_9 = defaults === null || defaults === void 0 ? void 0 : defaults.settings) === null || _9 === void 0 ? void 0 : _9.groundOcclusion;
         }
         if (gOcclusion == null) {
             // TODO: Need global default.
@@ -39477,6 +41664,17 @@
             BModels.ProjectViewBookmark.EContentType.WEB_3D_MODEL_SPACE,
             BModels.ProjectViewBookmark.EContentType.WEB_3D_SPLIT_PLUGIN
         ];
+        /**
+         * A bookmark's own shadows, else the view's defaults unless it is model-space, which reads brighter without.
+         */
+        function ResolveShadows(bSettings, defaults, contentType) {
+            let shadows = bSettings === null || bSettings === void 0 ? void 0 : bSettings.shadows;
+            if (shadows == null && contentType != BModels.ProjectViewBookmark.EContentType.WEB_3D_MODEL_SPACE) {
+                shadows = defaults === null || defaults === void 0 ? void 0 : defaults.shadows;
+            }
+            return shadows !== null && shadows !== void 0 ? shadows : { enabled: false };
+        }
+        ViewRenderEngine.ResolveShadows = ResolveShadows;
         /**
          * Returns where a model-space bookmark's camera goes, measured from the origin in effect.
          * @param viewer
@@ -44201,7 +46399,7 @@
     const HOLD_LOADER_DELAY_MS = 150;
     const CONTINUOUS_ANIMATION_SPEED = 0.02 / 3;
     const ZOOM_DISTANCE = 0.85;
-    const MIN_ZOOM_DISTANCE = 0.3;
+    const MIN_ZOOM_DISTANCE$1 = 0.3;
     const NEAR_NADIR_PITCH = -Math.PI / 2 + 0.05;
     const MIN_ORBIT_OFFSET_METERS = 5;
     // Caps how far a pivot may be from the camera relative to the camera's own altitude.
@@ -44407,7 +46605,7 @@
         const mag = (ZOOM_DISTANCE * 0.5) / Math.max(1, 4 - Math.log10(height));
         const zoom = zoomIn ? 1 - mag : 1 + mag;
         const offset = Cesium.Cartesian3.multiplyByScalar(Cesium.Cartesian3.subtract(p, ground, new Cesium.Cartesian3()), zoom, new Cesium.Cartesian3());
-        if (zoomIn && Cesium.Cartesian3.magnitude(offset) <= MIN_ZOOM_DISTANCE) {
+        if (zoomIn && Cesium.Cartesian3.magnitude(offset) <= MIN_ZOOM_DISTANCE$1) {
             return Promise.resolve(null);
         }
         const to = Cesium.Cartesian3.add(ground, offset, new Cesium.Cartesian3());
@@ -44631,7 +46829,7 @@
             const mag = (ZOOM_DISTANCE * 0.5) / Math.max(1, 4 - Math.log10(height));
             const zoom = zoomIn ? 1 - mag * 0.03 : 1 + mag * 0.03;
             const offset = Cesium.Cartesian3.multiplyByScalar(Cesium.Cartesian3.subtract(p, ground, new Cesium.Cartesian3()), zoom, new Cesium.Cartesian3());
-            if (zoomIn && Cesium.Cartesian3.magnitude(offset) <= MIN_ZOOM_DISTANCE) {
+            if (zoomIn && Cesium.Cartesian3.magnitude(offset) <= MIN_ZOOM_DISTANCE$1) {
                 active = false;
                 return;
             }
@@ -45440,7 +47638,7 @@
          * @param viewer
          */
         function InitViewer(params) {
-            const { viewer, destroyWidgets, styleContainer, nextspaceWidgets, widgetParams } = params;
+            const { viewer, destroyWidgets, styleContainer, nextspaceWidgets, widgetParams, cameraControls } = params;
             const data = { widgets: {} };
             if (destroyWidgets != false) {
                 try {
@@ -45467,6 +47665,12 @@
             // Newer cesium is much dimmer by default so we shift brightness a bit.
             exports.ViewUtils.ApplyDefaultBrightness(viewer);
             backgroundRendering(viewer);
+            if (cameraControls != false) {
+                exports.CameraControls.Attach(viewer);
+                if (exports.ViewUtils.GetModelSpace(viewer)) {
+                    exports.CameraControls.SetModelSpace(viewer, () => exports.ViewUtils.GetModelSpaceFrame(viewer));
+                }
+            }
             // Capturing the destroy call to destroy all widgets.
             const olDestroy = viewer.destroy;
             viewer.destroy = () => {
@@ -45475,6 +47679,7 @@
                 }
                 try {
                     ViewerUtils.DisposeNextspaceWidgets(viewer);
+                    exports.CameraControls.Detach(viewer);
                 }
                 // We don't want the actual destroy to fail.
                 catch (e) {
@@ -49609,7 +51814,7 @@
                         ...exports.ViewUtils.DefaultLightingProps(),
                         heightReference: heightRef,
                         scale: new Cesium.CallbackProperty(() => scale * styleScale, true),
-                        shadows: Cesium.ShadowMode.ENABLED,
+                        shadows: exports.ViewUtils.GetEntityShadowMode(params.viewer),
                         colorBlendAmount: blendAmount,
                         colorBlendMode: blendMode,
                         color: new Cesium.CallbackProperty(() => {
@@ -49644,7 +51849,7 @@
                     cEntity.model.uri = new Cesium.ConstantProperty(params.lodUrl);
                 }
                 cEntity.model.heightReference = new Cesium.ConstantProperty(heightRef);
-                cEntity.model.shadows = new Cesium.ConstantProperty(Cesium.ShadowMode.ENABLED);
+                cEntity.model.shadows = new Cesium.ConstantProperty(exports.ViewUtils.GetEntityShadowMode(params.viewer));
                 cEntity.model.colorBlendAmount = new Cesium.ConstantProperty(blendAmount);
                 cEntity.model.colorBlendMode = new Cesium.ConstantProperty(blendMode);
                 cEntity.model.distanceDisplayCondition = new Cesium.ConstantProperty(exports.EntityRenderEngine.GetDisplayCondition(params.minDistance, params.maxDistance));
@@ -50482,7 +52687,7 @@
                         zIndex: getZIndex(style, entity, params.tags),
                         distanceDisplayCondition: exports.EntityRenderEngine.GetDisplayCondition(params.minDistance, params.maxDistance, width),
                         cornerType: Cesium.CornerType.MITERED,
-                        shadows: Cesium.ShadowMode.ENABLED,
+                        shadows: exports.ViewUtils.GetEntityShadowMode(params.viewer),
                         fill: true
                     } : null,
                     position: exports.EntityUtils.GetPos({
@@ -54870,6 +57075,12 @@ void main() {
                     ? BModels.Geometry.ParsePoints(ring.LinearRing).map((point) => point.altitude)
                     : [])
             });
+            const drapesOnGround = (heightRef === Cesium.HeightReference.CLAMP_TO_GROUND &&
+                extrusion.value == undefined &&
+                !drawsDisplacedSurface);
+            if (drapesOnGround) {
+                posses = groundPosses(posses);
+            }
             posses = CullDuplicateCPosses(posses);
             if (posses.length < 4) {
                 return null;
@@ -54878,6 +57089,9 @@ void main() {
             const holePosses = holeRings.map((x) => {
                 const points = BModels.Geometry.ParsePoints(x.LinearRing);
                 let holePosses = points.map(x => Cesium.Cartesian3.fromDegrees(EnsureNumber(x.longitude), EnsureNumber(x.latitude), EnsureNumber(x.altitude)));
+                if (drapesOnGround) {
+                    holePosses = groundPosses(holePosses);
+                }
                 holePosses = CullDuplicateCPosses(holePosses);
                 BModels.Cartes.CloseRing3(holePosses);
                 return holePosses;
@@ -54928,7 +57142,7 @@ void main() {
                         fill: !drawsDisplacedSurface,
                         extrudedHeight: extrusion.value,
                         extrudedHeightReference: extrusion.exHeightRef,
-                        shadows: Cesium.ShadowMode.ENABLED,
+                        shadows: exports.ViewUtils.GetEntityShadowMode(params.viewer),
                         heightReference: heightRef,
                         classificationType: classification,
                         perPositionHeight: heightRef == Cesium.HeightReference.CLAMP_TO_GROUND ? false : true,
@@ -55008,7 +57222,7 @@ void main() {
                     viewer: params.viewer,
                     graphic: cEntity.polygon,
                     property: "shadows",
-                    value: Cesium.ShadowMode.ENABLED
+                    value: exports.ViewUtils.GetEntityShadowMode(params.viewer)
                 });
                 SetCPropIfChanged({
                     viewer: params.viewer,
@@ -55143,7 +57357,7 @@ void main() {
                             cornerType: Cesium.CornerType.MITERED,
                             classificationType: classification,
                             distanceDisplayCondition: exports.EntityRenderEngine.GetDisplayCondition(params.minDistance, params.maxDistance, width, false, size),
-                            shadows: Cesium.ShadowMode.ENABLED
+                            shadows: exports.ViewUtils.GetEntityShadowMode(params.viewer)
                         } : null,
                         show: true
                     });
@@ -55266,7 +57480,7 @@ void main() {
                             cornerType: Cesium.CornerType.MITERED,
                             classificationType: classification,
                             distanceDisplayCondition: exports.EntityRenderEngine.GetDisplayCondition(params.minDistance, params.maxDistance, width, false, size),
-                            shadows: Cesium.ShadowMode.ENABLED,
+                            shadows: exports.ViewUtils.GetEntityShadowMode(params.viewer),
                         } : null,
                         show: true
                     });
@@ -55664,6 +57878,18 @@ void main() {
     /*
      * The lon/lat bounding rectangle of a ring, which is the frame Cesium drapes an image material in.
      */
+    /*
+     * Moves a ring onto the ellipsoid, as Cesium fills only a strip of a ground polygon with high vertices.
+     */
+    function groundPosses(posses) {
+        return posses.map((pos) => {
+            const carto = Cesium.Cartographic.fromCartesian(pos);
+            if (!carto) {
+                return pos;
+            }
+            return Cesium.Cartesian3.fromRadians(carto.longitude, carto.latitude, 0);
+        });
+    }
     function polygonBbox(posses) {
         if (!posses || posses.length === 0) {
             return undefined;
@@ -57575,7 +59801,7 @@ void main() {
         StyleUtils.ApplyTypeStyle = ApplyTypeStyle;
     })(exports.StyleUtils || (exports.StyleUtils = {}));
 
-    const VERSION = "7.7.6";
+    const VERSION = "7.7.8";
     /**
      * 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.