cesium-multi-target-framework 0.1.0

package/dist/data/types.d.ts

@@ -0,0 +1,67 @@
+export interface TrackPoint {
+    lon: number;
+    lat: number;
+    height: number;
+    time: number;
+    heading?: number;
+    speed?: number;
+    source?: string;
+}
+export interface TargetData {
+    id: string;
+    type: string;
+    lon: number;
+    lat: number;
+    height: number;
+    speedH: number;
+    speedV: number;
+    heading: number;
+    /** 目标渲染颜色，标准格式为 #RRGGBB 或 #RRGGBBAA。 */
+    renderColor?: string;
+    /** 是否打开目标动画效果。 */
+    openAnimate?: boolean;
+    /** 动画类型，当前内置支持 "glow" 和 "发光"。 */
+    animateType?: string;
+    /** 动画颜色，不传时沿用 renderColor 或类型默认色。 */
+    animateColor?: string;
+    nationality?: string;
+    customInfo?: Record<string, unknown>;
+    track?: TrackPoint[];
+    secrecy?: number;
+    extra?: Record<string, unknown>;
+}
+export type StandardTargetData = TargetData;
+export interface IncrementalPayload {
+    upserts?: TargetData[];
+    removes?: string[];
+}
+export interface PackedTargetData {
+    replacePending?: boolean;
+    /** 首包/结构变化时提供；后续仅坐标更新可省略，沿用 worker 内已有 id 顺序 */
+    ids?: string[];
+    types?: string[] | string;
+    lon: Float64Array;
+    lat: Float64Array;
+    height?: Float32Array;
+    speedH?: Float32Array;
+    speedV?: Float32Array;
+    heading?: Float32Array;
+    secrecy?: Int16Array;
+    /** 每个目标的 0xRRGGBB 渲染颜色；不传则沿用 worker 内已有颜色或类型默认色。 */
+    renderColor?: Uint32Array;
+    /** 0=无动画，1=发光。 */
+    animate?: Uint8Array;
+    /** 每个目标的 0xRRGGBB 动画颜色。 */
+    animateColor?: Uint32Array;
+    removes?: string[];
+}
+export interface PackedDiffResult {
+    added?: PackedTargetData;
+    updated?: PackedTargetData;
+    removed: string[];
+}
+export interface DiffResult {
+    added: TargetData[];
+    updated: TargetData[];
+    removed: string[];
+}

package/dist/events/bus.d.ts

@@ -0,0 +1,336 @@
+import { EventBus, RegisterOptions } from 'web-event-bus';
+import { Cartesian2 } from 'cesium';
+import { ContextMenuContext, ContextMenuItemRegistration, LocateTargetOptions, MultiTargetFramework, TargetIdInput, TargetStyleOptions } from '../core/MultiTargetFramework';
+import { SceneEvents } from '../core/MultiTargetScene';
+import { IncrementalPayload, StandardTargetData } from '../data/types';
+import { LabelConfig } from '../config/types';
+import { SiteData, SiteLayerEvents } from '../site/types';
+import { SiteLayer } from '../site/SiteLayer';
+import { TrackManagerEvents, TrackRecord } from '../track/types';
+
+export declare const MTF_EVENT_NAMES: {
+    readonly scene: {
+        readonly perf: "mtf.scene.perf";
+        readonly dirty: "mtf.scene.dirty";
+        readonly packedDirty: "mtf.scene.packedDirty";
+        readonly pick: "mtf.scene.pick";
+        readonly hover: "mtf.scene.hover";
+        readonly selection: "mtf.scene.selection";
+        readonly contextmenu: "mtf.scene.contextmenu";
+    };
+    readonly track: {
+        readonly hover: "mtf.track.hover";
+    };
+    readonly site: {
+        readonly contextmenu: "mtf.site.contextmenu";
+        readonly pick: "mtf.site.pick";
+        readonly hover: "mtf.site.hover";
+    };
+};
+export declare const MTF_ACTION_NAMES: {
+    readonly framework: {
+        readonly addTarget: "mtf.framework.addTarget";
+        readonly updateTarget: "mtf.framework.updateTarget";
+        readonly setTargetData: "mtf.framework.setTargetData";
+        readonly upsertTargetData: "mtf.framework.upsertTargetData";
+        readonly removeTargetData: "mtf.framework.removeTargetData";
+        readonly applyTargetIncremental: "mtf.framework.applyTargetIncremental";
+        readonly setTargetColor: "mtf.framework.setTargetColor";
+        readonly setTargetGlow: "mtf.framework.setTargetGlow";
+        readonly hideTarget: "mtf.framework.hideTarget";
+        readonly showTarget: "mtf.framework.showTarget";
+        readonly disappearTarget: "mtf.framework.disappearTarget";
+        readonly appearTarget: "mtf.framework.appearTarget";
+        readonly setNameplateConfig: "mtf.framework.setNameplateConfig";
+        readonly selectTarget: "mtf.framework.selectTarget";
+        readonly selectTargets: "mtf.framework.selectTargets";
+        readonly unselectTarget: "mtf.framework.unselectTarget";
+        readonly clearSelection: "mtf.framework.clearSelection";
+        readonly boxTarget: "mtf.framework.boxTarget";
+        readonly unboxTarget: "mtf.framework.unboxTarget";
+        readonly locateTarget: "mtf.framework.locateTarget";
+        readonly registerContextMenuItem: "mtf.framework.registerContextMenuItem";
+        readonly showContextMenu: "mtf.framework.showContextMenu";
+        readonly closeContextMenu: "mtf.framework.closeContextMenu";
+        readonly destroy: "mtf.framework.destroy";
+    };
+    readonly tracks: {
+        readonly setTracks: "mtf.tracks.setTracks";
+        readonly getTracks: "mtf.tracks.getTracks";
+        readonly showTracks: "mtf.tracks.showTracks";
+        readonly hideTracks: "mtf.tracks.hideTracks";
+        readonly removeTracks: "mtf.tracks.removeTracks";
+        readonly clearTracks: "mtf.tracks.clearTracks";
+    };
+    readonly site: {
+        readonly setData: "mtf.site.setData";
+        readonly clear: "mtf.site.clear";
+        readonly pickAt: "mtf.site.pickAt";
+        readonly destroy: "mtf.site.destroy";
+    };
+};
+export interface FrameworkBusEventMap {
+    [MTF_EVENT_NAMES.scene.perf]: SceneEvents["perf"];
+    [MTF_EVENT_NAMES.scene.dirty]: SceneEvents["dirty"];
+    [MTF_EVENT_NAMES.scene.packedDirty]: SceneEvents["packedDirty"];
+    [MTF_EVENT_NAMES.scene.pick]: SceneEvents["pick"];
+    [MTF_EVENT_NAMES.scene.hover]: SceneEvents["hover"];
+    [MTF_EVENT_NAMES.scene.selection]: SceneEvents["selection"];
+    [MTF_EVENT_NAMES.scene.contextmenu]: SceneEvents["contextmenu"];
+    [MTF_EVENT_NAMES.track.hover]: TrackManagerEvents["hover"];
+    [MTF_EVENT_NAMES.site.contextmenu]: SiteLayerEvents["contextmenu"];
+    [MTF_EVENT_NAMES.site.pick]: SiteLayerEvents["pick"];
+    [MTF_EVENT_NAMES.site.hover]: SiteLayerEvents["hover"];
+}
+export interface FrameworkBusActionMap {
+    [MTF_ACTION_NAMES.framework.addTarget]: {
+        params: {
+            target: StandardTargetData;
+        };
+        result: StandardTargetData;
+    };
+    [MTF_ACTION_NAMES.framework.updateTarget]: {
+        params: {
+            target: StandardTargetData;
+        };
+        result: StandardTargetData;
+    };
+    [MTF_ACTION_NAMES.framework.setTargetData]: {
+        params: {
+            targets: StandardTargetData[];
+        };
+        result: void;
+    };
+    [MTF_ACTION_NAMES.framework.upsertTargetData]: {
+        params: {
+            targets: StandardTargetData[];
+        };
+        result: void;
+    };
+    [MTF_ACTION_NAMES.framework.removeTargetData]: {
+        params: {
+            ids: string[];
+        };
+        result: void;
+    };
+    [MTF_ACTION_NAMES.framework.applyTargetIncremental]: {
+        params: {
+            payload: IncrementalPayload;
+        };
+        result: void;
+    };
+    [MTF_ACTION_NAMES.framework.setTargetColor]: {
+        params: {
+            id: TargetIdInput;
+            color: string;
+            options?: TargetStyleOptions;
+        };
+        result: void;
+    };
+    [MTF_ACTION_NAMES.framework.setTargetGlow]: {
+        params: {
+            id: TargetIdInput;
+            enabled: boolean;
+            color?: string;
+            options?: TargetStyleOptions;
+        };
+        result: void;
+    };
+    [MTF_ACTION_NAMES.framework.hideTarget]: {
+        params: {
+            id: TargetIdInput;
+            options?: TargetStyleOptions;
+        };
+        result: void;
+    };
+    [MTF_ACTION_NAMES.framework.showTarget]: {
+        params: {
+            id: TargetIdInput;
+            options?: TargetStyleOptions;
+        };
+        result: void;
+    };
+    [MTF_ACTION_NAMES.framework.disappearTarget]: {
+        params: {
+            id: TargetIdInput;
+            options?: TargetStyleOptions;
+        };
+        result: void;
+    };
+    [MTF_ACTION_NAMES.framework.appearTarget]: {
+        params: {
+            id: TargetIdInput;
+            options?: TargetStyleOptions;
+        };
+        result: void;
+    };
+    [MTF_ACTION_NAMES.framework.setNameplateConfig]: {
+        params: {
+            config: LabelConfig;
+        };
+        result: void;
+    };
+    [MTF_ACTION_NAMES.framework.selectTarget]: {
+        params: {
+            id: string;
+            options?: TargetStyleOptions;
+        };
+        result: Awaited<ReturnType<MultiTargetFramework["selectTarget"]>>;
+    };
+    [MTF_ACTION_NAMES.framework.selectTargets]: {
+        params: {
+            ids: readonly string[];
+            options?: TargetStyleOptions;
+        };
+        result: Awaited<ReturnType<MultiTargetFramework["selectTargets"]>>;
+    };
+    [MTF_ACTION_NAMES.framework.unselectTarget]: {
+        params: {
+            id: string;
+        };
+        result: void;
+    };
+    [MTF_ACTION_NAMES.framework.clearSelection]: {
+        params: undefined;
+        result: void;
+    };
+    [MTF_ACTION_NAMES.framework.boxTarget]: {
+        params: {
+            id: TargetIdInput;
+            enabled?: boolean;
+            options?: TargetStyleOptions;
+        };
+        result: void;
+    };
+    [MTF_ACTION_NAMES.framework.unboxTarget]: {
+        params: {
+            id: TargetIdInput;
+            options?: TargetStyleOptions;
+        };
+        result: void;
+    };
+    [MTF_ACTION_NAMES.framework.locateTarget]: {
+        params: {
+            id: string;
+            options?: LocateTargetOptions;
+        };
+        result: Awaited<ReturnType<MultiTargetFramework["locateTarget"]>>;
+    };
+    [MTF_ACTION_NAMES.framework.registerContextMenuItem]: {
+        params: {
+            item: ContextMenuItemRegistration;
+        };
+        result: () => void;
+    };
+    [MTF_ACTION_NAMES.framework.showContextMenu]: {
+        params: {
+            context: ContextMenuContext;
+        };
+        result: Awaited<ReturnType<MultiTargetFramework["showContextMenu"]>>;
+    };
+    [MTF_ACTION_NAMES.framework.closeContextMenu]: {
+        params: undefined;
+        result: void;
+    };
+    [MTF_ACTION_NAMES.framework.destroy]: {
+        params: undefined;
+        result: void;
+    };
+    [MTF_ACTION_NAMES.tracks.setTracks]: {
+        params: {
+            tracks: readonly TrackRecord[];
+        };
+        result: void;
+    };
+    [MTF_ACTION_NAMES.tracks.getTracks]: {
+        params: {
+            targetIds?: readonly string[];
+        } | undefined;
+        result: TrackRecord[];
+    };
+    [MTF_ACTION_NAMES.tracks.showTracks]: {
+        params: {
+            targetIds: readonly string[];
+        };
+        result: void;
+    };
+    [MTF_ACTION_NAMES.tracks.hideTracks]: {
+        params: {
+            targetIds: readonly string[];
+        };
+        result: void;
+    };
+    [MTF_ACTION_NAMES.tracks.removeTracks]: {
+        params: {
+            targetIds: readonly string[];
+        };
+        result: void;
+    };
+    [MTF_ACTION_NAMES.tracks.clearTracks]: {
+        params: undefined;
+        result: void;
+    };
+    [MTF_ACTION_NAMES.site.setData]: {
+        params: {
+            sites: SiteData[];
+        };
+        result: void;
+    };
+    [MTF_ACTION_NAMES.site.clear]: {
+        params: undefined;
+        result: void;
+    };
+    [MTF_ACTION_NAMES.site.pickAt]: {
+        params: {
+            position: Cartesian2;
+            thresholdPx?: number;
+        };
+        result: SiteData | null;
+    };
+    [MTF_ACTION_NAMES.site.destroy]: {
+        params: undefined;
+        result: void;
+    };
+}
+export type FrameworkEventName = keyof FrameworkBusEventMap;
+export type FrameworkEventPayload<K extends FrameworkEventName> = FrameworkBusEventMap[K];
+export type FrameworkEventListener<K extends FrameworkEventName> = (payload: FrameworkBusEventMap[K]) => void;
+export type FrameworkBusActionName = keyof FrameworkBusActionMap;
+export type FrameworkBusActionParams<K extends FrameworkBusActionName> = FrameworkBusActionMap[K]["params"];
+export type FrameworkBusActionResult<K extends FrameworkBusActionName> = FrameworkBusActionMap[K]["result"];
+export interface FrameworkEventBus extends Omit<EventBus, "emit" | "on" | "off" | "register" | "invoke"> {
+    emit<K extends FrameworkEventName>(action: K, params: FrameworkBusEventMap[K]): void;
+    emit(action: string, params?: unknown): void;
+    on<K extends FrameworkEventName>(action: K, listener: FrameworkEventListener<K>): () => void;
+    on(action: string, listener: (params?: unknown) => void): () => void;
+    off<K extends FrameworkEventName>(action: K, listener: FrameworkEventListener<K>): void;
+    off(action: string, listener: (params?: unknown) => void): void;
+    register<K extends FrameworkBusActionName>(action: K, handler: (params: FrameworkBusActionParams<K>) => FrameworkBusActionResult<K> | Promise<FrameworkBusActionResult<K>>, options?: RegisterOptions): void;
+    register(action: string, handler: (params?: unknown) => unknown | Promise<unknown>, options?: RegisterOptions): void;
+    invoke<K extends FrameworkBusActionName>(action: K, params: FrameworkBusActionParams<K>): Promise<FrameworkBusActionResult<K>>;
+    invoke<T = unknown>(action: string, params?: unknown): Promise<T>;
+}
+export interface FrameworkBusBinding {
+    readonly active: boolean;
+    readonly owner: string;
+    dispose(): void;
+}
+export interface BindFrameworkEventBusOptions {
+    bus?: FrameworkEventBus;
+    owner?: string;
+    registerActions?: boolean;
+    bridgeEvents?: boolean;
+    replaceExisting?: boolean;
+}
+export interface BindSiteLayerEventBusOptions {
+    bus?: FrameworkEventBus;
+    owner?: string;
+    registerActions?: boolean;
+    bridgeEvents?: boolean;
+    replaceExisting?: boolean;
+}
+export declare function getFrameworkEventBus(): FrameworkEventBus;
+export declare function tryGetFrameworkEventBus(): FrameworkEventBus | null;
+export declare function createFrameworkEventBus(): FrameworkEventBus;
+export declare function bindFrameworkEventBus(framework: MultiTargetFramework, options?: BindFrameworkEventBusOptions): FrameworkBusBinding;
+export declare function bindSiteLayerEventBus(siteLayer: SiteLayer, options?: BindSiteLayerEventBusOptions): FrameworkBusBinding;

package/dist/index.d.ts

@@ -0,0 +1,22 @@
+export declare const VERSION = "0.2.0";
+export * from 'cesium';
+export { MultiTargetScene } from './core/MultiTargetScene';
+export type { PickedNodeLike, SceneContextMenuPayload, SceneEvents, SceneNodeStats, ScenePerfEvent, TickPerfEvent, WrappedScene, ResolvedConfig, } from './core/MultiTargetScene';
+export { createMultiTargetFramework, MultiTargetFramework } from './core/MultiTargetFramework';
+export type { ContextMenuContext, ContextMenuGroundTarget, ContextMenuItemRegistration, ContextMenuSiteTarget, ContextMenuTarget, ContextMenuTargetKind, ContextMenuTargetTarget, LocateTargetOptions, MultiTargetFrameworkApi, MultiTargetFrameworkOptions, MultiTargetTypeConfig, TargetIdInput, TargetStyleOptions, } from './core/MultiTargetFramework';
+export { EventEmitter } from './core/EventEmitter';
+export { bindFrameworkEventBus, bindSiteLayerEventBus, createFrameworkEventBus, getFrameworkEventBus, MTF_ACTION_NAMES, MTF_EVENT_NAMES, tryGetFrameworkEventBus, } from './events/bus';
+export type { BindFrameworkEventBusOptions, BindSiteLayerEventBusOptions, FrameworkBusActionMap, FrameworkBusActionName, FrameworkBusActionParams, FrameworkBusActionResult, FrameworkBusBinding, FrameworkBusEventMap, FrameworkEventBus, FrameworkEventListener, FrameworkEventName, FrameworkEventPayload, } from './events/bus';
+export { TrackManager } from './track/TrackManager';
+export type { TrackManagerApi, TrackManagerEvents, TrackHoverInfo, TrackRecord } from './track/types';
+export { SiteLayer } from './site/SiteLayer';
+export type { RenderedTargetFrame } from './render/ModelPoolRenderer';
+export type { TargetSnapshot, TargetStylePatch } from './worker/protocol';
+export type { SiteContextMenuPayload, SiteCategory, SiteData, SiteLayerEvents, SiteLayerOptions, SiteRenderStats, ResolvedSiteLayerOptions, ResolvedSiteTypeConfig, SiteLayerContext, SiteTypeConfig, SiteViewBounds, } from './site/types';
+export type { TargetData, StandardTargetData, TrackPoint, IncrementalPayload, PackedTargetData, PackedDiffResult, DiffResult, } from './data/types';
+export type { SceneConfig, ModelAssetConfig, NodeTypeConfig, LodConfig, PoolConfig, MergeConfig, PickConfig, CullConfig, HorizonCullConfig, LabelConfig, LabelFieldConfig, LabelFieldSource, LabelStyleConfig, LabelTypeConfig, NameplateContext, ResolvedLabelConfig, FrameConfig, DataPipelineConfig, AdaptiveConfig, QualityTier, AnimatedPoolConfig, TargetDomain, } from './config/types';
+export { DEFAULT_ANIMATED_POOL, DEFAULT_LOD, DEFAULT_POOL, DEFAULT_SCENE, TARGET_DOMAINS } from './config/types';
+export { createClusterWorkerClient } from './cluster/clusterClient';
+export type { ClusterWorkerClient, ClusterJobResult } from './cluster/clusterClient';
+export { createQuadClusterer, clusterProgressive, lonLatToLocalPlane, } from './cluster/QuadCluster';
+export type { QuadClusterer, ProgressiveClusterResult, ProgressiveClusterOptions, LocalPlane, LevelStat, } from './cluster/QuadCluster';

package/dist/render/AirGroundReferenceRenderer.d.ts

@@ -0,0 +1,20 @@
+import { Cartesian3, Scene } from 'cesium';
+
+export interface AirGroundReferenceTarget {
+    id: string;
+    position: Cartesian3;
+    visualScale: number;
+}
+export declare class AirGroundReferenceRenderer {
+    private readonly scene;
+    private readonly lineCollection;
+    private readonly pointCollection;
+    private readonly pool;
+    constructor(scene: Scene);
+    setTargets(targets: AirGroundReferenceTarget[]): void;
+    clear(): void;
+    destroy(): void;
+    private ensurePool;
+    private createSlot;
+    private updateSlot;
+}

package/dist/render/InstancedGltfBatch.d.ts

@@ -0,0 +1,37 @@
+import { Cartesian3, Scene } from 'cesium';
+
+/**
+ * InstancedGltfBatch
+ * ------------------
+ * 把一个**静态** glTF（忽略动画/蒙皮）合并成一份几何 + 贴图，按实例 modelMatrix 做 GPU
+ * 实例化绘制（自定义 DrawCommand + instanceDivisor）。作为 Cesium Primitive 加入
+ * scene.primitives，命令在场景 FBO 内执行 → 与地形/3DTiles 原生正确遮挡、移动不穿模。
+ * 一个 glTF URL 一个 batch；每实例一个 mat4（已相对 RTC 中心）。
+ */
+export declare class InstancedGltfBatch {
+    readonly url: string;
+    private readonly scene;
+    private readonly capacity;
+    private readonly center;
+    private instMatrices;
+    private count;
+    private dirty;
+    ready: boolean;
+    show: boolean;
+    private groups;
+    private segments;
+    private built;
+    constructor(scene: Scene, url: string, capacity?: number);
+    /** matrices: Float32Array(count*16) 列主序，平移已相对 center。 */
+    setInstances(matrices: Float32Array, count: number, center: Cartesian3): void;
+    setVisible(v: boolean): void;
+    private load;
+    update(frameState: any): void;
+    private _mm?;
+    private _cols;
+    private columnView;
+    private build;
+    private makeTexture;
+    isDestroyed(): boolean;
+    destroy(): boolean;
+}

package/dist/render/InstancedSymbolRenderer.d.ts

@@ -0,0 +1,65 @@
+import { Cartesian3, Scene } from 'cesium';
+import { RenderPacket } from '../worker/protocol';
+import { PointCloudRenderTypeStyle } from './PointCloudRenderer';
+import * as Cesium from "cesium";
+export interface InstancedSymbolRendererOptions {
+    typeStyles: PointCloudRenderTypeStyle[];
+    capacity?: number;
+    pixelSize?: number;
+}
+/**
+ * 原生实例化"地表定向符号"渲染器（Cesium 自定义 Primitive）。
+ * 消费 RenderPacket，仅渲染 点档(lodKind 0) + 视野内 + 单目标(count===1) 的条目，
+ * 躺地表切平面、按航向定向、恒定像素；命令在场景 FBO 内执行 → 与地形/3DTiles/原生几何
+ * 正确遮挡、移动不穿模。merged 簇与低/高模仍由 PointCloudRenderer / ModelPoolRenderer 处理。
+ */
+export declare class InstancedSymbolRenderer {
+    private readonly scene;
+    private readonly capacity;
+    private readonly pixelSize;
+    private readonly iconCount;
+    private readonly headingOffsets;
+    private readonly center;
+    private readonly pos;
+    private readonly col;
+    private readonly ico;
+    private readonly ids;
+    private count;
+    private dirty;
+    private readonly idIndex;
+    private readonly headingById;
+    private cmd;
+    private posBuf;
+    private colBuf;
+    private icoBuf;
+    private texture;
+    private iconImages;
+    private iconReady;
+    show: boolean;
+    constructor(scene: Scene, options: InstancedSymbolRendererOptions);
+    setVisible(v: boolean): void;
+    /** 通用实例入口（站点等静态对象用）。color 为 [r,g,b,a] 0~1，可选。 */
+    setInstances(items: ReadonlyArray<{
+        id: string;
+        lon: number;
+        lat: number;
+        height?: number;
+        heading?: number;
+        color?: [number, number, number, number];
+        iconIndex?: number;
+    }>): void;
+    /** 每包重建实例（worker 已做裁剪/合并，packet 即当前应渲染集）。 */
+    setPacket(packet: RenderPacket): void;
+    getTargetFrame(id: string, result?: Cesium.Cartesian3): {
+        position: Cartesian3;
+        heading: number;
+    } | undefined;
+    /** Cesium 渲染管线每帧回调（通过 scene.primitives.add 自动调用）。 */
+    update(frameState: any): void;
+    private buildAtlas;
+    private build;
+    isDestroyed(): boolean;
+    destroy(): boolean;
+    private renderHeadingOf;
+    private clearSlotsFrom;
+}

package/dist/render/LowModelInstancedRenderer.d.ts

@@ -0,0 +1,39 @@
+import { Cartesian3, Scene } from 'cesium';
+import { PointCloudRenderModelStyle } from './PointCloudRenderer';
+
+export interface LowModelInstanceCandidate {
+    id: string;
+    url: string;
+    modelKey: string;
+    modelStyle: PointCloudRenderModelStyle;
+    position: Cartesian3;
+    heading: number;
+    smoothMove: boolean;
+    moveDurationMs: number;
+}
+/**
+ * 低模渲染器：按模型 URL 分组到 InstancedGltfBatch 做 **GPU 实例化**（静态网格、不播动画）。
+ * 目标低模(ModelPoolRenderer)与站点低模(SiteLowModelRenderer)共用本类，故两者一并获得实例化。
+ * 公开 API 与运动平滑保持不变。
+ */
+export declare class LowModelInstancedRenderer {
+    private readonly scene;
+    private readonly fadeMs;
+    private readonly renderIds;
+    private readonly states;
+    private readonly batches;
+    private readonly scratch;
+    private readonly center;
+    constructor(scene: Scene, fadeMs: number);
+    activeTargetIds(): string[];
+    setCandidates(candidates: LowModelInstanceCandidate[]): string[];
+    getTargetFrame(id: string, result?: Cartesian3): {
+        position: Cartesian3;
+        heading: number;
+    } | undefined;
+    update(dtSec: number): void;
+    clear(): void;
+    suspend(): void;
+    destroy(): void;
+    private applyCandidate;
+}

package/dist/render/ModelPoolRenderer.d.ts

@@ -0,0 +1,43 @@
+import { Cartesian3, Viewer } from 'cesium';
+import { RenderPacket } from '../worker/protocol';
+import { PointCloudRenderTypeStyle } from './PointCloudRenderer';
+
+export interface RenderedTargetFrame {
+    position: Cartesian3;
+    heading: number;
+}
+export declare class ModelPoolRenderer {
+    private readonly viewer;
+    private readonly styles;
+    private readonly lowCapacity;
+    private readonly highCapacity;
+    private readonly fadeMs;
+    private readonly lowModels;
+    private readonly airReferences;
+    private readonly renderIds;
+    private readonly states;
+    private readonly retiring;
+    private readonly scene;
+    private animationKeepAliveElapsedSec;
+    private lastLowRenderCount;
+    private lastHighRenderCount;
+    constructor(viewer: Viewer, styles: PointCloudRenderTypeStyle[], lowCapacity: number, highCapacity: number, _dynamicLowCapacity: number, fadeMs: number);
+    activeTargetIds(): string[];
+    renderStats(): {
+        low: number;
+        high: number;
+    };
+    getTargetFrame(id: string, result?: Cartesian3): RenderedTargetFrame | undefined;
+    setPacket(packet: RenderPacket): string[];
+    update(dtSec: number): void;
+    clear(): void;
+    suspend(): void;
+    destroy(): void;
+    private applyCandidate;
+    private loadModel;
+    private removeState;
+    private retireStateModel;
+    private ensureAnimationClock;
+    private ensureModelAnimations;
+    private updateAirReferences;
+}