s3m-three 0.3.0 → 0.3.2

package/src/render/S3MViewer.ts

@@ -21,7 +21,7 @@
  * MapLibre / Mapbox 的胶水层在 s3m-maplibre 包的 S3MLayer.ts。
  */
 import * as THREE from 'three';
-import { S3MTileset } from '../tileset/S3MTileset.js';
+import { S3MTileset, usableGeoBounds } from '../tileset/S3MTileset.js';
 import type { BuildTileFn, TileNode } from '../tileset/S3MTileset.js';
 import { setMaxAnisotropy } from './TextureFactory.js';
 import {
@@ -33,6 +33,7 @@ import {
   createOutlineMaterial,
 } from './StyleMaterial.js';
 import type { OutlineMaterial, StyledMaterial, StyleMode, SelectMode, S3MStyle } from './StyleMaterial.js';
+import { applyPointCloudStyle, isOwnedPointCloudMaterial } from './PointCloudMaterial.js';
 import { Picker } from './Picker.js';
 import {
   buildFeatureEdgeSegments,
@@ -143,7 +144,42 @@ export interface PickResult extends FeatureAttributes {
   mesh: THREE.Mesh;
 }
 
+export interface LightOptions {
+  /** 环境光强度，默认 0.4 */
+  ambientIntensity?: number;
+  /** 环境光颜色，十六进制或 CSS 颜色字符串，默认 0xffffff */
+  ambientColor?: number | string;
+  /** 半球光天空强度，默认 0.8 */
+  hemisphereIntensity?: number;
+  /** 半球光天空颜色，默认 0xffffff */
+  hemisphereColor?: number | string;
+  /** 半球光地面颜色，默认 0xb6c0cb */
+  hemisphereGroundColor?: number | string;
+  /** 主平行光强度，默认 1.0 */
+  keyLightIntensity?: number;
+  /** 主平行光颜色，默认 0xffffff */
+  keyLightColor?: number | string;
+  /** 补光强度，默认 0.35 */
+  fillLightIntensity?: number;
+  /** 补光颜色，默认 0xffffff */
+  fillLightColor?: number | string;
+  /**
+   * 光照朝向模式：
+   * - 'headlamp': 默认头灯模式（随相机 bearing 旋转，受光面始终面向镜头）
+   * - 'fixed': 固定世界坐标方位角（如太阳光模拟）
+   */
+  mode?: 'headlamp' | 'fixed';
+  /** 方位角（度，0~360），固定模式下以正北为 0 顺时针，头灯模式下为相机相对偏角，默认 150 */
+  azimuth?: number;
+  /** 太阳/光源仰角（度，0~90），默认 50 */
+  altitude?: number;
+}
+
 export interface S3MViewerOptions {
+  /** 光照参数配置（强度、颜色、朝向模式、太阳方位角/仰角等） */
+  light?: LightOptions;
+  /** 全局总驻留瓦片上限（多数据集多图层共享预算），在所有可见数据集之间动态均衡分配，彻底防止爆显存 */
+  totalMaxTiles?: number;
   /** 单数据集简写 */
   configUrl?: string;
   /** 多数据集 */
@@ -191,6 +227,8 @@ interface MeshUserData {
   geoRef?: GeoPackageEntry;
   tileRef?: ParsedTile;
   primitiveType?: number;
+  /** 点云对象（THREE.Points）：不吃面着色，也没有棱可描 */
+  isPointCloud?: boolean;
   /** CPU 端现算的棱线对象（等宽线 Mesh） */
   edges?: THREE.Object3D | null;
   /** 数据自带棱线包（此时不再用 EdgesGeometry 现算） */
@@ -211,6 +249,11 @@ function styledMaterialOf(mesh: THREE.Mesh): StyledMaterial | null {
   return styled?.userData?.isStyled ? styled : null;
 }
 
+/** 点云是 THREE.Points 不是 Mesh，样式 / 拾取 / 卸载链路都靠这个判定放行 */
+function isPointCloudObject(o: THREE.Object3D): o is THREE.Points {
+  return (o as unknown as THREE.Points).isPoints === true;
+}
+
 /* ------------------------------------------------------------------ 图层 */
 
 export class S3MViewer {
@@ -272,7 +315,7 @@ export class S3MViewer {
   private _heightMax = -Infinity;
   private readonly _boxScratch = new THREE.Box3();
   private _selection: PickResult | null = null;
-  private _selectedMeshes: THREE.Mesh[] = [];
+  private _selectedMeshes: THREE.Object3D[] = [];
   private _outlineMesh: THREE.Mesh | null = null;
   private _outlineMeshes: THREE.Mesh[] = [];
   private _selectionEdges: THREE.Mesh | null = null;
@@ -286,8 +329,24 @@ export class S3MViewer {
   private _needsRepaint = true;
   private _frame = 0;
   private readonly _fps = { value: 0, last: 0 };
-  private _keyLight: THREE.DirectionalLight | null = null;
-  private _fillLight: THREE.DirectionalLight | null = null;
+  private _ambientLight!: THREE.AmbientLight;
+  private _hemiLight!: THREE.HemisphereLight;
+  private _keyLight!: THREE.DirectionalLight;
+  private _fillLight!: THREE.DirectionalLight;
+  private readonly _lightOptions: Required<LightOptions> = {
+    ambientIntensity: 0.4,
+    ambientColor: 0xffffff,
+    hemisphereIntensity: 0.8,
+    hemisphereColor: 0xffffff,
+    hemisphereGroundColor: 0xb6c0cb,
+    keyLightIntensity: 1.0,
+    keyLightColor: 0xffffff,
+    fillLightIntensity: 0.35,
+    fillLightColor: 0xffffff,
+    mode: 'headlamp',
+    azimuth: 150,
+    altitude: 50,
+  };
 
   private readonly _datasetQueue: S3MDatasetOptions[];
 
@@ -301,10 +360,20 @@ export class S3MViewer {
     this._onRequestRepaint();
   }
 
+  triggerRepaint(): void {
+    this._requestRepaint();
+  }
+
   constructor(options: S3MViewerOptions = {}) {
     this.options = options;
     this.pickable = options.pickable !== false;
     this._lodRangeScale = options.lodRangeScale ?? 1.0;
+    if (options.light) {
+      Object.assign(this._lightOptions, options.light);
+    }
+    if (options.totalMaxTiles) {
+      this._datasetManager.totalMaxTiles = options.totalMaxTiles;
+    }
     this._onRequestRepaint = options.onRequestRepaint ?? (() => {});
     this._getBearing = options.getBearing;
     this.onStats = options.onStats ?? (() => {});
@@ -313,6 +382,11 @@ export class S3MViewer {
     this.onError = options.onError ?? ((e) => console.warn('[s3m]', e));
 
     this.groundManager = new GroundManager(options.ground);
+    if (!this.scene) {
+      this.scene = new THREE.Scene();
+      this.scene.add(this.groundManager.group);
+      this._addLights();
+    }
     this._featureStyleManager = new FeatureStyleManager(
       () => this.style.floorHeight,
       () => this._requestRepaint(),
@@ -404,24 +478,70 @@ export class S3MViewer {
     this.canvas = null;
   }
 
+  private _createLights(): void {
+    this._ambientLight = new THREE.AmbientLight(this._lightOptions.ambientColor as any, this._lightOptions.ambientIntensity);
+    this._hemiLight = new THREE.HemisphereLight(
+      this._lightOptions.hemisphereColor as any,
+      this._lightOptions.hemisphereGroundColor as any,
+      this._lightOptions.hemisphereIntensity
+    );
+    this._keyLight = new THREE.DirectionalLight(this._lightOptions.keyLightColor as any, this._lightOptions.keyLightIntensity);
+    this._fillLight = new THREE.DirectionalLight(this._lightOptions.fillLightColor as any, this._lightOptions.fillLightIntensity);
+    this._updateLights();
+  }
+
   private _addLights(): void {
     if (!this.scene) return;
-    // 环境光与天光打底，保证背光面和折叠处不死黑
-    this.scene.add(new THREE.AmbientLight(0xffffff, 0.4));
-    this.scene.add(new THREE.HemisphereLight(0xffffff, 0xb6c0cb, 0.8));
-    // 主光 / 补光的方向每帧按地图朝向重算（见 _updateLights），
-    // 这样旋转视角时白模始终是亮的，不会转到背光面就一片死灰。
-    this._keyLight = new THREE.DirectionalLight(0xffffff, 1.0);
-    this._fillLight = new THREE.DirectionalLight(0xffffff, 0.35);
-    this.scene.add(this._keyLight, this._fillLight);
+    if (!this._ambientLight) this._createLights();
+    this.scene.add(this._ambientLight, this._hemiLight, this._keyLight, this._fillLight);
+  }
+
+  private _applyLightOptions(): void {
+    if (this._ambientLight) {
+      this._ambientLight.intensity = this._lightOptions.ambientIntensity;
+      this._ambientLight.color.set(this._lightOptions.ambientColor as any);
+    }
+    if (this._hemiLight) {
+      this._hemiLight.intensity = this._lightOptions.hemisphereIntensity;
+      this._hemiLight.color.set(this._lightOptions.hemisphereColor as any);
+      this._hemiLight.groundColor.set(this._lightOptions.hemisphereGroundColor as any);
+    }
+    if (this._keyLight) {
+      this._keyLight.intensity = this._lightOptions.keyLightIntensity;
+      this._keyLight.color.set(this._lightOptions.keyLightColor as any);
+    }
+    if (this._fillLight) {
+      this._fillLight.intensity = this._lightOptions.fillLightIntensity;
+      this._fillLight.color.set(this._lightOptions.fillLightColor as any);
+    }
+  }
+
+  /**
+   * 动态设置光照配置
+   */
+  setLight(options: Partial<LightOptions>): void {
+    Object.assign(this._lightOptions, options);
+    this._applyLightOptions();
+    this._updateLights();
+    this._needsRepaint = true;
+    this.triggerRepaint();
+  }
+
+  /**
+   * 获取当前光照配置快照
+   */
+  getLight(): LightOptions {
+    return { ...this._lightOptions };
   }
 
   /**
-   * 让光照跟着地图朝向走：主光在镜头后上方偏左，补光在后上方偏右。
-   * 相当于一盏头灯，看到的立面永远是受光面。
+   * 更新光照位置与方向：
+   * - 'headlamp': 随地图方位角 bearing 旋转，主光始终在镜头上方，受光面面向镜头；
+   * - 'fixed': 固定世界方位角（如模拟恒定日光）。
    */
   private _updateLights(): void {
-    const bearing = ((this._getBearing?.() ?? 0) * Math.PI) / 180;
+    if (!this._keyLight || !this._fillLight) return;
+    const bearing = this._lightOptions.mode === 'fixed' ? 0 : (((this._getBearing?.() ?? 0) * Math.PI) / 180);
     const place = (light: THREE.DirectionalLight | null, azOffsetDeg: number, elevDeg: number): void => {
       if (!light) return;
       const az = bearing + (azOffsetDeg * Math.PI) / 180;
@@ -429,8 +549,8 @@ export class S3MViewer {
       const c = Math.cos(el);
       light.position.set(Math.sin(az) * c, Math.cos(az) * c, Math.sin(el)).multiplyScalar(1000);
     };
-    place(this._keyLight, 150, 50);
-    place(this._fillLight, 215, 30);
+    place(this._keyLight, this._lightOptions.azimuth, this._lightOptions.altitude);
+    place(this._fillLight, this._lightOptions.azimuth + 65, Math.max(10, this._lightOptions.altitude - 20));
   }
 
   /* ---------------------------------------------------------------- 数据集 */
@@ -540,8 +660,11 @@ export class S3MViewer {
   /**
    * 物理地表网格的高度跟随「主数据集的应用层抬升量」，
    * 保证贴地后地表覆盖 / 地下透视的物理关系与被抬升的模型一致。
+   * `ground.trackHeight = false` 时不跟随：地表钉在当前高度，
+   * 高程调整只动模型不动切割面。
    */
   private _syncGroundHeight(): void {
+    if (!this.groundManager.trackHeight) return;
     const primaryId = this.datasets.keys().next().value;
     if (!primaryId) return;
     const userOffset = this._datasetManager.getDatasetHeight(primaryId);
@@ -704,6 +827,15 @@ export class S3MViewer {
     this._requestRepaint();
   }
 
+  /**
+   * 开关「物理地表作为深度遮挡源」：开启后地表以下的几何被真正切掉。
+   * 不依赖宿主是否开启 MapLibre terrain——深度缓冲是共用的，谁更近谁遮挡。
+   */
+  setGroundOcclude(enabled: boolean): void {
+    this.groundManager.setOcclude(enabled);
+    this._requestRepaint();
+  }
+
   /* ---------------------------------------------------------------- 状态纹理同步 */
 
   private _isFeatureHidden(smid: number | null, _batchId: number): boolean {
@@ -773,6 +905,7 @@ export class S3MViewer {
         mesh.geometry?.dispose?.();
         const styled = styledMaterialOf(mesh);
         if (styled) styled.dispose();
+        if (isOwnedPointCloudMaterial(mesh.material)) (mesh.material as THREE.Material).dispose();
         this._featureStyleManager.disposeMesh(mesh);
       });
     });
@@ -808,8 +941,10 @@ export class S3MViewer {
         continue;
       }
 
+      // 点云是 THREE.Points 不是 Mesh，但同样要进拾取表、吃不透明度、跟着着色模式走
+      const isPoints = isPointCloudObject(child);
       const mesh = child as THREE.Mesh;
-      if (!mesh.isMesh) continue;
+      if (!mesh.isMesh && !isPoints) continue;
       const ud = mesh.userData as MeshUserData;
       ud.pickId = this._allocPickId();
       ud.datasetId = entry.id;
@@ -822,41 +957,141 @@ export class S3MViewer {
       });
       this._indexMeshSmids(mesh);
       this._addMeshHeight(mesh);
-      if (this._edgesEnabled && !hasNativeEdges) this._ensureEdges(mesh);
+      // 点云没有「棱」：给一堆孤立点建 EdgesGeometry 又慢又没意义
+      if (this._edgesEnabled && !hasNativeEdges && !isPoints) this._ensureEdges(mesh);
 
       // 新瓦片要继承当前的不透明度与着色方式
-      const mat = styledMaterialOf(mesh);
-      if (mat) {
-        const o = Math.min(1, Math.max(0.05, this.style.opacity ?? 1));
-        mat.opacity = o;
-        mat.transparent = o < 0.999;
-        mat.depthWrite = o >= 0.999;
-        mat.flatShading = this.style.shading !== 'smooth';
-        mat.needsUpdate = true;
-        this._featureStyleManager.applyOverridesToMesh(mesh);
+      if (isPoints) {
+        this._applyPointCloudStyle(child as THREE.Points);
+      } else {
+        const mat = styledMaterialOf(mesh);
+        if (mat) {
+          const o = Math.min(1, Math.max(0.05, this.style.opacity ?? 1));
+          mat.opacity = o;
+          mat.transparent = o < 0.999;
+          mat.depthWrite = o >= 0.999;
+          mat.flatShading = this.style.shading !== 'smooth';
+          mat.needsUpdate = true;
+          this._featureStyleManager.applyOverridesToMesh(mesh);
+        }
       }
+
+      // 选中状态也要跟着继承：LOD 细化 / 瓦片重载会换掉 mesh，
+      // 不重放就出现「点中的那栋楼一拉近就没高亮了」
+      this._replaySelectionOnto(mesh);
     }
   }
 
-  /** 瓦片被淘汰：从拾取表和场景里摘掉，并释放它自己的 GPU 资源 */
-  private _unregisterTile(node: TileNode, entry: S3MDatasetEntry): void {
-    for (const child of [...node.group.children]) {
-      const mesh = child as THREE.Mesh;
-      if (!mesh.isMesh) continue;
-      const ud = mesh.userData as MeshUserData;
-      if (this._selection?.mesh === mesh || this._selectedMeshes.includes(mesh)) this.select(null);
-      if (ud.pickId != null) {
-        this._pickables.delete(ud.pickId);
-        this._releasePickId(ud.pickId);
-        ud.pickId = undefined;
+  /**
+   * 把「当前选中」重放到一块新登记的 mesh 上。
+   *
+   * 为什么需要：选中高亮是直接写在各 mesh 材质的 uSelBatch / uSelWhole 上的，
+   * 而 LOD 细化、瓦片重载、淘汰回补都会换掉 mesh —— 不重放的话，用户点中的那栋楼
+   * 一细化就失去高亮（状态还在 _selection.smid 里，只是没人往新 mesh 上刷）。
+   */
+  /**
+   * 判断一块无 SMID 单体化信息的网格（如倾斜摄影或白模整块）是否空间覆盖当前选中命中点
+   */
+  private _isMeshCoveringSelection(mesh: THREE.Mesh, sel: PickResult): boolean {
+    if (!sel.point) return false;
+    const geom = mesh.geometry;
+    if (!geom) return false;
+    if (!geom.boundingBox) geom.computeBoundingBox();
+    if (!geom.boundingBox) return false;
+
+    // 将选中的三维场景点转入网格局部坐标系进行包围盒检测
+    const pt = new THREE.Vector3(sel.point[0], sel.point[1], sel.point[2]);
+    mesh.updateWorldMatrix(true, false);
+    const inv = mesh.matrixWorld.clone().invert();
+    const localPt = pt.applyMatrix4(inv);
+
+    // 留出 0.5 米容差，避免刚好处于三角网格边缘缝隙时漏判
+    const box = geom.boundingBox.clone().expandByScalar(0.5);
+    return box.containsPoint(localPt);
+  }
+
+  private _replaySelectionOnto(mesh: THREE.Mesh): void {
+    const sel = this._selection;
+    if (!sel) return;
+    const mat = styledMaterialOf(mesh);
+    if (!mat) return;
+
+    const ud = mesh.userData as MeshUserData;
+    let batchId = -1;
+    if (sel.smid != null) {
+      const pickInfo = ud.geoRef?.pickInfo as Record<string | number, unknown> | undefined;
+      const entry = pickInfo?.[sel.smid] ?? pickInfo?.[String(sel.smid)];
+      batchId = entry ? pickEntryId(entry as any) : -1;
+    }
+    // 拾取命中的那块 mesh 用原始 batchId；同一 smid 散在别的几何里时按各自的区间算
+    if (mesh === sel.mesh) batchId = sel.batchId;
+    // 这块几何里根本没有这个单体 → 不动它（否则会把无关瓦片一起点亮）
+    if (batchId < 0 && mesh !== sel.mesh) {
+      if (sel.smid == null && ud.datasetId === sel.datasetId && this._isMeshCoveringSelection(mesh, sel)) {
+        batchId = -1;
+      } else {
+        return;
       }
-      this._unindexMeshSmids(mesh);
-      this._removeMeshHeight(mesh);
-      this._featureStyleManager.disposeMesh(mesh);
-      const styled = styledMaterialOf(mesh);
-      styled?.dispose?.();
-      mesh.geometry?.dispose?.();
     }
+
+    mat.userData.uSelBatch.value = batchId;
+    mat.userData.uSelWhole.value = batchId < 0 ? 1 : 0;
+    if (!this._selectedMeshes.includes(mesh)) this._selectedMeshes.push(mesh);
+    if (isPointCloudObject(mesh)) this._applyPointCloudStyle(mesh, true);
+    this.uniforms.uSelMix.value = 1;
+    this.uniforms.uDim.value = this.style.dimOthers ? 1 : 0;
+  }
+
+  /** 瓦片被淘汰：从拾取表和场景里摘掉，并深度彻底释放所有几何体与材质显存 */
+  private _unregisterTile(node: TileNode, entry: S3MDatasetEntry): void {
+    node.group.traverse((child) => {
+      const obj = child as any;
+      if (obj.userData?.pickId != null) {
+        this._pickables.delete(obj.userData.pickId);
+        this._releasePickId(obj.userData.pickId);
+        obj.userData.pickId = undefined;
+      }
+      if (obj.isMesh) {
+        const wasSelected = this._selectedMeshes.includes(obj);
+        if (wasSelected) {
+          this._selectedMeshes = this._selectedMeshes.filter((m) => m !== obj);
+        }
+        const currentSel = this._selection;
+        if (currentSel && currentSel.mesh === obj) {
+          const smid = currentSel.smid;
+          const carrier = (
+            smid != null
+              ? [...(this._smidMeshes.get(smid) ?? [])].find((m) => m !== obj && m.parent)
+              : this._selectedMeshes.find((m) => m !== obj && m.parent && (m.parent as any).visible) ??
+                this._selectedMeshes.find((m) => m !== obj && m.parent)
+          ) as THREE.Mesh | undefined;
+          if (carrier) {
+            // 选中身份交给承载同一 smid 的另一块 mesh（通常是接替显示的子瓦）
+            this._selection = { ...currentSel, mesh: carrier };
+            this._replaySelectionOnto(carrier);
+          } else {
+            this.select(null);
+          }
+        }
+        this._unindexMeshSmids(obj);
+        this._removeMeshHeight(obj);
+        this._featureStyleManager.disposeMesh(obj);
+        const styled = styledMaterialOf(obj);
+        styled?.dispose?.();
+      }
+      // 深度释放材质（点云、普通材质、材质数组）
+      if (isOwnedPointCloudMaterial(obj.material)) {
+        (obj.material as THREE.Material).dispose();
+      } else if (obj.material) {
+        if (Array.isArray(obj.material)) {
+          obj.material.forEach((m: any) => m?.dispose?.());
+        } else {
+          obj.material.dispose?.();
+        }
+      }
+      // 释放几何体显存缓冲
+      obj.geometry?.dispose?.();
+    });
     entry.root.remove(node.group);
   }
 
@@ -890,6 +1125,8 @@ export class S3MViewer {
     this.style = { ...this.style, ...patch };
     this._applyStyleUniforms();
     if ('opacity' in patch || 'depthWrite' in patch) this._applyOpacity();
+    // 点云不走 StyleMaterial 的 uMode，模式切换要单独同步它的材质
+    if ('mode' in patch) this._applyPointCloudStyles();
     if ('shading' in patch) this._applyShading();
     if ('edges' in patch) this.setEdges(!!this.style.edges);
     else if ('edgeColor' in patch || 'edgeWidth' in patch || 'opacity' in patch || 'edgeOpacity' in patch) {
@@ -959,6 +1196,10 @@ export class S3MViewer {
     // 关键：若 depthWrite 开启（默认开启），即使半透明也保持深度写入，完美遮挡背面棱线，防止背面线条透出
     const keepDepth = this.style.depthWrite !== false;
     for (const p of this._pickables.values()) {
+      if (isPointCloudObject(p.mesh)) {
+        this._applyPointCloudStyle(p.mesh);
+        continue;
+      }
       const m = styledMaterialOf(p.mesh);
       if (!m) continue;
       m.opacity = o;
@@ -968,6 +1209,19 @@ export class S3MViewer {
     this._requestRepaint();
   }
 
+  /** 单个点云对象同步当前样式（着色模式 + 不透明度 + 选中高亮） */
+  private _applyPointCloudStyle(points: THREE.Points, selected = this._selectedMeshes.includes(points)): void {
+    applyPointCloudStyle(points, this.style, this.uniforms, selected);
+  }
+
+  /** 全部点云刷新：着色模式切换时用（uniform 是共享引用，改色不用走这里） */
+  private _applyPointCloudStyles(): void {
+    for (const p of this._pickables.values()) {
+      if (isPointCloudObject(p.mesh)) this._applyPointCloudStyle(p.mesh);
+    }
+    this._requestRepaint();
+  }
+
   /** 平面/平滑着色：FLAT_SHADED 是编译期宏，改它必须重编译 */
   private _applyShading(): void {
     const flat = this.style.shading !== 'smooth';
@@ -1104,7 +1358,8 @@ export class S3MViewer {
       .map((p) => p.mesh)
       .filter((m) => {
         const ud = m.userData as MeshUserData;
-        return !ud.edges && !ud.nativeEdges;
+        // 点云没有棱可描
+        return !ud.edges && !ud.nativeEdges && !isPointCloudObject(m);
       });
     let i = 0;
     const step = (): void => {
@@ -1614,8 +1869,13 @@ export class S3MViewer {
   select(result: PickResult | null, { silent = false }: { silent?: boolean } = {}): void {
     // 清掉上一次
     if (this._selection) {
-      for (const mesh of this._selectedMeshes) {
-        const mat = styledMaterialOf(mesh);
+      for (const obj of this._selectedMeshes) {
+        // 点云：恢复成当前着色模式（去掉选中混色）
+        if (isPointCloudObject(obj)) {
+          this._applyPointCloudStyle(obj, false);
+          continue;
+        }
+        const mat = styledMaterialOf(obj as THREE.Mesh);
         if (mat) {
           mat.userData.uSelBatch.value = -1;
           mat.userData.uSelWhole.value = 0;
@@ -1666,14 +1926,22 @@ export class S3MViewer {
       mat.userData.uSelWhole.value = batchId < 0 ? 1 : 0;
       this._selectedMeshes.push(mesh);
     }
+    // 点云没有单体粒度：整块混成 selectColor，让选中至少看得见
+    for (const mesh of this._selectedMeshes) {
+      if (isPointCloudObject(mesh)) this._applyPointCloudStyle(mesh, true);
+    }
     this.uniforms.uSelMix.value = 1;
     this.uniforms.uDim.value = this.style.dimOthers ? 1 : 0;
 
     if (this.style.outline) {
-      if ((this.style.outlineStyle ?? 'edges') === 'edges') {
-        this._addSelectionEdges(result, targetMeshes);
-      } else {
-        this._addSelectionHull(result, targetMeshes);
+      // 棱线 / 外扩轮廓都是按「面」设计的，点云画不出来也不该画
+      const decoMeshes = [...targetMeshes].filter((m) => !isPointCloudObject(m));
+      if (decoMeshes.length) {
+        if ((this.style.outlineStyle ?? 'edges') === 'edges') {
+          this._addSelectionEdges(result, decoMeshes);
+        } else {
+          this._addSelectionHull(result, decoMeshes);
+        }
       }
     }
     this._requestRepaint();
@@ -1973,9 +2241,8 @@ export class S3MViewer {
     let maxLon = -Infinity;
     let maxLat = -Infinity;
     for (const entry of this.datasets.values()) {
-      const b = entry.tileset?.config?.geoBounds as
-        | { left: number; bottom: number; right: number; top: number }
-        | undefined;
+      // 同 DatasetManager.getBounds：退化 / 越界的 geoBounds 不参与，避免视角甩到 (0,0)
+      const b = usableGeoBounds(entry.tileset?.config?.geoBounds);
       if (!b) continue;
       minLon = Math.min(minLon, b.left);
       maxLon = Math.max(maxLon, b.right);