s3m-three 0.4.26 → 0.4.27

package/src/render/viewer/PickService.ts

@@ -49,11 +49,30 @@ export interface PickHost {
   readonly scene: THREE.Scene | null;
   readonly canvas: HTMLCanvasElement | null;
   readonly style: { floorHeight: number };
-  readonly sceneAnchor: { x: number; y: number; z: number; meterInMercator: number; altitude?: number } | null;
+  readonly sceneAnchor: {
+    x: number;
+    y: number;
+    z: number;
+    meterInMercatorEast?: number;
+    meterInMercatorNorth?: number;
+    meterInMercator: number;
+    altitude?: number;
+  } | null;
   readonly datasets: Map<string, { name: string }>;
   readonly featureStyleManager: FeatureStyleManager;
   readonly smidMeshes: Map<number, Set<THREE.Mesh>>;
   lngLatFromWorld(x: number, y: number): [number, number];
+  /**
+   * 世界坐标 → **规范**场景 ENU（把瓦片级放置的缩放反解掉）。
+   *
+   * `perTilePlacement` 开启时瓦片几何是绕自身中心缩放 `k` 倍后摆到正确位置的，
+   * 命中点的世界坐标因此不再等于「数据本身的 ENU」。拾取要报的是坐标本身，
+   * 不能带渲染相对底图的缩放，否则同一个屋顶在 20 km 外会比 1 km 内偏出几米，
+   * 量算、贴地、外部标注全都跟着错。
+   *
+   * 未开启本功能、或网格不在已放置的瓦片里时**原样返回**（默认路径零副作用）。
+   */
+  toCanonicalScene(p: THREE.Vector3, mesh?: THREE.Object3D | null): THREE.Vector3;
   gpuPathPoseAt(smid: number): { pos: [number, number, number]; yaw: number } | null;
   isFeatureHidden(smid: number | null, batchId: number): boolean;
 }
@@ -219,8 +238,10 @@ export class PickService {
     if (box && this.host.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.host.sceneAnchor.meterInMercator;
-      centerLngLat = this.host.lngLatFromWorld(v.x * s + this.host.sceneAnchor.x, -v.y * s + this.host.sceneAnchor.y);
+      const c = this.host.toCanonicalScene(v, ref.mesh);
+      const sEast = this.host.sceneAnchor.meterInMercatorEast ?? this.host.sceneAnchor.meterInMercator;
+      const sNorth = this.host.sceneAnchor.meterInMercatorNorth ?? this.host.sceneAnchor.meterInMercator;
+      centerLngLat = this.host.lngLatFromWorld(c.x * sEast + this.host.sceneAnchor.x, -c.y * sNorth + this.host.sceneAnchor.y);
     }
 
     // 精确命中点求交计算
@@ -237,7 +258,8 @@ export class PickService {
       const off = smid != null ? this.host.featureStyleManager.getFeatureEffectiveOffset(smid) : {};
       const trans = off.translation;
       const elev = off.elevation;
-      const finalPos = hitPoint.clone();
+      // 先反解瓦片级放置，再叠单体位移 —— 位移是「米」，必须落在规范 ENU 里
+      const finalPos = this.host.toCanonicalScene(hitPoint, ref.mesh).clone();
 
       if (off.rotation) {
         const rotMat = resolveRotationMatrix(off.rotation);
@@ -256,8 +278,9 @@ export class PickService {
       else if (elev) finalPos.z += elev;
 
       point = [finalPos.x, finalPos.y, finalPos.z];
-      const s = this.host.sceneAnchor.meterInMercator;
-      lngLat = this.host.lngLatFromWorld(finalPos.x * s + this.host.sceneAnchor.x, -finalPos.y * s + this.host.sceneAnchor.y);
+      const sEast = this.host.sceneAnchor.meterInMercatorEast ?? this.host.sceneAnchor.meterInMercator;
+      const sNorth = this.host.sceneAnchor.meterInMercatorNorth ?? this.host.sceneAnchor.meterInMercator;
+      lngLat = this.host.lngLatFromWorld(finalPos.x * sEast + this.host.sceneAnchor.x, -finalPos.y * sNorth + this.host.sceneAnchor.y);
       altitude = finalPos.z + (this.host.sceneAnchor.altitude ?? 0);
     } else if (centerLngLat && box && this.host.sceneAnchor) {
       lngLat = centerLngLat;
@@ -321,16 +344,18 @@ export class PickService {
       floorHeight: this.host.style.floorHeight,
     });
 
-    const s = anchor.meterInMercator;
+    const sEast = anchor.meterInMercatorEast ?? anchor.meterInMercator;
+    const sNorth = anchor.meterInMercatorNorth ?? anchor.meterInMercator;
     let point: [number, number, number] | null = null;
     let lngLat: [number, number] | null = null;
     let altitude: number | null = null;
     let centerLngLat: [number, number] | null = null;
 
     if (hitPoint) {
-      point = [hitPoint.x, hitPoint.y, hitPoint.z];
-      lngLat = this.host.lngLatFromWorld(hitPoint.x * s + anchor.x, -hitPoint.y * s + anchor.y);
-      altitude = hitPoint.z + (anchor.altitude ?? 0);
+      const c = this.host.toCanonicalScene(hitPoint, mesh);
+      point = [c.x, c.y, c.z];
+      lngLat = this.host.lngLatFromWorld(c.x * sEast + anchor.x, -c.y * sNorth + anchor.y);
+      altitude = c.z + (anchor.altitude ?? 0);
       // 泼溅命中的就是一个高斯，没有「单体中心」可言，用命中点当中心
       centerLngLat = lngLat;
     } else if (box) {
@@ -339,8 +364,9 @@ export class PickService {
         (box.minY + box.maxY) / 2,
         (box.minZ + box.maxZ) / 2
       ).applyMatrix4(mesh.matrixWorld);
-      centerLngLat = this.host.lngLatFromWorld(v.x * s + anchor.x, -v.y * s + anchor.y);
-      altitude = v.z + (anchor.altitude ?? 0);
+      const c = this.host.toCanonicalScene(v, mesh);
+      centerLngLat = this.host.lngLatFromWorld(c.x * sEast + anchor.x, -c.y * sNorth + anchor.y);
+      altitude = c.z + (anchor.altitude ?? 0);
     }
 
     return {
@@ -395,8 +421,9 @@ export class PickService {
     const target = new THREE.Vector3();
     const intersect = ray.intersectPlane(groundPlane, target);
     if (intersect) {
-      const s = this.host.sceneAnchor.meterInMercator;
-      const lngLat = this.host.lngLatFromWorld(intersect.x * s + this.host.sceneAnchor.x, -intersect.y * s + this.host.sceneAnchor.y);
+      const sEast = this.host.sceneAnchor.meterInMercatorEast ?? this.host.sceneAnchor.meterInMercator;
+      const sNorth = this.host.sceneAnchor.meterInMercatorNorth ?? this.host.sceneAnchor.meterInMercator;
+      const lngLat = this.host.lngLatFromWorld(intersect.x * sEast + this.host.sceneAnchor.x, -intersect.y * sNorth + this.host.sceneAnchor.y);
       const altitude = intersect.z + (this.host.sceneAnchor.altitude ?? 0);
       return {
         lngLat,
@@ -643,8 +670,9 @@ export class PickService {
           if (gpuPose) c.add(new THREE.Vector3(gpuPose.pos[0], gpuPose.pos[1], gpuPose.pos[2]));
 
           c.applyMatrix4(mesh.matrixWorld);
-          const s = this.host.sceneAnchor.meterInMercator;
-          const [lng, lat] = this.host.lngLatFromWorld(c.x * s + this.host.sceneAnchor.x, -c.y * s + this.host.sceneAnchor.y);
+          const sEast = this.host.sceneAnchor.meterInMercatorEast ?? this.host.sceneAnchor.meterInMercator;
+          const sNorth = this.host.sceneAnchor.meterInMercatorNorth ?? this.host.sceneAnchor.meterInMercator;
+          const [lng, lat] = this.host.lngLatFromWorld(c.x * sEast + this.host.sceneAnchor.x, -c.y * sNorth + this.host.sceneAnchor.y);
           if (lng < minLng) minLng = lng;
           if (lng > maxLng) maxLng = lng;
           if (lat < minLat) minLat = lat;

package/src/render/viewer/types.ts

@@ -77,7 +77,23 @@ export interface LightOptions {
   altitude?: number;
 }
 
+/**
+ * 本层绘制前如何处理宿主已有的深度缓冲。
+ * - `'scene'`  保留（默认）。地形能遮挡本层几何，适用于建筑、管线等离散对象。
+ * - `'clear'`  先清深度再画，本层只与自己做深度测试。适用于贴地地面类数据（倾斜摄影、大范围 DEM 化模型等），消除共面 z-fighting。
+ * - `'auto'`   按数据集类型推断：有 ground 覆盖 / OSGB 倾斜摄影 / 地面类网格 → `'clear'`，否则 `'scene'`。
+ */
+export type DepthMode = 'scene' | 'clear' | 'auto';
+
 export interface S3MViewerOptions {
+  /**
+   * 本层绘制前如何处理宿主已有的深度缓冲。
+   * - `'scene'`  保留（默认）。地形能遮挡本层几何，适用于建筑、管线等离散对象。
+   * - `'clear'`  先清深度再画，本层只与自己做深度测试。适用于贴地地面类数据。
+   * - `'auto'`   按数据集类型推断：有 ground 覆盖 / OSGB 倾斜摄影 / 地面类网格 → `'clear'`，否则 `'scene'`。
+   * 默认 `'scene'`，与改动前行为逐字一致。
+   */
+  depthMode?: DepthMode;
   /**
    * 光照预设：
    * - `'default'`（默认）：现有 PBR 打光，亮部线性总量 ≈ 2.55；
@@ -134,6 +150,34 @@ export interface S3MViewerOptions {
    * 所以默认不启用，由接入方按设备档位自行决定。运行时可用 `setLodPixelRatioCap()` 调整。
    */
   lodPixelRatioCap?: number;
+  /**
+   * 瓦片级放置（默认 `true`）。
+   *
+   * 开启后每块瓦片用自己的中心纬度算 `meterInMercator`，几何绕自身中心缩放，
+   * 修正「全场景共用一个切平面」在大范围下的尺度误差。
+   *
+   * 误差量级（北纬 40°，距场景锚点的距离 → 相对尺度的偏差）：
+   * `5 km → 0.065%`、`20 km → 0.26%（约 26 m）`、`200 km → 2.8%（约 2.8 km）`。
+   * 城市级（几公里）随手开无妨；多数据集相距几十公里、或单个数据集跨 20 km 以上时
+   * 必须开，否则远处的模型会整体偏大/偏小。
+   *
+   * 代价与遗留：
+   * - 每块瓦片的 `Object3D` 走 `matrixAutoUpdate = false`，多一次矩阵乘；
+   * - 场景 ENU 仍是**一个平面**，所以只是把误差按瓦片重新分摊（瓦片跨 2 km 时
+   *   剩余约 0.5 m），彻底消除要逐顶点烘焙墨卡托；
+   * - 拾取 / 量算的 `lngLat ↔ 场景 ENU` 换算仍用场景锚点的常量 s，在本模式下
+   *   保持修复前的误差量级（几何与反解不再自洽，但都不比之前差）。
+   *
+   * 见 `render/tilePlacement.ts` 的文件头。
+   */
+  perTilePlacement?: boolean;
+  /**
+   * 是否对瓦片逐顶点烘焙精确 Web 墨卡托偏移（消除全球大尺度下的视差游动/呼吸效应）。
+   * - undefined（默认）：自动判定。当瓦片集根节点包围球半径 > 25 km 时自动启用，<= 25 km 时保持关闭（逐字节保持原有 ENU 顶点缓冲不变）。
+   * - true：强制开启。
+   * - false：强制关闭。
+   */
+  bakeMercator?: boolean;
   /**
    * 每个数据集驻留三角形总数的软上限（默认不限制）。
    * 见 `S3MTilesetOptions.maxTriangles`：瓦片数管不住的场景（精模、大面片）用这条刹车。
@@ -237,6 +281,13 @@ export interface S3MViewerOptions {
    * 编译着色器、卡一帧。预热在首帧之后异步做，期间跳一两帧渲染，肉眼不可见。
    */
   prewarmShading?: boolean;
+  /**
+   * LOD 细化过渡策略：
+   * - 'binary'（默认）：整节点二值切换
+   * - 'incremental'：增量细化（primary / fallback 双列表 + LEQUAL 深度推移）
+   */
+  lodTransition?: 'binary' | 'incremental';
+  fallbackOffset?: { factor?: number; units?: number };
 }
 
 /* ------------------------------------------------------------------ 内部类型 */

package/src/tileset/S3MTileset.ts

@@ -32,6 +32,7 @@ import type {
 } from '../core/S3MBlockParser.js';
 import type { Anchor, ParsedTile, Stats, StyleUniforms } from '../core/types.js';
 import type { TileGeometryData } from '../core/TileGeometry.js';
+import { AUTO_BAKE_RADIUS_THRESHOLD } from '../core/BakeMercator.js';
 import type { TextureCreateOptions } from '../render/TextureFactory.js';
 import type { Group, Texture } from 'three';
 
@@ -304,10 +305,14 @@ export type BuildTileFn = (
     colorPipeline?: 'linear' | 'direct';
     /** 纹理创建参数（透传给 buildTileObjects → createTexture） */
     textureOptions?: TextureCreateOptions;
+  bakeMercator?: boolean;
+    tileAnchor?: { lon: number; lat: number; height?: number };
+    tileCenter?: { x: number; y: number; z?: number };
   }
 ) => Promise<{ group: Group; stats: Partial<Stats> }>;
 
 export interface S3MTilesetOptions {
+  bakeMercator?: boolean;
   configUrl: string;
   maxTiles?: number;
   maxConcurrent?: number;
@@ -388,6 +393,18 @@ export interface S3MTilesetOptions {
    *   'silent' —— 只记录到 `stats.degradations`，由 UI 自己决定怎么提示。
    */
   unsupported?: UnsupportedPolicy;
+  /**
+   * LOD 细化过渡策略：
+   * - 'binary'（默认）：整节点二值切换。所有子瓦片全部就绪或失败后，父瓦片整块隐藏、子瓦片整块接替。
+   * - 'incremental'：增量细化（primary / fallback 双列表 + LEQUAL 深度推移）。
+   *   子瓦片就绪一个显示一个，未就绪区域由父级（fallback）兜底填充，消除整块跳变与慢 child 阻塞。
+   */
+  lodTransition?: 'binary' | 'incremental';
+  /**
+   * 增量细化模式下 fallback 兜底瓦片的材质深度偏移系数。
+   * 默认 { factor: 1, units: 2 }，通过向远处推移深度配合 gl.LEQUAL 消除共面 z-fighting。
+   */
+  fallbackOffset?: { factor?: number; units?: number };
 }
 
 /** 估算单个纹理占用的显存字节数 */
@@ -505,6 +522,10 @@ export class S3MTileset {
    */
   maxMemory: number;
   lodRangeScale: number;
+  lodTransition: 'binary' | 'incremental';
+  fallbackOffset: { factor: number; units: number };
+  readonly primaryNodes = new Set<string>();
+  readonly fallbackNodes = new Set<string>();
 
   /** 数据集配置声明的高度范围（米），若配置未声明则返回 null */
   get heightRange(): { min: number; max: number } | null {
@@ -535,8 +556,16 @@ export class S3MTileset {
   /** 请求量的硬上限（软上限 maxTiles 的超额余量），见构造函数注释 */
   hardCap = 96;
   /** 本数据集是 S3M 1.x（SuperMapCache，.s3m）：子瓦地址规则与 3.x 不同 */
-  private isS3MV1 = false;
+  isS3MV1 = false;
   private _buildTile: BuildTileFn | null;
+  private _bakeMercator?: boolean;
+  rootRadius?: number;
+
+  shouldBakeMercator(radius?: number): boolean {
+    if (this._bakeMercator !== undefined) return this._bakeMercator;
+    const r = radius ?? this.rootRadius ?? 0;
+    return r > AUTO_BAKE_RADIUS_THRESHOLD;
+  }
   private readonly _polygonOffset: { factor: number; units: number } | undefined;
   private _materialQuality: 'pbr' | 'lambert' | undefined;
   private _colorPipeline: 'linear' | 'direct' | undefined;
@@ -550,6 +579,11 @@ export class S3MTileset {
   constructor(options: S3MTilesetOptions) {
     this.configUrl = options.configUrl;
     this.lodRangeScale = options.lodRangeScale ?? 3.0;
+    this.lodTransition = options.lodTransition ?? 'binary';
+    this.fallbackOffset = {
+      factor: options.fallbackOffset?.factor ?? 1,
+      units: options.fallbackOffset?.units ?? 2,
+    };
     this._onTile = options.onTile ?? (() => {});
     this._onTileRemoved = options.onTileRemoved ?? (() => {});
     this._onError = options.onError ?? ((e) => console.warn(e));
@@ -560,6 +594,7 @@ export class S3MTileset {
 
     // 渲染层可注入：Node 环境下不需要 three，也能跑 URL / 解析链路
     this._buildTile = options.buildTile ?? null;
+    this._bakeMercator = options.bakeMercator;
     this._polygonOffset = options.polygonOffset;
     this._materialQuality = options.materialQuality;
     this._colorPipeline = options.colorPipeline;
@@ -903,6 +938,9 @@ export class S3MTileset {
       if (refined !== allowRefined) continue;
       // 正在显示且没有可见子瓦接手 → 踢了就是洞
       if (!allowUncovered && node.group.visible) {
+        if (this.lodTransition === 'incremental') {
+          continue;
+        }
         const covered = childUrls.some((u) => {
           const c = this.nodes.get(u);
           return !!c && c.group.visible;
@@ -1350,6 +1388,11 @@ export class S3MTileset {
       // 解析成功但能力不完整的（目前只有 3DGS），在花力气建几何之前先决定处置
       this._noteDegradations(tile);
 
+            const lodForBake = this._pickLod(tile);
+      if (this.rootRadius === undefined && lodForBake?.boundingSphere?.radius) {
+        this.rootRadius = lodForBake.boundingSphere.radius;
+      }
+      const shouldBake = this.shouldBakeMercator(lodForBake?.boundingSphere?.radius);
       const build = await this._builder();
       const buildRes = await build(tile, {
         textureCache: this.textureCache,
@@ -1359,6 +1402,9 @@ export class S3MTileset {
         materialQuality: this._materialQuality,
         colorPipeline: this._colorPipeline,
         textureOptions: this._textureOptions,
+        bakeMercator: shouldBake,
+        tileAnchor: this.anchor,
+        tileCenter: lodForBake?.boundingSphere?.center,
       });
       const { group, stats } = buildRes;
       const texKeys = (buildRes as any).textureKeys ?? (group.userData?.textureKeys as string[] | undefined) ?? Object.keys(tile.textures ?? {});
@@ -1570,10 +1616,21 @@ export class S3MTileset {
       if (!p || !this.nodes.has(p)) roots.add(url);
     }
 
-    for (const rootUrl of roots) {
-      if (this._updateNodeVisibility(rootUrl, true, visited)) {
+    if (this.lodTransition === 'incremental') {
+      if (this._updateVisibilityIncremental(roots, visited)) {
         hasChanges = true;
       }
+    } else {
+      for (const rootUrl of roots) {
+        if (this._updateNodeVisibility(rootUrl, true, visited)) {
+          hasChanges = true;
+        }
+      }
+      this.primaryNodes.clear();
+      for (const [url, node] of this.nodes) {
+        if (node.group.visible) this.primaryNodes.add(url);
+      }
+      this.fallbackNodes.clear();
     }
 
     // 防御：若有任何未被 root 树访问到的游离瓦片，全部隐藏
@@ -1583,6 +1640,9 @@ export class S3MTileset {
           node.group.visible = false;
           hasChanges = true;
         }
+        if (this.lodTransition === 'incremental') {
+          this._restoreNodePolygonOffset(node);
+        }
       }
     }
 
@@ -1674,6 +1734,169 @@ export class S3MTileset {
     return changed;
   }
 
+
+  getLodTransition(): 'binary' | 'incremental' {
+    return this.lodTransition;
+  }
+
+  setLodTransition(mode: 'binary' | 'incremental'): void {
+    if (this.lodTransition === mode) return;
+    this.lodTransition = mode;
+    if (mode === 'binary') {
+      for (const node of this.nodes.values()) {
+        this._restoreNodePolygonOffset(node);
+      }
+      this.fallbackNodes.clear();
+    }
+  }
+
+  private _applyNodeFallbackPolygonOffset(node: TileNode, depth: number): boolean {
+    const factor = this.fallbackOffset.factor;
+    const units = Math.max(2, (10 - Math.min(depth, 8)) * this.fallbackOffset.units);
+    let changed = false;
+
+    node.group.traverse((obj) => {
+      const target = obj as { isMesh?: boolean; isPoints?: boolean; isLine?: boolean; material?: any };
+      if ((target.isMesh || target.isPoints || target.isLine) && target.material) {
+        const materials = Array.isArray(target.material) ? target.material : [target.material];
+        for (const mat of materials) {
+          if (!mat) continue;
+          if (!mat.userData) mat.userData = {};
+          if (!mat.userData._basePolygonOffset) {
+            mat.userData._basePolygonOffset = {
+              polygonOffset: mat.polygonOffset === true,
+              factor: mat.polygonOffsetFactor ?? 0,
+              units: mat.polygonOffsetUnits ?? 0,
+            };
+          }
+          const base = mat.userData._basePolygonOffset;
+          const targetFactor = base.factor + factor;
+          const targetUnits = base.units + units;
+          if (
+            mat.polygonOffset !== true ||
+            mat.polygonOffsetFactor !== targetFactor ||
+            mat.polygonOffsetUnits !== targetUnits
+          ) {
+            mat.polygonOffset = true;
+            mat.polygonOffsetFactor = targetFactor;
+            mat.polygonOffsetUnits = targetUnits;
+            changed = true;
+          }
+        }
+      }
+    });
+    return changed;
+  }
+
+  private _restoreNodePolygonOffset(node: TileNode): boolean {
+    let changed = false;
+    node.group.traverse((obj) => {
+      const target = obj as { isMesh?: boolean; isPoints?: boolean; isLine?: boolean; material?: any };
+      if ((target.isMesh || target.isPoints || target.isLine) && target.material) {
+        const materials = Array.isArray(target.material) ? target.material : [target.material];
+        for (const mat of materials) {
+          if (mat?.userData?._basePolygonOffset) {
+            const base = mat.userData._basePolygonOffset;
+            if (
+              mat.polygonOffset !== base.polygonOffset ||
+              mat.polygonOffsetFactor !== base.factor ||
+              mat.polygonOffsetUnits !== base.units
+            ) {
+              mat.polygonOffset = base.polygonOffset;
+              mat.polygonOffsetFactor = base.factor;
+              mat.polygonOffsetUnits = base.units;
+              changed = true;
+            }
+          }
+        }
+      }
+    });
+    return changed;
+  }
+
+  private _updateVisibilityIncremental(roots: Iterable<string>, visited: Set<string>): boolean {
+    const nextPrimary = new Set<string>();
+    const nextFallback = new Set<string>();
+    const nodeDepths = new Map<string, number>();
+
+    const traverse = (url: string, depth: number) => {
+      if (visited.has(url)) return;
+      visited.add(url);
+      nodeDepths.set(url, depth);
+
+      const node = this.nodes.get(url);
+      if (!node) return;
+
+      const childUrls = node.childUrls ?? (node.childUrl ? [node.childUrl] : []);
+      const hasChildren = childUrls.length > 0;
+      const readyChildren = childUrls.filter((cUrl) => this.nodes.has(cUrl));
+      const missingChildren = childUrls.filter(
+        (cUrl) => !this.nodes.has(cUrl) && !this.failed.has(cUrl)
+      );
+
+      const canRefine = !!node.needRefine && hasChildren && readyChildren.length > 0;
+
+      if (canRefine) {
+        if (missingChildren.length > 0) {
+          nextFallback.add(url);
+        }
+        for (const cUrl of readyChildren) {
+          traverse(cUrl, depth + 1);
+        }
+      } else {
+        nextPrimary.add(url);
+      }
+    };
+
+    for (const rootUrl of roots) {
+      traverse(rootUrl, 0);
+    }
+
+    let changed = false;
+
+    for (const [url, node] of this.nodes) {
+      if (!visited.has(url)) continue;
+
+      if (nextPrimary.has(url)) {
+        if (!node.group.visible) {
+          node.group.visible = true;
+          changed = true;
+        }
+        const depth = nodeDepths.get(url) ?? 0;
+        const targetOrder = 100 + depth;
+        if (node.group.renderOrder !== targetOrder) {
+          node.group.renderOrder = targetOrder;
+          changed = true;
+        }
+        if (this._restoreNodePolygonOffset(node)) changed = true;
+      } else if (nextFallback.has(url)) {
+        if (!node.group.visible) {
+          node.group.visible = true;
+          changed = true;
+        }
+        const depth = nodeDepths.get(url) ?? 0;
+        const targetOrder = depth;
+        if (node.group.renderOrder !== targetOrder) {
+          node.group.renderOrder = targetOrder;
+          changed = true;
+        }
+        if (this._applyNodeFallbackPolygonOffset(node, depth)) changed = true;
+      } else {
+        if (node.group.visible) {
+          node.group.visible = false;
+          changed = true;
+        }
+        if (this._restoreNodePolygonOffset(node)) changed = true;
+      }
+    }
+
+    this.primaryNodes.clear();
+    for (const u of nextPrimary) this.primaryNodes.add(u);
+    this.fallbackNodes.clear();
+    for (const u of nextFallback) this.fallbackNodes.add(u);
+
+    return changed;
+  }
   dispose(): void {
     this._workerClient?.dispose();
     for (const node of this.nodes.values()) {