cesium-multi-target-framework 0.1.0

package/dist/render/PointCloudRenderer.d.ts

@@ -0,0 +1,135 @@
+import { Cartesian3, Scene } from 'cesium';
+import { RenderPacket } from '../worker/protocol';
+import { LabelConfig, LabelStyleConfig, NameplateContext } from '../config/types';
+
+export interface PointCloudRenderTypeStyle {
+    type: string;
+    targetDomain?: "surface" | "air" | "underwater";
+    iconPath: string;
+    defaultColor: string;
+    pointHeadingOffset?: number;
+    lowModel?: PointCloudRenderModelStyle;
+    highModel?: PointCloudRenderModelStyle;
+    lowModelUrl?: string;
+    highModelUrl?: string;
+    scale?: number;
+    modelHeadingOffset?: number;
+    modelPitchOffset?: number;
+    modelRollOffset?: number;
+    predictMove?: boolean;
+    predictMinCameraHeight?: number;
+}
+export interface PointCloudRenderModelStyle {
+    url: string;
+    scale?: number;
+    headingOffset?: number;
+    pitchOffset?: number;
+    rollOffset?: number;
+    runAnimations?: boolean;
+    animationLoop?: "none" | "repeat" | "mirroredRepeat";
+    animationMultiplier?: number;
+}
+export interface PointCloudRendererOptions {
+    targetTypes?: PointCloudRenderTypeStyle[];
+    label?: LabelConfig;
+    labelTextResolver?: LabelTextResolver;
+}
+export type LabelResolveResult = string | string[] | {
+    text: string | string[];
+    style?: Partial<LabelStyleConfig>;
+} | null | undefined;
+export type LabelTextResolver = (ctx: NameplateContext) => LabelResolveResult;
+/**
+ * 三角方向点对照版：使用 Cesium BillboardCollection 复用三角贴图。
+ * 相比 PointPrimitive，它可以通过 rotation 表示 heading。
+ */
+export declare class PointCloudRenderer {
+    private readonly scene;
+    private readonly glowCollection;
+    private readonly collection;
+    private readonly labelCollection;
+    private readonly pool;
+    private readonly glowPool;
+    private readonly labelPool;
+    private readonly typeStyles;
+    private labelConfig;
+    private labelTextResolver;
+    private readonly imageIds;
+    private readonly imageUrls;
+    private readonly processedImages;
+    private readonly glowImage;
+    private readonly labelImageCache;
+    private readonly glowSourceIndexes;
+    private readonly labelSourceIndexes;
+    private readonly labelIds;
+    private readonly labelSmoothStarts;
+    private readonly labelSmoothTargets;
+    private readonly labelSmoothElapsedSec;
+    private readonly labelSmoothDurationSec;
+    private readonly labelScales;
+    private readonly labelTargetScales;
+    private readonly labelPositionsById;
+    private readonly labelScalesById;
+    private readonly labelLastClearVisibleAt;
+    private labelVisibleIds;
+    private readonly poolCategories;
+    private readonly poolIds;
+    private readonly poolHeadings;
+    private readonly poolMerged;
+    private readonly colorCache;
+    private readonly glowColorCache;
+    private readonly smoothStarts;
+    private readonly smoothTargets;
+    private readonly smoothElapsedSec;
+    private readonly smoothDurationSec;
+    private readonly baseWidths;
+    private readonly baseHeights;
+    private readonly pointScales;
+    private modelTargetIds;
+    private modelHandoffEnabled;
+    private anchorPositionResolver;
+    private readonly anchorPositionScratch;
+    private directionalExternal;
+    private targetVisible;
+    private visibleCount;
+    private glowActiveCount;
+    private labelActiveCount;
+    private glowPhase;
+    private readonly labelRtcRef;
+    private readonly labelRtcScratch;
+    constructor(scene: Scene, _fadeMs: number, options?: PointCloudRendererOptions);
+    setPacket(packet: RenderPacket): void;
+    clear(): void;
+    getTargetFrame(id: string, result?: Cartesian3): {
+        position: Cartesian3;
+        heading: number;
+    } | undefined;
+    update(_dtSec: number): void;
+    setPointLayerVisible(visible: boolean): void;
+    /** 单目标有向图标是否交由外部(实例化符号层)渲染。开启后本渲染器对 count===1 的条目不显示 billboard，
+     *  仍保留 merged 簇 billboard、glow、姓名版。 */
+    setDirectionalHandledExternally(external: boolean): void;
+    private slotVisible;
+    setModelTargetIds(ids: readonly string[], handoffEnabled?: boolean): void;
+    setAnchorPositionResolver(resolver: ((id: string, result: Cartesian3) => Cartesian3 | undefined) | null): void;
+    private syncLabelRtcReference;
+    private updateLabelPosition;
+    setLabelOptions(label: LabelConfig, labelTextResolver?: LabelTextResolver): void;
+    get pointLayerVisible(): boolean;
+    get heatmapActive(): boolean;
+    destroy(): void;
+    private ensurePool;
+    private ensureGlowPool;
+    private ensureLabelPool;
+    private applyLabelStyle;
+    private setLabelPosition;
+    private updateLabelScale;
+    private trimInactiveLabels;
+    private selectLabelInfos;
+    private labelImageOf;
+    private isLabelWithinOcclusionGrace;
+    private hideUnused;
+    private hideUnusedGlows;
+    private hideUnusedLabels;
+    private preprocessImages;
+}

package/dist/render/SelectionOverlayRenderer.d.ts

@@ -0,0 +1,37 @@
+import { Cartesian3, Scene } from 'cesium';
+import { ResolvedNodeTypeConfig } from '../config/types';
+import { RenderPacket } from '../worker/protocol';
+
+export interface SelectionTargetRef {
+    id: string;
+    position: Cartesian3;
+    size: number;
+}
+export declare class SelectionOverlayRenderer {
+    private readonly scene;
+    private readonly renderTypes;
+    private readonly collection;
+    private readonly pool;
+    private readonly baseSizes;
+    private readonly selectedIds;
+    private readonly pulseElapsedById;
+    private hoveredId;
+    private lastPacket;
+    private activeCount;
+    private readonly selectionImage;
+    private readonly hoverImage;
+    private readonly hoverBillboard;
+    constructor(scene: Scene, renderTypes: readonly ResolvedNodeTypeConfig[]);
+    setSelectedIds(ids: readonly string[]): void;
+    setPacket(packet: RenderPacket): void;
+    setHoveredId(id: string | null): void;
+    update(dtSec: number): void;
+    getRenderedTarget(id: string): SelectionTargetRef | undefined;
+    clear(): void;
+    destroy(): void;
+    private refresh;
+    private ensurePool;
+    private hideUnused;
+    private refreshHover;
+    private overlaySizeOf;
+}

package/dist/render/targetVisualMetrics.d.ts

@@ -0,0 +1,9 @@
+export interface TargetVisualDimensions {
+    width: number;
+    height: number;
+    maxDimension: number;
+}
+export declare const TARGET_OVERLAY_SIZE_MULTIPLIER = 1.75;
+export declare const TARGET_OVERLAY_MIN_SIZE = 36;
+export declare function targetVisualDimensionsOf(type: string, packetSize: number, merged?: boolean): TargetVisualDimensions;
+export declare function targetOverlaySizeOf(type: string, packetSize: number, merged?: boolean): number;

package/dist/site/SiteLayer.d.ts

@@ -0,0 +1,43 @@
+import { Cartesian2, Viewer } from 'cesium';
+import { EventEmitter } from '../core/EventEmitter';
+import { ResolvedSiteLayerOptions, SiteData, SiteLayerEvents, SiteLayerOptions, SiteRenderStats } from './types';
+
+export declare class SiteLayer extends EventEmitter<SiteLayerEvents> {
+    private readonly viewer;
+    readonly options: ResolvedSiteLayerOptions;
+    readonly stats: SiteRenderStats;
+    private readonly iconRenderer;
+    private readonly lowModelRenderer;
+    private readonly spatialIndex;
+    private readonly typeIndex;
+    private readonly typeColor;
+    private visibleSites;
+    private sites;
+    private screenPickIndex;
+    private hoverPosition;
+    private hoverRafId;
+    private lastHoverSiteId;
+    private destroyed;
+    private lastUpdateAt;
+    private lastFrameAt;
+    private rafId;
+    private readonly removeCameraListener;
+    private readonly inputHandler;
+    private readonly eventBusBinding;
+    constructor(viewer: Viewer, options: SiteLayerOptions);
+    /** 屏幕坐标拾取最近站点（实例化符号/低模无法 drillPick，按位置最近命中）。 */
+    pickAt(position: Cartesian2, thresholdPx?: number): SiteData | null;
+    setData(sites: SiteData[]): void;
+    clear(): void;
+    destroy(): void;
+    private tick;
+    private scheduleRefresh;
+    private refresh;
+    private handleContextMenuAt;
+    private scheduleHoverAt;
+    private flushHover;
+    private repickHover;
+    private clearHover;
+    private buildScreenPickIndex;
+    private nearestSiteAtScreen;
+}

package/dist/site/SiteLowModelRenderer.d.ts

@@ -0,0 +1,12 @@
+import { Scene } from 'cesium';
+import { ResolvedSiteTypeConfig, SiteData } from './types';
+
+export declare class SiteLowModelRenderer {
+    private readonly renderer;
+    private readonly typeByName;
+    constructor(scene: Scene, siteTypes: readonly ResolvedSiteTypeConfig[], fadeMs: number);
+    setSites(sites: readonly SiteData[]): void;
+    clear(): void;
+    update(dtSec: number): void;
+    destroy(): void;
+}

package/dist/site/SiteSpatialIndex.d.ts

@@ -0,0 +1,10 @@
+import { SiteData, SiteViewBounds } from './types';
+
+export declare class SiteSpatialIndex {
+    private readonly cellDeg;
+    private readonly buckets;
+    private sites;
+    constructor(cellDeg: number);
+    build(sites: readonly SiteData[]): void;
+    query(bounds: SiteViewBounds): number[];
+}

package/dist/site/types.d.ts

@@ -0,0 +1,72 @@
+import { Viewer, Cartesian3 } from 'cesium';
+import { ModelAssetConfig } from '../config/types';
+
+export type SiteCategory = "optical" | "radar" | "ais";
+export interface SiteTypeConfig {
+    type: string;
+    name?: string;
+    category: SiteCategory;
+    iconPath: string;
+    defaultColor?: string;
+    pointPixelSize?: number;
+    lowModel?: ModelAssetConfig;
+}
+export interface SiteData {
+    id: string;
+    type: string;
+    lon: number;
+    lat: number;
+    height: number;
+    heading?: number;
+    extra?: Record<string, unknown>;
+}
+export interface SiteLayerOptions {
+    siteTypes: SiteTypeConfig[];
+    modelSwitchHeight: number;
+    maxVisibleLowModels?: number;
+    updateThrottleMs?: number;
+    indexCellDeg?: number;
+    fadeMs?: number;
+}
+export interface ResolvedSiteTypeConfig extends SiteTypeConfig {
+    name: string;
+    defaultColor: string;
+    pointPixelSize: number;
+}
+export interface ResolvedSiteLayerOptions {
+    siteTypes: ResolvedSiteTypeConfig[];
+    siteTypesByType: Map<string, ResolvedSiteTypeConfig>;
+    modelSwitchHeight: number;
+    maxVisibleLowModels: number;
+    updateThrottleMs: number;
+    indexCellDeg: number;
+    fadeMs: number;
+}
+export interface SiteViewBounds {
+    west: number;
+    east: number;
+    south: number;
+    north: number;
+}
+export interface SiteRenderStats {
+    total: number;
+    inView: number;
+    iconCount: number;
+    lowModelCount: number;
+    lowModelEligibleCount: number;
+    mode: "icon" | "low-model";
+}
+export interface SiteLayerContext {
+    viewer: Viewer;
+}
+export interface SiteContextMenuPayload {
+    site: SiteData;
+    screenX: number;
+    screenY: number;
+    cartesian?: Cartesian3;
+}
+export interface SiteLayerEvents {
+    contextmenu: SiteContextMenuPayload;
+    pick: SiteData | null;
+    hover: SiteData | null;
+}

package/dist/track/TrackHoverPicker.d.ts

@@ -0,0 +1,26 @@
+import { Cartesian2, Cartesian3, Scene } from 'cesium';
+import { TrackPoint } from '../data/types';
+import { TrackHoverInfo } from './types';
+
+interface HoverPointRef {
+    targetId: string;
+    pointIndex: number;
+    point: TrackPoint;
+    position: Cartesian3;
+}
+export declare class TrackHoverPicker {
+    private readonly scene;
+    private readonly pixelThreshold;
+    private points;
+    private index;
+    private builtCameraPosition;
+    private builtCameraDirection;
+    private lastBuiltAt;
+    constructor(scene: Scene, pixelThreshold: number);
+    setPoints(points: readonly HoverPointRef[]): void;
+    invalidate(): void;
+    rebuild(): void;
+    pick(position: Cartesian2): TrackHoverInfo | null;
+    private ensureIndex;
+}
+export {};

package/dist/track/TrackManager.d.ts

@@ -0,0 +1,42 @@
+import { Viewer } from 'cesium';
+import { RenderPacket } from '../worker/protocol';
+import { EventEmitter } from '../core/EventEmitter';
+import { TrackManagerApi, TrackManagerEvents, TrackRecord } from './types';
+
+export declare class TrackManager extends EventEmitter<TrackManagerEvents> implements TrackManagerApi {
+    private readonly viewer;
+    private readonly records;
+    private readonly renderer;
+    private readonly hoverPicker;
+    private lastPacket;
+    private hoverPosition;
+    private lastPointerPosition;
+    private hoverRafId;
+    private rebuildHoverIndexTimer;
+    private currentHoverKey;
+    private readonly removeCameraListener;
+    private readonly onPointerMoveBound;
+    private readonly onPointerLeaveBound;
+    private readonly onPointerDownBound;
+    private readonly onWheelBound;
+    constructor(viewer: Viewer, pixelThreshold: number);
+    setTracks(tracks: readonly TrackRecord[]): void;
+    getTracks(targetIds?: readonly string[]): TrackRecord[];
+    showTracks(targetIds: readonly string[]): void;
+    hideTracks(targetIds: readonly string[]): void;
+    removeTracks(targetIds: readonly string[]): void;
+    clearTracks(): void;
+    setRenderPacket(packet: RenderPacket): void;
+    update(dtSec: number): void;
+    destroy(): void;
+    private setVisible;
+    private refresh;
+    private getVisibleRecords;
+    private toRenderRecords;
+    private onPointerMove;
+    private flushHoverPick;
+    private clearHover;
+    private scheduleHoverPick;
+    private scheduleHoverPickFromLastPointer;
+    private scheduleHoverIndexRebuild;
+}

package/dist/track/TrackRenderer.d.ts

@@ -0,0 +1,29 @@
+import { Cartesian3, Scene } from 'cesium';
+import { TrackPoint } from '../data/types';
+
+export interface TrackRenderRecord {
+    targetId: string;
+    points: TrackPoint[];
+    cartesianPoints: Cartesian3[];
+    currentPosition: Cartesian3 | null;
+}
+export declare class TrackRenderer {
+    private readonly scene;
+    private readonly historyCollection;
+    private readonly connectorCollection;
+    private readonly pointCollection;
+    private readonly linePool;
+    private readonly pointPool;
+    private lineCount;
+    private readonly pointImage;
+    constructor(scene: Scene);
+    setTracks(records: readonly TrackRenderRecord[]): void;
+    updateConnectors(records: readonly TrackRenderRecord[]): void;
+    clear(): void;
+    destroy(): void;
+    private ensureLinePool;
+    private ensurePoint;
+    private createLineSlot;
+    private hideUnusedLines;
+    private hideUnusedPoints;
+}

package/dist/track/types.d.ts

@@ -0,0 +1,27 @@
+import { TrackPoint } from '../data/types';
+
+export interface TrackRecord {
+    targetId: string;
+    visible?: boolean;
+    pointList?: TrackPoint[];
+    trackLine?: string;
+}
+export interface TrackHoverInfo {
+    targetId: string;
+    pointIndex: number;
+    point: TrackPoint;
+    screenX: number;
+    screenY: number;
+}
+export interface TrackManagerApi {
+    on<K extends keyof TrackManagerEvents>(event: K, handler: (payload: TrackManagerEvents[K]) => void): () => void;
+    setTracks(tracks: readonly TrackRecord[]): void;
+    getTracks(targetIds?: readonly string[]): TrackRecord[];
+    showTracks(targetIds: readonly string[]): void;
+    hideTracks(targetIds: readonly string[]): void;
+    removeTracks(targetIds: readonly string[]): void;
+    clearTracks(): void;
+}
+export interface TrackManagerEvents {
+    hover: TrackHoverInfo | null;
+}

package/dist/worker/protocol.d.ts

@@ -0,0 +1,182 @@
+import { IncrementalPayload, PackedTargetData, TargetData } from '../data/types';
+
+export interface ViewBounds {
+    west: number;
+    east: number;
+    south: number;
+    north: number;
+}
+export interface WorkerConfigPacket {
+    maxVisible: number;
+    rootLimit: number;
+    maxLevels: number;
+    cameraMergeBaseHeight: number;
+    cameraMergeStepHeight: number;
+    cameraMergeStepRadius: number;
+    globalViewportHeight: number;
+    globalCacheIntervalMs: number;
+    innerRatio: number;
+    viewportBufferRatio: number;
+    viewportBufferMinMeters: number;
+    pointAbove: number;
+    animatedBelow: number;
+    predictSeconds: number;
+    predictFitSeconds: number;
+    targetTypes: WorkerTargetTypeConfig[];
+}
+export interface WorkerTargetTypeConfig {
+    type: string;
+    category: number;
+    targetDomain: "surface" | "air" | "underwater";
+    forceHighModelInLowLod: boolean;
+    iconPath: string;
+    defaultColor: number;
+    smoothMove: boolean;
+    smoothMoveMinCameraHeight: number;
+    smoothMoveDurationMs: number;
+    predictMove: boolean;
+    predictMinCameraHeight: number;
+    predictSeconds?: number;
+    predictFitSeconds?: number;
+}
+export interface TargetStylePatch {
+    id: string;
+    styleKind?: "color" | "glow" | "hidden";
+    clearBefore?: boolean;
+    renderColor?: string;
+    openAnimate?: boolean;
+    animateType?: string;
+    animateColor?: string;
+    hidden?: boolean;
+}
+export interface TargetSnapshot {
+    id: string;
+    type: string;
+    lon: number;
+    lat: number;
+    height: number;
+    heading: number;
+    speedH: number;
+    renderColor: string;
+    openAnimate: boolean;
+    animateColor: string;
+    hidden: boolean;
+    nationality?: string;
+    customInfo?: Record<string, unknown>;
+}
+export type SceneWorkerRequest = {
+    type: "init";
+    config: WorkerConfigPacket;
+} | {
+    type: "stage-packed";
+    payload: PackedTargetData;
+} | {
+    type: "set-data";
+    targets: TargetData[];
+} | {
+    type: "incremental";
+    payload: IncrementalPayload;
+} | {
+    type: "realtime-upsert";
+    targets: TargetData[];
+} | {
+    type: "realtime-remove";
+    ids: string[];
+} | {
+    type: "style-patch";
+    patches: TargetStylePatch[];
+} | {
+    type: "target-query";
+    requestId: number;
+    id: string;
+} | {
+    type: "commit";
+    requestId: number;
+} | {
+    type: "viewport";
+    requestId: number;
+    bounds: ViewBounds;
+    global?: boolean;
+    cameraHeight: number;
+    cameraLon?: number;
+    cameraLat?: number;
+    cameraPitch?: number;
+    horizonCullDistance?: number;
+    maxRender: number;
+} | {
+    type: "destroy";
+};
+export interface WorkerRenderStats {
+    total: number;
+    level: number;
+    outsideLevel: number;
+    rawInView: number;
+    rawInBuffer: number;
+    rendered: number;
+    clusters: number;
+    lastMergeRadius: number;
+    pointCount: number;
+    lowModelCount: number;
+    highModelCount: number;
+    plainPointCount: number;
+    mergedPointCount: number;
+    mergedLowModelCount: number;
+    mergedHighModelCount: number;
+    forcedPointMode: boolean;
+}
+export interface RenderPacket {
+    requestId: number;
+    computeMs: number;
+    lon: Float64Array;
+    lat: Float64Array;
+    height: Float32Array;
+    heading: Float32Array;
+    speedH: Float32Array;
+    size: Float32Array;
+    count: Uint32Array;
+    flags: Uint8Array;
+    category: Uint8Array;
+    ids: string[];
+    moveDurationMs: Float32Array;
+    color: Uint32Array;
+    animation: Uint8Array;
+    animationColor: Uint32Array;
+    stats: WorkerRenderStats;
+}
+export type SceneWorkerResponse = {
+    type: "ready";
+} | {
+    type: "input";
+    kind: "packed" | "set-data" | "incremental";
+    upserts: number;
+    removes: number;
+    pendingBatches: number;
+} | {
+    type: "commit-done";
+    requestId: number;
+    added: number;
+    updated: number;
+    removed: number;
+    size: number;
+    computeMs: number;
+} | {
+    type: "realtime-done";
+    upserts: number;
+    removes: number;
+    size: number;
+    computeMs: number;
+} | {
+    type: "style-done";
+    updated: number;
+} | {
+    type: "target-info";
+    requestId: number;
+    target: TargetSnapshot | null;
+} | {
+    type: "viewport-cache-ready";
+    level: number;
+    buildMs: number;
+} | {
+    type: "render-done";
+    packet: RenderPacket;
+};

package/dist/worker/renderWorker.d.ts

@@ -0,0 +1 @@
+export {};