bruce-cesium 7.5.7 → 7.5.9

package/dist/types/rendering/render-managers/common/entity-label.d.ts

@@ -6,8 +6,8 @@ import { GetClusterIconPriority } from "./point-clustering-core";
  * Util for generating labels within cesium space on entities.
 */
 export declare namespace EntityLabel {
-    const ATTACH_KEY = "nextspace-navigator-entity-label";
-    interface IOptions {
+    export const ATTACH_KEY = "nextspace-navigator-entity-label";
+    export interface IOptions {
         presentation?: "text" | "icon" | "icon-text-above" | "icon-text-side";
         text?: string;
         icon?: string;
@@ -51,12 +51,12 @@ export declare namespace EntityLabel {
             representative?: "status" | "nearest";
         };
     }
-    function HasIcon(options: IOptions): boolean;
-    function IsImageUrl(value: string): boolean;
-    function GetDefaultImageUrl(entity: Entity.IEntity, api?: BruceApi.Api): string;
-    function WithPhoto(options: IOptions, url: string): IOptions;
-    function PhotoShape(width: number, height: number): "circle" | "rect";
-    interface IHoverRingState {
+    export function HasIcon(options: IOptions): boolean;
+    export function IsImageUrl(value: string): boolean;
+    export function GetDefaultImageUrl(entity: Entity.IEntity, api?: BruceApi.Api): string;
+    export function WithPhoto(options: IOptions, url: string): IOptions;
+    export function PhotoShape(width: number, height: number): "circle" | "rect";
+    export interface IHoverRingState {
         animation?: {
             target: number;
             targetInner: number;
@@ -70,7 +70,14 @@ export declare namespace EntityLabel {
             arcTime?: number;
         };
     }
-    interface IFrame {
+    export interface IModelBoxFrame {
+        points: TPoint[];
+        hull: TPoint[];
+        outline: TPoint[];
+        anchor: TPoint;
+        group: string;
+    }
+    export interface IFrame {
         canFlip?: boolean;
         textWrapped?: boolean;
         hasLeader?: boolean;
@@ -82,6 +89,8 @@ export declare namespace EntityLabel {
         leaderSide?: "left" | "right";
         distance?: number;
         iconRadius?: number;
+        modelBox?: IModelBoxFrame;
+        boxBlend?: number;
         id: string;
         text?: string;
         clusterBounds?: {
@@ -104,8 +113,8 @@ export declare namespace EntityLabel {
         priority?: number;
         options?: IOptions;
     }
-    type TIconLook = Pick<IOptions, "icon" | "iconUrl" | "iconClass" | "iconColor" | "iconBackground" | "iconPhoto">;
-    interface IPlacement {
+    export type TIconLook = Pick<IOptions, "icon" | "iconUrl" | "iconClass" | "iconColor" | "iconBackground" | "iconPhoto">;
+    export interface IPlacement {
         textSide?: "left" | "right";
         icons?: TIconLook[];
         frame: IFrame;
@@ -116,7 +125,7 @@ export declare namespace EntityLabel {
         members: string[];
         entityIds: string[];
     }
-    class PlacementMemory {
+    export class PlacementMemory {
         private previous;
         private nextOrder;
         Resolve(frames: IFrame[]): Map<string, {
@@ -124,11 +133,111 @@ export declare namespace EntityLabel {
             side: "left" | "right";
         }>;
     }
-    const IconPriority: typeof GetClusterIconPriority;
-    function Layout(input: IFrame[], memory?: PlacementMemory): IPlacement[];
-    function compatibleMembers<T>(seed: T, nearby: T[], group: (item: T) => string, look: (item: T) => string): T[];
-    function SetContainer(viewer: Cesium.Viewer, container?: HTMLElement | null): void;
-    class Label {
+    export const IconPriority: typeof GetClusterIconPriority;
+    export function Layout(input: IFrame[], memory?: PlacementMemory): IPlacement[];
+    export function compatibleMembers<T>(seed: T, nearby: T[], group: (item: T) => string, look: (item: T) => string): T[];
+    interface IParticipant {
+        project: () => IFrame;
+        apply: (placement?: IPlacement) => void;
+    }
+    export function SetContainer(viewer: Cesium.Viewer, container?: HTMLElement | null): void;
+    class Layer {
+        private viewer;
+        readonly element: HTMLDivElement;
+        coordinates: {
+            x: number;
+            y: number;
+            scaleX: number;
+            scaleY: number;
+        };
+        private participants;
+        private failed;
+        private placementMemory;
+        readonly modelBoxes: ModelBoxes;
+        private remove;
+        private forwardingWheel;
+        private pendingDrag;
+        private horizon;
+        private horizonScratch;
+        pointer: {
+            x: number;
+            y: number;
+        };
+        private pointerClient;
+        constructor(viewer: Cesium.Viewer);
+        private TrackPointer;
+        private PointerOut;
+        private ClearPointer;
+        private PreventNativeDrag;
+        private BeginDrag;
+        private FinishPendingDrag;
+        private EndPendingDrag;
+        private ContinueDrag;
+        private ForwardWheel;
+        Move(): void;
+        private MeasureCoordinates;
+        Add(participant: IParticipant): () => void;
+        IsBeyondHorizon(position: Cesium.Cartesian3): boolean;
+        private UpdateHorizon;
+        private Update;
+        private logFailure;
+    }
+    type TVec3 = [number, number, number];
+    export interface IModelShape {
+        centre: TVec3;
+        axes: [TVec3, TVec3, TVec3];
+        half: TVec3;
+    }
+    export function ReadOrientedBox(entity: Entity.IEntity): IModelShape;
+    export function GetModelBox(entity: Entity.IEntity, shape?: IModelShape): Cesium.Cartesian3[];
+    type TPoint = {
+        x: number;
+        y: number;
+    };
+    export interface IModelSolid {
+        centre: TVec3;
+        axes: [TVec3, TVec3, TVec3];
+        half: TVec3;
+    }
+    export function ModelSolid(corners: Cesium.Cartesian3[], origin: Cesium.Cartesian3): IModelSolid;
+    export function ModelSolidsTouch(a: IModelSolid, b: IModelSolid): boolean;
+    export function ModelBoxOutline(solids: IModelSolid[]): [TVec3, TVec3][];
+    export function HullsNear(a: TPoint[], b: TPoint[], margin: number): boolean;
+    interface IModelBoxRequest {
+        whole: boolean;
+        from: TPoint;
+        opacity: number;
+        zIndex: number;
+        color: string;
+        duration: number;
+    }
+    interface IModelBoxEntry {
+        selected: () => boolean;
+        hovered: () => boolean;
+        near: () => boolean;
+    }
+    export class ModelBoxes {
+        private entries;
+        private groups;
+        private hovered;
+        private outlines;
+        private hulls;
+        private frames;
+        private drawn;
+        private since;
+        private requests;
+        private looks;
+        private memberLooks;
+        Set(id: string, corners: Cesium.Cartesian3[], entityId: string, inputs: IModelBoxEntry): void;
+        Frame(id: string): IModelBoxFrame;
+        Hull(id: string): TPoint[];
+        Request(id: string, request: IModelBoxRequest): void;
+        private group;
+        Resolve(viewer: Cesium.Viewer, pointer?: TPoint): void;
+        Draw(viewer: Cesium.Viewer, element: HTMLElement, coordinates: Layer["coordinates"]): void;
+        private drawGroup;
+    }
+    export class Label {
         private id;
         private options;
         private groupId;
@@ -139,6 +248,8 @@ export declare namespace EntityLabel {
         private retainedHoverPosition;
         private ringAnimation;
         private cursorMotion;
+        private modelBox;
+        private boxMorph;
         private hoverRingState;
         SetHoverVisible(visible: boolean): void;
         private HoverOpacity;
@@ -197,6 +308,8 @@ export declare namespace EntityLabel {
         private buildIcon;
         private buildPhoto;
         private renderFor;
+        private loadModelBox;
+        private morphToBox;
         /**
          * Removes label from the viewer and unsubscribes from events.
          */
@@ -206,7 +319,7 @@ export declare namespace EntityLabel {
      * Creates an entity label for a given rego.
      * If one exists then the action is ignored.
      */
-    function Attach(params: {
+    export function Attach(params: {
         rego: VisualsRegister.IVisualRego;
         viewer: Cesium.Viewer;
         pos3d?: Cesium.Cartesian3;
@@ -223,7 +336,7 @@ export declare namespace EntityLabel {
      * Removes an entity label from a given rego.
      * If one doesn't exist then the action is ignored.
      */
-    function Detatch(params: {
+    export function Detatch(params: {
         rego?: VisualsRegister.IVisualRego;
         label?: Label;
         force?: boolean;
@@ -233,7 +346,8 @@ export declare namespace EntityLabel {
      * @param params
      * @returns
      */
-    function GetLabel(params: {
+    export function GetLabel(params: {
         rego: VisualsRegister.IVisualRego;
     }): Label;
+    export {};
 }

package/dist/types/rendering/texture-frame-series-animator.d.ts

@@ -179,6 +179,26 @@ export declare namespace TextureFrameSeriesAnimator {
         produceValueCanvas?: boolean;
         drapeExtent?: IExtent;
         maskBaseline?: boolean;
+        cacheBytes?: number;
+    }
+    function DilateValues(value: Uint8ClampedArray, width: number, height: number, passes: number, packed: boolean): void;
+    /**
+     * One frame's value pixels, the shape a label reads cells out of.
+     */
+    interface IValueRaster {
+        data: Uint8ClampedArray;
+        width: number;
+        height: number;
+    }
+    /**
+     * Two value frames and how far a fade between them has got, from 0 at the first to 1 at the second.
+     */
+    interface IValueFade {
+        from: Uint8ClampedArray | null;
+        to: Uint8ClampedArray;
+        width: number;
+        height: number;
+        mix: number;
     }
     class Animator {
         private readonly viewer;
@@ -228,6 +248,15 @@ export declare namespace TextureFrameSeriesAnimator {
         private extremesLoad;
         private floorPixels;
         private ceilingPixels;
+        private readonly valueOnly;
+        private fadeMix;
+        private fadeMixStart;
+        private valueCanvasVersion;
+        private rawCache;
+        private rawBytes;
+        private cachedBytes;
+        private lastFrameBytes;
+        private readonly cacheBudget;
         constructor(options: IOptions);
         /**
          * Explicit teardown: stops driving the entity's material, abandons any in-flight/pending fetch (results are simply ignored when they land),
@@ -258,6 +287,14 @@ export declare namespace TextureFrameSeriesAnimator {
          * or null unless the instance was constructed with produceValueCanvas.
          */
         GetValueCanvas(): HTMLCanvasElement | null;
+        /**
+         * The presented frame's value pixels, or null before one. Shares the cached array, so never write to it.
+         */
+        GetValueRaster(): IValueRaster | null;
+        /**
+         * The two value frames being faded between and the mix, or null unless the material is not driven.
+         */
+        GetValueFade(): IValueFade | null;
         /**
          * Increments every time a frame is presented, so a consumer holding the value canvas can tell
          * whether it needs re-uploading without diffing pixels or subscribing to anything.
@@ -268,6 +305,9 @@ export declare namespace TextureFrameSeriesAnimator {
         private swapToFrame;
         private ensureFrame;
         private nearestUncachedFrame;
+        private farthestCachedDistance;
+        private evictDecoded;
+        private keepRaw;
         private pumpFetchQueue;
         private fetchAndTint;
         private shouldPresent;
@@ -310,6 +350,8 @@ export declare namespace TextureFrameSeriesAnimator {
          */
         private applyBaselineMask;
         private beginCrossfadeTo;
+        private beginValueFadeTo;
+        private requestRender;
         private tickCrossfade;
         private presentPixels;
     }

package/dist/types/rendering/texture-value-labels.d.ts

@@ -1,5 +1,6 @@
 import * as Cesium from "cesium";
 import { TextureFrameSeriesAnimator } from "./texture-frame-series-animator";
+import { VisualsRegister } from "./visuals-register";
 /**
  * Prints a value texture's own numbers over the cells they belong to.
  */
@@ -35,6 +36,22 @@ export declare namespace TextureValueLabels {
         South: number;
         North: number;
     }
+    /**
+     * Value pixels, one texel per cell, value in R (and G when packed) and coverage in A.
+     */
+    interface IRaster {
+        data: Uint8ClampedArray;
+        width: number;
+        height: number;
+    }
+    /**
+     * Who the hover label is shown for, and the register that owns hover labels.
+     */
+    interface IHoverTarget {
+        register: VisualsRegister.Register;
+        entityId: string;
+        menuItemId?: string;
+    }
     interface IOptions {
         viewer: Cesium.Viewer;
         extent: IExtent;
@@ -45,6 +62,9 @@ export declare namespace TextureValueLabels {
             lon: number;
             lat: number;
         }[];
+        heightAt?: (lon: number, lat: number) => number | null;
+        heightKey?: () => unknown;
+        hover?: IHoverTarget;
     }
     /**
      * One cell's numbers, in the attribute's own units.
@@ -72,7 +92,7 @@ export declare namespace TextureValueLabels {
      */
     function ReadingAt(params: {
         metadata?: TextureFrameSeriesAnimator.IFrameArchiveMetadata;
-        source: ImageData;
+        source: IRaster;
         floor?: ImageData | null;
         ceiling?: ImageData | null;
         at: number;
@@ -110,23 +130,44 @@ export declare namespace TextureValueLabels {
         private clipRing?;
         private source;
         private painted;
+        private paintedRamp;
         private floor;
         private ceiling;
+        private readonly heightAt?;
+        private readonly heightKey?;
+        private readonly hover?;
         private disposed;
-        private drawn;
         private stride;
+        private readonly cellLabels;
+        private lingerTimer;
+        private drawnView;
+        private drawnInputs;
+        private readonly scratchWorld;
+        private readonly scratchWindow;
+        private readonly scratchClip;
+        private viewProjection;
+        private readonly viewProjectionScratch;
+        private hovering;
+        private hoverFrame;
+        private hoverAt;
+        private readonly onPointerMove;
+        private readonly onPointerLeave;
         constructor(options: IOptions);
         SetExtent(extent: IExtent): void;
         /**
-         * The current frame's decoded values, as the animator's value canvas already provides them.
+         * The current frame's decoded values.
          * @param source value pixels, one texel per cell
          */
-        SetSource(source: ImageData | null): void;
+        SetSource(source: IRaster | null): void;
         /**
          * The tinted pixels of the same frame, so the grid can skip cells the ramp painted nothing in.
-         * @param painted RGBA of the presented frame, or null to fall back to coverage alone
+         * @param painted RGBA of the presented frame, or null to fall back to the ramp or coverage alone
          */
         SetPainted(painted: Uint8ClampedArray | null): void;
+        /**
+         * The surface's 256 step RGBA ramp, for telling whether a cell was painted without a tinted frame.
+         */
+        SetPaintedRamp(ramp: Uint8Array | null): void;
         /**
          * The archive's per-cell extremes, when it publishes them. Without these a label can still
          * print the current reading, just not the range behind it.
@@ -136,26 +177,33 @@ export declare namespace TextureValueLabels {
         Clear(): void;
         Dispose(): void;
         /**
-         * Redraws every visible label. Cheap enough to call per rendered frame, because the cell
-         * count it considers is bounded by the view rather than by the texture.
+         * Redraws the grid and syncs the value labels, when anything they are drawn from has changed.
          */
         Render(): void;
+        private labelCells;
+        private syncCellLabels;
+        private clearCellLabels;
+        private updateHover;
+        private releaseHover;
+        private readingUnder;
+        private cellUnder;
         private drawGrid;
         private applyRingClip;
-        private tileCellOutline;
         private drawTileGrid;
         private groundAtScreenCentre;
         private coveredAt;
         private isCovered;
-        private widestLabel;
-        private cellOutline;
-        private drawLabel;
+        private labelLines;
         private readNear;
         private paintedAt;
         private readAt;
+        private texelAt;
         private lonAt;
         private latAt;
         private visibleTexels;
+        private surfaceHeight;
+        private projectCell;
         private project;
+        private projectInto;
     }
 }

package/dist/types/rendering/visuals-register.d.ts

@@ -576,9 +576,16 @@ export declare namespace VisualsRegister {
                 y: number;
             };
             createIfMissing?: boolean;
+            text?: string;
+            pos3d?: Cesium.Cartesian3;
         } | null): void;
         ClearLabelHover: () => void;
         private CheckLabelHoverBounds;
+        GetLabelHoverTarget(): Readonly<{
+            entityId: string;
+            menuItemId?: string;
+        }> | undefined;
+        IsLabelHovered(entityId: string, menuItemId?: string): boolean;
         GetLabelHoverPosition(entityId: string, menuItemId?: string): Readonly<{
             x: number;
             y: number;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bruce-cesium",
-  "version": "7.5.7",
+  "version": "7.5.9",
   "description": "",
   "keywords": [],
   "main": "dist/bruce-cesium.umd.js",
@@ -83,7 +83,7 @@
     "typescript": "^5.0.4"
   },
   "dependencies": {
-    "bruce-models": "^7.1.118",
+    "bruce-models": "^7.1.120",
     "tslib": "^2.4.1"
   }
 }