@jorgmoritz/gis-manager 0.1.49 → 0.1.51

package/dist/index.cjs

@@ -13,7 +13,7 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
 // package.json
 var package_default = {
   name: "@jorgmoritz/gis-manager",
-  version: "0.1.48"};
+  version: "0.1.51"};
 
 // src/utils/version.ts
 var version = package_default.version;
@@ -1695,6 +1695,765 @@ var CameraManager = class {
   }
 };
 
+// src/core/terrain-manager/TerrainManager.ts
+var TerrainManager = class {
+  constructor(CesiumNS, viewer) {
+    this.CesiumNS = CesiumNS;
+    this.viewer = viewer;
+    /** 已注册的地形源 */
+    __publicField(this, "sources", /* @__PURE__ */ new Map());
+    /** 当前激活的地形源 ID */
+    __publicField(this, "activeSourceId", null);
+    /** 事件发射器 */
+    __publicField(this, "events", new Emitter());
+  }
+  /**
+   * 注册地形源
+   * @param config 地形源配置
+   */
+  register(config) {
+    if (this.sources.has(config.id)) {
+      console.warn(`[TerrainManager] \u5730\u5F62\u6E90 "${config.id}" \u5DF2\u5B58\u5728\uFF0C\u5C06\u88AB\u8986\u76D6`);
+    }
+    const normalizedConfig = {
+      requestVertexNormals: true,
+      requestWaterMask: true,
+      priority: 0,
+      ...config
+    };
+    this.sources.set(config.id, normalizedConfig);
+    this.events.emit({ registered: { config: normalizedConfig } });
+    console.log(`[TerrainManager] \u5DF2\u6CE8\u518C\u5730\u5F62\u6E90: ${config.id}`);
+  }
+  /**
+   * 批量注册地形源
+   * @param configs 地形源配置数组
+   */
+  registerBatch(configs) {
+    configs.forEach((config) => this.register(config));
+  }
+  /**
+   * 切换到指定地形源
+   * @param sourceId 地形源 ID
+   * @param options 切换选项
+   */
+  async switchTo(sourceId, options) {
+    const config = this.sources.get(sourceId);
+    if (!config) {
+      const error = `\u5730\u5F62\u6E90 "${sourceId}" \u672A\u6CE8\u518C`;
+      console.error(`[TerrainManager] ${error}`);
+      return { success: false, activeId: this.activeSourceId, error };
+    }
+    try {
+      const provider = await this.createTerrainProvider(config);
+      if (!provider) {
+        throw new Error("\u65E0\u6CD5\u521B\u5EFA\u5730\u5F62\u63D0\u4F9B\u8005");
+      }
+      const previousId = this.activeSourceId;
+      this.viewer.terrainProvider = provider;
+      this.activeSourceId = sourceId;
+      this.events.emit({ switched: { fromId: previousId, toId: sourceId } });
+      console.log(`[TerrainManager] \u5DF2\u5207\u6362\u5730\u5F62: ${previousId} -> ${sourceId}`);
+      if (options?.flyTo && config.bounds) {
+        await this.flyToBounds(config.bounds, options.flyDuration);
+      }
+      return { success: true, activeId: sourceId };
+    } catch (error) {
+      const errMsg = error instanceof Error ? error.message : String(error);
+      console.error(`[TerrainManager] \u5207\u6362\u5730\u5F62\u5931\u8D25:`, error);
+      this.events.emit({ error: { id: sourceId, error } });
+      return { success: false, activeId: this.activeSourceId, error: errMsg };
+    }
+  }
+  /**
+   * 获取当前激活的地形源配置
+   */
+  getActive() {
+    if (!this.activeSourceId) return null;
+    return this.sources.get(this.activeSourceId) ?? null;
+  }
+  /**
+   * 获取当前激活的地形源 ID
+   */
+  getActiveId() {
+    return this.activeSourceId;
+  }
+  /**
+   * 获取指定地形源配置
+   * @param sourceId 地形源 ID
+   */
+  get(sourceId) {
+    return this.sources.get(sourceId);
+  }
+  /**
+   * 获取所有已注册的地形源
+   */
+  list() {
+    return Array.from(this.sources.values());
+  }
+  /**
+   * 检查地形源是否已注册
+   * @param sourceId 地形源 ID
+   */
+  has(sourceId) {
+    return this.sources.has(sourceId);
+  }
+  /**
+   * 移除地形源
+   * @param sourceId 地形源 ID
+   */
+  remove(sourceId) {
+    if (!this.sources.has(sourceId)) {
+      return false;
+    }
+    if (this.activeSourceId === sourceId) {
+      this.reset();
+    }
+    this.sources.delete(sourceId);
+    this.events.emit({ removed: { id: sourceId } });
+    console.log(`[TerrainManager] \u5DF2\u79FB\u9664\u5730\u5F62\u6E90: ${sourceId}`);
+    return true;
+  }
+  /**
+   * 重置为椭球体（无地形）
+   */
+  reset() {
+    const C = this.CesiumNS;
+    const previousId = this.activeSourceId;
+    this.viewer.terrainProvider = new C.EllipsoidTerrainProvider();
+    this.activeSourceId = null;
+    this.events.emit({ switched: { fromId: previousId, toId: null } });
+    console.log(`[TerrainManager] \u5DF2\u91CD\u7F6E\u5730\u5F62\u4E3A\u692D\u7403\u4F53`);
+  }
+  /**
+   * 清除所有已注册的地形源
+   */
+  clear() {
+    this.reset();
+    this.sources.clear();
+    console.log(`[TerrainManager] \u5DF2\u6E05\u9664\u6240\u6709\u5730\u5F62\u6E90`);
+  }
+  /**
+   * 销毁管理器
+   */
+  destroy() {
+    this.clear();
+  }
+  /**
+   * 创建地形提供者
+   */
+  async createTerrainProvider(config) {
+    const C = this.CesiumNS;
+    switch (config.providerType) {
+      case "ellipsoid":
+        return new C.EllipsoidTerrainProvider();
+      case "cesium-ion": {
+        const assetId = config.ionAssetId ?? 1;
+        const IonResource = C.IonResource ?? C.Resource;
+        if (IonResource?.fromAssetId) {
+          const resource = await IonResource.fromAssetId(assetId);
+          return await C.CesiumTerrainProvider.fromUrl(resource, {
+            requestVertexNormals: config.requestVertexNormals,
+            requestWaterMask: config.requestWaterMask
+          });
+        }
+        if (C.createWorldTerrain) {
+          return C.createWorldTerrain({
+            requestVertexNormals: config.requestVertexNormals,
+            requestWaterMask: config.requestWaterMask
+          });
+        }
+        return void 0;
+      }
+      case "url": {
+        if (!config.url) {
+          throw new Error("URL \u7C7B\u578B\u5730\u5F62\u6E90\u5FC5\u987B\u63D0\u4F9B url");
+        }
+        return await C.CesiumTerrainProvider.fromUrl(config.url, {
+          requestVertexNormals: config.requestVertexNormals,
+          requestWaterMask: config.requestWaterMask
+        });
+      }
+      default:
+        return void 0;
+    }
+  }
+  /**
+   * 飞行到指定范围
+   */
+  async flyToBounds(bounds, duration = 2) {
+    const C = this.CesiumNS;
+    const [west, south, east, north] = bounds;
+    const centerLon = (west + east) / 2;
+    const centerLat = (south + north) / 2;
+    const lonSpan = Math.abs(east - west);
+    const latSpan = Math.abs(north - south);
+    const maxSpan = Math.max(lonSpan, latSpan);
+    const cameraHeight = Math.max(maxSpan * 111e3 * 1.5, 1e3);
+    let terrainHeight = 0;
+    try {
+      const terrainProvider = this.viewer.terrainProvider;
+      if (terrainProvider && !(terrainProvider instanceof C.EllipsoidTerrainProvider)) {
+        const positions = [C.Cartographic.fromDegrees(centerLon, centerLat)];
+        const sampledPositions = await C.sampleTerrainMostDetailed(terrainProvider, positions);
+        terrainHeight = sampledPositions[0]?.height || 0;
+      }
+    } catch {
+    }
+    this.viewer.camera.flyTo({
+      destination: C.Cartesian3.fromDegrees(centerLon, centerLat, terrainHeight + cameraHeight),
+      orientation: {
+        heading: C.Math.toRadians(0),
+        pitch: C.Math.toRadians(-45),
+        roll: 0
+      },
+      duration
+    });
+  }
+};
+
+// src/core/imagery-manager/ImageryManager.ts
+var ImageryManager = class {
+  constructor(CesiumNS, viewer) {
+    this.CesiumNS = CesiumNS;
+    this.viewer = viewer;
+    /** 已加载的图层 */
+    __publicField(this, "layers", /* @__PURE__ */ new Map());
+    /** 事件发射器 */
+    __publicField(this, "events", new Emitter());
+  }
+  /**
+   * 添加影像图层
+   * @param config 图层配置
+   * @param options 加载选项
+   */
+  async add(config, options) {
+    if (this.layers.has(config.id)) {
+      console.warn(`[ImageryManager] \u56FE\u5C42 "${config.id}" \u5DF2\u5B58\u5728\uFF0C\u5C06\u88AB\u66FF\u6362`);
+      this.remove(config.id);
+    }
+    try {
+      const provider = this.createImageryProvider(config);
+      if (!provider) {
+        throw new Error("\u65E0\u6CD5\u521B\u5EFA\u5F71\u50CF\u63D0\u4F9B\u8005");
+      }
+      const layer = this.viewer.imageryLayers.addImageryProvider(provider);
+      layer.alpha = config.opacity ?? 1;
+      layer.show = config.show ?? true;
+      layer._customId = config.id;
+      this.layers.set(config.id, { config, layer });
+      this.applyZIndex(config.id, config.zIndex ?? 0);
+      this.events.emit({ added: { config } });
+      console.log(`[ImageryManager] \u5DF2\u6DFB\u52A0\u56FE\u5C42: ${config.id}`);
+      if (options?.flyTo && config.bounds) {
+        await this.flyToBounds(config.bounds, options.flyDuration);
+      }
+      return { id: config.id, success: true };
+    } catch (error) {
+      const errMsg = error instanceof Error ? error.message : String(error);
+      console.error(`[ImageryManager] \u6DFB\u52A0\u56FE\u5C42\u5931\u8D25:`, error);
+      this.events.emit({ error: { id: config.id, error } });
+      return { id: config.id, success: false, error: errMsg };
+    }
+  }
+  /**
+   * 批量添加影像图层
+   * @param configs 图层配置数组
+   * @param options 加载选项
+   */
+  async addBatch(configs, options) {
+    const sorted = [...configs].sort((a, b) => (a.zIndex ?? 0) - (b.zIndex ?? 0));
+    const results = [];
+    for (const config of sorted) {
+      const result = await this.add(config, options);
+      results.push(result);
+    }
+    return results;
+  }
+  /**
+   * 移除影像图层
+   * @param layerId 图层 ID
+   */
+  remove(layerId) {
+    const entry = this.layers.get(layerId);
+    if (!entry) {
+      return false;
+    }
+    this.viewer.imageryLayers.remove(entry.layer, true);
+    this.layers.delete(layerId);
+    this.events.emit({ removed: { id: layerId } });
+    console.log(`[ImageryManager] \u5DF2\u79FB\u9664\u56FE\u5C42: ${layerId}`);
+    return true;
+  }
+  /**
+   * 设置图层可见性
+   * @param layerId 图层 ID
+   * @param visible 是否可见
+   */
+  setVisible(layerId, visible) {
+    const entry = this.layers.get(layerId);
+    if (!entry) {
+      return false;
+    }
+    entry.layer.show = visible;
+    entry.config.show = visible;
+    this.events.emit({ visibilityChanged: { id: layerId, visible } });
+    return true;
+  }
+  /**
+   * 设置图层透明度
+   * @param layerId 图层 ID
+   * @param opacity 透明度 0-1
+   */
+  setOpacity(layerId, opacity) {
+    const entry = this.layers.get(layerId);
+    if (!entry) {
+      return false;
+    }
+    const clampedOpacity = Math.max(0, Math.min(1, opacity));
+    entry.layer.alpha = clampedOpacity;
+    entry.config.opacity = clampedOpacity;
+    this.events.emit({ opacityChanged: { id: layerId, opacity: clampedOpacity } });
+    return true;
+  }
+  /**
+   * 调整图层顺序
+   * @param layerId 图层 ID
+   * @param zIndex 新的层级
+   */
+  reorder(layerId, zIndex) {
+    const entry = this.layers.get(layerId);
+    if (!entry) {
+      return false;
+    }
+    entry.config.zIndex = zIndex;
+    this.applyZIndex(layerId, zIndex);
+    this.events.emit({ orderChanged: { id: layerId, zIndex } });
+    return true;
+  }
+  /**
+   * 将图层移到最上层
+   * @param layerId 图层 ID
+   */
+  bringToTop(layerId) {
+    const entry = this.layers.get(layerId);
+    if (!entry) {
+      return false;
+    }
+    const imageryLayers = this.viewer.imageryLayers;
+    const currentIndex = imageryLayers.indexOf(entry.layer);
+    if (currentIndex >= 0 && currentIndex < imageryLayers.length - 1) {
+      for (let i = currentIndex; i < imageryLayers.length - 1; i++) {
+        imageryLayers.raise(entry.layer);
+      }
+    }
+    const maxZIndex = Math.max(...Array.from(this.layers.values()).map((e) => e.config.zIndex ?? 0));
+    entry.config.zIndex = maxZIndex + 1;
+    this.events.emit({ orderChanged: { id: layerId, zIndex: entry.config.zIndex } });
+    return true;
+  }
+  /**
+   * 将图层移到最下层
+   * @param layerId 图层 ID
+   */
+  sendToBottom(layerId) {
+    const entry = this.layers.get(layerId);
+    if (!entry) {
+      return false;
+    }
+    const imageryLayers = this.viewer.imageryLayers;
+    const currentIndex = imageryLayers.indexOf(entry.layer);
+    if (currentIndex > 0) {
+      for (let i = currentIndex; i > 0; i--) {
+        imageryLayers.lower(entry.layer);
+      }
+    }
+    const minZIndex = Math.min(...Array.from(this.layers.values()).map((e) => e.config.zIndex ?? 0));
+    entry.config.zIndex = minZIndex - 1;
+    this.events.emit({ orderChanged: { id: layerId, zIndex: entry.config.zIndex } });
+    return true;
+  }
+  /**
+   * 获取图层配置
+   * @param layerId 图层 ID
+   */
+  get(layerId) {
+    return this.layers.get(layerId)?.config;
+  }
+  /**
+   * 获取底层 Cesium ImageryLayer
+   * @param layerId 图层 ID
+   */
+  getLayer(layerId) {
+    return this.layers.get(layerId)?.layer;
+  }
+  /**
+   * 获取所有图层配置
+   */
+  list() {
+    return Array.from(this.layers.values()).map((e) => e.config);
+  }
+  /**
+   * 获取所有底图图层
+   */
+  listBaseLayers() {
+    return this.list().filter((c) => c.layerType === "base");
+  }
+  /**
+   * 获取所有叠加图层
+   */
+  listOverlays() {
+    return this.list().filter((c) => c.layerType === "overlay");
+  }
+  /**
+   * 检查图层是否存在
+   * @param layerId 图层 ID
+   */
+  has(layerId) {
+    return this.layers.has(layerId);
+  }
+  /**
+   * 清除所有叠加层（保留底图）
+   */
+  clearOverlays() {
+    const overlays = this.listOverlays();
+    overlays.forEach((config) => this.remove(config.id));
+    console.log(`[ImageryManager] \u5DF2\u6E05\u9664 ${overlays.length} \u4E2A\u53E0\u52A0\u5C42`);
+  }
+  /**
+   * 清除所有图层
+   */
+  clear() {
+    const ids = Array.from(this.layers.keys());
+    ids.forEach((id) => this.remove(id));
+    console.log(`[ImageryManager] \u5DF2\u6E05\u9664\u6240\u6709\u56FE\u5C42`);
+  }
+  /**
+   * 销毁管理器
+   */
+  destroy() {
+    this.clear();
+  }
+  /**
+   * 创建影像提供者
+   */
+  createImageryProvider(config) {
+    const C = this.CesiumNS;
+    const autoDetectedConfig = this.autoDetectTiandituWmts(config);
+    let rectangle;
+    if (autoDetectedConfig.bounds) {
+      let bounds = autoDetectedConfig.bounds;
+      if (Math.abs(bounds[1]) > 90 && Math.abs(bounds[2]) <= 90) {
+        bounds = [bounds[0], bounds[2], bounds[1], bounds[3]];
+      }
+      rectangle = C.Rectangle.fromDegrees(bounds[0], bounds[1], bounds[2], bounds[3]);
+    }
+    const minLevel = autoDetectedConfig.zoomRange?.min;
+    const maxLevel = autoDetectedConfig.zoomRange?.max;
+    switch (autoDetectedConfig.provider) {
+      case "urlTemplate":
+      case "tms":
+        return new C.UrlTemplateImageryProvider({
+          url: autoDetectedConfig.url,
+          minimumLevel: minLevel,
+          maximumLevel: maxLevel,
+          rectangle,
+          subdomains: autoDetectedConfig.subdomains
+        });
+      case "wmts":
+        if (!autoDetectedConfig.wmts) {
+          throw new Error("WMTS \u63D0\u4F9B\u8005\u9700\u8981 wmts \u914D\u7F6E");
+        }
+        return new C.WebMapTileServiceImageryProvider({
+          url: autoDetectedConfig.url,
+          layer: autoDetectedConfig.wmts.layer,
+          style: autoDetectedConfig.wmts.style ?? "default",
+          tileMatrixSetID: autoDetectedConfig.wmts.tileMatrixSetID,
+          format: autoDetectedConfig.wmts.format ?? "image/png",
+          subdomains: autoDetectedConfig.subdomains,
+          tilingScheme: new C.WebMercatorTilingScheme(),
+          maximumLevel: maxLevel
+        });
+      case "wms":
+        if (!autoDetectedConfig.wms) {
+          throw new Error("WMS \u63D0\u4F9B\u8005\u9700\u8981 wms \u914D\u7F6E");
+        }
+        return new C.WebMapServiceImageryProvider({
+          url: autoDetectedConfig.url,
+          layers: autoDetectedConfig.wms.layers,
+          parameters: autoDetectedConfig.wms.parameters,
+          rectangle
+        });
+      case "arcgis":
+        return new C.ArcGisMapServerImageryProvider({
+          url: autoDetectedConfig.url
+        });
+      default:
+        return void 0;
+    }
+  }
+  /**
+   * 自动检测天地图 WMTS 服务并补充配置
+   */
+  autoDetectTiandituWmts(config) {
+    const url = config.url;
+    const isTiandituWmts = url.includes("tianditu.gov.cn") && url.includes("wmts");
+    if (!isTiandituWmts) {
+      return config;
+    }
+    if (config.provider === "wmts" && config.wmts) {
+      return config;
+    }
+    const tk = url.match(/tk=([^&]+)/)?.[1] || "f44fcec420c3eb1c56656e9a22dabb17";
+    let layer = "img";
+    let baseUrl = url;
+    if (url.includes("/img_w/")) {
+      layer = "img";
+      baseUrl = `https://t{s}.tianditu.gov.cn/img_w/wmts?tk=${tk}`;
+    } else if (url.includes("/cia_w/")) {
+      layer = "cia";
+      baseUrl = `https://t{s}.tianditu.gov.cn/cia_w/wmts?tk=${tk}`;
+    } else if (url.includes("/vec_w/")) {
+      layer = "vec";
+      baseUrl = `https://t{s}.tianditu.gov.cn/vec_w/wmts?tk=${tk}`;
+    } else if (url.includes("/cva_w/")) {
+      layer = "cva";
+      baseUrl = `https://t{s}.tianditu.gov.cn/cva_w/wmts?tk=${tk}`;
+    } else if (url.includes("/ter_w/")) {
+      layer = "ter";
+      baseUrl = `https://t{s}.tianditu.gov.cn/ter_w/wmts?tk=${tk}`;
+    } else if (url.includes("/cta_w/")) {
+      layer = "cta";
+      baseUrl = `https://t{s}.tianditu.gov.cn/cta_w/wmts?tk=${tk}`;
+    }
+    console.log(`[ImageryManager] \u81EA\u52A8\u68C0\u6D4B\u5230\u5929\u5730\u56FE WMTS \u670D\u52A1: layer=${layer}`);
+    return {
+      ...config,
+      url: baseUrl,
+      provider: "wmts",
+      subdomains: config.subdomains || ["0", "1", "2", "3", "4", "5", "6", "7"],
+      wmts: {
+        layer,
+        style: "default",
+        tileMatrixSetID: "w",
+        format: "tiles"
+      },
+      zoomRange: config.zoomRange || { max: 18 }
+    };
+  }
+  /**
+   * 应用图层顺序
+   */
+  applyZIndex(layerId, zIndex) {
+    const entry = this.layers.get(layerId);
+    if (!entry) return;
+    const imageryLayers = this.viewer.imageryLayers;
+    const currentIndex = imageryLayers.indexOf(entry.layer);
+    if (currentIndex < 0) return;
+    const sortedEntries = Array.from(this.layers.entries()).map(([id, e]) => ({ id, zIndex: e.config.zIndex ?? 0, layer: e.layer })).sort((a, b) => a.zIndex - b.zIndex);
+    const targetIndex = sortedEntries.findIndex((e) => e.id === layerId);
+    if (targetIndex < 0) return;
+    const diff = targetIndex - currentIndex;
+    if (diff > 0) {
+      for (let i = 0; i < diff; i++) {
+        imageryLayers.raise(entry.layer);
+      }
+    } else if (diff < 0) {
+      for (let i = 0; i < -diff; i++) {
+        imageryLayers.lower(entry.layer);
+      }
+    }
+  }
+  /**
+   * 飞行到指定范围
+   */
+  async flyToBounds(bounds, duration = 2) {
+    const C = this.CesiumNS;
+    const [west, south, east, north] = bounds;
+    const centerLon = (west + east) / 2;
+    const centerLat = (south + north) / 2;
+    const lonSpan = Math.abs(east - west);
+    const latSpan = Math.abs(north - south);
+    const maxSpan = Math.max(lonSpan, latSpan);
+    const cameraHeight = Math.max(maxSpan * 111e3 * 1.2, 500);
+    this.viewer.camera.flyTo({
+      destination: C.Cartesian3.fromDegrees(centerLon, centerLat, cameraHeight),
+      orientation: {
+        heading: C.Math.toRadians(0),
+        pitch: C.Math.toRadians(-90),
+        roll: 0
+      },
+      duration
+    });
+  }
+};
+
+// src/core/tileset-manager/TilesetManager.ts
+var TilesetManager = class {
+  constructor(CesiumNS, viewer) {
+    this.CesiumNS = CesiumNS;
+    this.viewer = viewer;
+    /** 已加载的 Tileset */
+    __publicField(this, "tilesets", /* @__PURE__ */ new Map());
+    /** 事件发射器 */
+    __publicField(this, "events", new Emitter());
+  }
+  /**
+   * 添加 3D Tiles
+   * @param config Tileset 配置
+   * @param options 加载选项
+   */
+  async add(config, options) {
+    if (this.tilesets.has(config.id)) {
+      console.log(`[TilesetManager] Tileset "${config.id}" \u5DF2\u5B58\u5728\uFF0C\u8FD4\u56DE\u7F13\u5B58`);
+      return { id: config.id, success: true };
+    }
+    try {
+      const tileset = await this.createTileset(config);
+      if (!tileset) {
+        throw new Error("\u65E0\u6CD5\u521B\u5EFA Tileset");
+      }
+      this.viewer.scene.primitives.add(tileset);
+      tileset._customId = config.id;
+      tileset._url = config.url;
+      this.tilesets.set(config.id, { config, tileset });
+      this.events.emit({ added: { config } });
+      console.log(`[TilesetManager] \u5DF2\u6DFB\u52A0 Tileset: ${config.id}`);
+      if (options?.flyTo) {
+        await this.flyToTileset(tileset, options.flyDuration);
+      }
+      return { id: config.id, success: true };
+    } catch (error) {
+      const errMsg = error instanceof Error ? error.message : String(error);
+      console.error(`[TilesetManager] \u6DFB\u52A0 Tileset \u5931\u8D25:`, error);
+      this.events.emit({ error: { id: config.id, error } });
+      return { id: config.id, success: false, error: errMsg };
+    }
+  }
+  /**
+   * 移除 Tileset
+   * @param tilesetId Tileset ID
+   */
+  remove(tilesetId) {
+    const entry = this.tilesets.get(tilesetId);
+    if (!entry) {
+      return false;
+    }
+    this.viewer.scene.primitives.remove(entry.tileset);
+    this.tilesets.delete(tilesetId);
+    this.events.emit({ removed: { id: tilesetId } });
+    console.log(`[TilesetManager] \u5DF2\u79FB\u9664 Tileset: ${tilesetId}`);
+    return true;
+  }
+  /**
+   * 设置 Tileset 可见性
+   * @param tilesetId Tileset ID
+   * @param visible 是否可见
+   */
+  setVisible(tilesetId, visible) {
+    const entry = this.tilesets.get(tilesetId);
+    if (!entry) {
+      return false;
+    }
+    entry.tileset.show = visible;
+    entry.config.show = visible;
+    this.events.emit({ visibilityChanged: { id: tilesetId, visible } });
+    return true;
+  }
+  /**
+   * 获取 Tileset 配置
+   * @param tilesetId Tileset ID
+   */
+  get(tilesetId) {
+    return this.tilesets.get(tilesetId)?.config;
+  }
+  /**
+   * 获取底层 Cesium Tileset
+   * @param tilesetId Tileset ID
+   */
+  getTileset(tilesetId) {
+    return this.tilesets.get(tilesetId)?.tileset;
+  }
+  /**
+   * 获取所有 Tileset 配置
+   */
+  list() {
+    return Array.from(this.tilesets.values()).map((e) => e.config);
+  }
+  /**
+   * 检查 Tileset 是否存在
+   * @param tilesetId Tileset ID
+   */
+  has(tilesetId) {
+    return this.tilesets.has(tilesetId);
+  }
+  /**
+   * 飞行到指定 Tileset
+   * @param tilesetId Tileset ID
+   * @param duration 飞行时长
+   */
+  async flyTo(tilesetId, duration) {
+    const entry = this.tilesets.get(tilesetId);
+    if (!entry) {
+      return false;
+    }
+    await this.flyToTileset(entry.tileset, duration);
+    return true;
+  }
+  /**
+   * 清除所有 Tileset
+   */
+  clear() {
+    const ids = Array.from(this.tilesets.keys());
+    ids.forEach((id) => this.remove(id));
+    console.log(`[TilesetManager] \u5DF2\u6E05\u9664\u6240\u6709 Tileset`);
+  }
+  /**
+   * 销毁管理器
+   */
+  destroy() {
+    this.clear();
+  }
+  /**
+   * 创建 Tileset
+   */
+  async createTileset(config) {
+    const C = this.CesiumNS;
+    const pointCloudShading = config.pointCloudShading ?? {
+      attenuation: true,
+      geometricErrorScale: 1,
+      eyeDomeLighting: true,
+      eyeDomeLightingStrength: 1,
+      eyeDomeLightingRadius: 1
+    };
+    const tileset = await C.Cesium3DTileset.fromUrl(config.url, {
+      show: config.show ?? true,
+      maximumScreenSpaceError: config.maximumScreenSpaceError ?? 16,
+      dynamicScreenSpaceError: true,
+      dynamicScreenSpaceErrorDensity: 278e-5,
+      dynamicScreenSpaceErrorFactor: 4,
+      skipLevelOfDetail: false,
+      baseScreenSpaceError: 1024,
+      skipScreenSpaceErrorFactor: 16,
+      skipLevels: 1,
+      immediatelyLoadDesiredLevelOfDetail: false,
+      loadSiblings: false,
+      cullWithChildrenBounds: true,
+      pointCloudShading
+    });
+    return tileset;
+  }
+  /**
+   * 飞行到 Tileset
+   */
+  async flyToTileset(tileset, duration = 2) {
+    try {
+      await this.viewer.flyTo(tileset, { duration });
+    } catch {
+    }
+  }
+};
+
 // src/core/SceneManager.ts
 var SceneManager = class {
   constructor(CesiumNS, options) {
@@ -1702,6 +2461,9 @@ var SceneManager = class {
     __publicField(this, "viewer");
     __publicField(this, "layerManager");
     __publicField(this, "cameraManager");
+    __publicField(this, "terrainManager");
+    __publicField(this, "imageryManager");
+    __publicField(this, "tilesetManager");
     console.log("SceneManager constructor", options);
     assertCesiumAssetsConfigured();
     ensureCesiumIonToken(CesiumNS);
@@ -1709,10 +2471,8 @@ var SceneManager = class {
     const container = this.resolveContainer(options.container);
     this.viewer = new CesiumNS.Viewer(container, {
       baseLayer: false,
-      // 时间控制相关
       animation: false,
       timeline: false,
-      // UI控件
       geocoder: false,
       homeButton: false,
       sceneModePicker: false,
@@ -1720,15 +2480,11 @@ var SceneManager = class {
       navigationHelpButton: false,
       fullscreenButton: false,
       vrButton: false,
-      // 信息框
       infoBox: false,
       selectionIndicator: false,
-      // 默认数据源
       shouldAnimate: false,
-      // 地形和影像
       terrainProvider: void 0,
       creditContainer: void 0,
-      // 其他
       contextOptions: {
         webgl: {
           alpha: true,
@@ -1737,7 +2493,6 @@ var SceneManager = class {
           antialias: true,
           powerPreference: "high-performance",
           preserveDrawingBuffer: true
-          // 必需：允许 canvas.toDataURL() 截图
         }
       },
       ...viewerOptions
@@ -1749,6 +2504,9 @@ var SceneManager = class {
       }
     });
     this.cameraManager = new CameraManager(CesiumNS, this.viewer);
+    this.terrainManager = new TerrainManager(CesiumNS, this.viewer);
+    this.imageryManager = new ImageryManager(CesiumNS, this.viewer);
+    this.tilesetManager = new TilesetManager(CesiumNS, this.viewer);
     if (imagery) this.applyImagery(imagery);
     if (terrain) this.applyTerrain(terrain);
     if (typeof shadows === "boolean") this.setShadows(shadows);
@@ -1759,7 +2517,7 @@ var SceneManager = class {
     return this.viewer;
   }
   /**
-   * Set a black background for areas without imagery. Optionally clear existing base imagery layers.
+   * Set a black background for areas without imagery.
    */
   useBlackBackground(removeAllImagery = true) {
     const C = this.CesiumNS;
@@ -1767,6 +2525,9 @@ var SceneManager = class {
     this.viewer.scene.globe.baseColor = C.Color.BLACK;
   }
   destroy() {
+    this.terrainManager?.destroy();
+    this.imageryManager?.destroy();
+    this.tilesetManager?.destroy();
     this.viewer?.destroy();
     this.viewer = void 0;
   }
@@ -1791,6 +2552,18 @@ var SceneManager = class {
   getLayerManager() {
     return this.layerManager;
   }
+  getTerrainManager() {
+    return this.terrainManager;
+  }
+  getImageryManager() {
+    return this.imageryManager;
+  }
+  getTilesetManager() {
+    return this.tilesetManager;
+  }
+  /**
+   * @deprecated 请使用 getImageryManager().add() 代替
+   */
   setBaseImagery(url, layer_id, opts) {
     for (let i = 0; i < this.viewer.imageryLayers.length; i++) {
       const layer2 = this.viewer.imageryLayers.get(i);
@@ -1813,7 +2586,9 @@ var SceneManager = class {
     }
     return layer;
   }
-  // private tilese3DtMap: Map<string, any> = new Map();
+  /**
+   * @deprecated 请使用 getTilesetManager().add() 代替
+   */
   async set3DTiles(url, layer_id) {
     const primitives = this.viewer.scene.primitives;
     for (let i = primitives.length - 1; i >= 0; i--) {
@@ -1837,6 +2612,9 @@ var SceneManager = class {
       return void 0;
     }
   }
+  /**
+   * @deprecated 请使用 getTerrainManager().switchTo() 代替
+   */
   async setTerrain(options) {
     if (this.viewer.scene.skyBox) {
       this.viewer.scene.skyBox.show = false;
@@ -1845,7 +2623,6 @@ var SceneManager = class {
     this.viewer.scene.globe.baseColor = this.CesiumNS.Color.BLACK;
     return this.applyTerrain(options);
   }
-  // Expose DSM (3D Tiles) loading for demos and consumers
   async addDSM(options) {
     const handle = await this.layerManager.addDSM(options);
     try {
@@ -1874,8 +2651,7 @@ var SceneManager = class {
     try {
       const handle = this.layerManager.addDOM(options);
       if (!handle) return void 0;
-      const layer = this.layerManager.getImageryLayer(handle.id);
-      return layer;
+      return this.layerManager.getImageryLayer(handle.id);
     } catch (e) {
       console.error("[SceneManager] Failed to apply imagery:", e);
       return void 0;
@@ -1884,7 +2660,6 @@ var SceneManager = class {
   async apply3Dtiles(url) {
     const tileset = await this.CesiumNS.Cesium3DTileset.fromUrl(url, {
       maximumScreenSpaceError: 16,
-      // 降低以提高点云质量
       dynamicScreenSpaceError: true,
       dynamicScreenSpaceErrorDensity: 278e-5,
       dynamicScreenSpaceErrorFactor: 4,
@@ -1895,14 +2670,12 @@ var SceneManager = class {
       immediatelyLoadDesiredLevelOfDetail: false,
       loadSiblings: false,
       cullWithChildrenBounds: true,
-      // 点云特定选项
       pointCloudShading: {
         attenuation: true,
         geometricErrorScale: 1,
         maximumAttenuation: void 0,
         baseResolution: void 0,
         eyeDomeLighting: true,
-        // 启用 EDL 可以改善点云视觉效果
         eyeDomeLightingStrength: 1,
         eyeDomeLightingRadius: 1
       }
@@ -1912,7 +2685,6 @@ var SceneManager = class {
   async applyTerrain(options) {
     try {
       const handle = await this.layerManager.addDEM(options);
-      console.log("handle", this.viewer.terrainProvider);
       return handle ? this.viewer.terrainProvider : void 0;
     } catch (e) {
       console.error("[SceneManager] Failed to apply terrain:", e);
@@ -13337,6 +14109,7 @@ var MassPolygonManager = class {
     // 事件处理器
     __publicField(this, "hoverHandler");
     __publicField(this, "clickHandler");
+    __publicField(this, "rightClickHandler");
     // 悬停状态
     __publicField(this, "highlightedId");
     __publicField(this, "originalHighlightFillColor");
@@ -13345,11 +14118,36 @@ var MassPolygonManager = class {
     __publicField(this, "selectedId");
     __publicField(this, "originalSelectFillColor");
     __publicField(this, "originalSelectOutlineColor");
+    // 贴地模式高亮用的独立 Primitive
+    __publicField(this, "highlightPrimitive");
+    __publicField(this, "selectPrimitive");
+    // 贴地模式轮廓线
+    __publicField(this, "groundOutlinePrimitive");
     // 节流相关
     __publicField(this, "lastPickTime", 0);
     __publicField(this, "pickThrottleMs", 50);
     // 悬停标签
     __publicField(this, "hoverLabel");
+    // 静态标签（每个多边形的名称标签）
+    __publicField(this, "staticLabelCollection");
+    __publicField(this, "staticLabelsVisible", false);
+    __publicField(this, "staticLabelStyle", {
+      font: "12px sans-serif",
+      fillColor: "#000000",
+      // 黑色字
+      outlineColor: "#ffffff",
+      // 白色描边
+      outlineWidth: 2,
+      showBackground: false,
+      backgroundColor: "rgba(0,0,0,0.5)",
+      backgroundPadding: [4, 2],
+      pixelOffset: [0, 0],
+      scale: 1
+    });
+    // 地形高度缓存（用于 hover 标签等需要快速访问地形高度的场景）
+    __publicField(this, "terrainHeightCache", /* @__PURE__ */ new Map());
+    // 销毁标志
+    __publicField(this, "isDestroyed", false);
     // ========== 编辑支持方法 ==========
     // 隐藏的多边形原始颜色存储
     __publicField(this, "hiddenPolygonColors", /* @__PURE__ */ new Map());
@@ -13363,6 +14161,7 @@ var MassPolygonManager = class {
     this.interactionOptions = {
       enableHover: false,
       enableClick: false,
+      enableRightClick: false,
       highlightStyle: {
         fillColor: "rgba(255, 255, 0, 0.7)",
         outlineColor: "rgba(255, 255, 0, 1)"
@@ -13382,7 +14181,8 @@ var MassPolygonManager = class {
         pixelOffset: [0, -20]
       },
       onHover: void 0,
-      onClick: void 0
+      onClick: void 0,
+      onRightClick: void 0
     };
   }
   /**
@@ -13414,6 +14214,7 @@ var MassPolygonManager = class {
       this.interactionOptions = {
         enableHover: interaction.enableHover ?? false,
         enableClick: interaction.enableClick ?? false,
+        enableRightClick: interaction.enableRightClick ?? false,
         highlightStyle: {
           fillColor: interaction.highlightStyle?.fillColor ?? this.interactionOptions.highlightStyle.fillColor,
           outlineColor: interaction.highlightStyle?.outlineColor ?? this.interactionOptions.highlightStyle.outlineColor
@@ -13433,12 +14234,27 @@ var MassPolygonManager = class {
           pixelOffset: interaction.hoverLabelStyle?.pixelOffset ?? this.interactionOptions.hoverLabelStyle.pixelOffset
         },
         onHover: interaction.onHover,
-        onClick: interaction.onClick
+        onClick: interaction.onClick,
+        onRightClick: interaction.onRightClick
       };
     }
     this.isClampToGround = options?.clampToGround ?? false;
     const asynchronous = options?.asynchronous ?? true;
     this.polygonHeight = options?.height ?? 0;
+    if (options?.staticLabelStyle) {
+      const labelStyle = options.staticLabelStyle;
+      this.staticLabelStyle = {
+        font: labelStyle.font ?? this.staticLabelStyle.font,
+        fillColor: labelStyle.fillColor ?? this.staticLabelStyle.fillColor,
+        outlineColor: labelStyle.outlineColor ?? this.staticLabelStyle.outlineColor,
+        outlineWidth: labelStyle.outlineWidth ?? this.staticLabelStyle.outlineWidth,
+        showBackground: labelStyle.showBackground ?? this.staticLabelStyle.showBackground,
+        backgroundColor: labelStyle.backgroundColor ?? this.staticLabelStyle.backgroundColor,
+        backgroundPadding: labelStyle.backgroundPadding ?? this.staticLabelStyle.backgroundPadding,
+        pixelOffset: labelStyle.pixelOffset ?? this.staticLabelStyle.pixelOffset,
+        scale: labelStyle.scale ?? this.staticLabelStyle.scale
+      };
+    }
     if (this.isClampToGround && this.viewer.scene.globe) {
       this.viewer.scene.globe.depthTestAgainstTerrain = true;
     }
@@ -13458,55 +14274,112 @@ var MassPolygonManager = class {
         continue;
       }
       const positions = this.convertPointsToCartesian(polygon.points);
-      const polygonGeometry = new C.PolygonGeometry({
-        polygonHierarchy: new C.PolygonHierarchy(positions),
-        perPositionHeight: false,
-        height: this.polygonHeight
-        // 使用配置的高度
-      });
-      fillInstances.push(new C.GeometryInstance({
-        geometry: polygonGeometry,
-        id: polygon.id,
-        attributes: {
-          color: C.ColorGeometryInstanceAttribute.fromColor(fillColor),
-          show: new C.ShowGeometryInstanceAttribute(true)
-        }
-      }));
-      const outlinePositionsWithHeight = polygon.points.map(
-        (p) => C.Cartesian3.fromDegrees(p.lon, p.lat, this.polygonHeight)
+      if (this.isClampToGround) {
+        const polygonGeometry = new C.PolygonGeometry({
+          polygonHierarchy: new C.PolygonHierarchy(positions)
+        });
+        fillInstances.push(new C.GeometryInstance({
+          geometry: polygonGeometry,
+          id: polygon.id,
+          attributes: {
+            color: C.ColorGeometryInstanceAttribute.fromColor(fillColor)
+          }
+        }));
+      } else {
+        const polygonGeometry = new C.PolygonGeometry({
+          polygonHierarchy: new C.PolygonHierarchy(positions),
+          perPositionHeight: false,
+          height: this.polygonHeight
+        });
+        fillInstances.push(new C.GeometryInstance({
+          geometry: polygonGeometry,
+          id: polygon.id,
+          attributes: {
+            color: C.ColorGeometryInstanceAttribute.fromColor(fillColor),
+            show: new C.ShowGeometryInstanceAttribute(true)
+          }
+        }));
+      }
+      const outlinePositions = polygon.points.map(
+        (p) => C.Cartesian3.fromDegrees(p.lon, p.lat, this.isClampToGround ? 0 : this.polygonHeight)
       );
-      outlinePositionsWithHeight.push(outlinePositionsWithHeight[0]);
-      const outlineGeometry = new C.PolylineGeometry({
-        positions: outlinePositionsWithHeight,
-        width: this.currentStyle.outlineWidth
-      });
-      outlineInstances.push(new C.GeometryInstance({
-        geometry: outlineGeometry,
-        id: `${polygon.id}-outline`,
-        attributes: {
-          color: C.ColorGeometryInstanceAttribute.fromColor(outlineColor),
-          show: new C.ShowGeometryInstanceAttribute(true)
-        }
-      }));
+      outlinePositions.push(outlinePositions[0]);
+      if (this.isClampToGround) {
+        const groundOutlineGeometry = new C.GroundPolylineGeometry({
+          positions: outlinePositions,
+          width: this.currentStyle.outlineWidth
+        });
+        outlineInstances.push(new C.GeometryInstance({
+          geometry: groundOutlineGeometry,
+          id: `${polygon.id}-outline`,
+          attributes: {
+            color: C.ColorGeometryInstanceAttribute.fromColor(outlineColor)
+          }
+        }));
+      } else {
+        const outlineGeometry = new C.PolylineGeometry({
+          positions: outlinePositions,
+          width: this.currentStyle.outlineWidth
+        });
+        outlineInstances.push(new C.GeometryInstance({
+          geometry: outlineGeometry,
+          id: `${polygon.id}-outline`,
+          attributes: {
+            color: C.ColorGeometryInstanceAttribute.fromColor(outlineColor),
+            show: new C.ShowGeometryInstanceAttribute(true)
+          }
+        }));
+      }
     }
     if (fillInstances.length > 0) {
       const appearance = new C.PerInstanceColorAppearance({ flat: true, translucent: true });
-      this.primitive = new C.Primitive({ geometryInstances: fillInstances, appearance, asynchronous });
+      if (this.isClampToGround) {
+        this.primitive = new C.GroundPrimitive({
+          geometryInstances: fillInstances,
+          appearance,
+          asynchronous,
+          releaseGeometryInstances: false,
+          allowPicking: true
+        });
+      } else {
+        this.primitive = new C.Primitive({
+          geometryInstances: fillInstances,
+          appearance,
+          asynchronous,
+          releaseGeometryInstances: false,
+          allowPicking: true
+        });
+      }
       this.layerCollection.add(this.primitive);
     }
     if (outlineInstances.length > 0) {
-      const appearance = new C.PolylineColorAppearance();
-      this.outlinePrimitive = new C.Primitive({ geometryInstances: outlineInstances, appearance, asynchronous });
-      this.layerCollection.add(this.outlinePrimitive);
+      if (this.isClampToGround) {
+        const appearance = new C.PolylineColorAppearance();
+        this.groundOutlinePrimitive = new C.GroundPolylinePrimitive({
+          geometryInstances: outlineInstances,
+          appearance,
+          asynchronous
+        });
+        this.layerCollection.add(this.groundOutlinePrimitive);
+      } else {
+        const appearance = new C.PolylineColorAppearance();
+        this.outlinePrimitive = new C.Primitive({ geometryInstances: outlineInstances, appearance, asynchronous });
+        this.layerCollection.add(this.outlinePrimitive);
+      }
     }
-    this.labelCollection = new C.LabelCollection();
+    this.labelCollection = new C.LabelCollection({ scene: this.viewer.scene });
     this.layerCollection.add(this.labelCollection);
+    this.staticLabelCollection = new C.LabelCollection({ scene: this.viewer.scene });
+    this.layerCollection.add(this.staticLabelCollection);
     if (this.interactionOptions.enableHover) {
       this.setupHoverHandler();
     }
     if (this.interactionOptions.enableClick) {
       this.setupClickHandler();
     }
+    if (this.interactionOptions.enableRightClick) {
+      this.setupRightClickHandler();
+    }
     this.viewer.scene.requestRender();
     return {
       primitive: this.primitive,
@@ -13527,19 +14400,25 @@ var MassPolygonManager = class {
         const now = Date.now();
         if (now - this.lastPickTime < this.pickThrottleMs) return;
         this.lastPickTime = now;
-        const pickedObject = this.viewer.scene.pick(movement.endPosition);
-        if (pickedObject?.id && typeof pickedObject.id === "string") {
-          const polygonId = pickedObject.id.endsWith("-outline") ? pickedObject.id.replace("-outline", "") : pickedObject.id;
-          if (this.polygonDataMap.has(polygonId)) {
-            if (this.highlightedId !== polygonId) {
-              this.clearHighlight();
-              this.highlightPolygon(polygonId);
-              const data = this.polygonDataMap.get(polygonId);
-              if (data) this.showLabel(data);
-              this.interactionOptions.onHover?.(polygonId, data ?? null);
+        let polygonId = null;
+        if (this.isClampToGround) {
+          polygonId = this.pickPolygonByPosition(movement.endPosition);
+        } else {
+          const pickedObject = this.viewer.scene.pick(movement.endPosition);
+          if (pickedObject?.id && typeof pickedObject.id === "string") {
+            const pickedId = pickedObject.id.endsWith("-outline") ? pickedObject.id.replace("-outline", "") : pickedObject.id;
+            if (this.polygonDataMap.has(pickedId)) {
+              polygonId = pickedId;
             }
-          } else {
-            this.handleMouseLeave();
+          }
+        }
+        if (polygonId) {
+          if (this.highlightedId !== polygonId) {
+            this.clearHighlight();
+            this.highlightPolygon(polygonId);
+            const data = this.polygonDataMap.get(polygonId);
+            if (data) this.showLabel(data);
+            this.interactionOptions.onHover?.(polygonId, data ?? null);
           }
         } else {
           this.handleMouseLeave();
@@ -13559,23 +14438,26 @@ var MassPolygonManager = class {
     this.clickHandler = new C.ScreenSpaceEventHandler(this.viewer.scene.canvas);
     this.clickHandler.setInputAction(
       (movement) => {
-        const pickedObject = this.viewer.scene.pick(movement.position);
-        if (pickedObject?.id && typeof pickedObject.id === "string") {
-          const polygonId = pickedObject.id.endsWith("-outline") ? pickedObject.id.replace("-outline", "") : pickedObject.id;
-          if (this.polygonDataMap.has(polygonId)) {
-            if (this.selectedId === polygonId) {
-              this.deselect();
-              this.interactionOptions.onClick?.(null, null);
-            } else {
-              this.select(polygonId);
-              const data = this.polygonDataMap.get(polygonId);
-              this.interactionOptions.onClick?.(polygonId, data ?? null);
+        let polygonId = null;
+        if (this.isClampToGround) {
+          polygonId = this.pickPolygonByPosition(movement.position);
+        } else {
+          const pickedObject = this.viewer.scene.pick(movement.position);
+          if (pickedObject?.id && typeof pickedObject.id === "string") {
+            const pickedId = pickedObject.id.endsWith("-outline") ? pickedObject.id.replace("-outline", "") : pickedObject.id;
+            if (this.polygonDataMap.has(pickedId)) {
+              polygonId = pickedId;
             }
+          }
+        }
+        if (polygonId) {
+          if (this.selectedId === polygonId) {
+            this.deselect();
+            this.interactionOptions.onClick?.(null, null);
           } else {
-            if (this.selectedId) {
-              this.deselect();
-              this.interactionOptions.onClick?.(null, null);
-            }
+            this.select(polygonId);
+            const data = this.polygonDataMap.get(polygonId);
+            this.interactionOptions.onClick?.(polygonId, data ?? null);
           }
         } else {
           if (this.selectedId) {
@@ -13587,6 +14469,79 @@ var MassPolygonManager = class {
       C.ScreenSpaceEventType.LEFT_CLICK
     );
   }
+  /**
+   * 设置右键事件处理器
+   */
+  setupRightClickHandler() {
+    if (this.rightClickHandler) {
+      this.rightClickHandler.destroy();
+    }
+    const C = this.CesiumNS;
+    this.rightClickHandler = new C.ScreenSpaceEventHandler(this.viewer.scene.canvas);
+    this.rightClickHandler.setInputAction(
+      (movement) => {
+        let polygonId = null;
+        if (this.isClampToGround) {
+          polygonId = this.pickPolygonByPosition(movement.position);
+        } else {
+          const pickedObject = this.viewer.scene.pick(movement.position);
+          if (pickedObject?.id && typeof pickedObject.id === "string") {
+            const pickedId = pickedObject.id.endsWith("-outline") ? pickedObject.id.replace("-outline", "") : pickedObject.id;
+            if (this.polygonDataMap.has(pickedId)) {
+              polygonId = pickedId;
+            }
+          }
+        }
+        if (polygonId) {
+          this.select(polygonId);
+          const data = this.polygonDataMap.get(polygonId);
+          if (data) {
+            const canvas = this.viewer.scene.canvas;
+            const canvasRect = canvas.getBoundingClientRect();
+            const screenX = canvasRect.left + movement.position.x;
+            const screenY = canvasRect.top + movement.position.y;
+            this.interactionOptions.onRightClick?.(polygonId, data, { x: screenX, y: screenY });
+          }
+        }
+      },
+      C.ScreenSpaceEventType.RIGHT_CLICK
+    );
+  }
+  /**
+   * 通过屏幕坐标获取地理位置，然后判断在哪个多边形内
+   * 用于贴地模式下的精确拾取
+   */
+  pickPolygonByPosition(screenPosition) {
+    const C = this.CesiumNS;
+    const ray = this.viewer.camera.getPickRay(screenPosition);
+    if (!ray) return null;
+    const cartesian = this.viewer.scene.globe.pick(ray, this.viewer.scene);
+    if (!cartesian) return null;
+    const cartographic = C.Cartographic.fromCartesian(cartesian);
+    const lon = C.Math.toDegrees(cartographic.longitude);
+    const lat = C.Math.toDegrees(cartographic.latitude);
+    for (const [id, polygon] of this.polygonDataMap) {
+      if (this.isPointInPolygon(lon, lat, polygon.points)) {
+        return id;
+      }
+    }
+    return null;
+  }
+  /**
+   * 判断点是否在多边形内（射线法）
+   */
+  isPointInPolygon(lon, lat, points) {
+    let inside = false;
+    const n = points.length;
+    for (let i = 0, j = n - 1; i < n; j = i++) {
+      const xi = points[i].lon, yi = points[i].lat;
+      const xj = points[j].lon, yj = points[j].lat;
+      if (yi > lat !== yj > lat && lon < (xj - xi) * (lat - yi) / (yj - yi) + xi) {
+        inside = !inside;
+      }
+    }
+    return inside;
+  }
   /**
    * 处理鼠标离开
    */
@@ -13604,6 +14559,11 @@ var MassPolygonManager = class {
     if (id === this.selectedId) return;
     const C = this.CesiumNS;
     if (!this.primitive) return;
+    if (this.isClampToGround) {
+      this.highlightPolygonWithSeparatePrimitive(id, "highlight");
+      this.highlightedId = id;
+      return;
+    }
     try {
       const fillAttributes = this.primitive.getGeometryInstanceAttributes?.(id);
       if (fillAttributes?.color) {
@@ -13624,11 +14584,60 @@ var MassPolygonManager = class {
     } catch (e) {
     }
   }
+  /**
+   * 贴地模式下使用独立 Primitive 高亮/选中多边形
+   */
+  highlightPolygonWithSeparatePrimitive(id, type) {
+    const C = this.CesiumNS;
+    const polygonData = this.polygonDataMap.get(id);
+    if (!polygonData) return;
+    if (type === "highlight" && this.highlightPrimitive) {
+      this.layerCollection?.remove(this.highlightPrimitive);
+      this.highlightPrimitive = void 0;
+    } else if (type === "select" && this.selectPrimitive) {
+      this.layerCollection?.remove(this.selectPrimitive);
+      this.selectPrimitive = void 0;
+    }
+    const positions = this.convertPointsToCartesian(polygonData.points);
+    const color = type === "highlight" ? C.Color.fromCssColorString(this.interactionOptions.highlightStyle.fillColor) : C.Color.fromCssColorString(this.interactionOptions.selectStyle.fillColor);
+    const geometry = new C.PolygonGeometry({
+      polygonHierarchy: new C.PolygonHierarchy(positions)
+    });
+    const instance = new C.GeometryInstance({
+      geometry,
+      id: `${id}-${type}`,
+      attributes: {
+        color: C.ColorGeometryInstanceAttribute.fromColor(color)
+      }
+    });
+    const primitive = new C.GroundPrimitive({
+      geometryInstances: instance,
+      appearance: new C.PerInstanceColorAppearance({ flat: true, translucent: true }),
+      asynchronous: false
+      // 同步创建，立即显示
+    });
+    if (type === "highlight") {
+      this.highlightPrimitive = primitive;
+    } else {
+      this.selectPrimitive = primitive;
+    }
+    this.layerCollection?.add(primitive);
+    this.viewer.scene.requestRender();
+  }
   /**
    * 清除悬停高亮
    */
   clearHighlight() {
     if (!this.highlightedId) return;
+    if (this.isClampToGround) {
+      if (this.highlightPrimitive) {
+        this.layerCollection?.remove(this.highlightPrimitive);
+        this.highlightPrimitive = void 0;
+      }
+      this.highlightedId = void 0;
+      this.viewer.scene.requestRender();
+      return;
+    }
     try {
       if (this.primitive && this.originalHighlightFillColor) {
         const fillAttributes = this.primitive.getGeometryInstanceAttributes?.(this.highlightedId);
@@ -13664,6 +14673,11 @@ var MassPolygonManager = class {
     }
     const C = this.CesiumNS;
     if (!this.primitive) return false;
+    if (this.isClampToGround) {
+      this.highlightPolygonWithSeparatePrimitive(id, "select");
+      this.selectedId = id;
+      return true;
+    }
     try {
       const fillAttributes = this.primitive.getGeometryInstanceAttributes?.(id);
       if (fillAttributes?.color) {
@@ -13691,6 +14705,15 @@ var MassPolygonManager = class {
    */
   deselect() {
     if (!this.selectedId) return;
+    if (this.isClampToGround) {
+      if (this.selectPrimitive) {
+        this.layerCollection?.remove(this.selectPrimitive);
+        this.selectPrimitive = void 0;
+      }
+      this.selectedId = void 0;
+      this.viewer.scene.requestRender();
+      return;
+    }
     try {
       if (this.primitive && this.originalSelectFillColor) {
         const fillAttributes = this.primitive.getGeometryInstanceAttributes?.(this.selectedId);
@@ -13725,7 +14748,7 @@ var MassPolygonManager = class {
     return this.selectedId ?? null;
   }
   /**
-   * 计算多边形中心点
+   * 计算多边形中心点（简单平均）
    */
   calculatePolygonCenter(points) {
     let sumLon = 0, sumLat = 0, sumHeight = 0;
@@ -13740,8 +14763,45 @@ var MassPolygonManager = class {
       height: sumHeight / points.length
     };
   }
+  /**
+   * 计算多边形质心（更准确的中心点算法）
+   * 使用多边形质心公式，对于凹多边形也能得到正确的中心位置
+   */
+  calculatePolygonCentroid(points) {
+    if (points.length < 3) {
+      return this.calculatePolygonCenter(points);
+    }
+    let signedArea = 0;
+    let cx = 0;
+    let cy = 0;
+    let sumHeight = 0;
+    const n = points.length;
+    for (let i = 0; i < n; i++) {
+      const x0 = points[i].lon;
+      const y0 = points[i].lat;
+      const x1 = points[(i + 1) % n].lon;
+      const y1 = points[(i + 1) % n].lat;
+      const a = x0 * y1 - x1 * y0;
+      signedArea += a;
+      cx += (x0 + x1) * a;
+      cy += (y0 + y1) * a;
+      sumHeight += points[i].height ?? 0;
+    }
+    signedArea *= 0.5;
+    if (Math.abs(signedArea) < 1e-10) {
+      return this.calculatePolygonCenter(points);
+    }
+    cx = cx / (6 * signedArea);
+    cy = cy / (6 * signedArea);
+    return {
+      lon: cx,
+      lat: cy,
+      height: sumHeight / n
+    };
+  }
   /**
    * 显示悬停标签
+   * 使用缓存的地形高度（如果可用）来正确放置标签
    */
   showLabel(polygonData) {
     if (!this.interactionOptions.showHoverLabel || !polygonData.name) return;
@@ -13750,7 +14810,24 @@ var MassPolygonManager = class {
     const style = this.interactionOptions.hoverLabelStyle;
     this.hideLabel();
     const center = this.calculatePolygonCenter(polygonData.points);
-    const position = C.Cartesian3.fromDegrees(center.lon, center.lat, this.polygonHeight);
+    let labelHeight;
+    if (this.isClampToGround) {
+      const cachedHeight = this.terrainHeightCache.get(polygonData.id);
+      if (cachedHeight !== void 0) {
+        labelHeight = cachedHeight + 2;
+      } else {
+        const terrainHeight = queryTerrainHeightByLonLatSync(
+          this.CesiumNS,
+          this.viewer,
+          center.lon,
+          center.lat
+        );
+        labelHeight = terrainHeight + 2;
+      }
+    } else {
+      labelHeight = this.polygonHeight;
+    }
+    const position = C.Cartesian3.fromDegrees(center.lon, center.lat, labelHeight);
     this.hoverLabel = this.labelCollection.add({
       position,
       text: polygonData.name,
@@ -13811,36 +14888,170 @@ var MassPolygonManager = class {
   }
   /**
    * 飞行到所有多边形的范围
+   * 
+   * 优化说明：
+   * 1. 多点采样地形高度（四角 + 中心），取最大值确保相机不会陷入地下
+   * 2. 修正 pitch 角度对视角高度的影响计算
+   * 3. 添加最小/最大高度限制，防止极端情况
+   * 4. 使用异步地形查询获取更精确的高度
+   * 5. 添加销毁检查，防止异步回调在实例销毁后执行
    */
   flyToBounds(options) {
+    if (this.isDestroyed) {
+      console.warn("[MassPolygonManager] \u5B9E\u4F8B\u5DF2\u9500\u6BC1\uFF0C\u8DF3\u8FC7 flyToBounds");
+      return;
+    }
     const bounds = this.getBounds();
     if (!bounds) {
       console.warn("[MassPolygonManager] \u6CA1\u6709\u591A\u8FB9\u5F62\u6570\u636E\uFF0C\u65E0\u6CD5\u98DE\u884C");
       return;
     }
+    if (bounds.width <= 0 || bounds.height <= 0) {
+      console.warn("[MassPolygonManager] \u591A\u8FB9\u5F62\u8303\u56F4\u65E0\u6548\uFF0C\u8DF3\u8FC7\u98DE\u884C");
+      return;
+    }
+    const C = this.CesiumNS;
+    const camera = this.viewer.camera;
+    const duration = options?.duration ?? 2;
+    const padding = options?.padding ?? 0.2;
+    const pitch = options?.pitch ?? C.Math.toRadians(-45);
+    const heading = options?.heading ?? 0;
+    const minHeight = options?.minHeight ?? 100;
+    const maxHeight = options?.maxHeight ?? 1e5;
+    const paddedWest = bounds.west - bounds.width * padding;
+    const paddedEast = bounds.east + bounds.width * padding;
+    const paddedSouth = bounds.south - bounds.height * padding;
+    const paddedNorth = bounds.north + bounds.height * padding;
+    const samplePoints = [
+      [bounds.centerLon, bounds.centerLat],
+      // 中心
+      [paddedWest, paddedSouth],
+      // 左下
+      [paddedEast, paddedSouth],
+      // 右下
+      [paddedWest, paddedNorth],
+      // 左上
+      [paddedEast, paddedNorth],
+      // 右上
+      [(paddedWest + paddedEast) / 2, paddedSouth],
+      // 下边中点
+      [(paddedWest + paddedEast) / 2, paddedNorth],
+      // 上边中点
+      [paddedWest, (paddedSouth + paddedNorth) / 2],
+      // 左边中点
+      [paddedEast, (paddedSouth + paddedNorth) / 2]
+      // 右边中点
+    ];
+    Promise.all(
+      samplePoints.map(
+        ([lon, lat]) => queryTerrainHeightByLonLat(this.CesiumNS, this.viewer, lon, lat)
+      )
+    ).then((terrainHeights) => {
+      if (this.isDestroyed) {
+        console.warn("[MassPolygonManager] \u5B9E\u4F8B\u5DF2\u9500\u6BC1\uFF0C\u8DF3\u8FC7\u98DE\u884C\u64CD\u4F5C");
+        return;
+      }
+      const is2DMode = this.viewer.scene.mode === C.SceneMode.SCENE2D;
+      const validTerrainHeights = terrainHeights.filter((h) => h >= -500 && h < 1e4);
+      const maxTerrainHeight = is2DMode || validTerrainHeights.length === 0 ? 0 : Math.max(...validTerrainHeights, 0);
+      const earthRadius = 6371e3;
+      const avgLat = (paddedSouth + paddedNorth) / 2;
+      const latRad = avgLat * (Math.PI / 180);
+      const rectWidth = (paddedEast - paddedWest) * (Math.PI / 180) * earthRadius * Math.cos(latRad);
+      const rectHeight = (paddedNorth - paddedSouth) * (Math.PI / 180) * earthRadius;
+      if (!isFinite(rectWidth) || !isFinite(rectHeight) || rectWidth <= 0 || rectHeight <= 0) {
+        console.warn("[MassPolygonManager] \u8303\u56F4\u8BA1\u7B97\u7ED3\u679C\u65E0\u6548\uFF0C\u8DF3\u8FC7\u98DE\u884C");
+        return;
+      }
+      const frustum = camera.frustum;
+      const fovy = frustum.fovy || frustum.fov || C.Math.toRadians(60);
+      const canvas = this.viewer.scene.canvas;
+      const aspectRatio = canvas.width / canvas.height;
+      const absPitch = Math.abs(pitch);
+      const sinPitch = Math.sin(absPitch);
+      let viewHeight;
+      if (absPitch > C.Math.toRadians(80)) {
+        const tanHalfFovy = Math.tan(fovy / 2);
+        const heightForVertical = rectHeight / (2 * tanHalfFovy);
+        const heightForHorizontal = rectWidth / (2 * tanHalfFovy * aspectRatio);
+        viewHeight = Math.max(heightForVertical, heightForHorizontal);
+      } else {
+        const tanHalfFovy = Math.tan(fovy / 2);
+        const heightForVertical = sinPitch > 0.1 ? rectHeight / (2 * tanHalfFovy * sinPitch) : rectHeight / (2 * tanHalfFovy);
+        const heightForHorizontal = rectWidth / (2 * tanHalfFovy * aspectRatio);
+        viewHeight = Math.max(heightForVertical, heightForHorizontal);
+      }
+      viewHeight *= 1.2;
+      viewHeight = Math.max(minHeight, Math.min(maxHeight, viewHeight));
+      const altitude = maxTerrainHeight + viewHeight;
+      const destination = C.Cartesian3.fromDegrees(bounds.centerLon, bounds.centerLat, altitude);
+      const orientation = { heading, pitch, roll: 0 };
+      if (duration > 0) {
+        camera.flyTo({ destination, orientation, duration });
+      } else {
+        camera.setView({ destination, orientation });
+      }
+      console.log(
+        `[MassPolygonManager] \u98DE\u884C\u5230\u8FB9\u754C: \u4E2D\u5FC3(${bounds.centerLon.toFixed(6)}, ${bounds.centerLat.toFixed(6)}), \u8303\u56F4(${rectWidth.toFixed(0)}m x ${rectHeight.toFixed(0)}m), \u6700\u9AD8\u5730\u5F62: ${maxTerrainHeight.toFixed(0)}m, \u89C6\u89D2\u9AD8\u5EA6: ${viewHeight.toFixed(0)}m, \u76F8\u673A\u9AD8\u5EA6: ${altitude.toFixed(0)}m`
+      );
+    }).catch((error) => {
+      if (this.isDestroyed) {
+        return;
+      }
+      console.warn("[MassPolygonManager] \u5730\u5F62\u67E5\u8BE2\u5931\u8D25\uFF0C\u4F7F\u7528\u540C\u6B65\u65B9\u6CD5:", error);
+      this.flyToBoundsSync(options);
+    });
+  }
+  /**
+   * 同步版本的飞行方法（降级方案）
+   */
+  flyToBoundsSync(options) {
+    const bounds = this.getBounds();
+    if (!bounds) return;
     const C = this.CesiumNS;
     const camera = this.viewer.camera;
     const duration = options?.duration ?? 2;
     const padding = options?.padding ?? 0.2;
     const pitch = options?.pitch ?? C.Math.toRadians(-45);
     const heading = options?.heading ?? 0;
+    const minHeight = options?.minHeight ?? 100;
+    const maxHeight = options?.maxHeight ?? 1e5;
     const paddedWest = bounds.west - bounds.width * padding;
     const paddedEast = bounds.east + bounds.width * padding;
     const paddedSouth = bounds.south - bounds.height * padding;
     const paddedNorth = bounds.north + bounds.height * padding;
+    const terrainHeight = queryTerrainHeightByLonLatSync(
+      this.CesiumNS,
+      this.viewer,
+      bounds.centerLon,
+      bounds.centerLat
+    );
+    const is2DMode = this.viewer.scene.mode === C.SceneMode.SCENE2D;
+    const validTerrainHeight = is2DMode || terrainHeight < -500 || terrainHeight >= 1e4 ? 0 : terrainHeight;
     const earthRadius = 6371e3;
-    const rectWidth = (paddedEast - paddedWest) * (Math.PI / 180) * earthRadius * Math.cos(bounds.centerLat * Math.PI / 180);
+    const avgLat = (paddedSouth + paddedNorth) / 2;
+    const latRad = avgLat * (Math.PI / 180);
+    const rectWidth = (paddedEast - paddedWest) * (Math.PI / 180) * earthRadius * Math.cos(latRad);
     const rectHeight = (paddedNorth - paddedSouth) * (Math.PI / 180) * earthRadius;
     const frustum = camera.frustum;
     const fovy = frustum.fovy || frustum.fov || C.Math.toRadians(60);
     const canvas = this.viewer.scene.canvas;
     const aspectRatio = canvas.width / canvas.height;
-    const fovx = 2 * Math.atan(Math.tan(fovy / 2) * aspectRatio);
     const absPitch = Math.abs(pitch);
-    const sinPitch = Math.sin(absPitch) || 0.707;
-    const altitudeForHeight = rectHeight / 2 / Math.tan(fovy / 2) / sinPitch;
-    const altitudeForWidth = rectWidth / 2 / Math.tan(fovx / 2) / sinPitch;
-    const altitude = Math.max(altitudeForHeight, altitudeForWidth, 500) * 1.1;
+    const sinPitch = Math.sin(absPitch);
+    const tanHalfFovy = Math.tan(fovy / 2);
+    let viewHeight;
+    if (absPitch > C.Math.toRadians(80)) {
+      const heightForVertical = rectHeight / (2 * tanHalfFovy);
+      const heightForHorizontal = rectWidth / (2 * tanHalfFovy * aspectRatio);
+      viewHeight = Math.max(heightForVertical, heightForHorizontal);
+    } else {
+      const heightForVertical = sinPitch > 0.1 ? rectHeight / (2 * tanHalfFovy * sinPitch) : rectHeight / (2 * tanHalfFovy);
+      const heightForHorizontal = rectWidth / (2 * tanHalfFovy * aspectRatio);
+      viewHeight = Math.max(heightForVertical, heightForHorizontal);
+    }
+    viewHeight = Math.max(minHeight, Math.min(maxHeight, viewHeight * 1.2));
+    const altitude = validTerrainHeight + viewHeight;
     const destination = C.Cartesian3.fromDegrees(bounds.centerLon, bounds.centerLat, altitude);
     const orientation = { heading, pitch, roll: 0 };
     if (duration > 0) {
@@ -13848,7 +15059,6 @@ var MassPolygonManager = class {
     } else {
       camera.setView({ destination, orientation });
     }
-    console.log(`[MassPolygonManager] \u98DE\u884C\u5230\u8FB9\u754C: \u4E2D\u5FC3(${bounds.centerLon.toFixed(6)}, ${bounds.centerLat.toFixed(6)}), \u9AD8\u5EA6: ${altitude.toFixed(0)}m`);
   }
   /**
    * 设置可见性
@@ -13857,7 +15067,184 @@ var MassPolygonManager = class {
     if (this.layerCollection) {
       this.layerCollection.show = visible;
     }
+    if (this.viewer?.scene) {
+      try {
+        this.viewer.scene.requestRender();
+      } catch (e) {
+      }
+    }
+  }
+  /**
+   * 获取图层可见性
+   */
+  getVisibility() {
+    return this.layerCollection?.show ?? false;
+  }
+  /**
+   * 隐藏整个图层
+   */
+  hide() {
+    this.setVisibility(false);
+  }
+  /**
+   * 显示整个图层
+   */
+  show() {
+    this.setVisibility(true);
+  }
+  /**
+   * 切换图层可见性
+   * @returns 切换后的可见性状态
+   */
+  toggleVisibility() {
+    const newVisibility = !this.getVisibility();
+    this.setVisibility(newVisibility);
+    return newVisibility;
+  }
+  // ==================== 静态标签管理 ====================
+  /**
+   * 显示所有多边形的静态标签（异步版本）
+   * 在每个多边形的中心点显示其名称
+   * 
+   * 注意：
+   * 1. LabelCollection 不支持 heightReference 属性
+   * 2. 贴地模式下，使用异步方法查询地形高度来正确放置标签
+   * 3. 通过 disableDepthTestDistance 确保标签始终可见
+   * 4. 查询的地形高度会被缓存，供 hover 标签使用
+   */
+  async showStaticLabels() {
+    if (!this.staticLabelCollection) return;
+    const C = this.CesiumNS;
+    this.staticLabelCollection.removeAll();
+    const polygonsWithCenters = [];
+    for (const polygon of this.polygonDataMap.values()) {
+      if (!polygon.name) continue;
+      const center = this.calculatePolygonCentroid(polygon.points);
+      polygonsWithCenters.push({ polygon, center });
+    }
+    if (polygonsWithCenters.length === 0) {
+      this.staticLabelsVisible = true;
+      return;
+    }
+    let labelHeights;
+    if (this.isClampToGround) {
+      const coordinates = polygonsWithCenters.map(({ center }) => ({
+        lon: center.lon,
+        lat: center.lat
+      }));
+      try {
+        const terrainHeights = await queryTerrainHeightsByLonLat(
+          this.CesiumNS,
+          this.viewer,
+          coordinates
+        );
+        labelHeights = terrainHeights.map((h) => h + 2);
+        for (let i = 0; i < polygonsWithCenters.length; i++) {
+          const polygonId = polygonsWithCenters[i].polygon.id;
+          this.terrainHeightCache.set(polygonId, terrainHeights[i]);
+        }
+        console.log(`[MassPolygonManager] \u5F02\u6B65\u67E5\u8BE2\u5730\u5F62\u9AD8\u5EA6\u5B8C\u6210\uFF0C\u8303\u56F4: ${Math.min(...terrainHeights).toFixed(1)}m ~ ${Math.max(...terrainHeights).toFixed(1)}m`);
+      } catch (error) {
+        console.warn("[MassPolygonManager] \u5F02\u6B65\u67E5\u8BE2\u5730\u5F62\u9AD8\u5EA6\u5931\u8D25\uFF0C\u4F7F\u7528\u9ED8\u8BA4\u9AD8\u5EA6:", error);
+        labelHeights = polygonsWithCenters.map(() => 2);
+      }
+    } else {
+      labelHeights = polygonsWithCenters.map(() => this.polygonHeight);
+    }
+    if (this.isDestroyed || !this.staticLabelCollection) {
+      console.warn("[MassPolygonManager] \u5B9E\u4F8B\u5DF2\u9500\u6BC1\uFF0C\u8DF3\u8FC7\u521B\u5EFA\u6807\u7B7E");
+      return;
+    }
+    for (let i = 0; i < polygonsWithCenters.length; i++) {
+      const { polygon, center } = polygonsWithCenters[i];
+      const labelHeight = labelHeights[i];
+      const position = C.Cartesian3.fromDegrees(center.lon, center.lat, labelHeight);
+      this.staticLabelCollection.add({
+        position,
+        text: polygon.name,
+        font: this.staticLabelStyle.font,
+        fillColor: C.Color.fromCssColorString(this.staticLabelStyle.fillColor),
+        outlineColor: C.Color.fromCssColorString(this.staticLabelStyle.outlineColor),
+        outlineWidth: this.staticLabelStyle.outlineWidth,
+        style: C.LabelStyle.FILL_AND_OUTLINE,
+        showBackground: this.staticLabelStyle.showBackground,
+        backgroundColor: C.Color.fromCssColorString(this.staticLabelStyle.backgroundColor),
+        backgroundPadding: new C.Cartesian2(this.staticLabelStyle.backgroundPadding[0], this.staticLabelStyle.backgroundPadding[1]),
+        pixelOffset: new C.Cartesian2(this.staticLabelStyle.pixelOffset[0], this.staticLabelStyle.pixelOffset[1]),
+        scale: this.staticLabelStyle.scale,
+        verticalOrigin: C.VerticalOrigin.CENTER,
+        horizontalOrigin: C.HorizontalOrigin.CENTER,
+        // 禁用深度测试，确保标签始终可见（不会被地形遮挡）
+        disableDepthTestDistance: Number.POSITIVE_INFINITY
+      });
+    }
+    this.staticLabelsVisible = true;
+    this.viewer.scene.requestRender();
+    console.log(`[MassPolygonManager] \u5DF2\u663E\u793A ${this.staticLabelCollection.length} \u4E2A\u9759\u6001\u6807\u7B7E`);
+  }
+  /**
+   * 预加载所有多边形质心的地形高度（用于 hover 标签）
+   * 在贴地模式下，建议在 create() 后调用此方法
+   */
+  async preloadTerrainHeights() {
+    if (!this.isClampToGround) return;
+    const polygons = Array.from(this.polygonDataMap.values());
+    if (polygons.length === 0) return;
+    const coordinates = polygons.map((polygon) => {
+      const center = this.calculatePolygonCentroid(polygon.points);
+      return { lon: center.lon, lat: center.lat };
+    });
+    try {
+      const terrainHeights = await queryTerrainHeightsByLonLat(
+        this.CesiumNS,
+        this.viewer,
+        coordinates
+      );
+      for (let i = 0; i < polygons.length; i++) {
+        this.terrainHeightCache.set(polygons[i].id, terrainHeights[i]);
+      }
+      console.log(`[MassPolygonManager] \u9884\u52A0\u8F7D\u5730\u5F62\u9AD8\u5EA6\u5B8C\u6210: ${polygons.length} \u4E2A\u591A\u8FB9\u5F62`);
+    } catch (error) {
+      console.warn("[MassPolygonManager] \u9884\u52A0\u8F7D\u5730\u5F62\u9AD8\u5EA6\u5931\u8D25:", error);
+    }
+  }
+  /**
+   * 隐藏所有多边形的静态标签
+   */
+  hideStaticLabels() {
+    if (!this.staticLabelCollection) return;
+    this.staticLabelCollection.removeAll();
+    this.staticLabelsVisible = false;
     this.viewer.scene.requestRender();
+    console.log("[MassPolygonManager] \u5DF2\u9690\u85CF\u9759\u6001\u6807\u7B7E");
+  }
+  /**
+   * 切换静态标签显示状态
+   * @returns 切换后的显示状态
+   */
+  async toggleStaticLabels() {
+    if (this.staticLabelsVisible) {
+      this.hideStaticLabels();
+    } else {
+      await this.showStaticLabels();
+    }
+    return this.staticLabelsVisible;
+  }
+  /**
+   * 获取静态标签显示状态
+   */
+  getStaticLabelsVisible() {
+    return this.staticLabelsVisible;
+  }
+  /**
+   * 设置静态标签样式
+   * @param style 样式配置（部分）
+   */
+  async setStaticLabelStyle(style) {
+    this.staticLabelStyle = { ...this.staticLabelStyle, ...style };
+    if (this.staticLabelsVisible) {
+      await this.showStaticLabels();
+    }
   }
   /**
    * 更新样式（需要重新创建所有多边形）
@@ -13881,6 +15268,10 @@ var MassPolygonManager = class {
       this.clickHandler.destroy();
       this.clickHandler = void 0;
     }
+    if (this.rightClickHandler) {
+      this.rightClickHandler.destroy();
+      this.rightClickHandler = void 0;
+    }
     this.highlightedId = void 0;
     this.selectedId = void 0;
     this.originalHighlightFillColor = void 0;
@@ -13888,20 +15279,35 @@ var MassPolygonManager = class {
     this.originalSelectFillColor = void 0;
     this.originalSelectOutlineColor = void 0;
     this.hoverLabel = void 0;
-    if (this.layerCollection) {
-      this.viewer.scene.primitives.remove(this.layerCollection);
+    this.highlightPrimitive = void 0;
+    this.selectPrimitive = void 0;
+    if (this.layerCollection && this.viewer?.scene?.primitives) {
+      try {
+        this.viewer.scene.primitives.remove(this.layerCollection);
+      } catch (e) {
+      }
       this.layerCollection = void 0;
     }
     this.primitive = void 0;
     this.outlinePrimitive = void 0;
+    this.groundOutlinePrimitive = void 0;
     this.labelCollection = void 0;
+    this.staticLabelCollection = void 0;
+    this.staticLabelsVisible = false;
     this.polygonDataMap.clear();
-    this.viewer.scene.requestRender();
+    this.terrainHeightCache.clear();
+    if (this.viewer?.scene) {
+      try {
+        this.viewer.scene.requestRender();
+      } catch (e) {
+      }
+    }
   }
   /**
    * 销毁并释放资源
    */
   destroy() {
+    this.isDestroyed = true;
     this.clear();
   }
   /**
@@ -14295,6 +15701,7 @@ exports.CameraManager = CameraManager;
 exports.Emitter = Emitter;
 exports.FlightSimulator = FlightSimulator;
 exports.FrustumPyramid = FrustumPyramid;
+exports.ImageryManager = ImageryManager;
 exports.LODManager = LODManager;
 exports.LayerManager = LayerManager;
 exports.MassPolygonManager = MassPolygonManager;
@@ -14305,6 +15712,8 @@ exports.RealtimeFlightTracker = RealtimeFlightTracker;
 exports.SceneManager = SceneManager;
 exports.Selector = Selector;
 exports.StateManager = StateManager;
+exports.TerrainManager = TerrainManager;
+exports.TilesetManager = TilesetManager;
 exports.assertCesiumAssetsConfigured = assertCesiumAssetsConfigured;
 exports.bringDataSourceToTop = bringDataSourceToTop;
 exports.bringPrimitiveCollectionToTop = bringPrimitiveCollectionToTop;