bruce-cesium 7.6.3 → 7.6.5

package/dist/bruce-cesium.es5.js

@@ -1,6 +1,6 @@
 import * as Cesium from 'cesium';
-import { Cartographic, ColorMaterialProperty, Entity, Color, ConstantProperty, CallbackProperty, Primitive, Cesium3DTileFeature, Math as Math$1, Cartesian3, JulianDate, Quaternion, Transforms, HeadingPitchRoll, HeightReference, Matrix4, ConstantPositionProperty, DistanceDisplayCondition, ColorBlendMode, ShadowMode, ClassificationType, Model, ShaderSource, Ellipsoid, Geometry, GeometryAttribute, ComponentDatatype, PrimitiveType, BoundingSphere, GeometryPipeline, Cartesian2, Cartesian4, sampleTerrain, Texture, PixelFormat, Sampler, TextureWrap, TextureMinificationFilter, TextureMagnificationFilter, PixelDatatype, VertexArray, BufferUsage, ShaderProgram, RenderState, BlendingState, DrawCommand, Pass, ArcType, CornerType, ImageMaterialProperty, PolygonHierarchy, PolylineGraphics, Rectangle, SceneMode, IntersectionTests, Ray, SceneTransforms, HorizontalOrigin, VerticalOrigin, NearFarScalar, Matrix3, KmlDataSource, GeoJsonDataSource, FeatureDetection, Cesium3DTileStyle, Cesium3DTileColorBlendMode, HeadingPitchRange, Ion, IonResource, Cesium3DTileset, EllipsoidTerrainProvider, IonImageryProvider, createWorldImagery, createWorldImageryAsync, BingMapsImageryProvider, BingMapsStyle, MapboxImageryProvider, MapboxStyleImageryProvider, ArcGisMapServerImageryProvider, OpenStreetMapImageryProvider, UrlTemplateImageryProvider, GridImageryProvider, GeographicTilingScheme, ImageryLayer, TileMapServiceImageryProvider, CesiumTerrainProvider, Intersect, OrthographicFrustum, EasingFunction, ModelGraphics, PolygonGraphics, CorridorGraphics, PointGraphics, BillboardGraphics, EllipseGraphics, PolylineDashMaterialProperty, PolygonPipeline, GeometryInstance, EllipsoidGeodesic, sampleTerrainMostDetailed, defined, CesiumInspector, ClockRange, DynamicEnvironmentMapManager, CustomDataSource, ScreenSpaceEventHandler, ScreenSpaceEventType, Fullscreen, CzmlDataSource } from 'cesium';
-import { Cartes, LRUCache, ProjectViewTile, ENVIRONMENT, Calculator, ClientFile, Entity as Entity$1, EntityLod, EntityTag, EntityType, ObjectUtils, Style, UrlUtils, Carto, Geometry as Geometry$1, Bounds, ClientFileValueMap, Color as Color$1, MenuItem, ProjectView, ProjectViewBookmark, Tileset, ZoomControl, BruceEvent, EntityCoords, Api, DataLab, DelayQueue, AccountConcept, RecordChangeFeed, BruceApi, EntityRelation, EntitySource, ProgramKey, ProjectViewLegacyTile, Camera, Account, AccountLimits, Session, ProjectViewBookmarkGroup, EntityAttachment, EntityAttachmentType, EntityAttribute, MathUtils, EntityRelationType, EntityHistoricData } from 'bruce-models';
+import { Cartographic, ColorMaterialProperty, Entity, Color, ConstantProperty, CallbackProperty, Primitive, Cesium3DTileFeature, Math as Math$1, Cartesian3, JulianDate, Quaternion, Transforms, HeadingPitchRoll, HeightReference, Matrix4, ColorBlendMode, ShadowMode, ClassificationType, Model, ShaderSource, Ellipsoid, Geometry, GeometryAttribute, ComponentDatatype, PrimitiveType, BoundingSphere, GeometryPipeline, Cartesian2, Cartesian4, sampleTerrain, Texture, PixelFormat, Sampler, TextureWrap, TextureMinificationFilter, TextureMagnificationFilter, PixelDatatype, VertexArray, BufferUsage, ShaderProgram, RenderState, BlendingState, DrawCommand, Pass, ArcType, CornerType, ConstantPositionProperty, HorizontalOrigin, VerticalOrigin, DistanceDisplayCondition, ImageMaterialProperty, PolygonHierarchy, PolylineGraphics, Rectangle, SceneMode, IntersectionTests, Ray, SceneTransforms, NearFarScalar, Matrix3, KmlDataSource, GeoJsonDataSource, FeatureDetection, Cesium3DTileStyle, HeadingPitchRange, Ion, IonResource, EllipsoidTerrainProvider, IonImageryProvider, createWorldImagery, createWorldImageryAsync, BingMapsImageryProvider, BingMapsStyle, MapboxImageryProvider, MapboxStyleImageryProvider, ArcGisMapServerImageryProvider, OpenStreetMapImageryProvider, UrlTemplateImageryProvider, GridImageryProvider, GeographicTilingScheme, ImageryLayer, TileMapServiceImageryProvider, CesiumTerrainProvider, Cesium3DTileColorBlendMode, Cesium3DTileset, Intersect, OrthographicFrustum, EasingFunction, ModelGraphics, PolygonGraphics, CorridorGraphics, PointGraphics, BillboardGraphics, EllipseGraphics, PolylineDashMaterialProperty, PolygonPipeline, EllipsoidGeodesic, sampleTerrainMostDetailed, defined, CesiumInspector, ClockRange, DynamicEnvironmentMapManager, CustomDataSource, ScreenSpaceEventHandler, ScreenSpaceEventType, GeometryInstance, Fullscreen, CzmlDataSource } from 'cesium';
+import { Cartes, LRUCache, ProjectViewTile, ENVIRONMENT, Calculator, ClientFile, Entity as Entity$1, EntityLod, EntityTag, EntityType, ObjectUtils, Style, UrlUtils, Carto, Geometry as Geometry$1, Api, Bounds, ClientFileValueMap, Color as Color$1, MenuItem, ProjectView, ProjectViewBookmark, Tileset, ZoomControl, BruceEvent, EntityCoords, DataLab, DelayQueue, AccountConcept, RecordChangeFeed, BruceApi, EntityRelation, ProgramKey, ProjectViewLegacyTile, EntitySource, Camera, Account, AccountLimits, Session, ProjectViewBookmarkGroup, EntityAttachment, EntityAttachmentType, EntityAttribute, MathUtils, EntityRelationType, EntityHistoricData } from 'bruce-models';
 
 /**
  * Ensures a number is returned from a given value.
@@ -7688,6 +7688,8 @@ var EntityLabel;
             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.
@@ -7997,6 +7999,9 @@ var EntityLabel;
                 return;
             }
             this._pos3d = pos3d;
+            if (!this.prePositioned && visual instanceof Cesium3DTileFeature) {
+                this.followTilesetPart(visual, counter);
+            }
             let text = "Unknown Entity";
             const additionalTexts = this.additionalTexts ? this.additionalTexts : [];
             if (this.rego) {
@@ -8458,13 +8463,12 @@ var EntityLabel;
                 // 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 = Cartesian3.midpoint(corners[0], corners[7], new Cartesian3());
                     if (motion) {
                         Matrix4.multiplyByPoint(motion, centre, centre);
@@ -8476,7 +8480,8 @@ var EntityLabel;
                     // 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: () => {
@@ -8510,6 +8515,12 @@ var EntityLabel;
                             desiredHeightRef: 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 = EntityUtils.GetTilesetRootFrame(tileset);
+                    this._pos3d = (rootFrame && 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;
                 }
@@ -9243,6 +9254,43 @@ var EntityLabel;
             };
             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 = EntityUtils.IsAssemblyPart(known) ? known : null;
+            if (!entity && this.api) {
+                try {
+                    entity = (await Entity$1.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 = 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 = EntityUtils.GetTilesetRootFrame(this.tilesetPart.tileset);
+            const inverse = Matrix4.inverseTransformation(this.tilesetPart.record, new Matrix4());
+            return drawn ? Matrix4.multiply(drawn, inverse, inverse) : null;
+        }
         /*
          * Reads the record's geometry box, preferring an entity a label group already hydrated.
          */
@@ -9416,21 +9464,17 @@ var EntityLabelGroup;
 (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 = Cartographic.fromCartesian(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 ? Math$1.toDegrees(cartographic.longitude) : location === null || location === void 0 ? void 0 : location.longitude,
-            latitude: cartographic ? Math$1.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
         };
     }
@@ -9543,7 +9587,8 @@ var EntityLabelGroup;
             const response = await 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
             };
         };
@@ -9896,7 +9941,7 @@ var EntityLabelGroup;
             }
         }
         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) {
@@ -9913,19 +9958,22 @@ var EntityLabelGroup;
                 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
+                ? Cartesian3.fromDegrees(item.longitude, item.latitude, item.altitude || 0)
+                : null);
+            if (!position) {
                 return;
             }
             const visual = new Entity({
-                position: Cartesian3.fromDegrees(item.longitude, item.latitude, item.altitude || 0),
+                position: position,
                 point: { heightReference: HeightReference.NONE, pixelSize: 0 }
             });
             this.standalone.set(entityId, new 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 });
@@ -9934,6 +9982,41 @@ var EntityLabelGroup;
             }));
             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 (!EntityUtils.GetAssemblyPartPos3d({ viewer, entity })) {
+                return null;
+            }
+            let last = null;
+            return new CallbackProperty((time) => {
+                var _a, _b, _c;
+                const at = JulianDate.toDate(time !== null && time !== void 0 ? time : viewer.clock.currentTime).getTime();
+                const simulated = (_b = (_a = EntitySimulation.Get(viewer)) === null || _a === void 0 ? void 0 : _a.ApplyAt(entity, at)) !== null && _b !== void 0 ? _b : entity;
+                last = (_c = 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 EntityUtils.GetTilesetRootFrame(tileset);
+                }
+            }
+            return null;
+        }
         Remove(id) {
             var _a;
             const known = this.definitions.delete(id);
@@ -23523,7 +23606,9 @@ var TilesetCadRenderManager;
                     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();
         }
@@ -38270,7 +38355,7 @@ var ViewRenderEngine;
         if (!bookmark) {
             let bookmarkId = params.bookmarkId;
             if (!bookmarkId) {
-                bookmarkId = view.DefaultUISlideID;
+                bookmarkId = view["Default.UISlide.ID"];
             }
             bookmark = bookmarkId ? (await ProjectViewBookmark.Get({
                 api,
@@ -38331,7 +38416,7 @@ var ViewRenderEngine;
         if (!bookmark) {
             let bookmarkId = params.bookmarkId;
             if (!bookmarkId) {
-                bookmarkId = view.DefaultUISlideID;
+                bookmarkId = view["Default.UISlide.ID"];
             }
             bookmark = bookmarkId ? (await ProjectViewBookmark.Get({
                 api,
@@ -44112,37 +44197,46 @@ class WidgetNavCompass$$1 extends Widget.AWidget {
 
 const CESIUM_VIEWER_MANAGER_KEY = "_cesiumViewerManager";
 const CESIUM_VIEWER_EVENT_TRACKER_KEY = "_cesiumViewerEventTracker";
-/**
- * Bug related to entities not being visible after they were added then a render was requested.
- * It was 4 point entities in York. They would not appear until a request render was recalled.
- * Adding this slow render loop as a band-aid fix.
- */
 const BACKGROUND_RENDERING_KEY = "_backgroundRendering";
+// How long after the scene last drew it is drawn once more.
+const FOLLOW_UP_RENDER_MS = 3000;
+/*
+ * Draws once more a few seconds after the scene last drew, for graphics not ready by the render that asked for them.
+ */
 function backgroundRendering(viewer) {
     if (viewer[BACKGROUND_RENDERING_KEY]) {
         return;
     }
     viewer[BACKGROUND_RENDERING_KEY] = true;
+    // Wall time, since scene.lastRenderTime is the scene clock's and stands still while the clock is paused.
+    let lastRenderAt = performance.now();
+    // Whether the last render was the follow up, so a still scene is drawn once more rather than forever.
+    let followedUp = false;
+    let requested = false;
+    const removeListener = viewer.scene.postRender.addEventListener(() => {
+        lastRenderAt = performance.now();
+        followedUp = requested;
+        requested = false;
+    });
     const interval = setInterval(() => {
         var _a;
         if (!(viewer === null || viewer === void 0 ? void 0 : viewer.cesiumWidget) || !(viewer === null || viewer === void 0 ? void 0 : viewer.scene) || viewer.isDestroyed()) {
             clearInterval(interval);
+            removeListener();
             return;
         }
         // We'll ignore the call if the viewer container is not visible.
         if (!viewer.container || ((_a = viewer.container.style) === null || _a === void 0 ? void 0 : _a.display) == "none") {
             return;
         }
+        if (followedUp || requested || performance.now() - lastRenderAt < FOLLOW_UP_RENDER_MS) {
+            return;
+        }
         try {
-            // Check if last render time is greater than 3 seconds ago.
-            // We check in case something else is also requesting renders.
-            const lastRenderTime = viewer.scene.lastRenderTime;
-            if (!lastRenderTime || JulianDate.secondsDifference(JulianDate.now(), lastRenderTime) > 3) {
-                // Check if window is active/in focus.
-                // TODO: Should render the moment it is in focus as well.
-                if (document.hasFocus()) {
-                    viewer.scene.requestRender();
-                }
+            // Only while the window has focus. TODO: should render the moment it regains focus as well.
+            if (document.hasFocus()) {
+                requested = true;
+                viewer.scene.requestRender();
             }
         }
         catch (e) {
@@ -44543,6 +44637,47 @@ function calcEntityLocation(entity, modelSpace) {
     }
     return Matrix4.multiplyByPoint(enuFrame, new Cartesian3(tx, ty, tz), new 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) ? 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 ? Matrix4.multiply(parent, local, new Matrix4()) : matrixFromRows(bruce === null || bruce === void 0 ? void 0 : bruce.AssemblyWorldPosition);
+    if (world && (!pivot || pivot.every(Number.isFinite))) {
+        return Matrix4.multiplyByPoint(world, pivot ? Cartesian3.fromArray(pivot) : Cartesian3.ZERO, new 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) ? 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 ? Cartesian3.fromDegrees(0, 0, 0) : 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 = Transforms.eastNorthUpToFixedFrame(origin);
+    Matrix4.multiply(frame, Matrix4.fromTranslation(new Cartesian3(EnsureNumber(transform.x), EnsureNumber(transform.y), EnsureNumber(transform.z))), frame);
+    const hpr = HeadingPitchRoll.fromDegrees(EnsureNumber(transform.heading), EnsureNumber(transform.pitch), EnsureNumber(transform.roll));
+    return Matrix4.multiply(frame, Matrix4.fromRotation(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.
@@ -44588,6 +44723,61 @@ function getModelBoundsCenter(viewer, part, pos3d, bounds) {
 const _assemblyAxisShift = new Quaternion(0, 0, -Math.SQRT1_2, Math.SQRT1_2);
 var EntityUtils;
 (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, ViewUtils.GetModelSpace(viewer));
+        return offset && frame ? Matrix4.multiplyByPoint(frame, offset, new 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 = Matrix4.getScale(transform, new Cartesian3());
+        if (!(scale.x > 0)) {
+            return null;
+        }
+        return Matrix4.multiplyByUniformScale(transform, 1 / scale.x, new Matrix4());
+    }
+    EntityUtils.GetTilesetRootFrame = GetTilesetRootFrame;
     /**
      * Returns the location for given entity or entities.
      * If available it will also compute a rectangle.
@@ -46450,6 +46640,418 @@ function OneTimeError(key, message) {
     }
 }
 
+/**
+ * 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 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 = Transforms.eastNorthUpToFixedFrame(pos3d);
+        const rad = Math$1.toRadians(heading);
+        const local = new Cartesian3(Math.sin(rad), Math.cos(rad), 0);
+        const world = Matrix4.multiplyByPointAsVector(enu, local, new Cartesian3());
+        return 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 = Math$1.toRadians(orientation.heading);
+        const p = Math$1.toRadians(orientation.pitch);
+        const r = Math$1.toRadians(orientation.roll);
+        const forward = new Cartesian3(Math.sin(h) * Math.cos(p), Math.cos(h) * Math.cos(p), Math.sin(p));
+        const level = new Cartesian3(Math.cos(h), -Math.sin(h), 0);
+        const up = Cartesian3.cross(level, forward, new Cartesian3());
+        // Positive roll lowers the right side.
+        const right = Cartesian3.add(Cartesian3.multiplyByScalar(level, Math.cos(r), new Cartesian3()), Cartesian3.multiplyByScalar(up, -Math.sin(r), new Cartesian3()), new Cartesian3());
+        const enu = Transforms.eastNorthUpToFixedFrame(pos3d);
+        const toWorld = (local) => {
+            const world = Matrix4.multiplyByPointAsVector(enu, local, new Cartesian3());
+            return 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 = 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, Cartesian3.distance(camera, pos3d) * 0.01);
+        const ahead = Cartesian3.add(pos3d, Cartesian3.multiplyByScalar(axis, step, new Cartesian3()), new Cartesian3());
+        const from = project(viewer.scene, pos3d, new Cartesian2());
+        const to = project(viewer.scene, ahead, new 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 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 DrawingUtils.GetDrawnPos3d({
+            viewer,
+            heightRef,
+            pos3d,
+            terrainId: 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 == 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 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 CallbackProperty(() => GetCValue(viewer, parent.position), false);
+        const displayCondition = EntityRenderEngine.GetDisplayCondition(params.minDistance, params.maxDistance);
+        const pixelOffset = new 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 Entity({
+                id: 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 ConstantProperty(image.canvasDataUri);
+            ring.billboard.width = new ConstantProperty(image.size);
+            ring.billboard.height = new ConstantProperty(image.size);
+            ring.billboard.rotation = rotationProp;
+            ring.billboard.heightReference = new ConstantProperty(heightRef);
+            ring.billboard.pixelOffset = new ConstantProperty(pixelOffset);
+            ring.billboard.distanceDisplayCondition = new ConstantProperty(displayCondition);
+            ring.position = position;
+            ring.show = true;
+        }
+        CesiumEntityStyler.BakeDefaultColor({
+            entity: ring,
+            viewer,
+            colors: {
+                "billboard": 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 = Color.fromCssColorString(RING_CSS);
+        let last = [];
+        let basisAt = null;
+        let basis = null;
+        const positions = new CallbackProperty(() => {
+            const drawn = getDrawnPos3d(viewer, parent, heightRef);
+            if (!drawn) {
+                return last;
+            }
+            // The local frame only changes when the point moves.
+            if (!basisAt || !Cartesian3.equals(basisAt, drawn)) {
+                basis = GetBasis(drawn, orientation);
+                basisAt = Cartesian3.clone(drawn);
+            }
+            const scale = radiusPx * getMetresPerPixel(viewer, drawn);
+            if (!isFinite(scale) || scale <= 0) {
+                return last;
+            }
+            last = outline.map(([u, v]) => {
+                const point = Cartesian3.multiplyByScalar(basis.forward, u * scale, new Cartesian3());
+                Cartesian3.add(point, Cartesian3.multiplyByScalar(basis.right, v * scale, new Cartesian3()), point);
+                return Cartesian3.add(point, drawn, point);
+            });
+            return last;
+        }, false);
+        const displayCondition = 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 Entity({
+                id: ObjectUtils.UId(15),
+                polyline: {
+                    positions,
+                    width: RING_STROKE,
+                    material: color,
+                    arcType: 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 CallbackProperty(() => GetCValue(viewer, parent.position), false),
+                show: true
+            });
+        }
+        else {
+            ring.polyline.positions = positions;
+            ring.polyline.distanceDisplayCondition = new ConstantProperty(displayCondition);
+            ring.show = true;
+        }
+        CesiumEntityStyler.SetDefaultColor({
+            color,
+            entity: ring,
+            viewer,
+            override: true,
+            requestRender: false
+        });
+        return ring;
+    }
+})(EntityRenderEnginePointOrientation || (EntityRenderEnginePointOrientation = {}));
+
 /**
  * Handles point rendering.
  */
@@ -46491,14 +47093,21 @@ var EntityRenderEnginePoint;
         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 = 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];
@@ -46510,7 +47119,7 @@ var EntityRenderEnginePoint;
                     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 = () => {
@@ -46763,6 +47372,11 @@ var EntityRenderEnginePoint;
                     }
                     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
+                    };
                 }
             }
         }
@@ -47136,6 +47750,7 @@ var EntityRenderEnginePoint;
                 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.
@@ -47185,6 +47800,31 @@ var EntityRenderEnginePoint;
             }
             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 = StyleEffective.Combine(styleTraceParts);
         return cEntity;
@@ -47319,7 +47959,8 @@ const createImageBillboard = (url) => {
         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);
@@ -55584,7 +56225,7 @@ var StyleUtils;
     StyleUtils.ApplyTypeStyle = ApplyTypeStyle;
 })(StyleUtils || (StyleUtils = {}));
 
-const VERSION = "7.6.3";
+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.