s3m-three 0.1.0 → 0.2.0

package/dist/render/S3MLayer.js

@@ -1,1860 +0,0 @@
-/**
- * S3M × MapLibre / Mapbox 图层
- *
- * 坐标链路：
- *   S3M 顶点（数据集局部 ENU，米）
- *     → 数据集 Group 偏移：把各数据集锚点对齐到「场景锚点」
- *     → L 矩阵：ENU → Web Mercator 归一化坐标
- *     → 宿主传入的 mercator→clip 矩阵
- *
- * 关键点：three 场景原点固定在**场景锚点**（第一个数据集的位置），
- * 所有顶点只保留「相对锚点的米」，避免 float32 在墨卡托大坐标下的抖动（RTC 思路）。
- * 多数据集叠加时，每个数据集一个 Group，用 position 承担锚点差。
- *
- * 兼容性：图层只依赖 `MapLike` 这组鸭子类型接口，MapLibre GL JS v4/v5 与
- * Mapbox GL JS v2/v3 都可以直接 `map.addLayer(layer)`，不引入任一方的类型依赖。
- */
-import * as THREE from 'three';
-import { setMaxAnisotropy } from './TextureFactory.js';
-import { STYLE, STYLE_LABELS, SELECT_MODE, SELECT_MODE_LABELS, createSharedUniforms, createOutlineMaterial, } from './StyleMaterial.js';
-import { Picker } from './Picker.js';
-import { buildFeatureEdgeSegments, buildThickLineGeometry, createLineSharedUniforms, createThickLineMaterial, } from './EdgeLines.js';
-import { buildOrthoMVP, extractFovRadians, extractNearFar, extractProjectionMatrix, } from './OrthoProjection.js';
-import { resolveFeature, measureSegments, buildAttributes, buildInstanceLookup, pickEntryId, DEFAULT_FLOOR_HEIGHT, } from '../core/FeatureInfo.js';
-import { AttributeQuery } from '../core/AttributeQuery.js';
-import { DEFAULT_FOV, lngLatFromWorld, } from './CoordinateHelper.js';
-import { DatasetManager, } from './DatasetManager.js';
-import { FeatureStyleManager, } from './FeatureStyleManager.js';
-import { GroundManager, } from './GroundManager.js';
-export { GroundManager, DatasetManager, FeatureStyleManager };
-const MAX_PICK_ID = 65534;
-export const DEFAULT_STYLE = {
-    mode: STYLE.TEXTURE,
-    colorA: '#dfe6ee',
-    colorB: '#1d4ed8',
-    colorC: '#fbbf24',
-    selectColor: '#22d3ee',
-    selectMode: SELECT_MODE.OVERLAY,
-    selectOpacity: 0.65,
-    selectEmissive: 0.35,
-    selectElevation: 0,
-    floorHeight: DEFAULT_FLOOR_HEIGHT,
-    speed: 1,
-    opacity: 1,
-    shading: 'flat',
-    dimOthers: true,
-    dimFactor: 0.42,
-    outline: true,
-    outlineStyle: 'edges',
-    outlineColor: '#22d3ee',
-    outlineWidth: 0.9,
-    outlineWidthPx: 3,
-    edges: false,
-    edgeWidth: 1.2,
-    edgeColor: '#334155',
-    edgeOpacity: 0.45,
-    roofThreshold: 0.65,
-    texMix: 0,
-    depthWrite: true,
-};
-function styledMaterialOf(mesh) {
-    const m = Array.isArray(mesh.material) ? mesh.material[0] : mesh.material;
-    const styled = m;
-    return styled?.userData?.isStyled ? styled : null;
-}
-/* ------------------------------------------------------------------ 图层 */
-export class S3MLayer {
-    id;
-    type = 'custom';
-    renderingMode = '3d';
-    options;
-    pickable;
-    onStats;
-    onReady;
-    onPick;
-    onError;
-    map = null;
-    renderer = null;
-    scene = null;
-    camera = null;
-    picker = null;
-    uniforms;
-    style;
-    outlineMaterial;
-    /** 等宽线共享的分辨率 uniform（全局棱线 + 选中棱线共用） */
-    lineShared;
-    /** 全局棱线材质 */
-    edgeMaterial;
-    /** 选中棱线材质 */
-    selectionEdgeMaterial;
-    /** 3D 物理地表面 / 基坑开挖管理器 */
-    groundManager;
-    /** 多数据集生命周期与锚点管理器 */
-    _datasetManager = new DatasetManager();
-    /** 单体样式、专题着色与状态纹理管理器 */
-    _featureStyleManager;
-    /** 兼容 datasets 映射表暴露 */
-    get datasets() {
-        return this._datasetManager.datasets;
-    }
-    /** 场景主锚点（ENU 原点对应的世界坐标） */
-    get sceneAnchor() {
-        return this._datasetManager.sceneAnchor;
-    }
-    set sceneAnchor(val) {
-        this._datasetManager.sceneAnchor = val;
-    }
-    _pickables = new Map();
-    _pickSeq = 0;
-    _freePickIds = [];
-    /** SMID → 包含它的网格。改单个单体样式时只重算这几块，不用全量扫 */
-    _smidMeshes = new Map();
-    /** 每块网格的世界高度范围，用来增量维护 uHeightMin / uHeightMax */
-    _meshHeight = new Map();
-    _heightMin = Infinity;
-    _heightMax = -Infinity;
-    _boxScratch = new THREE.Box3();
-    _selection = null;
-    _selectedMeshes = [];
-    _outlineMesh = null;
-    _outlineMeshes = [];
-    _selectionEdges = null;
-    _selectionEdgeMeshes = [];
-    _edgesEnabled = false;
-    /** 业务属性查询（可选，配了 `attributes` 才有） */
-    attributeQuery = null;
-    _enuMatrix = new THREE.Matrix4();
-    _needsRepaint = true;
-    _frame = 0;
-    _fps = { value: 0, last: 0 };
-    _keyLight = null;
-    _fillLight = null;
-    _datasetQueue;
-    /** 投影模式；正交不可用时（老版本 MapLibre）自动退回透视并告警一次 */
-    _projection = 'perspective';
-    _orthoWarned = false;
-    _lodRangeScale = 1.0;
-    constructor(options = {}) {
-        this.id = options.id ?? 's3m';
-        this.options = options;
-        this.pickable = options.pickable !== false;
-        this._lodRangeScale = options.lodRangeScale ?? 1.0;
-        this._projection = options.projection === 'orthographic' ? 'orthographic' : 'perspective';
-        this.onStats = options.onStats ?? (() => { });
-        this.onReady = options.onReady ?? (() => { });
-        this.onPick = options.onPick ?? (() => { });
-        this.onError = options.onError ?? ((e) => console.warn('[s3m]', e));
-        this.groundManager = new GroundManager(options.ground);
-        this._featureStyleManager = new FeatureStyleManager(() => this.style.floorHeight, () => this.map?.triggerRepaint(), () => {
-            if (this._selection)
-                this._syncSelectionStyle();
-        }, () => this.getAllMeshes(), (mesh) => this._applyOverridesToMesh(mesh));
-        this.uniforms = createSharedUniforms();
-        this.style = { ...DEFAULT_STYLE, ...(options.style ?? {}) };
-        this.outlineMaterial = createOutlineMaterial(this.uniforms);
-        this.lineShared = createLineSharedUniforms();
-        this.edgeMaterial = createThickLineMaterial(this.lineShared, {
-            color: this.style.edgeColor,
-            opacity: this.style.edgeOpacity ?? 0.45,
-            width: this.style.edgeWidth ?? 1.2,
-        });
-        this.selectionEdgeMaterial = createThickLineMaterial(this.lineShared, {
-            color: this.style.outlineColor ?? this.style.selectColor,
-            opacity: 1,
-            width: this.style.outlineWidthPx ?? 3,
-        });
-        this._fps.last = performance.now();
-        this._datasetQueue = this._normalizeDatasets(options);
-        if (options.attributes)
-            this.attributeQuery = new AttributeQuery(options.attributes);
-    }
-    _onProjectionChange = () => {
-        this._recomputeAnchors();
-    };
-    /* ---------------------------------------------------------------- 生命周期 */
-    onAdd(map, gl) {
-        this.map = map;
-        this.renderer = new THREE.WebGLRenderer({
-            canvas: map.getCanvas(),
-            context: gl,
-            antialias: true,
-        });
-        this.renderer.autoClear = false;
-        this.renderer.setPixelRatio(1);
-        // 白模 albedo 接近 1，不做色调映射会过曝成一片纯白、丢失明暗关系
-        this.renderer.toneMapping = THREE.ACESFilmicToneMapping;
-        this.renderer.toneMappingExposure = 1.0;
-        setMaxAnisotropy(this.renderer.capabilities.getMaxAnisotropy());
-        this.scene = new THREE.Scene();
-        this.scene.add(this.groundManager.group);
-        this._addLights();
-        this.camera = new THREE.Camera();
-        this.camera.matrixAutoUpdate = false;
-        this.picker = new Picker(this.renderer);
-        this._applyStyleUniforms();
-        for (const ds of this._datasetQueue)
-            void this.addDataset(ds).catch((e) => this.onError(e));
-        this._recomputeAnchors();
-        map.on('click', this._onClick);
-        // MapLibre v6 起 setProjection() 会 fire 'projectiontransition'（style.ts 的
-        // _setProjectionInternal 里触发）。事件名必须是全称，写 'projection' 永远不会触发。
-        // v4 / v5 / Mapbox 没有这个事件，监听一个不存在的事件名是安全的（只是不 fire），
-        // 而 v4/v5 本来也不支持运行时切投影，初始投影在 onAdd 的 _recomputeAnchors 里已覆盖。
-        if (typeof map.on === 'function') {
-            map.on('projectiontransition', this._onProjectionChange);
-        }
-    }
-    onRemove() {
-        this.map?.off('click', this._onClick);
-        if (typeof this.map?.off === 'function') {
-            this.map.off('projectiontransition', this._onProjectionChange);
-        }
-        for (const id of [...this.datasets.keys()])
-            this.removeDataset(id);
-        this.groundManager.dispose();
-        this.picker?.dispose();
-        this.picker = null;
-        this.outlineMaterial.dispose();
-        this.edgeMaterial.dispose();
-        this.selectionEdgeMaterial.dispose();
-        this.scene?.clear();
-        this._selectedMeshes = [];
-        this._outlineMeshes = [];
-        this._selectionEdgeMeshes = [];
-        this._outlineMesh = null;
-        this._selectionEdges = null;
-        this._smidMeshes.clear();
-        this._meshHeight.clear();
-        this._heightMin = Infinity;
-        this._heightMax = -Infinity;
-        this.renderer?.dispose();
-        this.renderer = null;
-        this.map = null;
-    }
-    _addLights() {
-        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);
-    }
-    /**
-     * 让光照跟着地图朝向走：主光在镜头后上方偏左，补光在后上方偏右。
-     * 相当于一盏头灯，看到的立面永远是受光面。
-     */
-    _updateLights() {
-        const bearing = ((this.map?.getBearing?.() ?? 0) * Math.PI) / 180;
-        const place = (light, azOffsetDeg, elevDeg) => {
-            if (!light)
-                return;
-            const az = bearing + (azOffsetDeg * Math.PI) / 180;
-            const el = (elevDeg * Math.PI) / 180;
-            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);
-    }
-    /* ---------------------------------------------------------------- 数据集 */
-    _normalizeDatasets(options) {
-        if (Array.isArray(options.datasets))
-            return options.datasets.filter((d) => !!d?.configUrl);
-        if (options.configUrl)
-            return [{ id: 'default', name: '默认数据集', configUrl: options.configUrl }];
-        return [];
-    }
-    /** 追加一个数据集。图层 addLayer 之前调用会抛错。 */
-    async addDataset(ds) {
-        if (!this.scene)
-            throw new Error('[s3m] 图层尚未 addLayer，不能添加数据集');
-        const entry = await this._datasetManager.addDataset(ds, this.scene, this.map, this.uniforms, this._lodRangeScale, this.options.buildTile, this.options.maxTiles ?? 64, this.options.maxConcurrent ?? 4, {
-            onTile: (node, e) => {
-                this._registerTile(node, e);
-                this.onStats(this.stats);
-                this._needsRepaint = true;
-                this.map?.triggerRepaint();
-            },
-            onTileRemoved: (node, e) => {
-                this._unregisterTile(node, e);
-                this.onStats(this.stats);
-                this._needsRepaint = true;
-                this.map?.triggerRepaint();
-            },
-            onStats: () => {
-                this.onStats(this.stats);
-                this.map?.triggerRepaint();
-            },
-            onError: (e) => {
-                this.onError(e);
-                this.onStats(this.stats);
-            },
-            onReady: (e) => {
-                this.onReady(e);
-                this._refreshAllHeights();
-                if (!this.groundManager.excavationBounds) {
-                    this.groundManager.autoFitExcavation(this.datasets.values());
-                }
-            },
-            triggerRepaint: () => {
-                this.map?.triggerRepaint();
-            },
-        });
-        return entry;
-    }
-    /**
-     * 归一化世界坐标 → 经纬度 [lng, lat]
-     */
-    _lngLatFromWorld(x, y) {
-        return lngLatFromWorld(this.map, x, y);
-    }
-    /** 当地图 CRS 投影切换或宿主 map 挂载后，重新计算场景锚点与各数据集 offset */
-    _recomputeAnchors() {
-        this._datasetManager.recomputeAnchors(this.map);
-        this._refreshAllHeights();
-        this.map?.triggerRepaint();
-    }
-    /**
-     * 获取指定数据集的垂直高程偏移（米）。
-     * 若不传 id，默认获取第一个（或默认）数据集的高程偏移。
-     */
-    getDatasetHeight(id) {
-        return this._datasetManager.getDatasetHeight(id);
-    }
-    /**
-     * 设置指定数据集的垂直高程偏移（米），正数抬升，负数下降。
-     */
-    setDatasetHeight(idOrHeight, heightOffset) {
-        let id;
-        let h;
-        if (typeof idOrHeight === 'number') {
-            id = this.datasets.keys().next().value ?? '';
-            h = idOrHeight;
-        }
-        else {
-            id = idOrHeight;
-            h = heightOffset ?? 0;
-        }
-        this._datasetManager.setDatasetHeight(id, h, this.map);
-        this._refreshAllHeights();
-        this.map?.triggerRepaint();
-    }
-    /**
-     * 动态设置指定数据集的垂直对齐基准（'origin' | 'bottom' | 'top' | 'center'）。
-     */
-    setDatasetAlign(idOrAlign, align) {
-        let id;
-        let a;
-        if (align === undefined && (idOrAlign === 'origin' || idOrAlign === 'bottom' || idOrAlign === 'top' || idOrAlign === 'center')) {
-            id = this.datasets.keys().next().value ?? '';
-            a = idOrAlign;
-        }
-        else {
-            id = idOrAlign;
-            a = align ?? 'origin';
-        }
-        this._datasetManager.setDatasetAlign(id, a, this.map);
-        this._refreshAllHeights();
-        this.map?.triggerRepaint();
-    }
-    /** @internal 语义高度对齐计算代理，供内部与测试使用 */
-    _computeAlignOffset(tileset, align) {
-        return this._datasetManager.computeAlignOffset(tileset, align);
-    }
-    /* ---------------------------------------------------------------- 单体自定义样式 & 过滤 */
-    /**
-     * 为指定单体（SMID）设置独立自定义样式（颜色、拔高、透明度）。
-     */
-    setFeatureStyle(smid, style) {
-        this._featureStyleManager.setFeatureStyle(smid, style, this._meshesOf([smid]));
-    }
-    /** 批量为多个单体设置样式 */
-    setFeaturesStyle(smids, style) {
-        this._featureStyleManager.setFeaturesStyle(smids, style, this._meshesOf(smids));
-    }
-    /** 获取指定单体的自定义样式 */
-    getFeatureStyle(smid) {
-        return this._featureStyleManager.getFeatureStyle(smid);
-    }
-    /** 获取所有自定义样式的单体映射表 */
-    getFeatureStyles() {
-        return this._featureStyleManager.getFeatureStyles();
-    }
-    /** 移除指定单体的自定义样式，恢复为图层全局样式 */
-    removeFeatureStyle(smid) {
-        this._featureStyleManager.removeFeatureStyle(smid, this._meshesOf([smid]));
-    }
-    /** 清空所有单体的自定义样式 */
-    clearFeatureStyles() {
-        this._featureStyleManager.clearFeatureStyles();
-    }
-    /* ---------------------------------------------------------------- 按业务字段着色 */
-    setAttributeSource(options) {
-        this.attributeQuery = options ? new AttributeQuery(options) : null;
-    }
-    getLoadedSmids() {
-        return [...this._smidMeshes.keys()];
-    }
-    auditBatches() {
-        const res = this._featureStyleManager.auditBatches(this._pickables.values());
-        res.smids = this._smidMeshes.size;
-        return res;
-    }
-    getThematicField() {
-        return this._featureStyleManager.thematicField;
-    }
-    setThematicColors(colors, field = 'custom') {
-        this._featureStyleManager.setThematicColors(colors, field);
-    }
-    clearThematic() {
-        this._featureStyleManager.clearThematicColors();
-    }
-    /* ---------------------------------------------------------------- 按业务字段过滤 / 抬高 */
-    getFilterField() {
-        return this._featureStyleManager.fieldFilter?.field ?? null;
-    }
-    filterByField(options) {
-        return this._featureStyleManager.filterByField(options, this.attributeQuery, this.getLoadedSmids());
-    }
-    clearFieldFilter() {
-        this._featureStyleManager.clearFieldFilter();
-    }
-    getElevationField() {
-        return this._featureStyleManager.elevationField;
-    }
-    elevateByField(options) {
-        return this._featureStyleManager.elevateByField(options, this.attributeQuery, this.getLoadedSmids());
-    }
-    setThematicElevation(elevations, field = 'custom') {
-        this._featureStyleManager.setThematicElevation(elevations, field);
-    }
-    clearThematicElevation() {
-        this._featureStyleManager.clearThematicElevation();
-    }
-    colorByField(options) {
-        return this._featureStyleManager.colorByField(options, this.attributeQuery, this.getLoadedSmids());
-    }
-    setFilter(filter) {
-        this._featureStyleManager.setFilter(filter, this.uniforms);
-    }
-    getFilter() {
-        return this._featureStyleManager.filter;
-    }
-    clearFilter() {
-        this._featureStyleManager.clearFilter(this.uniforms);
-    }
-    /* ---------------------------------------------------------------- 3D 物理地表与基坑 */
-    /** 设置 3D 物理地表面渲染模式：'none' 关闭 | 'translucent' 半透明透视 | 'excavate' 基坑开挖 */
-    setGroundMode(mode) {
-        this.groundManager.setMode(mode);
-        this.map?.triggerRepaint();
-    }
-    /** 设置 3D 物理地表面不透明度 (0~1) */
-    setGroundOpacity(opacity) {
-        this.groundManager.setOpacity(opacity);
-        this.map?.triggerRepaint();
-    }
-    /** 设置基坑开挖范围 [minX, minY, maxX, maxY]（米，场景 ENU 坐标） */
-    setExcavationBounds(bounds) {
-        this.groundManager.setExcavationBounds(bounds);
-        this.map?.triggerRepaint();
-    }
-    /* ---------------------------------------------------------------- 状态纹理同步 */
-    _isFeatureHidden(smid, _batchId) {
-        if (smid == null)
-            return false;
-        const ff = this._featureStyleManager.fieldFilter;
-        if (ff) {
-            const inSet = ff.matched.has(smid);
-            if (ff.mode === 'keep' ? !inSet : inSet)
-                return true;
-        }
-        const filter = this._featureStyleManager.filter;
-        if (filter) {
-            if (filter.include && filter.include.length > 0 && !filter.include.includes(smid))
-                return true;
-            if (filter.exclude && filter.exclude.length > 0 && filter.exclude.includes(smid))
-                return true;
-        }
-        const st = this._featureStyleManager.featureStyles.get(smid);
-        if (st?.hidden)
-            return true;
-        return false;
-    }
-    getAllMeshes() {
-        const list = [];
-        for (const p of this._pickables.values())
-            list.push(p.mesh);
-        return list;
-    }
-    _meshesOf(smids) {
-        const out = new Set();
-        for (const smid of smids) {
-            const set = this._smidMeshes.get(smid);
-            if (set)
-                for (const mesh of set)
-                    out.add(mesh);
-        }
-        return out;
-    }
-    _markOverridesDirty(scope = 'all') {
-        if (scope === 'all') {
-            this._featureStyleManager.markOverridesDirty(undefined, this.getAllMeshes());
-        }
-        else {
-            this._featureStyleManager.markOverridesDirty(scope);
-        }
-    }
-    flushOverrides() {
-        this._featureStyleManager.flushOverrides();
-    }
-    /** @internal 内部状态纹理烘焙代理，保留供回归单测与钩子使用 */
-    _applyOverridesToMesh(mesh) {
-        this._featureStyleManager.applyOverridesToMesh(mesh);
-    }
-    removeDataset(id) {
-        const entry = this.datasets.get(id);
-        if (!entry)
-            return;
-        if (this._selection?.datasetId === id)
-            this.select(null);
-        this._datasetManager.removeDataset(id, this.scene, this.map, (e) => {
-            e.root.traverse((o) => {
-                const mesh = o;
-                const ud = mesh.userData;
-                if (ud.pickId != null) {
-                    this._pickables.delete(ud.pickId);
-                    this._releasePickId(ud.pickId);
-                    ud.pickId = undefined;
-                }
-                this._unindexMeshSmids(mesh);
-                this._removeMeshHeight(mesh);
-                mesh.geometry?.dispose?.();
-                const styled = styledMaterialOf(mesh);
-                if (styled)
-                    styled.dispose();
-                this._featureStyleManager.disposeMesh(mesh);
-            });
-        });
-        for (const [pickId, p] of this._pickables)
-            if (p.datasetId === id)
-                this._pickables.delete(pickId);
-        this.onStats(this.stats);
-        this.map?.triggerRepaint();
-    }
-    /** 清空当前所有数据集 */
-    clearDatasets() {
-        for (const id of [...this.datasets.keys()])
-            this.removeDataset(id);
-    }
-    setDatasetVisible(id, visible) {
-        this._datasetManager.setDatasetVisible(id, visible);
-        if (!visible && this._selection?.datasetId === id)
-            this.select(null);
-        this.map?.triggerRepaint();
-    }
-    /* ---------------------------------------------------------------- 瓦片注册 */
-    _registerTile(node, entry) {
-        entry.root.add(node.group);
-        node.group.updateMatrixWorld(true);
-        const hasNativeEdges = node.group.userData.hasNativeEdges === true;
-        for (const child of node.group.children) {
-            // 数据自带的棱线包：只跟着 edges 开关显示，不参与拾取、不参与着色
-            if (child.isLineSegments && child.userData.isEdgeLines) {
-                child.visible = this._edgesEnabled;
-                this._styleEdgeLine(child);
-                continue;
-            }
-            const mesh = child;
-            if (!mesh.isMesh)
-                continue;
-            const ud = mesh.userData;
-            ud.pickId = this._allocPickId();
-            ud.datasetId = entry.id;
-            ud.nativeEdges = hasNativeEdges;
-            this._pickables.set(ud.pickId, {
-                datasetId: entry.id,
-                mesh,
-                tile: node.tile,
-                skeletonName: ud.skeletonName ?? '',
-            });
-            this._indexMeshSmids(mesh);
-            this._addMeshHeight(mesh);
-            if (this._edgesEnabled && !hasNativeEdges)
-                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);
-            }
-        }
-    }
-    /** 瓦片被淘汰：从拾取表和场景里摘掉，并释放它自己的 GPU 资源 */
-    _unregisterTile(node, entry) {
-        for (const child of [...node.group.children]) {
-            const mesh = child;
-            if (!mesh.isMesh)
-                continue;
-            const ud = mesh.userData;
-            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;
-            }
-            this._unindexMeshSmids(mesh);
-            this._removeMeshHeight(mesh);
-            this._featureStyleManager.disposeMesh(mesh);
-            const styled = styledMaterialOf(mesh);
-            styled?.dispose?.();
-            mesh.geometry?.dispose?.();
-        }
-        entry.root.remove(node.group);
-    }
-    /**
-     * 拾取 ID 只有 2 个字节（RG 两个通道），65535 个网格就到头了，
-     * 所以必须回收：瓦片淘汰 / 数据集移除时把 id 还回池子。
-     */
-    _allocPickId() {
-        const reused = this._freePickIds.pop();
-        if (reused !== undefined)
-            return reused;
-        if (this._pickSeq > MAX_PICK_ID) {
-            for (let id = 0; id <= MAX_PICK_ID; id++)
-                if (!this._pickables.has(id))
-                    return id;
-            throw new Error(`[s3m] 可拾取网格超过 ${MAX_PICK_ID + 1} 个，2 字节 ID 编码不够用`);
-        }
-        return this._pickSeq++;
-    }
-    _releasePickId(id) {
-        this._freePickIds.push(id);
-    }
-    /* ---------------------------------------------------------------- 样式 */
-    /** 动态设置图层整体透明度 (0.0 ~ 1.0) */
-    setOpacity(opacity) {
-        this.setStyle({ opacity });
-    }
-    /** 合并并应用样式。只改 uniform 的项不会触发几何/着色器重建。 */
-    setStyle(patch = {}) {
-        this.style = { ...this.style, ...patch };
-        this._applyStyleUniforms();
-        if ('opacity' in patch || 'depthWrite' in patch)
-            this._applyOpacity();
-        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) {
-            this._refreshEdgeLines();
-        }
-        if (this._selection) {
-            // 换描边画法要重建几何；颜色 / 粗细 / 拔高只是 uniform，拖着滑块也不卡
-            if ('outline' in patch || 'outlineStyle' in patch)
-                this.select(this._selection, { silent: true });
-            else
-                this._syncSelectionStyle();
-        }
-        this.map?.triggerRepaint();
-    }
-    getStyle() {
-        return { ...this.style, modeLabel: STYLE_LABELS[this.style.mode] };
-    }
-    _applyStyleUniforms() {
-        const u = this.uniforms;
-        const s = this.style;
-        u.uMode.value = s.mode;
-        u.uColorA.value.set(s.colorA);
-        u.uColorB.value.set(s.colorB);
-        u.uColorC.value.set(s.colorC);
-        u.uSelColor.value.set(s.selectColor);
-        u.uFloorHeight.value = s.floorHeight;
-        const selMode = s.selectMode ?? SELECT_MODE.OVERLAY;
-        if (u.uSelMode) {
-            u.uSelMode.value =
-                selMode === SELECT_MODE.REPLACE
-                    ? 0
-                    : selMode === SELECT_MODE.MULTIPLY
-                        ? 2
-                        : selMode === SELECT_MODE.GLOW_ONLY
-                            ? 3
-                            : 1;
-        }
-        if (u.uSelOpacity && s.selectOpacity != null)
-            u.uSelOpacity.value = s.selectOpacity;
-        if (u.uSelEmissive && s.selectEmissive != null)
-            u.uSelEmissive.value = s.selectEmissive;
-        if (u.uSelElevation && s.selectElevation != null)
-            u.uSelElevation.value = s.selectElevation;
-        if (u.uDimFactor && s.dimFactor != null)
-            u.uDimFactor.value = s.dimFactor;
-        if (u.uRoofThreshold && s.roofThreshold != null) {
-            u.uRoofThreshold.value = s.roofThreshold;
-        }
-        if (u.uTexMix && s.texMix != null) {
-            u.uTexMix.value = s.texMix;
-        }
-        if (this.outlineMaterial) {
-            if (this.outlineMaterial.uniforms.uElevation && s.selectElevation != null) {
-                this.outlineMaterial.uniforms.uElevation.value = s.selectElevation;
-            }
-            if (s.outlineWidth != null)
-                this.outlineMaterial.uniforms.uWidth.value = s.outlineWidth;
-            if (s.outlineColor != null) {
-                this.outlineMaterial.uniforms.uColor.value.set(s.outlineColor);
-            }
-            else {
-                this.outlineMaterial.uniforms.uColor.value.set(s.selectColor);
-            }
-        }
-    }
-    /** 透明度：只改材质状态，不触发着色器重编译，所以可以跟着滑块实时拖 */
-    _applyOpacity() {
-        const o = Math.min(1, Math.max(0.05, this.style.opacity ?? 1));
-        const transparent = o < 0.999;
-        // 关键：若 depthWrite 开启（默认开启），即使半透明也保持深度写入，完美遮挡背面棱线，防止背面线条透出
-        const keepDepth = this.style.depthWrite !== false;
-        for (const p of this._pickables.values()) {
-            const m = styledMaterialOf(p.mesh);
-            if (!m)
-                continue;
-            m.opacity = o;
-            m.transparent = transparent;
-            m.depthWrite = transparent ? keepDepth : true;
-        }
-        this.map?.triggerRepaint();
-    }
-    /** 平面/平滑着色：FLAT_SHADED 是编译期宏，改它必须重编译 */
-    _applyShading() {
-        const flat = this.style.shading !== 'smooth';
-        for (const p of this._pickables.values()) {
-            const m = styledMaterialOf(p.mesh);
-            if (!m || m.flatShading === flat)
-                continue;
-            m.flatShading = flat;
-            m.needsUpdate = true;
-        }
-        this.map?.triggerRepaint();
-    }
-    /**
-     * 高度范围增量维护。
-     *
-     * 原来每注册一块瓦片都要把所有网格重新遍历一遍、每个都 clone 一个 Box3 再乘矩阵，
-     * 加载 n 块瓦片就是 O(n²) 次矩阵乘 + n² 个垃圾对象。现在只在网格进出的记一次，
-     * 全局值从缓存里滚：只有被移除的那块正好卡在边界上时，才回退到一次 O(n) 重算。
-     */
-    _addMeshHeight(mesh) {
-        const bb = mesh.geometry?.boundingBox;
-        if (!bb)
-            return;
-        this._boxScratch.copy(bb).applyMatrix4(mesh.matrixWorld);
-        const min = this._boxScratch.min.z;
-        const max = this._boxScratch.max.z;
-        if (!Number.isFinite(min) || !Number.isFinite(max))
-            return;
-        this._meshHeight.set(mesh, { min, max });
-        if (min < this._heightMin)
-            this._heightMin = min;
-        if (max > this._heightMax)
-            this._heightMax = max;
-        this._pushHeightRange();
-    }
-    _removeMeshHeight(mesh) {
-        const rec = this._meshHeight.get(mesh);
-        if (!rec)
-            return;
-        this._meshHeight.delete(mesh);
-        // 只有正好卡在边界上才需要重算，否则滚动的 min/max 依然成立
-        if (rec.min === this._heightMin || rec.max === this._heightMax)
-            this._recomputeHeightRange();
-        else
-            this._pushHeightRange();
-    }
-    /** 数据集整体位移（换高程偏移 / 重新布局）后，缓存的世界高度全部失效 */
-    _refreshAllHeights() {
-        if (this._meshHeight.size === 0)
-            return;
-        const meshes = [...this._meshHeight.keys()];
-        this._meshHeight.clear();
-        this._heightMin = Infinity;
-        this._heightMax = -Infinity;
-        for (const mesh of meshes)
-            this._addMeshHeight(mesh);
-        this._pushHeightRange();
-    }
-    _recomputeHeightRange() {
-        let min = Infinity;
-        let max = -Infinity;
-        for (const h of this._meshHeight.values()) {
-            if (h.min < min)
-                min = h.min;
-            if (h.max > max)
-                max = h.max;
-        }
-        this._heightMin = min;
-        this._heightMax = max;
-        this._pushHeightRange();
-    }
-    _pushHeightRange() {
-        let min = this._heightMin;
-        let max = this._heightMax;
-        if (!Number.isFinite(min) || !Number.isFinite(max) || max <= min) {
-            min = 0;
-            max = 100;
-        }
-        this.uniforms.uHeightMin.value = min;
-        this.uniforms.uHeightMax.value = max;
-    }
-    /** 建 SMID → 网格 反查表，逐单体改样式时才知道该重算哪几块 */
-    _indexMeshSmids(mesh) {
-        const pickInfo = mesh.userData.geoRef?.pickInfo;
-        if (!pickInfo)
-            return;
-        for (const key of Object.keys(pickInfo)) {
-            const smid = Number(key);
-            if (!Number.isFinite(smid) || smid < 0)
-                continue;
-            let set = this._smidMeshes.get(smid);
-            if (!set)
-                this._smidMeshes.set(smid, (set = new Set()));
-            set.add(mesh);
-        }
-    }
-    _unindexMeshSmids(mesh) {
-        const pickInfo = mesh.userData.geoRef?.pickInfo;
-        if (!pickInfo)
-            return;
-        for (const key of Object.keys(pickInfo)) {
-            const smid = Number(key);
-            const set = this._smidMeshes.get(smid);
-            if (!set)
-                continue;
-            set.delete(mesh);
-            if (set.size === 0)
-                this._smidMeshes.delete(smid);
-        }
-    }
-    /**
-     * 全局棱线开关。
-     *
-     * 数据自带棱线包（primitiveType 13）时直接用，成本为零；
-     * 没有的话才用 EdgesGeometry 现算 —— 那是 CPU 端的活，几十万面一次性建会卡住主线程
-     * （实测 20 个网格 1.9s），所以按 8ms 一帧切片，边建边出。
-     *
-     * 棱线本身用「屏幕空间等宽线」画（见 EdgeLines.ts）：WebGL 的 lineWidth 基本无效，
-     * 只有摊成面向屏幕的四边形，`edgeWidth` 才能真正调粗。
-     */
-    setEdges(enabled) {
-        this._edgesEnabled = enabled;
-        this.style.edges = enabled;
-        // 数据自带的棱线：直接切可见性
-        for (const entry of this.datasets.values()) {
-            entry.root.traverse((o) => {
-                const ud = o.userData;
-                if (ud.isEdgeLines) {
-                    o.visible = enabled;
-                    this._styleEdgeLine(o);
-                }
-            });
-        }
-        this._syncEdgeStyle();
-        if (!enabled) {
-            for (const p of this._pickables.values())
-                this._removeEdges(p.mesh);
-            this.map?.triggerRepaint();
-            return;
-        }
-        const pending = [...this._pickables.values()]
-            .map((p) => p.mesh)
-            .filter((m) => {
-            const ud = m.userData;
-            return !ud.edges && !ud.nativeEdges;
-        });
-        let i = 0;
-        const step = () => {
-            const t0 = performance.now();
-            while (i < pending.length && performance.now() - t0 < 8)
-                this._ensureEdges(pending[i++]);
-            if (i < pending.length)
-                setTimeout(step, 0);
-            else
-                this.map?.triggerRepaint();
-        };
-        step();
-    }
-    /** 让全局棱线材质跟上 style.edgeColor / edgeWidth / edgeOpacity */
-    _syncEdgeStyle() {
-        const s = this.style;
-        const u = this.edgeMaterial.uniforms;
-        u.uColor.value.set(s.edgeColor);
-        u.uWidth.value = Math.max(0.1, s.edgeWidth ?? 1.2);
-        u.uOpacity.value =
-            Math.min(1, Math.max(0, s.edgeOpacity ?? 0.45)) * Math.min(1, Math.max(0.05, s.opacity ?? 1));
-    }
-    /** 让数据自带的棱线跟着 style.edgeColor / opacity 走（这些是 LineBasicMaterial，改不了粗细） */
-    _styleEdgeLine(lines) {
-        const mat = lines.material;
-        if (!mat || !mat.color)
-            return;
-        mat.color.set(this.style.edgeColor);
-        const baseOpacity = this.style.edgeOpacity ?? 0.45;
-        mat.opacity = baseOpacity * Math.min(1, Math.max(0.05, this.style.opacity ?? 1));
-        mat.transparent = true;
-        mat.polygonOffset = true;
-        mat.polygonOffsetFactor = -1;
-        mat.polygonOffsetUnits = -1;
-        mat.needsUpdate = true;
-    }
-    _refreshEdgeLines() {
-        this._syncEdgeStyle();
-        for (const entry of this.datasets.values()) {
-            entry.root.traverse((o) => {
-                if (o.userData.isEdgeLines)
-                    this._styleEdgeLine(o);
-            });
-        }
-    }
-    _ensureEdges(mesh) {
-        const ud = mesh.userData;
-        if (ud.edges || ud.nativeEdges || !mesh.geometry)
-            return;
-        const indexCount = mesh.geometry.index?.count ?? 0;
-        // 棱线是 CPU 端建的，超大几何直接跳过，避免拖慢加载
-        if (indexCount > 120000)
-            return;
-        const source = new THREE.EdgesGeometry(mesh.geometry, 40);
-        const attr = source.getAttribute('position');
-        const segments = attr ? attr.array : null;
-        source.dispose();
-        if (!segments || segments.length < 6)
-            return;
-        const lines = new THREE.Mesh(buildThickLineGeometry(segments), this.edgeMaterial);
-        lines.renderOrder = 2;
-        // 屏幕空间外扩后可能超出原包围球，关掉剔除更稳
-        lines.frustumCulled = false;
-        lines.raycast = () => { };
-        lines.userData.isThickEdge = true;
-        ud.edges = lines;
-        mesh.add(lines); // 作为子节点，自动继承 mesh 的世界变换
-    }
-    _removeEdges(mesh) {
-        const ud = mesh.userData;
-        const lines = ud.edges;
-        if (!lines)
-            return;
-        mesh.remove(lines);
-        lines.geometry?.dispose();
-        ud.edges = null;
-    }
-    /* ---------------------------------------------------------------- 拾取 */
-    _onClick = (e) => {
-        if (!this.pickable)
-            return;
-        const hit = this.pickFromEvent(e);
-        if (!hit) {
-            this.select(null);
-            return;
-        }
-        this.select(hit);
-        this.onPick(hit);
-    };
-    /** 事件对象（宿主 MouseEvent 或原生事件）→ 拾取结果 */
-    pickFromEvent(e) {
-        const canvas = this.map?.getCanvas();
-        if (!canvas)
-            return null;
-        const rect = canvas.getBoundingClientRect();
-        const oe = e.originalEvent ?? e;
-        return this.pick(oe.clientX - rect.left, oe.clientY - rect.top);
-    }
-    /** 获取指定屏幕像素对应的场景射线（用于高精度求交与穿透拾取） */
-    getRayAt(x, y) {
-        if (!this.camera || !this.map)
-            return null;
-        const canvas = this.map.getCanvas();
-        const w = canvas.clientWidth || canvas.width;
-        const h = canvas.clientHeight || canvas.height;
-        if (!w || !h)
-            return null;
-        const ndcX = (x / w) * 2 - 1;
-        const ndcY = -(y / h) * 2 + 1;
-        const near = new THREE.Vector3(ndcX, ndcY, -1).unproject(this.camera);
-        const far = new THREE.Vector3(ndcX, ndcY, 1).unproject(this.camera);
-        const dir = far.clone().sub(near).normalize();
-        return new THREE.Ray(near, dir);
-    }
-    _intersectMeshAtRay(mesh, ray, instanceIndex) {
-        const raycaster = new THREE.Raycaster();
-        raycaster.ray.copy(ray);
-        const hits = raycaster.intersectObject(mesh, false);
-        if (!hits.length)
-            return null;
-        if (instanceIndex != null) {
-            const match = hits.find((h) => h.instanceId === instanceIndex);
-            return match ? match.point : hits[0].point;
-        }
-        return hits[0].point;
-    }
-    _buildPickResult(hit, ref, exactPoint, ray) {
-        const ud = ref.mesh.userData;
-        let smid = null;
-        let batchId = hit.batchId;
-        let instanceIndex = hit.instanceIndex;
-        let geoRef = ud.geoRef;
-        let segments = [];
-        if (instanceIndex != null) {
-            const feature = this._instanceFeature(ref.mesh, geoRef, instanceIndex);
-            if (!feature)
-                return null;
-            smid = feature.smid;
-            batchId = feature.batchId;
-        }
-        else {
-            geoRef = ud.geoByBatchId?.get(hit.batchId) ?? ud.geoRef;
-            const resolved = resolveFeature(geoRef, hit.batchId);
-            smid = resolved.smid;
-            segments = resolved.segments;
-        }
-        if (this._isFeatureHidden(smid, batchId))
-            return null;
-        let box = null;
-        let totalTriangles = 0;
-        if (instanceIndex != null) {
-            box = this._instanceBox(ref.mesh, instanceIndex);
-            totalTriangles = ref.mesh.geometry.index ? Math.round(ref.mesh.geometry.index.count / 3) : 0;
-        }
-        else if (smid != null && this._smidMeshes.has(smid)) {
-            const meshes = this._smidMeshes.get(smid);
-            let minX = Infinity;
-            let minY = Infinity;
-            let minZ = Infinity;
-            let maxX = -Infinity;
-            let maxY = -Infinity;
-            let maxZ = -Infinity;
-            let count = 0;
-            for (const m of meshes) {
-                const mUd = m.userData;
-                const mPick = mUd.geoRef?.pickInfo;
-                const entry = mPick?.[smid] ??
-                    mPick?.[String(smid)];
-                const bId = entry ? pickEntryId(entry) : -1;
-                const mSegs = entry?.segments ?? (bId >= 0 ? resolveFeature(mUd.geoRef, bId).segments : []);
-                const mBox = measureSegments(m.geometry, mSegs);
-                if (mBox) {
-                    if (mBox.minX < minX)
-                        minX = mBox.minX;
-                    if (mBox.minY < minY)
-                        minY = mBox.minY;
-                    if (mBox.minZ < minZ)
-                        minZ = mBox.minZ;
-                    if (mBox.maxX > maxX)
-                        maxX = mBox.maxX;
-                    if (mBox.maxY > maxY)
-                        maxY = mBox.maxY;
-                    if (mBox.maxZ > maxZ)
-                        maxZ = mBox.maxZ;
-                    count += mBox.count;
-                    totalTriangles += mBox.triangles;
-                }
-            }
-            if (count > 0) {
-                box = { minX, minY, minZ, maxX, maxY, maxZ, count, triangles: totalTriangles };
-            }
-        }
-        if (!box) {
-            box = measureSegments(ref.mesh.geometry, segments);
-            if (!box && ref.mesh.geometry) {
-                if (!ref.mesh.geometry.boundingBox)
-                    ref.mesh.geometry.computeBoundingBox();
-                const bb = ref.mesh.geometry.boundingBox;
-                if (bb) {
-                    box = {
-                        minX: bb.min.x,
-                        maxX: bb.max.x,
-                        minY: bb.min.y,
-                        maxY: bb.max.y,
-                        minZ: bb.min.z,
-                        maxZ: bb.max.z,
-                        count: 0,
-                        triangles: 0,
-                    };
-                }
-            }
-        }
-        const geometry = ref.mesh.geometry;
-        const triangles = totalTriangles > 0 ? totalTriangles : (geometry.index ? Math.round(geometry.index.count / 3) : 0);
-        const attributes = buildAttributes({ smid, box, triangles, floorHeight: this.style.floorHeight });
-        let centerLngLat = null;
-        if (box && this.sceneAnchor) {
-            const v = new THREE.Vector3((box.minX + box.maxX) / 2, (box.minY + box.maxY) / 2, (box.minZ + box.maxZ) / 2);
-            v.applyMatrix4(ref.mesh.matrixWorld);
-            const s = this.sceneAnchor.meterInMercator;
-            centerLngLat = this._lngLatFromWorld(v.x * s + this.sceneAnchor.x, -v.y * s + this.sceneAnchor.y);
-        }
-        // 精确命中点求交计算
-        let hitPoint = exactPoint ?? null;
-        if (!hitPoint && ray) {
-            hitPoint = this._intersectMeshAtRay(ref.mesh, ray, instanceIndex);
-        }
-        let point = null;
-        let lngLat = null;
-        let altitude = null;
-        if (hitPoint && this.sceneAnchor) {
-            const off = smid != null ? this._featureStyleManager.getFeatureEffectiveOffset(smid) : {};
-            const trans = off.translation;
-            const elev = off.elevation;
-            const finalPos = hitPoint.clone();
-            if (trans)
-                finalPos.add(new THREE.Vector3(trans[0], trans[1], trans[2]));
-            else if (elev)
-                finalPos.z += elev;
-            point = [finalPos.x, finalPos.y, finalPos.z];
-            const s = this.sceneAnchor.meterInMercator;
-            lngLat = this._lngLatFromWorld(finalPos.x * s + this.sceneAnchor.x, -finalPos.y * s + this.sceneAnchor.y);
-            altitude = finalPos.z + (this.sceneAnchor.altitude ?? 0);
-        }
-        else if (centerLngLat && box && this.sceneAnchor) {
-            lngLat = centerLngLat;
-            altitude = (box.minZ + box.maxZ) / 2 + (this.sceneAnchor.altitude ?? 0);
-        }
-        return {
-            datasetId: ref.datasetId,
-            datasetName: this.datasets.get(ref.datasetId)?.name ?? ref.datasetId,
-            objectId: hit.objectId,
-            batchId,
-            instanceIndex,
-            skeletonName: ref.skeletonName,
-            centerLngLat,
-            point,
-            lngLat,
-            altitude,
-            ...attributes,
-            mesh: ref.mesh,
-        };
-    }
-    /** 按 canvas 左上角的 CSS 像素坐标拾取。 */
-    pick(x, y) {
-        if (!this.picker || !this.scene || !this.camera || !this.sceneAnchor)
-            return null;
-        const hit = this.picker.pick(this.scene, this.camera, x, y);
-        if (!hit)
-            return null;
-        const ref = this._pickables.get(hit.objectId);
-        if (!ref)
-            return null;
-        const ray = this.getRayAt(x, y);
-        return this._buildPickResult(hit, ref, undefined, ray ?? undefined);
-    }
-    /**
-     * 拾取指定屏幕像素对应的世界坐标与场景位置。
-     * 优先与命中的建筑网格精确求交；未命中建筑时若视线与地表相交则返回地面交点。
-     */
-    pickPosition(x, y) {
-        if (!this.camera || !this.sceneAnchor || !this.map)
-            return null;
-        const hit = this.pick(x, y);
-        if (hit?.point && hit?.lngLat && hit.altitude != null) {
-            return {
-                lngLat: hit.lngLat,
-                altitude: hit.altitude,
-                point: hit.point,
-            };
-        }
-        const ray = this.getRayAt(x, y);
-        if (!ray)
-            return null;
-        const groundPlane = new THREE.Plane(new THREE.Vector3(0, 0, 1), 0);
-        const target = new THREE.Vector3();
-        const intersect = ray.intersectPlane(groundPlane, target);
-        if (intersect) {
-            const s = this.sceneAnchor.meterInMercator;
-            const lngLat = this._lngLatFromWorld(intersect.x * s + this.sceneAnchor.x, -intersect.y * s + this.sceneAnchor.y);
-            const altitude = intersect.z + (this.sceneAnchor.altitude ?? 0);
-            return {
-                lngLat,
-                altitude,
-                point: [intersect.x, intersect.y, intersect.z],
-            };
-        }
-        return null;
-    }
-    /**
-     * 沿视线方向穿透拾取多个单体，按由近至远排序返回。
-     */
-    drillPick(x, y, limit = 10) {
-        if (!this.sceneAnchor || !this.camera || !this.map)
-            return [];
-        const ray = this.getRayAt(x, y);
-        if (!ray)
-            return [];
-        const raycaster = new THREE.Raycaster();
-        raycaster.ray.copy(ray);
-        const meshes = [...this._pickables.values()]
-            .map((p) => p.mesh)
-            .filter((m) => {
-            let curr = m;
-            while (curr) {
-                if (!curr.visible)
-                    return false;
-                curr = curr.parent;
-            }
-            return true;
-        });
-        const hits = raycaster.intersectObjects(meshes, false);
-        if (!hits.length)
-            return [];
-        const results = [];
-        const seenSmids = new Set();
-        const seenBatches = new Set();
-        for (const hit of hits) {
-            if (results.length >= limit)
-                break;
-            const mesh = hit.object;
-            const ud = mesh.userData;
-            if (ud.pickId == null)
-                continue;
-            const ref = this._pickables.get(ud.pickId);
-            if (!ref)
-                continue;
-            let smid = null;
-            let batchId = -1;
-            let instanceIndex = hit.instanceId;
-            if (instanceIndex != null) {
-                const feature = this._instanceFeature(mesh, ud.geoRef, instanceIndex);
-                if (!feature)
-                    continue;
-                smid = feature.smid;
-                batchId = feature.batchId;
-            }
-            else if (hit.faceIndex != null) {
-                const batchAttr = mesh.geometry.attributes.aBatchId;
-                if (batchAttr) {
-                    const idx = mesh.geometry.index ? mesh.geometry.index.getX(hit.faceIndex * 3) : hit.faceIndex * 3;
-                    batchId = Math.round(batchAttr.getX(idx));
-                    const geoRef = ud.geoByBatchId?.get(batchId) ?? ud.geoRef;
-                    const resolved = resolveFeature(geoRef, batchId);
-                    smid = resolved.smid;
-                }
-            }
-            if (smid != null) {
-                if (seenSmids.has(smid))
-                    continue;
-                seenSmids.add(smid);
-            }
-            else {
-                const key = `${ud.pickId}:${batchId}:${instanceIndex ?? -1}`;
-                if (seenBatches.has(key))
-                    continue;
-                seenBatches.add(key);
-            }
-            if (this._isFeatureHidden(smid, batchId))
-                continue;
-            const pickHit = {
-                objectId: ud.pickId,
-                batchId,
-                instanceIndex,
-            };
-            const res = this._buildPickResult(pickHit, ref, hit.point);
-            if (res)
-                results.push(res);
-        }
-        return results;
-    }
-    /**
-     * 获取指定 SMID 单体的经纬度包围盒 [[minLng, minLat], [maxLng, maxLat]]。
-     * 若模型尚未加载到场景中或无此单体则返回 null。
-     */
-    getFeatureBounds(smid) {
-        if (!this.sceneAnchor)
-            return null;
-        let minLng = Infinity;
-        let maxLng = -Infinity;
-        let minLat = Infinity;
-        let maxLat = -Infinity;
-        let found = false;
-        for (const ref of this._pickables.values()) {
-            const mesh = ref.mesh;
-            const ud = mesh.userData;
-            const geoRef = ud.geoRef;
-            const pickInfo = geoRef?.pickInfo;
-            if (!pickInfo)
-                continue;
-            let box = null;
-            if (mesh.isInstancedMesh) {
-                let lookup = ud.instanceLookup;
-                if (!lookup) {
-                    lookup = buildInstanceLookup(pickInfo);
-                    ud.instanceLookup = lookup;
-                }
-                for (const [instIdx, feat] of lookup) {
-                    if (feat.smid === smid) {
-                        box = this._instanceBox(mesh, instIdx);
-                        break;
-                    }
-                }
-            }
-            else {
-                const infoMap = pickInfo;
-                const entry = infoMap[smid] ?? infoMap[String(smid)];
-                if (entry) {
-                    const bId = pickEntryId(entry);
-                    const resolved = resolveFeature(geoRef, bId);
-                    box = measureSegments(mesh.geometry, resolved.segments);
-                    if (!box && mesh.geometry) {
-                        if (!mesh.geometry.boundingBox)
-                            mesh.geometry.computeBoundingBox();
-                        const bb = mesh.geometry.boundingBox;
-                        if (bb) {
-                            box = {
-                                minX: bb.min.x,
-                                maxX: bb.max.x,
-                                minY: bb.min.y,
-                                maxY: bb.max.y,
-                                minZ: bb.min.z,
-                                maxZ: bb.max.z,
-                                count: 0,
-                                triangles: 0,
-                            };
-                        }
-                    }
-                }
-            }
-            if (box) {
-                found = true;
-                const corners = [
-                    new THREE.Vector3(box.minX, box.minY, box.minZ),
-                    new THREE.Vector3(box.maxX, box.minY, box.minZ),
-                    new THREE.Vector3(box.minX, box.maxY, box.minZ),
-                    new THREE.Vector3(box.maxX, box.maxY, box.minZ),
-                    new THREE.Vector3(box.minX, box.minY, box.maxZ),
-                    new THREE.Vector3(box.maxX, box.minY, box.maxZ),
-                    new THREE.Vector3(box.minX, box.maxY, box.maxZ),
-                    new THREE.Vector3(box.maxX, box.maxY, box.maxZ),
-                ];
-                const off = smid != null ? this._featureStyleManager.getFeatureEffectiveOffset(smid) : {};
-                const trans = off.translation;
-                const elev = off.elevation;
-                for (const c of corners) {
-                    if (trans)
-                        c.add(new THREE.Vector3(trans[0], trans[1], trans[2]));
-                    else if (elev)
-                        c.z += elev;
-                    c.applyMatrix4(mesh.matrixWorld);
-                    const s = this.sceneAnchor.meterInMercator;
-                    const [lng, lat] = this._lngLatFromWorld(c.x * s + this.sceneAnchor.x, -c.y * s + this.sceneAnchor.y);
-                    if (lng < minLng)
-                        minLng = lng;
-                    if (lng > maxLng)
-                        maxLng = lng;
-                    if (lat < minLat)
-                        minLat = lat;
-                    if (lat > maxLat)
-                        maxLat = lat;
-                }
-            }
-        }
-        if (!found)
-            return null;
-        return [
-            [minLng, minLat],
-            [maxLng, maxLat],
-        ];
-    }
-    /**
-     * 视角聚焦飞向指定 SMID 单体。
-     * @param smid 单体 SMID
-     * @param options 传给宿主 map.fitBounds 的参数（如 padding, maxZoom, duration 等）
-     * @returns 是否成功找到并触发飞向
-     */
-    flyToFeature(smid, options) {
-        const bounds = this.getFeatureBounds(smid);
-        if (!bounds || !this.map)
-            return false;
-        const mapAny = this.map;
-        if (typeof mapAny.fitBounds === 'function') {
-            mapAny.fitBounds(bounds, {
-                padding: 50,
-                maxZoom: 19,
-                duration: 1200,
-                ...options,
-            });
-            return true;
-        }
-        return false;
-    }
-    /** 实例序号 → 所属单体（按网格缓存反查表，实例多的数据不用每次重建） */
-    _instanceFeature(mesh, geoRef, instanceIndex) {
-        const ud = mesh.userData;
-        if (!ud.instanceLookup)
-            ud.instanceLookup = buildInstanceLookup(geoRef?.pickInfo);
-        return ud.instanceLookup.get(instanceIndex) ?? null;
-    }
-    /** 实例化几何的单体包围盒：base mesh 的包围盒套上该实例的矩阵 */
-    _instanceBox(mesh, instanceIndex) {
-        const im = mesh;
-        if (!im.isInstancedMesh)
-            return null;
-        const geometry = mesh.geometry;
-        if (!geometry.boundingBox)
-            geometry.computeBoundingBox();
-        const bb = geometry.boundingBox;
-        if (!bb)
-            return null;
-        const m = new THREE.Matrix4();
-        im.getMatrixAt(instanceIndex, m);
-        const box = bb.clone().applyMatrix4(m);
-        return {
-            minX: box.min.x,
-            minY: box.min.y,
-            minZ: box.min.z,
-            maxX: box.max.x,
-            maxY: box.max.y,
-            maxZ: box.max.z,
-            count: geometry.getAttribute('position')?.count ?? 0,
-            triangles: geometry.index ? Math.round(geometry.index.count / 3) : 0,
-        };
-    }
-    /** 选中/取消选中单体。`silent` 为 true 时不回调 onPick。 */
-    select(result, { silent = false } = {}) {
-        // 清掉上一次
-        if (this._selection) {
-            for (const mesh of this._selectedMeshes) {
-                const mat = styledMaterialOf(mesh);
-                if (mat) {
-                    mat.userData.uSelBatch.value = -1;
-                    mat.userData.uSelWhole.value = 0;
-                }
-            }
-            this._selectedMeshes = [];
-            this._clearSelectionDecoration();
-            this._selection = null;
-        }
-        if (!result) {
-            this.uniforms.uSelMix.value = 0;
-            this.uniforms.uDim.value = 0;
-            this.outlineMaterial.uniforms.uSelBatch.value = -1;
-            this.outlineMaterial.uniforms.uSelWhole.value = 0;
-            this.outlineMaterial.uniforms.uElevation.value = 0;
-            this.map?.triggerRepaint();
-            if (!silent)
-                this.onPick(null);
-            return;
-        }
-        this._selection = result;
-        const targetMeshes = new Set();
-        if (result.smid != null) {
-            const smidSet = this._smidMeshes.get(result.smid);
-            if (smidSet) {
-                for (const m of smidSet)
-                    targetMeshes.add(m);
-            }
-        }
-        targetMeshes.add(result.mesh);
-        for (const mesh of targetMeshes) {
-            const mat = styledMaterialOf(mesh);
-            if (!mat)
-                continue;
-            let batchId = result.batchId;
-            if (result.instanceIndex != null && mesh === result.mesh) {
-                batchId = result.batchId;
-            }
-            else if (result.smid != null) {
-                const ud = mesh.userData;
-                const pickInfo = ud.geoRef?.pickInfo;
-                const entry = pickInfo?.[result.smid] ??
-                    pickInfo?.[String(result.smid)];
-                const bId = entry ? pickEntryId(entry) : -1;
-                batchId = bId >= 0 ? bId : (mesh === result.mesh ? result.batchId : -1);
-            }
-            mat.userData.uSelBatch.value = batchId;
-            // 没有单体化信息时整块高亮，否则会出现「点中了但什么都没亮、其他全暗了」
-            mat.userData.uSelWhole.value = batchId < 0 ? 1 : 0;
-            this._selectedMeshes.push(mesh);
-        }
-        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);
-            }
-        }
-        this.map?.triggerRepaint();
-    }
-    /**
-     * 选中单体的棱线：只挑这个单体自己的三角面算折边，再画成屏幕空间等宽线。
-     * 抽出来的线段数很少（一栋楼通常几百到几千条），所以选中开销可以忽略。
-     */
-    _addSelectionEdges(result, meshes) {
-        this._syncSelectionStyle();
-        for (const mesh of meshes) {
-            const ud = mesh.userData;
-            const geoRef = ud.geoRef;
-            let segments = [];
-            if (mesh === result.mesh && result.instanceIndex != null) {
-                // 实例化几何没有逐单体的顶点区间，整个 base mesh 就是这一栋的外形
-                segments = [{ vertexOffset: 0, vertexCount: mesh.geometry.getAttribute('position')?.count ?? 0 }];
-            }
-            else if (result.smid != null) {
-                const pickInfo = geoRef?.pickInfo;
-                const entry = pickInfo?.[result.smid] ??
-                    pickInfo?.[String(result.smid)];
-                const bId = entry ? pickEntryId(entry) : -1;
-                segments = entry?.segments ?? (bId >= 0 ? resolveFeature(geoRef, bId).segments : []);
-            }
-            else if (mesh === result.mesh) {
-                const localGeo = ud.geoByBatchId?.get(result.batchId) ?? geoRef;
-                segments = resolveFeature(localGeo, result.batchId).segments;
-            }
-            const pairs = buildFeatureEdgeSegments(mesh.geometry, segments);
-            if (pairs && pairs.length > 0) {
-                const lines = new THREE.Mesh(buildThickLineGeometry(pairs), this.selectionEdgeMaterial);
-                lines.renderOrder = 4;
-                // 屏幕空间外扩后可能超出原包围球，关掉剔除更稳
-                lines.frustumCulled = false;
-                lines.raycast = () => { };
-                lines.userData.isSelectionEdge = true;
-                if (mesh === result.mesh && result.instanceIndex != null) {
-                    this._applyInstanceTransform(lines, result);
-                }
-                mesh.add(lines); // 作为子节点，直接继承世界变换
-                this._selectionEdgeMeshes.push(lines);
-            }
-        }
-        if (this._selectionEdgeMeshes.length === 0) {
-            // 抽不出折边（退化几何 / 没有任何夹角）时退回外扩轮廓，至少保证选中可见
-            this._addSelectionHull(result, meshes);
-            return;
-        }
-        this._selectionEdges = this._selectionEdgeMeshes[0] ?? null;
-    }
-    /** 实例化几何：把某个实例的矩阵套到一个普通 Mesh/子节点上（子节点不参与父级的 instanceMatrix） */
-    _applyInstanceTransform(obj, result) {
-        const im = result.mesh;
-        if (result.instanceIndex == null || !im.isInstancedMesh)
-            return;
-        const m = new THREE.Matrix4();
-        im.getMatrixAt(result.instanceIndex, m);
-        m.decompose(obj.position, obj.quaternion, obj.scale);
-    }
-    /** 旧的描边画法：背面外扩法，整块几何一起上，靠 uSelBatch 只显示选中那栋 */
-    _addSelectionHull(result, meshes) {
-        const instanced = result.instanceIndex != null;
-        // 实例化：轮廓是这个实例的单独一份副本（普通 Mesh），所以整份都画；
-        // 顶点区间型：整块几何一起画，靠 uSelBatch 只显示选中那栋。
-        this.outlineMaterial.uniforms.uSelBatch.value = instanced ? -1 : result.batchId;
-        this.outlineMaterial.uniforms.uSelWhole.value = instanced || result.batchId < 0 ? 1 : 0;
-        this.outlineMaterial.uniforms.uElevation.value = instanced
-            ? this._selectionElevation(result)
-            : this.style.selectElevation ?? 0;
-        for (const mesh of meshes) {
-            const mat = styledMaterialOf(mesh);
-            if (mat?.userData?.uBatchTex) {
-                this.outlineMaterial.uniforms.uBatchTex.value = mat.userData.uBatchTex.value;
-                this.outlineMaterial.uniforms.uBatchTexWidth.value = mat.userData.uBatchTexWidth.value;
-                this.outlineMaterial.uniforms.uBatchTexActive.value = mat.userData.uBatchTexActive.value;
-            }
-            const outline = new THREE.Mesh(mesh.geometry, this.outlineMaterial);
-            outline.renderOrder = 3;
-            outline.frustumCulled = false;
-            outline.raycast = () => { };
-            if (mesh === result.mesh && result.instanceIndex != null) {
-                this._applyInstanceTransform(outline, result);
-            }
-            mesh.add(outline); // 作为子节点，直接继承世界变换
-            this._outlineMeshes.push(outline);
-        }
-        this._outlineMesh = this._outlineMeshes[0] ?? null;
-    }
-    /** 只改 uniform：颜色 / 粗细 / 拔高，拖着滑块实时生效，不重建几何 */
-    _syncSelectionStyle() {
-        const s = this.style;
-        const u = this.selectionEdgeMaterial.uniforms;
-        u.uColor.value.set(s.outlineColor ?? s.selectColor);
-        u.uWidth.value = Math.max(0.1, s.outlineWidthPx ?? 3);
-        u.uOpacity.value = Math.min(1, Math.max(0.05, s.opacity ?? 1));
-        u.uElevation.value = this._selection ? this._selectionElevation(this._selection) : 0;
-        // 外扩描边是另一个材质实例，单体状态纹理的开关是建的时候抄过去的。
-        // 先选中、再抬高（或反过来）时模板会停留在旧值，这里补一次同步。
-        for (const outline of this._outlineMeshes) {
-            const parent = outline.parent;
-            const ud = parent ? styledMaterialOf(parent)?.userData : null;
-            if (ud?.uBatchTex) {
-                this.outlineMaterial.uniforms.uBatchTex.value = ud.uBatchTex.value;
-                this.outlineMaterial.uniforms.uBatchTexWidth.value = ud.uBatchTexWidth.value;
-                this.outlineMaterial.uniforms.uBatchTexActive.value = ud.uBatchTexActive.value;
-            }
-        }
-    }
-    /** 选中单体的实际拔高 = 全局选中拔高 + 该单体的独立拔高（与着色器口径一致） */
-    _selectionElevation(result) {
-        let elev = this.style.selectElevation ?? 0;
-        if (result.smid != null) {
-            const off = this._featureStyleManager.getFeatureEffectiveOffset(result.smid);
-            if (off.elevation)
-                elev += off.elevation;
-        }
-        return elev;
-    }
-    _clearSelectionDecoration() {
-        for (const outline of this._outlineMeshes) {
-            outline.parent?.remove(outline);
-        }
-        this._outlineMeshes = [];
-        this._outlineMesh = null;
-        for (const edges of this._selectionEdgeMeshes) {
-            edges.parent?.remove(edges);
-            edges.geometry.dispose();
-        }
-        this._selectionEdgeMeshes = [];
-        this._selectionEdges = null;
-    }
-    /* ---------------------------------------------------------------- 渲染 */
-    /** 等宽线要按设备像素换算线宽：uResolution 用绘图缓冲尺寸，uDpr 是缓冲 / CSS 的比值 */
-    _updateLineResolution(canvas) {
-        const w = canvas.width || 1;
-        const h = canvas.height || 1;
-        const cssW = canvas.clientWidth || w;
-        this.lineShared.uResolution.value.set(w, h);
-        this.lineShared.uDpr.value = Math.max(1, w / cssW);
-    }
-    /** 从 render 参数里取出 mercator→clip 矩阵，兼容 MapLibre v4 / v5 与 Mapbox 两种签名 */
-    _extractMatrix(arg) {
-        if (Array.isArray(arg))
-            return arg;
-        if (arg instanceof Float64Array || arg instanceof Float32Array)
-            return arg;
-        const o = arg;
-        return o?.defaultProjectionData?.mainMatrix ?? o?.modelViewProjectionMatrix ?? null;
-    }
-    /**
-     * 正交模式：把透视 MVP 换成同视角正交 MVP。
-     * 返回 null = 本帧保持透视（拿不到独立投影矩阵 / 矩阵不同源），只告警一次。
-     */
-    _applyOrtho(arg, mvp) {
-        const { nearZ, farZ } = extractNearFar(arg);
-        const projectionMatrix = extractProjectionMatrix(arg);
-        if (!projectionMatrix) {
-            this._warnOrtho('render() 输入里没有独立的投影矩阵（需要 MapLibre ≥ 5）');
-            return null;
-        }
-        const built = buildOrthoMVP({ projectionMatrix, mvp: mvp.elements, nearZ, farZ }, {
-            distance: this.map?.transform?.cameraToCenterDistance ?? 0,
-            fov: this._frameFov(arg),
-            aspect: this._canvasAspect(),
-        });
-        if (!built) {
-            this._warnOrtho('拿到的投影矩阵与 MVP 不同源（反推结果不是仿射变换）');
-            return null;
-        }
-        return built.matrix;
-    }
-    /** 正交不可用只告警一次，不每帧刷屏 */
-    _warnOrtho(reason) {
-        if (this._orthoWarned)
-            return;
-        this._orthoWarned = true;
-        console.warn(`[s3m] 正交模式不可用：${reason}，本帧保持透视`);
-    }
-    /**
-     * 本帧垂直视场角（弧度）。取 render() 入参的 fov（≥5 直接给弧度），
-     * 退回 transform.fovInRadians。**不用 transform.fov**：v5 起它是「度」。
-     */
-    _frameFov(arg) {
-        return extractFovRadians(arg, this.map?.transform?.fovInRadians) ?? DEFAULT_FOV;
-    }
-    _canvasAspect() {
-        const canvas = this.map?.getCanvas?.();
-        if (!canvas || !canvas.height)
-            return 1;
-        return canvas.width / canvas.height;
-    }
-    /**
-     * 切换投影模式，下一帧生效。
-     *
-     * 正交只影响本层：底图瓦片、地形、DOM Marker / 弹窗仍走 MapLibre 的透视
-     * 投影，和正交层差 ≈ 楼高 / 相机距（城市尺度几十到上百像素），App 需要
-     * 自行把这些层退出。拾取、选中描边、按单体着色/隐藏/抬高不受影响。
-     */
-    setProjection(mode) {
-        const next = mode === 'orthographic' ? 'orthographic' : 'perspective';
-        if (this._projection === next)
-            return;
-        this._projection = next;
-        this._orthoWarned = false;
-        this.map?.triggerRepaint();
-    }
-    /** 当前 LOD 切换距离缩放系数 */
-    get lodRangeScale() {
-        return this._lodRangeScale;
-    }
-    /**
-     * 动态调整 LOD 切换范围缩放系数。
-     * scale > 1 时倾向保留粗模（降低瓦片请求与面数）；scale < 1 时提前细化加载高精瓦片。
-     */
-    setLodRangeScale(scale, datasetId) {
-        if (scale <= 0)
-            return;
-        if (datasetId) {
-            const entry = this.datasets.get(datasetId);
-            if (entry?.tileset)
-                entry.tileset.lodRangeScale = scale;
-        }
-        else {
-            this._lodRangeScale = scale;
-            for (const entry of this.datasets.values()) {
-                if (entry.tileset)
-                    entry.tileset.lodRangeScale = scale;
-            }
-        }
-        this.map?.triggerRepaint();
-    }
-    /** 当前投影模式 */
-    get projection() {
-        return this._projection;
-    }
-    render(gl, arg) {
-        if (!this.renderer || !this.scene || !this.camera || !this.sceneAnchor || !this.map)
-            return;
-        // 脏标记正常由微任务刷掉；这里再兜一次底，保证「本帧画出来的」一定是最新样式
-        this.flushOverrides();
-        const matrix = this._extractMatrix(arg);
-        if (!matrix)
-            return;
-        const canvas = this.map.getCanvas();
-        const s = this.sceneAnchor.meterInMercator;
-        // ENU → Mercator：x 向东，y 向北（墨卡托 y 朝南，所以取负），z 向上
-        this._enuMatrix.set(s, 0, 0, this.sceneAnchor.x, 0, -s, 0, this.sceneAnchor.y, 0, 0, s, this.sceneAnchor.z, 0, 0, 0, 1);
-        // 正交模式：把本帧的透视投影换成同视角正交投影。视图矩阵从 MapLibre 输入
-        // 反推（P⁻¹×MVP），不是自建相机，所以不会和宿主的 pan/zoom/pitch 错位。
-        let mvp = new THREE.Matrix4().fromArray(matrix);
-        if (this._projection === 'orthographic')
-            mvp = this._applyOrtho(arg, mvp) ?? mvp;
-        mvp.multiply(this._enuMatrix);
-        this.camera.projectionMatrix.copy(mvp);
-        this.camera.projectionMatrixInverse.copy(mvp).invert();
-        // 相机在场景 ENU 中的位置
-        let camEnu = [0, 0, 0];
-        try {
-            const p = this.map.getFreeCameraOptions?.()?.position;
-            if (p) {
-                camEnu = [
-                    (p.x - this.sceneAnchor.x) / s,
-                    -(p.y - this.sceneAnchor.y) / s,
-                    (p.z - this.sceneAnchor.z) / s,
-                ];
-            }
-        }
-        catch {
-            /* FreeCamera 不可用时退回原点，只影响 LOD 精度 */
-        }
-        // 补齐相机的真实场景坐标与世界矩阵逆矩阵，确保依赖 matrixWorldInverse 的场景正常运作
-        this.camera.position.set(camEnu[0], camEnu[1], camEnu[2]);
-        this.camera.matrixWorld.setPosition(camEnu[0], camEnu[1], camEnu[2]);
-        this.camera.matrixWorldInverse.copy(this.camera.matrixWorld).invert();
-        // 更新 3D 物理地表面中心随相机延伸
-        this.groundManager.update(this.camera);
-        // 同上：弧度视场角。MapLibre v5 起 transform.fov 是「度」，当弧度用会让
-        // LOD 屏幕误差算大 20% 以上（提前加载更细的瓦片）
-        const fov = this._frameFov(arg);
-        let tilesetChanged = false;
-        for (const entry of this.datasets.values()) {
-            if (!entry.visible || !entry.tileset)
-                continue;
-            const local = [
-                camEnu[0] - entry.offset[0],
-                camEnu[1] - entry.offset[1],
-                camEnu[2] - entry.offset[2],
-            ];
-            if (entry.tileset.update(local, fov, canvas.height)) {
-                tilesetChanged = true;
-            }
-        }
-        if (this.style.mode === STYLE.DYNAMIC) {
-            this.uniforms.uTime.value += 0.016 * (this.style.speed ?? 1);
-        }
-        this._updateLights();
-        // 等宽棱线按设备像素撑开，分辨率每帧同步一次
-        this._updateLineResolution(canvas);
-        this.renderer.setViewport(0, 0, canvas.width, canvas.height);
-        this.renderer.resetState();
-        this.renderer.render(this.scene, this.camera);
-        // 动态着色 / 瓦片加载中 / 瓦片层级或可见性改变，都需要继续驱动下一帧
-        if (this.style.mode === STYLE.DYNAMIC || this.stats.loading > 0 || tilesetChanged)
-            this.map.triggerRepaint();
-        this._frame++;
-        const now = performance.now();
-        if (now - this._fps.last > 500) {
-            this._fps.value = Math.round((this._frame * 1000) / (now - this._fps.last));
-            this._frame = 0;
-            this._fps.last = now;
-        }
-    }
-    /* ---------------------------------------------------------------- 只读属性 */
-    get fps() {
-        return this._fps.value;
-    }
-    get stats() {
-        const total = {
-            tiles: 0,
-            loading: 0,
-            failed: 0,
-            meshes: 0,
-            vertices: 0,
-            triangles: 0,
-            datasets: this.datasets.size,
-        };
-        for (const entry of this.datasets.values()) {
-            const s = entry.tileset?.stats;
-            if (!s)
-                continue;
-            total.tiles += s.tiles;
-            total.loading += s.loading;
-            total.failed += s.failed;
-            total.meshes += s.meshes;
-            total.vertices += s.vertices;
-            total.triangles += s.triangles;
-        }
-        return total;
-    }
-    /** 所有数据集合并后的经纬度包围盒 */
-    getBounds() {
-        let minLon = Infinity;
-        let minLat = Infinity;
-        let maxLon = -Infinity;
-        let maxLat = -Infinity;
-        for (const entry of this.datasets.values()) {
-            const b = entry.tileset?.config?.geoBounds;
-            if (!b)
-                continue;
-            minLon = Math.min(minLon, b.left);
-            maxLon = Math.max(maxLon, b.right);
-            minLat = Math.min(minLat, b.bottom);
-            maxLat = Math.max(maxLat, b.top);
-        }
-        if (!isFinite(minLon))
-            return null;
-        return [
-            [minLon, minLat],
-            [maxLon, maxLat],
-        ];
-    }
-    dispose() {
-        this.onRemove();
-    }
-}
-export { STYLE, STYLE_LABELS, SELECT_MODE, SELECT_MODE_LABELS };
-//# sourceMappingURL=S3MLayer.js.map