bruce-cesium 6.1.3 → 6.1.5

package/dist/bruce-cesium.umd.js

@@ -32679,6 +32679,210 @@
         ViewerUtils.GetEventTracker = GetEventTracker;
     })(exports.ViewerUtils || (exports.ViewerUtils = {}));
 
+    const labels = {};
+    const updaters = {};
+    const positions = {};
+    const colors = {};
+    const names = {};
+    const entities = {};
+    const viewers = {};
+    function createDOMLabel(viewer, id, name, colorCss) {
+        var _a;
+        const label = document.createElement("div");
+        label.innerHTML = `<div style="margin-bottom:0px">${name !== null && name !== void 0 ? name : ""}</div>`;
+        label.setAttribute("style", `
+        position: absolute;
+        z-index: 2; /* keep under app panels */
+        display: none;
+        pointer-events: none;
+        padding: 6px 10px;
+        border-radius: 8px;
+        font-family: Arial, sans-serif;
+        font-size: 13px;
+        font-weight: 500;
+        color: #ffffff;
+        background-color: ${colorCss !== null && colorCss !== void 0 ? colorCss : "#3b82f6"};
+        border: 1px solid rgba(255,255,255,0.2);
+        box-shadow: 0 2px 8px rgba(0,0,0,0.25);
+        text-shadow: 0 1px 2px rgba(0,0,0,0.5);
+        white-space: nowrap;
+        transform: none;
+    `);
+        ((_a = viewer === null || viewer === void 0 ? void 0 : viewer.container) !== null && _a !== void 0 ? _a : document.body).appendChild(label);
+        labels[id] = label;
+        colors[id] = colorCss;
+        names[id] = name;
+        return label;
+    }
+    function updateDOMLabel(viewer, label, pos3d) {
+        if (!viewer || viewer.isDestroyed() || !label || !pos3d) {
+            return;
+        }
+        const CESIUM = Cesium;
+        const toWindow = Cesium.SceneTransforms.hasOwnProperty("wgs84ToWindowCoordinates")
+            ? CESIUM.SceneTransforms.wgs84ToWindowCoordinates
+            : CESIUM.SceneTransforms.worldToWindowCoordinates;
+        const screenPos = toWindow(viewer.scene, pos3d);
+        if (!screenPos || isNaN(screenPos.x) || isNaN(screenPos.y)) {
+            label.style.display = "none";
+            return;
+        }
+        const cameraPos = viewer.camera.position;
+        const distance = Cesium.Cartesian3.distance(cameraPos, pos3d);
+        const maxDistance = 25000; // Max visibility distance for labels
+        const canvas = viewer.canvas;
+        const withinBounds = screenPos.x >= 0 && screenPos.x <= canvas.clientWidth &&
+            screenPos.y >= 0 && screenPos.y <= canvas.clientHeight;
+        if (!withinBounds || distance >= maxDistance) {
+            label.style.display = "none";
+            return;
+        }
+        // Keep full opacity; no distance-based fading
+        // Keep the label close to the cursor regardless of zoom
+        // Use small, constant pixel offsets to bottom-right
+        const offsetX = 12; // px
+        const offsetY = 10; // px
+        let leftPx = screenPos.x + offsetX;
+        let topPx = screenPos.y + offsetY;
+        const pad = 8;
+        const w = label.offsetWidth || 120;
+        const h = label.offsetHeight || 28;
+        leftPx = Math.min(Math.max(pad, leftPx), canvas.clientWidth - w - pad);
+        topPx = Math.min(Math.max(pad, topPx), canvas.clientHeight - h - pad);
+        label.style.left = `${leftPx}px`;
+        label.style.top = `${topPx}px`;
+        label.style.display = "block";
+        label.style.opacity = "1";
+    }
+    (function (LiveCursor) {
+        function Upsert({ viewer, id, name, colorCss, pos3d, entityId, image, showBillboard = true, showEllipse = true, billboardWidth = 30, billboardHeight = 30, labelZIndex }) {
+            if (!labels[id]) {
+                createDOMLabel(viewer, id, name !== null && name !== void 0 ? name : "", colorCss !== null && colorCss !== void 0 ? colorCss : "#3b82f6");
+            }
+            else {
+                // Update text/color only if changed
+                if (typeof name === "string" && name !== names[id]) {
+                    names[id] = name;
+                    labels[id].innerHTML = `<div style="margin-bottom:0px">${name}</div>`;
+                }
+                if (typeof colorCss === "string" && colorCss !== colors[id]) {
+                    colors[id] = colorCss;
+                    labels[id].style.backgroundColor = colorCss;
+                }
+            }
+            if (typeof labelZIndex === "number") {
+                labels[id].style.zIndex = `${labelZIndex}`;
+            }
+            positions[id] = pos3d;
+            viewers[id] = viewer;
+            // Manage Cesium entity
+            if ((showBillboard || showEllipse) && !entities[id]) {
+                const eid = entityId !== null && entityId !== void 0 ? entityId : `live-cursor-${id}`;
+                const color = colorCss ? Cesium.Color.fromCssColorString(colorCss) : Cesium.Color.WHITE;
+                const entity = viewer.entities.add({
+                    id: eid,
+                    position: pos3d,
+                    billboard: showBillboard && image ? {
+                        image,
+                        width: billboardWidth,
+                        height: billboardHeight,
+                        heightReference: Cesium.HeightReference.NONE,
+                        disableDepthTestDistance: Number.POSITIVE_INFINITY,
+                        distanceDisplayCondition: new Cesium.DistanceDisplayCondition(0, 30000),
+                        scaleByDistance: new Cesium.NearFarScalar(100, 1.5, 10000, 0.8),
+                        verticalOrigin: Cesium.VerticalOrigin.BOTTOM,
+                        horizontalOrigin: Cesium.HorizontalOrigin.CENTER
+                    } : undefined,
+                    ellipse: showEllipse ? {
+                        semiMajorAxis: 50.0,
+                        semiMinorAxis: 50.0,
+                        height: 0,
+                        outline: true,
+                        outlineColor: color.withAlpha(0.8),
+                        outlineWidth: 3,
+                        fill: true,
+                        material: color.withAlpha(0.2),
+                        heightReference: Cesium.HeightReference.CLAMP_TO_GROUND,
+                        distanceDisplayCondition: new Cesium.DistanceDisplayCondition(0, 15000)
+                    } : undefined
+                });
+                if (entity.ellipse) {
+                    entity.ellipse.semiMajorAxis = new Cesium.CallbackProperty(() => {
+                        const time = viewer.clock.currentTime;
+                        const pulse = Math.sin(Cesium.JulianDate.secondsDifference(time, viewer.clock.startTime) * 2) * 0.5 + 1;
+                        return 50 + (pulse * 20);
+                    }, false);
+                    entity.ellipse.semiMinorAxis = new Cesium.CallbackProperty(() => {
+                        const time = viewer.clock.currentTime;
+                        const pulse = Math.sin(Cesium.JulianDate.secondsDifference(time, viewer.clock.startTime) * 2) * 0.5 + 1;
+                        return 50 + (pulse * 20);
+                    }, false);
+                }
+                entities[id] = entity;
+            }
+            else if ((showBillboard || showEllipse) && entities[id]) {
+                const entity = entities[id];
+                const animated = new exports.CesiumAnimatedProperty.AnimatePosition({
+                    durationMs: 50,
+                    targetPos3d: pos3d,
+                    startPos3d: entity.position,
+                    viewer: viewer
+                });
+                entity.position = new Cesium.CallbackProperty(() => animated.GetValue(), false);
+            }
+            if (!updaters[id]) {
+                const remover = viewer.scene.postUpdate.addEventListener(() => {
+                    const label = labels[id];
+                    let p = positions[id];
+                    // If we manage an entity with an animated position, follow its current value
+                    const ent = entities[id];
+                    if (ent === null || ent === void 0 ? void 0 : ent.position) {
+                        const posProp = ent.position;
+                        const date = viewer.scene.lastRenderTime || viewer.clock.currentTime;
+                        const val = (posProp === null || posProp === void 0 ? void 0 : posProp.getValue) ? posProp.getValue(date) : posProp;
+                        if (val && !isNaN(val.x)) {
+                            p = val;
+                        }
+                    }
+                    if (!label || !p) {
+                        return;
+                    }
+                    updateDOMLabel(viewer, label, p);
+                });
+                updaters[id] = remover;
+            }
+            // Perform an immediate update for the current frame
+            updateDOMLabel(viewer, labels[id], pos3d);
+        }
+        LiveCursor.Upsert = Upsert;
+        function Remove(id) {
+            const label = labels[id];
+            if (label && label.parentElement) {
+                label.parentElement.removeChild(label);
+            }
+            delete labels[id];
+            delete positions[id];
+            delete names[id];
+            delete colors[id];
+            if (updaters[id]) {
+                try {
+                    updaters[id]();
+                }
+                catch { }
+                delete updaters[id];
+            }
+            // Remove entity if present
+            const entity = entities[id];
+            const viewer = viewers[id];
+            if (entity && viewer && viewer.entities.contains(entity)) {
+                viewer.entities.remove(entity);
+            }
+            delete entities[id];
+            delete viewers[id];
+        }
+        LiveCursor.Remove = Remove;
+    })(exports.LiveCursor || (exports.LiveCursor = {}));
+
     (function (WidgetControlViewBar) {
         class AControl {
             get WidgetViewBar() {
@@ -33450,7 +33654,7 @@
         }
     }
 
-    const VERSION = "6.1.3";
+    const VERSION = "6.1.5";
 
     exports.VERSION = VERSION;
     exports.isOutlineChanged = isOutlineChanged;