bruce-cesium 7.6.4 → 7.6.5

package/dist/bruce-cesium.umd.js

@@ -7668,6 +7668,8 @@
                 this.modelBox = null;
                 this.boxMorph = { value: 0, from: 0, target: 0, start: 0, anchor: undefined, group: undefined,
                     shift: { x: 0, y: 0, start: 0 } };
+                // A CAD part's record and its tileset, so the label stays on the part wherever the tileset is drawn now.
+                this.tilesetPart = null;
                 // Counter to help differentiate between createLabel calls.
                 this.counter = 0;
                 // Whether this label has asked its group for a default image, which it does once on screen.
@@ -7977,6 +7979,9 @@
                     return;
                 }
                 this._pos3d = pos3d;
+                if (!this.prePositioned && visual instanceof Cesium.Cesium3DTileFeature) {
+                    this.followTilesetPart(visual, counter);
+                }
                 let text = "Unknown Entity";
                 const additionalTexts = this.additionalTexts ? this.additionalTexts : [];
                 if (this.rego) {
@@ -8438,13 +8443,12 @@
                     // Past the wait a slow record no longer holds the label back; a box that comes later eases in.
                     setTimeout(settle, MODEL_BOX_WAIT);
                     this.modelBox.load.then(corners => {
-                        var _a, _b;
                         if (!corners || this.disposed || this.counter !== counter) {
                             return;
                         }
                         // A record that disagrees with where the model was found describes another placement, such as a moved tileset.
                         // A part known to have moved from its record, eg. a joint turning, is judged where it has moved to.
-                        const motion = (_b = (_a = this.rego) === null || _a === void 0 ? void 0 : _a.motion) === null || _b === void 0 ? void 0 : _b.call(_a, this.viewer.clock.currentTime);
+                        const motion = this.motionAt(this.viewer.clock.currentTime);
                         const centre = Cesium.Cartesian3.midpoint(corners[0], corners[7], new Cesium.Cartesian3());
                         if (motion) {
                             Cesium.Matrix4.multiplyByPoint(motion, centre, centre);
@@ -8456,7 +8460,8 @@
                         // Let go a little further out than it is taken, so a camera resting at the limit does not flip it.
                         let near = false;
                         layer.modelBoxes.Set(this.id, corners, rego.entityId, {
-                            motion: rego.motion ? () => rego.motion(this.viewer.clock.currentTime) : undefined,
+                            // Asked each frame, since a CAD part's tileset may only be known once its record is read.
+                            motion: () => this.motionAt(this.viewer.clock.currentTime),
                             selected: () => { var _a, _b; return Boolean((_b = (_a = this.visualRegister) === null || _a === void 0 ? void 0 : _a.GetState({ entityId: rego.entityId, menuItemId: rego.menuItemId })) === null || _b === void 0 ? void 0 : _b.selected); },
                             hovered: () => { var _a, _b; return Boolean((_b = (_a = this.visualRegister) === null || _a === void 0 ? void 0 : _a.IsLabelHovered) === null || _b === void 0 ? void 0 : _b.call(_a, rego.entityId, rego.menuItemId)); },
                             near: () => {
@@ -8490,6 +8495,12 @@
                                 desiredHeightRef: Cesium.HeightReference.NONE, heightRef, pos3d: position, viewer: this.viewer
                             });
                     }
+                    // A CAD part sits where its tileset is drawn this frame.
+                    else if (!this.prePositioned && this.tilesetPart) {
+                        const { tileset, entity } = this.tilesetPart;
+                        const rootFrame = exports.EntityUtils.GetTilesetRootFrame(tileset);
+                        this._pos3d = (rootFrame && exports.EntityUtils.GetAssemblyPartPos3d({ viewer: this.viewer, entity, rootFrame })) || this._pos3d;
+                    }
                     if (!Number.isFinite((_b = this._pos3d) === null || _b === void 0 ? void 0 : _b.x)) {
                         return null;
                     }
@@ -9223,6 +9234,43 @@
                 };
                 step();
             }
+            /*
+             * Keeps a label on a CAD Assembly part where its tileset is drawn, which a record cannot know as it moves.
+             */
+            async followTilesetPart(feature, counter) {
+                var _a, _b, _c;
+                const known = (_c = (_b = (_a = this.visualRegister) === null || _a === void 0 ? void 0 : _a.GetLabelGroupFor(this.rego.entityId, this.rego.menuItemId)) === null || _b === void 0 ? void 0 : _b.item) === null || _c === void 0 ? void 0 : _c.entity;
+                let entity = exports.EntityUtils.IsAssemblyPart(known) ? known : null;
+                if (!entity && this.api) {
+                    try {
+                        entity = (await BModels.Entity.Get({ api: this.api, entityId: this.rego.entityId, expandLocation: true, migrated: true })).entity;
+                    }
+                    // Expanding location fails for entities outside an assembly, which keep the position already found.
+                    catch {
+                        return;
+                    }
+                }
+                const record = exports.EntityUtils.GetAssemblyRecordFrame(entity);
+                if (!record || this.disposed || this.counter !== counter || !feature.tileset) {
+                    return;
+                }
+                this.tilesetPart = { tileset: feature.tileset, entity, record };
+                this.viewer.scene.requestRender();
+            }
+            /*
+             * Rigid motion from where the record places this Entity to where it is drawn, see IVisualRego.motion.
+             * A CAD part has none of its own, so it moves with its tileset.
+             */
+            motionAt(time) {
+                var _a, _b;
+                const own = (_b = (_a = this.rego) === null || _a === void 0 ? void 0 : _a.motion) === null || _b === void 0 ? void 0 : _b.call(_a, time);
+                if (own || !this.tilesetPart) {
+                    return own !== null && own !== void 0 ? own : null;
+                }
+                const drawn = exports.EntityUtils.GetTilesetRootFrame(this.tilesetPart.tileset);
+                const inverse = Cesium.Matrix4.inverseTransformation(this.tilesetPart.record, new Cesium.Matrix4());
+                return drawn ? Cesium.Matrix4.multiply(drawn, inverse, inverse) : null;
+            }
             /*
              * Reads the record's geometry box, preferring an entity a label group already hydrated.
              */
@@ -9395,21 +9443,17 @@
     (function (EntityLabelGroup) {
         /*
          * Keeps the query response useful even when the Entity has no loaded visual yet.
+         * An Assembly part is placed from its record when shown (Manager.RefreshEntity); Location is its fallback.
          */
         function FromEntity(entity) {
-            var _a, _b, _c, _d;
+            var _a, _b, _c;
             const location = (_a = entity === null || entity === void 0 ? void 0 : entity.Bruce) === null || _a === void 0 ? void 0 : _a.Location;
-            const pivot = (_b = entity === null || entity === void 0 ? void 0 : entity.Bruce) === null || _b === void 0 ? void 0 : _b.GeometryWorldPivot;
-            let cartographic;
-            if ((pivot === null || pivot === void 0 ? void 0 : pivot.length) >= 3 && pivot.every(Number.isFinite)) {
-                cartographic = Cesium.Cartographic.fromCartesian(Cesium.Cartesian3.fromArray(pivot));
-            }
             return {
-                entityId: (_c = entity === null || entity === void 0 ? void 0 : entity.Bruce) === null || _c === void 0 ? void 0 : _c.ID,
-                text: (_d = entity === null || entity === void 0 ? void 0 : entity.Bruce) === null || _d === void 0 ? void 0 : _d.Name,
-                longitude: cartographic ? Cesium.Math.toDegrees(cartographic.longitude) : location === null || location === void 0 ? void 0 : location.longitude,
-                latitude: cartographic ? Cesium.Math.toDegrees(cartographic.latitude) : location === null || location === void 0 ? void 0 : location.latitude,
-                altitude: cartographic ? cartographic.height : location === null || location === void 0 ? void 0 : location.altitude,
+                entityId: (_b = entity === null || entity === void 0 ? void 0 : entity.Bruce) === null || _b === void 0 ? void 0 : _b.ID,
+                text: (_c = entity === null || entity === void 0 ? void 0 : entity.Bruce) === null || _c === void 0 ? void 0 : _c.Name,
+                longitude: location === null || location === void 0 ? void 0 : location.longitude,
+                latitude: location === null || location === void 0 ? void 0 : location.latitude,
+                altitude: location === null || location === void 0 ? void 0 : location.altitude,
                 entity
             };
         }
@@ -9522,7 +9566,8 @@
                 const response = await BModels.DataLab.Run({ api, query, skip: offset, load: limit, migrated: true, req: { noCache: true, abortSignal: signal } });
                 const entities = response.entities || response.items || [];
                 return {
-                    items: entities.map(FromEntity),
+                    // A simulated stand-in or patch wins over what the query read, as it does for hand-picked groups.
+                    items: entities.map(entity => { var _a, _b; return FromEntity((_b = simulation === null || simulation === void 0 ? void 0 : simulation.Resolve((_a = entity === null || entity === void 0 ? void 0 : entity.Bruce) === null || _a === void 0 ? void 0 : _a.ID, entity)) !== null && _b !== void 0 ? _b : entity); }),
                     hasMore: response.totalCount != null ? offset + entities.length < response.totalCount : entities.length === limit
                 };
             };
@@ -9875,7 +9920,7 @@
                 }
             }
             RefreshEntity(entityId) {
-                var _a, _b, _c, _d, _e, _f, _g;
+                var _a, _b, _c, _d, _e, _f, _g, _h;
                 const match = this.Resolve(entityId);
                 const registered = this.register.GetRego({ entityId });
                 if (!registered && match && this.standalone.has(entityId) && this.standaloneItems.get(entityId) === match.item) {
@@ -9892,19 +9937,22 @@
                     return;
                 }
                 const item = match.item;
-                if (![item.longitude, item.latitude, (_d = item.altitude) !== null && _d !== void 0 ? _d : 0].every(Number.isFinite) || Math.abs(item.latitude) > 90) {
+                const position = (_d = this.assemblyPosition(item.entity)) !== null && _d !== void 0 ? _d : ([item.longitude, item.latitude, (_e = item.altitude) !== null && _e !== void 0 ? _e : 0].every(Number.isFinite) && Math.abs(item.latitude) <= 90
+                    ? Cesium.Cartesian3.fromDegrees(item.longitude, item.latitude, item.altitude || 0)
+                    : null);
+                if (!position) {
                     return;
                 }
                 const visual = new Cesium.Entity({
-                    position: Cesium.Cartesian3.fromDegrees(item.longitude, item.latitude, item.altitude || 0),
+                    position: position,
                     point: { heightReference: Cesium.HeightReference.NONE, pixelSize: 0 }
                 });
                 this.standalone.set(entityId, new exports.EntityLabel.Label({
                     viewer: this.register.Viewer,
                     visualRegister: this.register,
-                    api: (_e = this.register.ApiGetters) === null || _e === void 0 ? void 0 : _e.GetBruceApi(),
+                    api: (_f = this.register.ApiGetters) === null || _f === void 0 ? void 0 : _f.GetBruceApi(),
                     rego: { entityId, visual, name: item.text || entityId, priority: 0 },
-                    options: { ...match.options, text: (_g = (_f = match.options.text) !== null && _f !== void 0 ? _f : item.text) !== null && _g !== void 0 ? _g : entityId },
+                    options: { ...match.options, text: (_h = (_g = match.options.text) !== null && _g !== void 0 ? _g : item.text) !== null && _h !== void 0 ? _h : entityId },
                     groupId: match.groupId,
                     visible: () => {
                         const state = this.register.GetState({ entityId });
@@ -9913,6 +9961,41 @@
                 }));
                 this.standaloneItems.set(entityId, item);
             }
+            /*
+             * Places an undrawn Assembly part where its Assembly is now: model-space, history and simulation included.
+             * Returns null for anything else, which keeps its record's Location.
+             */
+            assemblyPosition(entity) {
+                const viewer = this.register.Viewer;
+                if (!exports.EntityUtils.GetAssemblyPartPos3d({ viewer, entity })) {
+                    return null;
+                }
+                let last = null;
+                return new Cesium.CallbackProperty((time) => {
+                    var _a, _b, _c;
+                    const at = Cesium.JulianDate.toDate(time !== null && time !== void 0 ? time : viewer.clock.currentTime).getTime();
+                    const simulated = (_b = (_a = exports.EntitySimulation.Get(viewer)) === null || _a === void 0 ? void 0 : _a.ApplyAt(entity, at)) !== null && _b !== void 0 ? _b : entity;
+                    last = (_c = exports.EntityUtils.GetAssemblyPartPos3d({ viewer, entity: simulated, rootFrame: this.drawnFrame(entity) })) !== null && _c !== void 0 ? _c : last;
+                    return last;
+                }, false);
+            }
+            /*
+             * The frame of a CAD tileset drawn at this Assembly's root, which moves with its history and simulation.
+             */
+            drawnFrame(entity) {
+                var _a, _b;
+                const root = (_a = entity === null || entity === void 0 ? void 0 : entity.Bruce) === null || _a === void 0 ? void 0 : _a.AssemblyRootLocation;
+                for (const { tileset } of this.register.GetTilesets()) {
+                    const at = (_b = tileset._bruceCoords) === null || _b === void 0 ? void 0 : _b.location;
+                    if (at && root &&
+                        Math.abs(+at.latitude - +root.latitude) < 1e-7 &&
+                        Math.abs(+at.longitude - +root.longitude) < 1e-7 &&
+                        Math.abs((+at.altitude || 0) - (+root.altitude || 0)) < 0.01) {
+                        return exports.EntityUtils.GetTilesetRootFrame(tileset);
+                    }
+                }
+                return null;
+            }
             Remove(id) {
                 var _a;
                 const known = this.definitions.delete(id);
@@ -23471,7 +23554,9 @@
                         ucs: coords === null || coords === void 0 ? void 0 : coords.ucs,
                         location: (coords === null || coords === void 0 ? void 0 : coords.location) == null ? settings.location : coords.location,
                         transform: (coords === null || coords === void 0 ? void 0 : coords.transform) == null ? settings.transform : coords.transform
-                    }
+                    },
+                    // Placed as first drawn, or a model-space tileset jumps to its site on a history or simulation update.
+                    modelSpace: this.modelSpace
                 });
                 this.viewer.scene.requestRender();
             }
@@ -38170,7 +38255,7 @@
             if (!bookmark) {
                 let bookmarkId = params.bookmarkId;
                 if (!bookmarkId) {
-                    bookmarkId = view.DefaultUISlideID;
+                    bookmarkId = view["Default.UISlide.ID"];
                 }
                 bookmark = bookmarkId ? (await BModels.ProjectViewBookmark.Get({
                     api,
@@ -38231,7 +38316,7 @@
             if (!bookmark) {
                 let bookmarkId = params.bookmarkId;
                 if (!bookmarkId) {
-                    bookmarkId = view.DefaultUISlideID;
+                    bookmarkId = view["Default.UISlide.ID"];
                 }
                 bookmark = bookmarkId ? (await BModels.ProjectViewBookmark.Get({
                     api,
@@ -44444,6 +44529,47 @@
         }
         return Cesium.Matrix4.multiplyByPoint(enuFrame, new Cesium.Cartesian3(tx, ty, tz), new Cesium.Cartesian3());
     }
+    /*
+     * Reads a row-major 4x4 from a record, or null when it is missing or malformed.
+     */
+    function matrixFromRows(rows) {
+        if (!Array.isArray(rows) || rows.length !== 4) {
+            return null;
+        }
+        const values = [].concat(...rows).map(Number);
+        return values.length === 16 && values.every(Number.isFinite) ? Cesium.Matrix4.fromRowMajorArray(values) : null;
+    }
+    /*
+     * An Assembly part's geometry centre in its root's frame, via its parent so a simulated AssemblyPosition counts.
+     */
+    function calcAssemblyPartOffset(entity) {
+        const bruce = entity === null || entity === void 0 ? void 0 : entity.Bruce;
+        const pivot = Array.isArray(bruce === null || bruce === void 0 ? void 0 : bruce.GeometryPivot) && bruce.GeometryPivot.length >= 3 ? bruce.GeometryPivot.slice(0, 3).map(Number) : null;
+        const parent = matrixFromRows(bruce === null || bruce === void 0 ? void 0 : bruce.AssemblyParentWorldPosition);
+        const local = matrixFromRows(bruce === null || bruce === void 0 ? void 0 : bruce.AssemblyPosition);
+        const world = parent && local ? Cesium.Matrix4.multiply(parent, local, new Cesium.Matrix4()) : matrixFromRows(bruce === null || bruce === void 0 ? void 0 : bruce.AssemblyWorldPosition);
+        if (world && (!pivot || pivot.every(Number.isFinite))) {
+            return Cesium.Matrix4.multiplyByPoint(world, pivot ? Cesium.Cartesian3.fromArray(pivot) : Cesium.Cartesian3.ZERO, new Cesium.Cartesian3());
+        }
+        const worldPivot = Array.isArray(bruce === null || bruce === void 0 ? void 0 : bruce.GeometryWorldPivot) ? bruce.GeometryWorldPivot.slice(0, 3).map(Number) : [];
+        return worldPivot.length === 3 && worldPivot.every(Number.isFinite) ? Cesium.Cartesian3.fromArray(worldPivot) : null;
+    }
+    /*
+     * The frame a part's record places it in, as the API's Location: the root (0,0 in model-space), then its transform.
+     */
+    function calcAssemblyRootFrame(entity, modelSpace) {
+        var _a, _b, _c;
+        const root = (_a = entity === null || entity === void 0 ? void 0 : entity.Bruce) === null || _a === void 0 ? void 0 : _a.AssemblyRootLocation;
+        if (!root && !modelSpace) {
+            return null;
+        }
+        const origin = modelSpace ? Cesium.Cartesian3.fromDegrees(0, 0, 0) : Cesium.Cartesian3.fromDegrees(EnsureNumber(root.longitude), EnsureNumber(root.latitude), EnsureNumber(root.altitude));
+        const transform = (_c = (_b = entity.Bruce) === null || _b === void 0 ? void 0 : _b.AssemblyWorldTransform) !== null && _c !== void 0 ? _c : {};
+        const frame = Cesium.Transforms.eastNorthUpToFixedFrame(origin);
+        Cesium.Matrix4.multiply(frame, Cesium.Matrix4.fromTranslation(new Cesium.Cartesian3(EnsureNumber(transform.x), EnsureNumber(transform.y), EnsureNumber(transform.z))), frame);
+        const hpr = Cesium.HeadingPitchRoll.fromDegrees(EnsureNumber(transform.heading), EnsureNumber(transform.pitch), EnsureNumber(transform.roll));
+        return Cesium.Matrix4.multiply(frame, Cesium.Matrix4.fromRotation(Cesium.Matrix3.fromHeadingPitchRoll(hpr)), frame);
+    }
     // Records created within about this long ago are the ones the oversized GeometryRadius bug could have written.
     const GEOMETRY_RADIUS_SUSPECT_AGE_MS = 1000 * 60 * 60 * 24 * 183;
     // Above this a recent record's radius is treated as that bug rather than a real size.
@@ -44488,6 +44614,61 @@
     // +90° rotation around Z: aligns GLTF Y-up forward with Cesium ENU North.
     const _assemblyAxisShift = new Cesium.Quaternion(0, 0, -Math.SQRT1_2, Math.SQRT1_2);
     (function (EntityUtils) {
+        /**
+         * Returns where an Assembly part's geometry centre is, without asking the API or the scene.
+         * Bruce.Location only holds where the API last placed it, so this composes from the root's frame instead.
+         * @param params.rootFrame the frame its Assembly is drawn in now, eg. GetTilesetRootFrame of its CAD tileset.
+         * Default: the frame its record describes, at 0,0 in model-space.
+         * @returns null when the record is not an Assembly part or lacks its matrices.
+         */
+        function GetAssemblyPartPos3d(params) {
+            var _a;
+            const { viewer, entity } = params;
+            if (!IsAssemblyPart(entity)) {
+                return null;
+            }
+            const offset = calcAssemblyPartOffset(entity);
+            const frame = (_a = params.rootFrame) !== null && _a !== void 0 ? _a : calcAssemblyRootFrame(entity, exports.ViewUtils.GetModelSpace(viewer));
+            return offset && frame ? Cesium.Matrix4.multiplyByPoint(frame, offset, new Cesium.Cartesian3()) : null;
+        }
+        EntityUtils.GetAssemblyPartPos3d = GetAssemblyPartPos3d;
+        /**
+         * Returns the geospatial frame a part's record assumes for its root, the one the API works Location out in.
+         * Comparing it with where the Assembly is drawn gives how far the drawing has moved from the record.
+         * @param entity
+         */
+        function GetAssemblyRecordFrame(entity) {
+            return IsAssemblyPart(entity) ? calcAssemblyRootFrame(entity, false) : null;
+        }
+        EntityUtils.GetAssemblyRecordFrame = GetAssemblyRecordFrame;
+        /**
+         * Returns whether a record is an Assembly part, ie. placed through its root rather than its own Location.
+         * @param entity
+         */
+        function IsAssemblyPart(entity) {
+            const bruce = entity === null || entity === void 0 ? void 0 : entity.Bruce;
+            return ((bruce === null || bruce === void 0 ? void 0 : bruce.AssemblyRootLocation) != null &&
+                (bruce.AssemblyWorldPosition != null || bruce.AssemblyPosition != null || bruce.GeometryWorldPivot != null));
+        }
+        EntityUtils.IsAssemblyPart = IsAssemblyPart;
+        /**
+         * Returns the frame a tileset is drawn in now, without its scale, so Assembly offsets in metres apply to it.
+         * It follows whatever moved the tileset: history, a simulated root, or model-space.
+         * @param tileset
+         */
+        function GetTilesetRootFrame(tileset) {
+            var _a, _b;
+            const transform = (_a = tileset === null || tileset === void 0 ? void 0 : tileset.root) === null || _a === void 0 ? void 0 : _a.transform;
+            if (!transform || ((_b = tileset.isDestroyed) === null || _b === void 0 ? void 0 : _b.call(tileset))) {
+                return null;
+            }
+            const scale = Cesium.Matrix4.getScale(transform, new Cesium.Cartesian3());
+            if (!(scale.x > 0)) {
+                return null;
+            }
+            return Cesium.Matrix4.multiplyByUniformScale(transform, 1 / scale.x, new Cesium.Matrix4());
+        }
+        EntityUtils.GetTilesetRootFrame = GetTilesetRootFrame;
         /**
          * Returns the location for given entity or entities.
          * If available it will also compute a rectangle.
@@ -46349,6 +46530,418 @@
         }
     }
 
+    /**
+     * Draws the orientation effect a point style can ask for, an open ring whose pointer shows which way the Entity faces.
+     */
+    var EntityRenderEnginePointOrientation;
+    (function (EntityRenderEnginePointOrientation) {
+        // Compared as the wire string, since an older bruce-models in the host has no EPointEffectType at runtime.
+        EntityRenderEnginePointOrientation.ORIENTATION_EFFECT = "ORIENTATION";
+        // Clearance between the glyph and the ring, and the smallest ring, matching entity-label.ts's icon ring.
+        EntityRenderEnginePointOrientation.RING_PADDING = 4;
+        EntityRenderEnginePointOrientation.RING_MIN = 10;
+        const RING_STROKE = 2;
+        const RING_CSS = "rgba(255, 255, 255, 0.8)";
+        const RING_GLOW_CSS = "rgba(0, 0, 0, 0.3)";
+        const RING_GLOW_BLUR = 5;
+        // The pointer reaches TIP_BASE + TIP_GROWTH * sqrt(radius) px past the ring, so it grows slower than the ring.
+        const TIP_BASE = 3;
+        const TIP_GROWTH = 2.2;
+        // Share of the circle kept around the heading. Label rings keep 0.35, but the pointer uses most of it.
+        const ARC_FRACTION = 0.5;
+        // The arc always runs at least this far past where the pointer leaves it, so it still reads as a ring.
+        const ARC_TAIL = Math.PI / 30;
+        const ARC_STEPS = 12;
+        // Copies of the cap outline nested toward its centre, enough for 2 px strokes to read as a fill.
+        const CAP_FILL_LOOPS = 4;
+        // Canvas oversampling so the stroke stays crisp on high density screens.
+        const RING_DPR = 2;
+        const _ringCache = new BModels.LRUCache(50);
+        /*
+         * Whether a point style asks for the orientation effect.
+         */
+        function IsEnabled(style) {
+            var _a;
+            return ((_a = style === null || style === void 0 ? void 0 : style.effect) === null || _a === void 0 ? void 0 : _a.type) === EntityRenderEnginePointOrientation.ORIENTATION_EFFECT;
+        }
+        EntityRenderEnginePointOrientation.IsEnabled = IsEnabled;
+        /*
+         * The Entity's orientation from Bruce.Transform, or null when it has no usable heading to show.
+         */
+        function GetOrientation(entity) {
+            var _a;
+            const transform = (_a = entity === null || entity === void 0 ? void 0 : entity.Bruce) === null || _a === void 0 ? void 0 : _a.Transform;
+            const raw = transform === null || transform === void 0 ? void 0 : transform.heading;
+            if (raw == null ||
+                (typeof raw == "string" && !raw.trim())) {
+                return null;
+            }
+            const heading = Number(raw);
+            if (!isFinite(heading)) {
+                return null;
+            }
+            const pitch = Number(transform.pitch);
+            const roll = Number(transform.roll);
+            return {
+                heading,
+                pitch: isFinite(pitch) ? pitch : 0,
+                roll: isFinite(roll) ? roll : 0
+            };
+        }
+        EntityRenderEnginePointOrientation.GetOrientation = GetOrientation;
+        /*
+         * Ring radius in px for a glyph of the given radius.
+         */
+        function GetRingRadius(glyphRadius) {
+            const radius = Number(glyphRadius);
+            return Math.max(EntityRenderEnginePointOrientation.RING_MIN, (isFinite(radius) ? radius : 0) + EntityRenderEnginePointOrientation.RING_PADDING);
+        }
+        EntityRenderEnginePointOrientation.GetRingRadius = GetRingRadius;
+        /*
+         * How far the pointer's tip sits from the centre, as a multiple of the ring radius.
+         */
+        function GetTipRatio(ringRadius) {
+            return 1 + (TIP_BASE + TIP_GROWTH * Math.sqrt(ringRadius)) / ringRadius;
+        }
+        EntityRenderEnginePointOrientation.GetTipRatio = GetTipRatio;
+        /*
+         * The open ring in a unit frame, u forward and v right: arc tail, tangent to the tip, tangent back, arc tail.
+         * The pointer's sides are tangents to the circle, so the arc runs into the tip with no visible joint.
+         */
+        function GetOutline(tipRatio) {
+            const touch = Math.acos(1 / tipRatio);
+            const half = Math.max(Math.PI * ARC_FRACTION, touch + ARC_TAIL);
+            const points = [];
+            for (let i = 0; i <= ARC_STEPS; i++) {
+                const phi = -half + (half - touch) * i / ARC_STEPS;
+                points.push([Math.cos(phi), Math.sin(phi)]);
+            }
+            points.push([tipRatio, 0]);
+            for (let i = 0; i <= ARC_STEPS; i++) {
+                const phi = touch + (half - touch) * i / ARC_STEPS;
+                points.push([Math.cos(phi), Math.sin(phi)]);
+            }
+            return points;
+        }
+        EntityRenderEnginePointOrientation.GetOutline = GetOutline;
+        /*
+         * The filled cap between the pointer's sides and the circle, in the same unit frame as GetOutline.
+         */
+        function GetCap(tipRatio) {
+            const touch = Math.acos(1 / tipRatio);
+            const points = [[tipRatio, 0]];
+            for (let i = 0; i <= ARC_STEPS; i++) {
+                const phi = touch - 2 * touch * i / ARC_STEPS;
+                points.push([Math.cos(phi), Math.sin(phi)]);
+            }
+            return points;
+        }
+        EntityRenderEnginePointOrientation.GetCap = GetCap;
+        /*
+         * The outline as one path with its cap filled by nested copies of the cap's outline, for a polyline that cannot fill.
+         * Back and forth strokes would need sharp reversals, which Cesium mitres into spikes; nested loops only turn at the
+         * cap's own corners. Like GetOutline it starts and ends on the arc tails.
+         */
+        function GetFilledOutline(tipRatio) {
+            const outline = GetOutline(tipRatio);
+            const tipIndex = outline.findIndex(([u, v]) => u === tipRatio && v === 0);
+            const cap = GetCap(tipRatio);
+            const cu = cap.reduce((sum, [u]) => sum + u, 0) / cap.length;
+            const cv = cap.reduce((sum, [, v]) => sum + v, 0) / cap.length;
+            const loops = [];
+            for (let i = 0; i < CAP_FILL_LOOPS; i++) {
+                const k = 1 - i / CAP_FILL_LOOPS;
+                for (const [u, v] of cap) {
+                    loops.push([cu + (u - cu) * k, cv + (v - cv) * k]);
+                }
+            }
+            loops.push([tipRatio, 0]);
+            return [...outline.slice(0, tipIndex + 1), ...loops, ...outline.slice(tipIndex + 1)];
+        }
+        EntityRenderEnginePointOrientation.GetFilledOutline = GetFilledOutline;
+        /*
+         * Draws the ring for a glyph as a billboard image pointing up, or null where there is no canvas to draw on.
+         */
+        function CreateRingBillboard(glyphRadius) {
+            var _a;
+            const radius = GetRingRadius(glyphRadius);
+            const key = radius.toFixed(1);
+            const cached = _ringCache.Get(key);
+            if (cached) {
+                return cached;
+            }
+            const tipRatio = GetTipRatio(radius);
+            const size = Math.ceil((radius * tipRatio + RING_STROKE + RING_GLOW_BLUR) * 2);
+            const canvas = document.createElement("canvas");
+            canvas.width = size * RING_DPR;
+            canvas.height = size * RING_DPR;
+            const context = (_a = canvas.getContext) === null || _a === void 0 ? void 0 : _a.call(canvas, "2d");
+            if (!context) {
+                return null;
+            }
+            context.scale(RING_DPR, RING_DPR);
+            // Forward is up the image, right is to the right.
+            const toCanvas = ([u, v]) => [size / 2 + v * radius, size / 2 - u * radius];
+            const trace = (points, close) => {
+                context.beginPath();
+                points.map(toCanvas).forEach(([x, y], i) => i ? context.lineTo(x, y) : context.moveTo(x, y));
+                if (close) {
+                    context.closePath();
+                }
+            };
+            context.shadowColor = RING_GLOW_CSS;
+            context.shadowBlur = RING_GLOW_BLUR;
+            context.fillStyle = RING_CSS;
+            trace(GetCap(tipRatio), true);
+            context.fill();
+            context.strokeStyle = RING_CSS;
+            context.lineWidth = RING_STROKE;
+            context.lineJoin = "round";
+            context.lineCap = "round";
+            trace(GetOutline(tipRatio), false);
+            context.stroke();
+            const ring = {
+                canvasDataUri: canvas.toDataURL("image/png"),
+                size
+            };
+            _ringCache.Set(key, ring);
+            return ring;
+        }
+        EntityRenderEnginePointOrientation.CreateRingBillboard = CreateRingBillboard;
+        /*
+         * World space unit vector along the local horizon at a heading in degrees clockwise from north.
+         */
+        function GetHeadingAxis(pos3d, heading) {
+            const enu = Cesium.Transforms.eastNorthUpToFixedFrame(pos3d);
+            const rad = Cesium.Math.toRadians(heading);
+            const local = new Cesium.Cartesian3(Math.sin(rad), Math.cos(rad), 0);
+            const world = Cesium.Matrix4.multiplyByPointAsVector(enu, local, new Cesium.Cartesian3());
+            return Cesium.Cartesian3.normalize(world, world);
+        }
+        EntityRenderEnginePointOrientation.GetHeadingAxis = GetHeadingAxis;
+        /*
+         * World space forward and right unit vectors for a full orientation, which span the plane the 3D ring lies in.
+         */
+        function GetBasis(pos3d, orientation) {
+            const h = Cesium.Math.toRadians(orientation.heading);
+            const p = Cesium.Math.toRadians(orientation.pitch);
+            const r = Cesium.Math.toRadians(orientation.roll);
+            const forward = new Cesium.Cartesian3(Math.sin(h) * Math.cos(p), Math.cos(h) * Math.cos(p), Math.sin(p));
+            const level = new Cesium.Cartesian3(Math.cos(h), -Math.sin(h), 0);
+            const up = Cesium.Cartesian3.cross(level, forward, new Cesium.Cartesian3());
+            // Positive roll lowers the right side.
+            const right = Cesium.Cartesian3.add(Cesium.Cartesian3.multiplyByScalar(level, Math.cos(r), new Cesium.Cartesian3()), Cesium.Cartesian3.multiplyByScalar(up, -Math.sin(r), new Cesium.Cartesian3()), new Cesium.Cartesian3());
+            const enu = Cesium.Transforms.eastNorthUpToFixedFrame(pos3d);
+            const toWorld = (local) => {
+                const world = Cesium.Matrix4.multiplyByPointAsVector(enu, local, new Cesium.Cartesian3());
+                return Cesium.Cartesian3.normalize(world, world);
+            };
+            return { forward: toWorld(forward), right: toWorld(right) };
+        }
+        EntityRenderEnginePointOrientation.GetBasis = GetBasis;
+        /*
+         * Counter-clockwise billboard rotation that turns its up edge along a world direction as the camera sees it.
+         * Cesium's alignedAxis squares its angle and drops perspective, up to 160 degrees out when side on.
+         */
+        function GetScreenRotation(viewer, pos3d, axis) {
+            const transforms = Cesium.SceneTransforms;
+            const project = transforms.wgs84ToWindowCoordinates || transforms.worldToWindowCoordinates;
+            const camera = viewer.camera.positionWC || viewer.camera.position;
+            // A step proportional to distance keeps the two projections a few pixels apart at any zoom.
+            const step = Math.max(0.01, Cesium.Cartesian3.distance(camera, pos3d) * 0.01);
+            const ahead = Cesium.Cartesian3.add(pos3d, Cesium.Cartesian3.multiplyByScalar(axis, step, new Cesium.Cartesian3()), new Cesium.Cartesian3());
+            const from = project(viewer.scene, pos3d, new Cesium.Cartesian2());
+            const to = project(viewer.scene, ahead, new Cesium.Cartesian2());
+            if (!from || !to) {
+                return null;
+            }
+            const dx = to.x - from.x;
+            const dy = to.y - from.y;
+            if (Math.abs(dx) + Math.abs(dy) < 1e-6) {
+                return null;
+            }
+            return Math.atan2(-dx, -dy);
+        }
+        EntityRenderEnginePointOrientation.GetScreenRotation = GetScreenRotation;
+        /*
+         * Metres one CSS pixel covers at a position, since billboard sizes and polyline widths are CSS pixels.
+         */
+        function getMetresPerPixel(viewer, pos3d) {
+            const scene = viewer.scene;
+            const sphere = new Cesium.BoundingSphere(pos3d, 0);
+            const perBufferPixel = viewer.camera.getPixelSize(sphere, scene.drawingBufferWidth, scene.drawingBufferHeight);
+            return perBufferPixel * (scene.pixelRatio || 1);
+        }
+        /*
+         * Where the parent is drawn this frame, as an absolute position, or null while its ground is not known yet.
+         */
+        function getDrawnPos3d(viewer, parent, heightRef) {
+            const pos3d = GetCValue(viewer, parent.position);
+            if (!pos3d) {
+                return null;
+            }
+            return exports.DrawingUtils.GetDrawnPos3d({
+                viewer,
+                heightRef,
+                pos3d,
+                terrainId: exports.ViewUtils.GetTerrainCacheId(viewer)
+            });
+        }
+        /*
+         * Creates or updates the ring for a point, or returns null when it cannot be drawn.
+         * Clamped to ground it shows only the heading as a billboard, otherwise the full 3D orientation.
+         */
+        function Render(params) {
+            const { viewer, parent, orientation, heightRef } = params;
+            if (!viewer || !parent || !orientation) {
+                return null;
+            }
+            const clamped = heightRef == Cesium.HeightReference.CLAMP_TO_GROUND;
+            const ring = clamped ? renderBillboard(params) : renderPolyline(params);
+            if (ring) {
+                ring._orientationRing = true;
+                ring._noEdit = true;
+                ring._parentEntity = parent;
+            }
+            return ring;
+        }
+        EntityRenderEnginePointOrientation.Render = Render;
+        /*
+         * The ring among a point's sibling graphics, if it has one.
+         */
+        function FindRing(siblings) {
+            return (siblings === null || siblings === void 0 ? void 0 : siblings.find(x => x === null || x === void 0 ? void 0 : x._orientationRing)) || null;
+        }
+        EntityRenderEnginePointOrientation.FindRing = FindRing;
+        /*
+         * The heading only ring, a billboard turned every frame to point along the ground.
+         */
+        function renderBillboard(params) {
+            var _a;
+            const { viewer, parent, orientation, heightRef } = params;
+            const image = CreateRingBillboard(params.glyphRadius);
+            if (!image) {
+                return null;
+            }
+            let rotation = 0;
+            const rotationProp = new Cesium.CallbackProperty(() => {
+                const drawn = getDrawnPos3d(viewer, parent, heightRef);
+                if (drawn) {
+                    const next = GetScreenRotation(viewer, drawn, GetHeadingAxis(drawn, orientation.heading));
+                    if (next != null) {
+                        rotation = next;
+                    }
+                }
+                return rotation;
+            }, false);
+            const position = new Cesium.CallbackProperty(() => GetCValue(viewer, parent.position), false);
+            const displayCondition = exports.EntityRenderEngine.GetDisplayCondition(params.minDistance, params.maxDistance);
+            const pixelOffset = new Cesium.Cartesian2(0, -(params.glyphOffsetY || 0));
+            let ring = ((_a = params.existing) === null || _a === void 0 ? void 0 : _a.billboard) ? params.existing : null;
+            if (!ring) {
+                ring = new Cesium.Entity({
+                    id: BModels.ObjectUtils.UId(15),
+                    billboard: {
+                        image: image.canvasDataUri,
+                        width: image.size,
+                        height: image.size,
+                        rotation: rotationProp,
+                        heightReference: heightRef,
+                        pixelOffset,
+                        distanceDisplayCondition: displayCondition
+                    },
+                    position,
+                    show: true
+                });
+            }
+            else {
+                ring.billboard.image = new Cesium.ConstantProperty(image.canvasDataUri);
+                ring.billboard.width = new Cesium.ConstantProperty(image.size);
+                ring.billboard.height = new Cesium.ConstantProperty(image.size);
+                ring.billboard.rotation = rotationProp;
+                ring.billboard.heightReference = new Cesium.ConstantProperty(heightRef);
+                ring.billboard.pixelOffset = new Cesium.ConstantProperty(pixelOffset);
+                ring.billboard.distanceDisplayCondition = new Cesium.ConstantProperty(displayCondition);
+                ring.position = position;
+                ring.show = true;
+            }
+            exports.CesiumEntityStyler.BakeDefaultColor({
+                entity: ring,
+                viewer,
+                colors: {
+                    "billboard": Cesium.Color.WHITE
+                },
+                refresh: false
+            });
+            return ring;
+        }
+        /*
+         * The full orientation ring, a polyline in the orientation's plane, resized each frame to hold its screen size.
+         */
+        function renderPolyline(params) {
+            var _a;
+            const { viewer, parent, orientation, heightRef } = params;
+            const radiusPx = GetRingRadius(params.glyphRadius);
+            const outline = GetFilledOutline(GetTipRatio(radiusPx));
+            const color = Cesium.Color.fromCssColorString(RING_CSS);
+            let last = [];
+            let basisAt = null;
+            let basis = null;
+            const positions = new Cesium.CallbackProperty(() => {
+                const drawn = getDrawnPos3d(viewer, parent, heightRef);
+                if (!drawn) {
+                    return last;
+                }
+                // The local frame only changes when the point moves.
+                if (!basisAt || !Cesium.Cartesian3.equals(basisAt, drawn)) {
+                    basis = GetBasis(drawn, orientation);
+                    basisAt = Cesium.Cartesian3.clone(drawn);
+                }
+                const scale = radiusPx * getMetresPerPixel(viewer, drawn);
+                if (!isFinite(scale) || scale <= 0) {
+                    return last;
+                }
+                last = outline.map(([u, v]) => {
+                    const point = Cesium.Cartesian3.multiplyByScalar(basis.forward, u * scale, new Cesium.Cartesian3());
+                    Cesium.Cartesian3.add(point, Cesium.Cartesian3.multiplyByScalar(basis.right, v * scale, new Cesium.Cartesian3()), point);
+                    return Cesium.Cartesian3.add(point, drawn, point);
+                });
+                return last;
+            }, false);
+            const displayCondition = exports.EntityRenderEngine.GetDisplayCondition(params.minDistance, params.maxDistance);
+            let ring = ((_a = params.existing) === null || _a === void 0 ? void 0 : _a.polyline) ? params.existing : null;
+            if (!ring) {
+                ring = new Cesium.Entity({
+                    id: BModels.ObjectUtils.UId(15),
+                    polyline: {
+                        positions,
+                        width: RING_STROKE,
+                        material: color,
+                        arcType: Cesium.ArcType.NONE,
+                        // The positions are already absolute. Unset reads as clamped to the culler, which then grounds the ring.
+                        clampToGround: false,
+                        distanceDisplayCondition: displayCondition
+                    },
+                    position: new Cesium.CallbackProperty(() => GetCValue(viewer, parent.position), false),
+                    show: true
+                });
+            }
+            else {
+                ring.polyline.positions = positions;
+                ring.polyline.distanceDisplayCondition = new Cesium.ConstantProperty(displayCondition);
+                ring.show = true;
+            }
+            exports.CesiumEntityStyler.SetDefaultColor({
+                color,
+                entity: ring,
+                viewer,
+                override: true,
+                requestRender: false
+            });
+            return ring;
+        }
+    })(EntityRenderEnginePointOrientation || (EntityRenderEnginePointOrientation = {}));
+
     (function (EntityRenderEnginePoint) {
         /**
          * Creates a circle billboard (canvas) for a point.
@@ -46386,14 +46979,21 @@
             let animatePosition = null;
             let shouldShowTrack = false;
             let trackStyle = null;
+            // The drawn glyph's half size and how far its centre sits above the anchor, for sizing the orientation ring.
+            let glyph = null;
+            // The orientation ring a previous render left, which the effect decides to keep or remove at the end.
+            let existingRing = null;
             const prepareExistingGraphic = (cEntity, maxSiblings = 0) => {
                 // Gather entity in case previous version had sibling graphics we no longer need.
                 const parts = exports.EntityUtils.GatherEntity({
                     entity: cEntity,
                 });
                 if (parts.length > 1) {
+                    // The ring is held apart so the sibling count below only ever trims the track.
+                    existingRing = EntityRenderEnginePointOrientation.FindRing(cEntity._siblingGraphics);
+                    const others = (cEntity._siblingGraphics || []).filter(x => x !== existingRing);
                     // We'll cull all except the allowed number of siblings.
-                    cEntity._siblingGraphics = cEntity._siblingGraphics.slice(0, maxSiblings);
+                    cEntity._siblingGraphics = others.slice(0, maxSiblings).concat(existingRing ? [existingRing] : []);
                     // We'll remove all that aren't in the allowed (direct) list.
                     for (let i = 0; i < parts.length - 1; i++) {
                         const part = parts[i];
@@ -46405,7 +47005,7 @@
                         console.warn("Point.Render: Parent entity was not null. This should not happen.");
                     }
                 }
-                siblings = cEntity._siblingGraphics;
+                siblings = (cEntity._siblingGraphics || []).filter(x => x !== existingRing);
                 cEntity._siblingGraphics = [];
             };
             const updateShouldShowTrack = () => {
@@ -46658,6 +47258,11 @@
                         }
                         cEntity.billboard._billboardSize = image.height;
                         cEntity.billboard._billboardImgKey = imageKey;
+                        // Icons hang from their bottom edge, so the glyph's centre sits half its height up.
+                        glyph = {
+                            radius: Math.max(image.width || image.height, image.height) * iconScale / 2,
+                            offsetY: image.height * iconScale / 2
+                        };
                     }
                 }
             }
@@ -47031,6 +47636,7 @@
                     cEntity.billboard._billboardImgKey = imgKey;
                 }
                 cEntity.billboard._billboardSize = Math.ceil(circleBillboard.height / 2);
+                glyph = { radius: size / 2, offsetY: 0 };
             }
             // Generate a polyline 'track' for the historic data.
             // We do this for historic data that exists and is moving.
@@ -47080,6 +47686,31 @@
                 }
                 trackEntity._parentEntity = cEntity;
             }
+            // Cylinders set no glyph, so a style switching to one drops its ring.
+            const orientation = glyph && cEntity && EntityRenderEnginePointOrientation.IsEnabled(style)
+                ? EntityRenderEnginePointOrientation.GetOrientation(entity)
+                : null;
+            const ring = orientation ? EntityRenderEnginePointOrientation.Render({
+                viewer: params.viewer,
+                parent: cEntity,
+                existing: existingRing,
+                orientation,
+                heightRef,
+                glyphRadius: glyph.radius,
+                glyphOffsetY: glyph.offsetY,
+                minDistance: params.minDistance,
+                maxDistance: params.maxDistance
+            }) : null;
+            if (existingRing && existingRing !== ring) {
+                RemoveCEntityFromScene(params.viewer, existingRing);
+            }
+            if (ring) {
+                siblings.push(ring);
+                // A new graphic on an existing visual needs a full refresh to be added, as the track does.
+                if (ring !== existingRing && params.rego) {
+                    params.rego.stale = true;
+                }
+            }
             cEntity._siblingGraphics = siblings;
             cEntity.styleEffective = exports.StyleEffective.Combine(styleTraceParts);
             return cEntity;
@@ -47214,7 +47845,8 @@
             canvas.getContext("2d").drawImage(image, 0, 0);
             return {
                 canvasDataUri: canvas.toDataURL("image/png"),
-                height: image.height
+                height: image.height,
+                width: image.width
             };
         });
         _billboardCache$1.Set(cacheKey, prom);
@@ -55445,7 +56077,7 @@ void main() {
         StyleUtils.ApplyTypeStyle = ApplyTypeStyle;
     })(exports.StyleUtils || (exports.StyleUtils = {}));
 
-    const VERSION = "7.6.4";
+    const VERSION = "7.6.5";
     /**
      * Updates the environment instance used by bruce-cesium to one specified.
      * This can be used to ensure that the instance a parent is referencing is shared between bruce-cesium, bruce-models, and the parent app.