three-base 2.0.197 → 2.0.198

package/MktMesh/MktMesh.d.ts

@@ -121,6 +121,12 @@ export default class MktMesh extends Mesh<BufferGeometry, ShaderMaterial> {
     /** 当前全景纹理形态（只读）。消费方（预览立方体等自持材质的路径）据此算 `mktPanoTiledFlag`，
      *  必须与基类喂纹理处用同一个值，否则标记与地址不同源 ⇒ 整图被按 1/2 横向铺满球面（10-06 晚起纵向不分块，四槽时代是 1/4）。 */
     get panoTexMode(): PanoTexMode;
+    /** 优先加载的全景个数（存档 `textures` 的前 n 项）：**-1 = 全部、0 = 一个都不提前、n = 前 n 个**（2026-11-05 需求）。
+     *  默认取 `PANO_IMPORT_PRIORITY_DEFAULT`（=4）；宿主想换档在渲染循环跑起来之前 `setPanoPriorityCount(-1)` 一行即可
+     *  （与 `_ossSize`、`_panoTexMode` 同一套注入路径 ⇒ 编辑器与预览各自的配置各自推下来）。 */
+    private _panoPriorityCount;
+    /** 当前优先加载个数（只读，回显用）。 */
+    get panoPriorityCount(): number;
     private _tmpV3;
     /**
      * 图片平面层（⭐ 10-26 旨入库）：对象挂在**本 MktMesh 的子树**里，⛔ 不是场景根
@@ -338,6 +344,11 @@ export default class MktMesh extends Mesh<BufferGeometry, ShaderMaterial> {
      *     下一帧 `feedFaceMapping` 里共用的那份 binder 见「槽内现有形态 ≠ 目标形态」自动走整档判齐、一次换绑并同帧翻标记。
      *  编辑器 MktDevMesh 走的是自己那路（同一个 binder、同一份策略），本方法对它只是记下形态。 */
     setPanoTexMode(mode: PanoTexMode): void;
+    /** 设置优先加载的全景个数：-1 = 全部 / 0 = 不提前 / n = 存档前 n 个（2026-11-05 需求）。
+     *  收口：负数（含 -2、NaN 一类）一律归到 -1「全加载」，正数向下取整；非有限值回落默认档。
+     *  改档⛔ 需要重新 `importData` —— 名册每帧重排，下一帧 `prefetchHeadPanoramas` 直接用新数点名
+     *  （`prioritize` 幂等 ⇒ 已在队列里的那批不重复投喂，也不会把已出队的旧批再塞回去）。 */
+    setPanoPriorityCount(count: number): void;
     /**
      * 记下「当前激活（名册 0 号槽 = 中心）是第几个全景」。
      * ⭐ 皇上旨 2026-10-03 旨②：预览立方体已与墙**共用同一份材质**，原来那句「把中心那几张抄给立方体单全景材质」
@@ -499,11 +510,12 @@ export default class MktMesh extends Mesh<BufferGeometry, ShaderMaterial> {
      *  @param onModelLoad 每只 GLB 落地时回调一次（可选）——按需渲染的宿主（编辑器）拿它标脏；每帧真画的预览不传 */
     importData(data: MktMeshData, projName?: string, onModelLoad?: () => void): void;
     /**
-     * 把**存档里前 `PANO_IMPORT_PRIORITY` 个全景**按存档顺序登记进拼合器的**加载任务队列**
+     * 把**存档里前 `panoPriorityCount` 个全景**（-1 = 整份全加载）按存档顺序登记进拼合器的**加载任务队列**
      *（2026-10-29 需求「优先加载前 2 个全景素材」+ 2026-10-30 需求逐字：「给 mktmesh 内部加一个加载任务队列，
      *  把模型和平面图排在最前面，然后按照顺序，依次把前 2 个全景的顺序把瓦片加载任务添加到任务队列里面，
      *  第一个加载完了，就把这个加载任务从任务队列里面去掉，然后加载第二个；
-     *  如果后续再按照距离计算需要加载哪个全景的时候，同样地添加到加载任务队列的后面等待加载」）。
+     *  如果后续再按照距离计算需要加载哪个全景的时候，同样地添加到加载任务队列的后面等待加载」
+     *  + 2026-11-05 需求「提前加载多少个全景改由配置决定，-1 全加载 / 0 不加载 / n 前 n 个，默认 4」）。
      * 由两处渲染循环每帧点一次：基类 `onBeforeRender`（预览弹窗 / 发布页）与编辑器的 `updateFloorTexture`
      *（`MktDevMesh` 覆写了 `onBeforeRender`，只点 `syncProjInvMatrix` + `tickProgressiveReveal`，库内那句在编辑态不跑）。
      *
@@ -512,21 +524,23 @@ export default class MktMesh extends Mesh<BufferGeometry, ShaderMaterial> {
      *      （GLB 逐只 `loadModel` 不 throttle；平面那 4 片一次性 `_imgTileLoader.preload`），
      *      而全景瓦片最早也要等下一帧的 `pump` 才发第一片 ⇒ 发起次序天然是「模型 → 平面图 → 全景」，
      *      ⛔ 这里不再把它们塞进队列重复管一遍（塞了就是第二把尺）。
-     *   ② 本方法把存档 0 号、1 号依次 `prioritize` 进队列 ⇒ 拼合器每帧**只喂队首那一组**，
+     *   ② 本方法把存档 0 号起这 n 号依次 `prioritize` 进队列 ⇒ 拼合器每帧**只喂队首那一组**，
      *      0 号 32 格全落定（画进 RT，或该格本就缺地址/判死）才出队、1 号才开始发第一片。
      *      比 10-29 那版（只是把两批挪到在册顺序前面、额度仍被两批分摊）更硬：**第 1 颗独享额度，最快出全图**。
+     *      n = -1（全加载）时这一条变成「整份存档按存档顺序串行」⇒ 距离名册插不到前面，出清速度取决于总片数。
      *   ③ 名册按距离点到的其他全景走 `feedFaceMapping` 里那句 `ensure(t.tiles)`（不带队列）⇒ 只入册、
      *      排在队列后面等，队列空了才按在册顺序补料（现行口径不变）。
      * ⚠️⚠️ 为什么每帧点而⛔ 只在 `importData` 里点一记：预览每开一次都换渲染器，`_switchRenderer` 把在册组
      *   整份作废（队列里的键也在同一刻失效）；只在载入那次点名等于白点。本方法点在 `pump` 之后、名册逐槽
-     *   `ensure` 之前 ⇒ 每帧把这两记任务补回队列头部（`prioritize` 幂等，已在队列里就不挪，所以 0 号恒在 1 号前）。
+     *   `ensure` 之前 ⇒ 每帧把这几记任务补回队列头部（`prioritize` 幂等，已在队列里就不挪，所以存档次序恒不变）。
      * ⚠️ 代价如实记：
-     *   · 队列非空时**其他全景一片都不发** ⇒ 开机那几秒里，离注视点最近、但不在存档前两颗的那面墙会多灰一会儿。
+     *   · 队列非空时**其他全景一片都不发** ⇒ 开机那几秒里，离注视点最近、但不在存档前 n 颗的那面墙会多灰一会儿。
      *   · 一颗「永远下不完」的瓦片（下载失败还没累计到判死）会压住队列；判死阈值是解码失败 3 次
-     *     （`_dead`），退避重试期间队首不落定 ⇒ 第 2 颗跟着延后。真实数据里缺片是「地址为空/404」，
+     *     （`_dead`），退避重试期间队首不落定 ⇒ 后面几颗跟着延后。真实数据里缺片是「地址为空/404」，
      *     404 走三次即判死、那一格拼合涂灰 ⇒ 队列照样出清。
-     *   · 这两颗全景若本来不在开机那一刻的名册里，它们的瓦片与拼合槽 RT 会被**提前**建出来
-     *     （现行口径每颗全景 2 槽 × 6144² ≈ 384MB 显存）—— 组在运行中不淘汰，走进这两个景点迟早要建。
+     *   · 这批全景若本来不在开机那一刻的名册里，它们的瓦片与拼合槽 RT 会被**提前**建出来
+     *     （现行口径每颗全景 2 槽 × 6144² ≈ 384MB 显存）—— 组在运行中不淘汰，走进这些景点迟早要建；
+     *     ⚠️ n = -1（全加载）时这一条按存档全景总数放大，显存与在途请求都跟着涨。
      * ⚠️ 形态判据读 `this._panoTexMode`（整图形态那一档一张全景只有一张整图，走 `_texCache` 那条路，
      *   走错档就是白下 32 片）⇒ 宿主若用自己那份形态变量（编辑器的 `store.panoTexMode`），
      *   要在调 `importData` 之前先 `setPanoTexMode` 推进来，编辑器那侧已按此接线。

package/MktMesh/MktMesh.js

@@ -49,11 +49,13 @@ import { stripAssetHost, absAssetUrl } from "./assetUrl";
 //    原先各住在本站两个渲染器里一份 ⇒ 下游直接用包里的 `MktMesh` 时，存档里的 `images`/`models` 两键没人读。
 //    入库之后它们挂在 `MktMesh` **自己的子树**下，与墙同一棵变换 ⇒ 预览那三根 transform 滑杆搬得动整份展品。
 import { ImagePlane } from "./imagePlane";
-import { ModelSlot } from "./modelSlot";
+import { ModelSlot, glbFileName } from "./modelSlot";
 import { ImagePlaneTileLoader } from "./imageTileLoader";
-/** 载入 JSON 时**优先**加载几个全景的素材（2026-10-29 需求「优先加载前 2 个全景图的素材，然后再加载其他的」）。
- *  口径 = 存档 `textures` 数组的前 n 项；其余全景照常按每帧的槽位名册（离注视点最近 8 个）排队，只是排在它们后面。 */
-const PANO_IMPORT_PRIORITY = 2;
+/** 载入 JSON 时**优先**加载几个全景的素材的**默认档**（数值只写这一处）。
+ *  口径 = 存档 `textures` 数组的前 n 项（n = -1 视为整份全加载）；其余全景照常按每帧的槽位名册（离注视点最近 8 个）排队，只是排在它们后面。
+ *  2026-10-29 需求「优先加载前 2 个全景图的素材，然后再加载其他的」立的是 2；
+ *  2026-11-05 需求逐字「现在要默认把全景全部都要默认加载, 现在需要通过配置来设置, 提前加载多少个全景 -1 就是全加载 0就是不加载 1就是加载个 2就提前加载2个 一次类推, 默认加载前4个」⇒ 换成 4，并让这一档可被实例覆写。 */
+const PANO_IMPORT_PRIORITY_DEFAULT = 4;
 /** 隐藏期预热那一次绘制用的镜头（模块级共用：它只是个「有合法的投影矩阵可读」的载体，永不动 ⇒ ⛔ 不必每实例造一份）。 */
 const GPU_WARM_CAMERA = new OrthographicCamera(-1, 1, 1, -1, 0.1, 10);
 /**
@@ -193,6 +195,14 @@ export default class MktMesh extends Mesh {
     get panoTexMode() {
         return this._panoTexMode;
     }
+    /** 优先加载的全景个数（存档 `textures` 的前 n 项）：**-1 = 全部、0 = 一个都不提前、n = 前 n 个**（2026-11-05 需求）。
+     *  默认取 `PANO_IMPORT_PRIORITY_DEFAULT`（=4）；宿主想换档在渲染循环跑起来之前 `setPanoPriorityCount(-1)` 一行即可
+     *  （与 `_ossSize`、`_panoTexMode` 同一套注入路径 ⇒ 编辑器与预览各自的配置各自推下来）。 */
+    _panoPriorityCount = PANO_IMPORT_PRIORITY_DEFAULT;
+    /** 当前优先加载个数（只读，回显用）。 */
+    get panoPriorityCount() {
+        return this._panoPriorityCount;
+    }
     // 复用临时对象（避免每帧 new，降低 GC 压力）
     _tmpV3 = new Vector3();
     /**
@@ -284,6 +294,7 @@ export default class MktMesh extends Mesh {
             //   `updateTexture`（它里面那记 `pump` 是「第一次拿到 renderer ⇒ 在册组整份作废」的现场）之后、
             //   `feedFaceMapping`（名册逐槽入册）之前 —— 顺序倒过来就是「名册在前、我们垫底」= 静默失效。
             //   编辑态那份在 `MktDevMesh` 的宿主循环里照同一相对位置点（⛔ 别在这儿加第三处）。
+            //   2026-11-05 需求：这一批点几颗改由 `panoPriorityCount` 定（默认 4，-1 = 存档全部）⇒ 本句不动。
             this.prefetchHeadPanoramas();
             this.feedFaceMapping();
             this.tickProgressiveReveal();
@@ -1069,6 +1080,18 @@ export default class MktMesh extends Mesh {
             return;
         this._panoTexMode = next;
     }
+    /** 设置优先加载的全景个数：-1 = 全部 / 0 = 不提前 / n = 存档前 n 个（2026-11-05 需求）。
+     *  收口：负数（含 -2、NaN 一类）一律归到 -1「全加载」，正数向下取整；非有限值回落默认档。
+     *  改档⛔ 需要重新 `importData` —— 名册每帧重排，下一帧 `prefetchHeadPanoramas` 直接用新数点名
+     *  （`prioritize` 幂等 ⇒ 已在队列里的那批不重复投喂，也不会把已出队的旧批再塞回去）。 */
+    setPanoPriorityCount(count) {
+        if (!Number.isFinite(count))
+            this._panoPriorityCount = PANO_IMPORT_PRIORITY_DEFAULT;
+        else {
+            const n = Math.floor(count);
+            this._panoPriorityCount = n < 0 ? -1 : n;
+        }
+    }
     /**
      * 记下「当前激活（名册 0 号槽 = 中心）是第几个全景」。
      * ⭐ 皇上旨 2026-10-03 旨②：预览立方体已与墙**共用同一份材质**，原来那句「把中心那几张抄给立方体单全景材质」
@@ -1189,6 +1212,9 @@ export default class MktMesh extends Mesh {
             ms.dispose();
         }
         this.models = [];
+        // 用户 2026-11-04「日志少打印点吧」⇒ 这一路（进厅 / 切项目 / 预览的整层重建）几十颗⛔ 不再一颗一行：
+        //   名单先攒着，循环结束打**一条**（文件名口径与 `setModelUrl` 那一记共用 `glbFileName`）⇒ 一颗不落、一行到位。
+        const glbNames = [];
         for (const d of datas) {
             const ms = new ModelSlot(d.name);
             ms.applyData(d);
@@ -1200,9 +1226,12 @@ export default class MktMesh extends Mesh {
                 //（⚠️ 与旧的「GLB 在路上时这一槽露出占位方块」不同：整层重建这一路一颗都不露，直到轮到自己亮）
                 ms.visible = false;
                 this._revealPending.push(ms);
+                glbNames.push(glbFileName(d.url));
                 void ms.loadModel(d.url).then(() => this._queueModelMount(ms, onEachLoad));
             }
         }
+        if (glbNames.length > 0)
+            console.log(`[MktMesh] 整层重建加载 ${glbNames.length} 个 glb：${glbNames.join("、")}`);
     }
     /** 把「备好待挂」的那一槽交给全局队列；⛔ 去重闸门自备（`addWork` 按闭包引用判重，新闭包它判不出来） */
     _queueModelMount(ms, onEachLoad) {
@@ -1641,11 +1670,12 @@ export default class MktMesh extends Mesh {
         this.setModels((data.models ?? []).map((d) => ({ ...d, url: d.url ? absAssetUrl(d.url, pn) : "" })), onModelLoad);
     }
     /**
-     * 把**存档里前 `PANO_IMPORT_PRIORITY` 个全景**按存档顺序登记进拼合器的**加载任务队列**
+     * 把**存档里前 `panoPriorityCount` 个全景**（-1 = 整份全加载）按存档顺序登记进拼合器的**加载任务队列**
      *（2026-10-29 需求「优先加载前 2 个全景素材」+ 2026-10-30 需求逐字：「给 mktmesh 内部加一个加载任务队列，
      *  把模型和平面图排在最前面，然后按照顺序，依次把前 2 个全景的顺序把瓦片加载任务添加到任务队列里面，
      *  第一个加载完了，就把这个加载任务从任务队列里面去掉，然后加载第二个；
-     *  如果后续再按照距离计算需要加载哪个全景的时候，同样地添加到加载任务队列的后面等待加载」）。
+     *  如果后续再按照距离计算需要加载哪个全景的时候，同样地添加到加载任务队列的后面等待加载」
+     *  + 2026-11-05 需求「提前加载多少个全景改由配置决定，-1 全加载 / 0 不加载 / n 前 n 个，默认 4」）。
      * 由两处渲染循环每帧点一次：基类 `onBeforeRender`（预览弹窗 / 发布页）与编辑器的 `updateFloorTexture`
      *（`MktDevMesh` 覆写了 `onBeforeRender`，只点 `syncProjInvMatrix` + `tickProgressiveReveal`，库内那句在编辑态不跑）。
      *
@@ -1654,27 +1684,31 @@ export default class MktMesh extends Mesh {
      *      （GLB 逐只 `loadModel` 不 throttle；平面那 4 片一次性 `_imgTileLoader.preload`），
      *      而全景瓦片最早也要等下一帧的 `pump` 才发第一片 ⇒ 发起次序天然是「模型 → 平面图 → 全景」，
      *      ⛔ 这里不再把它们塞进队列重复管一遍（塞了就是第二把尺）。
-     *   ② 本方法把存档 0 号、1 号依次 `prioritize` 进队列 ⇒ 拼合器每帧**只喂队首那一组**，
+     *   ② 本方法把存档 0 号起这 n 号依次 `prioritize` 进队列 ⇒ 拼合器每帧**只喂队首那一组**，
      *      0 号 32 格全落定（画进 RT，或该格本就缺地址/判死）才出队、1 号才开始发第一片。
      *      比 10-29 那版（只是把两批挪到在册顺序前面、额度仍被两批分摊）更硬：**第 1 颗独享额度，最快出全图**。
+     *      n = -1（全加载）时这一条变成「整份存档按存档顺序串行」⇒ 距离名册插不到前面，出清速度取决于总片数。
      *   ③ 名册按距离点到的其他全景走 `feedFaceMapping` 里那句 `ensure(t.tiles)`（不带队列）⇒ 只入册、
      *      排在队列后面等，队列空了才按在册顺序补料（现行口径不变）。
      * ⚠️⚠️ 为什么每帧点而⛔ 只在 `importData` 里点一记：预览每开一次都换渲染器，`_switchRenderer` 把在册组
      *   整份作废（队列里的键也在同一刻失效）；只在载入那次点名等于白点。本方法点在 `pump` 之后、名册逐槽
-     *   `ensure` 之前 ⇒ 每帧把这两记任务补回队列头部（`prioritize` 幂等，已在队列里就不挪，所以 0 号恒在 1 号前）。
+     *   `ensure` 之前 ⇒ 每帧把这几记任务补回队列头部（`prioritize` 幂等，已在队列里就不挪，所以存档次序恒不变）。
      * ⚠️ 代价如实记：
-     *   · 队列非空时**其他全景一片都不发** ⇒ 开机那几秒里，离注视点最近、但不在存档前两颗的那面墙会多灰一会儿。
+     *   · 队列非空时**其他全景一片都不发** ⇒ 开机那几秒里，离注视点最近、但不在存档前 n 颗的那面墙会多灰一会儿。
      *   · 一颗「永远下不完」的瓦片（下载失败还没累计到判死）会压住队列；判死阈值是解码失败 3 次
-     *     （`_dead`），退避重试期间队首不落定 ⇒ 第 2 颗跟着延后。真实数据里缺片是「地址为空/404」，
+     *     （`_dead`），退避重试期间队首不落定 ⇒ 后面几颗跟着延后。真实数据里缺片是「地址为空/404」，
      *     404 走三次即判死、那一格拼合涂灰 ⇒ 队列照样出清。
-     *   · 这两颗全景若本来不在开机那一刻的名册里，它们的瓦片与拼合槽 RT 会被**提前**建出来
-     *     （现行口径每颗全景 2 槽 × 6144² ≈ 384MB 显存）—— 组在运行中不淘汰，走进这两个景点迟早要建。
+     *   · 这批全景若本来不在开机那一刻的名册里，它们的瓦片与拼合槽 RT 会被**提前**建出来
+     *     （现行口径每颗全景 2 槽 × 6144² ≈ 384MB 显存）—— 组在运行中不淘汰，走进这些景点迟早要建；
+     *     ⚠️ n = -1（全加载）时这一条按存档全景总数放大，显存与在途请求都跟着涨。
      * ⚠️ 形态判据读 `this._panoTexMode`（整图形态那一档一张全景只有一张整图，走 `_texCache` 那条路，
      *   走错档就是白下 32 片）⇒ 宿主若用自己那份形态变量（编辑器的 `store.panoTexMode`），
      *   要在调 `importData` 之前先 `setPanoTexMode` 推进来，编辑器那侧已按此接线。
      */
     prefetchHeadPanoramas() {
-        const n = Math.min(PANO_IMPORT_PRIORITY, this.textures.length);
+        const total = this.textures.length;
+        // -1 = 整份；0 = 一个都不提前（这一句直接空转，其余全景仍按距离名册排队 = 回到 10-29 之前的行为）
+        const n = this._panoPriorityCount < 0 ? total : Math.min(this._panoPriorityCount, total);
         // 正着点：0 号先入队 ⇒ 队首是它，落定后才轮到 1 号（`prioritize` 对已在队列里的键不挪位置）
         for (let i = 0; i < n; i++) {
             const info = this.textures[i];

package/MktMesh/MktMesh.ts

@@ -75,12 +75,14 @@ import { stripAssetHost, absAssetUrl } from "./assetUrl";
 //    原先各住在本站两个渲染器里一份 ⇒ 下游直接用包里的 `MktMesh` 时，存档里的 `images`/`models` 两键没人读。
 //    入库之后它们挂在 `MktMesh` **自己的子树**下，与墙同一棵变换 ⇒ 预览那三根 transform 滑杆搬得动整份展品。
 import { ImagePlane, type ImagePlaneData } from "./imagePlane";
-import { ModelSlot, type ModelSlotData } from "./modelSlot";
+import { ModelSlot, glbFileName, type ModelSlotData } from "./modelSlot";
 import { ImagePlaneTileLoader } from "./imageTileLoader";
 
-/** 载入 JSON 时**优先**加载几个全景的素材（2026-10-29 需求「优先加载前 2 个全景图的素材，然后再加载其他的」）。
- *  口径 = 存档 `textures` 数组的前 n 项；其余全景照常按每帧的槽位名册（离注视点最近 8 个）排队，只是排在它们后面。 */
-const PANO_IMPORT_PRIORITY = 2;
+/** 载入 JSON 时**优先**加载几个全景的素材的**默认档**（数值只写这一处）。
+ *  口径 = 存档 `textures` 数组的前 n 项（n = -1 视为整份全加载）；其余全景照常按每帧的槽位名册（离注视点最近 8 个）排队，只是排在它们后面。
+ *  2026-10-29 需求「优先加载前 2 个全景图的素材，然后再加载其他的」立的是 2；
+ *  2026-11-05 需求逐字「现在要默认把全景全部都要默认加载, 现在需要通过配置来设置, 提前加载多少个全景 -1 就是全加载 0就是不加载 1就是加载个 2就提前加载2个 一次类推, 默认加载前4个」⇒ 换成 4，并让这一档可被实例覆写。 */
+const PANO_IMPORT_PRIORITY_DEFAULT = 4;
 
 /** 隐藏期预热那一次绘制用的镜头（模块级共用：它只是个「有合法的投影矩阵可读」的载体，永不动 ⇒ ⛔ 不必每实例造一份）。 */
 const GPU_WARM_CAMERA = new OrthographicCamera(-1, 1, 1, -1, 0.1, 10);
@@ -231,6 +233,15 @@ export default class MktMesh extends Mesh<BufferGeometry, ShaderMaterial> {
         return this._panoTexMode;
     }
 
+    /** 优先加载的全景个数（存档 `textures` 的前 n 项）：**-1 = 全部、0 = 一个都不提前、n = 前 n 个**（2026-11-05 需求）。
+     *  默认取 `PANO_IMPORT_PRIORITY_DEFAULT`（=4）；宿主想换档在渲染循环跑起来之前 `setPanoPriorityCount(-1)` 一行即可
+     *  （与 `_ossSize`、`_panoTexMode` 同一套注入路径 ⇒ 编辑器与预览各自的配置各自推下来）。 */
+    private _panoPriorityCount: number = PANO_IMPORT_PRIORITY_DEFAULT;
+    /** 当前优先加载个数（只读，回显用）。 */
+    get panoPriorityCount(): number {
+        return this._panoPriorityCount;
+    }
+
     // 复用临时对象（避免每帧 new，降低 GC 压力）
     private _tmpV3: Vector3 = new Vector3();
 
@@ -323,6 +334,7 @@ export default class MktMesh extends Mesh<BufferGeometry, ShaderMaterial> {
             //   `updateTexture`（它里面那记 `pump` 是「第一次拿到 renderer ⇒ 在册组整份作废」的现场）之后、
             //   `feedFaceMapping`（名册逐槽入册）之前 —— 顺序倒过来就是「名册在前、我们垫底」= 静默失效。
             //   编辑态那份在 `MktDevMesh` 的宿主循环里照同一相对位置点（⛔ 别在这儿加第三处）。
+            //   2026-11-05 需求：这一批点几颗改由 `panoPriorityCount` 定（默认 4，-1 = 存档全部）⇒ 本句不动。
             this.prefetchHeadPanoramas();
             this.feedFaceMapping();
             this.tickProgressiveReveal();
@@ -1108,6 +1120,18 @@ export default class MktMesh extends Mesh<BufferGeometry, ShaderMaterial> {
         this._panoTexMode = next;
     }
 
+    /** 设置优先加载的全景个数：-1 = 全部 / 0 = 不提前 / n = 存档前 n 个（2026-11-05 需求）。
+     *  收口：负数（含 -2、NaN 一类）一律归到 -1「全加载」，正数向下取整；非有限值回落默认档。
+     *  改档⛔ 需要重新 `importData` —— 名册每帧重排，下一帧 `prefetchHeadPanoramas` 直接用新数点名
+     *  （`prioritize` 幂等 ⇒ 已在队列里的那批不重复投喂，也不会把已出队的旧批再塞回去）。 */
+    setPanoPriorityCount(count: number): void {
+        if (!Number.isFinite(count)) this._panoPriorityCount = PANO_IMPORT_PRIORITY_DEFAULT;
+        else {
+            const n = Math.floor(count);
+            this._panoPriorityCount = n < 0 ? -1 : n;
+        }
+    }
+
     /**
      * 记下「当前激活（名册 0 号槽 = 中心）是第几个全景」。
      * ⭐ 皇上旨 2026-10-03 旨②：预览立方体已与墙**共用同一份材质**，原来那句「把中心那几张抄给立方体单全景材质」
@@ -1237,6 +1261,9 @@ export default class MktMesh extends Mesh<BufferGeometry, ShaderMaterial> {
             ms.dispose();
         }
         this.models = [];
+        // 用户 2026-11-04「日志少打印点吧」⇒ 这一路（进厅 / 切项目 / 预览的整层重建）几十颗⛔ 不再一颗一行：
+        //   名单先攒着，循环结束打**一条**（文件名口径与 `setModelUrl` 那一记共用 `glbFileName`）⇒ 一颗不落、一行到位。
+        const glbNames: string[] = [];
         for (const d of datas) {
             const ms = new ModelSlot(d.name);
             ms.applyData(d);
@@ -1248,9 +1275,11 @@ export default class MktMesh extends Mesh<BufferGeometry, ShaderMaterial> {
                 //（⚠️ 与旧的「GLB 在路上时这一槽露出占位方块」不同：整层重建这一路一颗都不露，直到轮到自己亮）
                 ms.visible = false;
                 this._revealPending.push(ms);
+                glbNames.push(glbFileName(d.url));
                 void ms.loadModel(d.url).then(() => this._queueModelMount(ms, onEachLoad));
             }
         }
+        if (glbNames.length > 0) console.log(`[MktMesh] 整层重建加载 ${glbNames.length} 个 glb：${glbNames.join("、")}`);
     }
 
     /** 把「备好待挂」的那一槽交给全局队列；⛔ 去重闸门自备（`addWork` 按闭包引用判重，新闭包它判不出来） */
@@ -1683,11 +1712,12 @@ export default class MktMesh extends Mesh<BufferGeometry, ShaderMaterial> {
     }
 
     /**
-     * 把**存档里前 `PANO_IMPORT_PRIORITY` 个全景**按存档顺序登记进拼合器的**加载任务队列**
+     * 把**存档里前 `panoPriorityCount` 个全景**（-1 = 整份全加载）按存档顺序登记进拼合器的**加载任务队列**
      *（2026-10-29 需求「优先加载前 2 个全景素材」+ 2026-10-30 需求逐字：「给 mktmesh 内部加一个加载任务队列，
      *  把模型和平面图排在最前面，然后按照顺序，依次把前 2 个全景的顺序把瓦片加载任务添加到任务队列里面，
      *  第一个加载完了，就把这个加载任务从任务队列里面去掉，然后加载第二个；
-     *  如果后续再按照距离计算需要加载哪个全景的时候，同样地添加到加载任务队列的后面等待加载」）。
+     *  如果后续再按照距离计算需要加载哪个全景的时候，同样地添加到加载任务队列的后面等待加载」
+     *  + 2026-11-05 需求「提前加载多少个全景改由配置决定，-1 全加载 / 0 不加载 / n 前 n 个，默认 4」）。
      * 由两处渲染循环每帧点一次：基类 `onBeforeRender`（预览弹窗 / 发布页）与编辑器的 `updateFloorTexture`
      *（`MktDevMesh` 覆写了 `onBeforeRender`，只点 `syncProjInvMatrix` + `tickProgressiveReveal`，库内那句在编辑态不跑）。
      *
@@ -1696,27 +1726,31 @@ export default class MktMesh extends Mesh<BufferGeometry, ShaderMaterial> {
      *      （GLB 逐只 `loadModel` 不 throttle；平面那 4 片一次性 `_imgTileLoader.preload`），
      *      而全景瓦片最早也要等下一帧的 `pump` 才发第一片 ⇒ 发起次序天然是「模型 → 平面图 → 全景」，
      *      ⛔ 这里不再把它们塞进队列重复管一遍（塞了就是第二把尺）。
-     *   ② 本方法把存档 0 号、1 号依次 `prioritize` 进队列 ⇒ 拼合器每帧**只喂队首那一组**，
+     *   ② 本方法把存档 0 号起这 n 号依次 `prioritize` 进队列 ⇒ 拼合器每帧**只喂队首那一组**，
      *      0 号 32 格全落定（画进 RT，或该格本就缺地址/判死）才出队、1 号才开始发第一片。
      *      比 10-29 那版（只是把两批挪到在册顺序前面、额度仍被两批分摊）更硬：**第 1 颗独享额度，最快出全图**。
+     *      n = -1（全加载）时这一条变成「整份存档按存档顺序串行」⇒ 距离名册插不到前面，出清速度取决于总片数。
      *   ③ 名册按距离点到的其他全景走 `feedFaceMapping` 里那句 `ensure(t.tiles)`（不带队列）⇒ 只入册、
      *      排在队列后面等，队列空了才按在册顺序补料（现行口径不变）。
      * ⚠️⚠️ 为什么每帧点而⛔ 只在 `importData` 里点一记：预览每开一次都换渲染器，`_switchRenderer` 把在册组
      *   整份作废（队列里的键也在同一刻失效）；只在载入那次点名等于白点。本方法点在 `pump` 之后、名册逐槽
-     *   `ensure` 之前 ⇒ 每帧把这两记任务补回队列头部（`prioritize` 幂等，已在队列里就不挪，所以 0 号恒在 1 号前）。
+     *   `ensure` 之前 ⇒ 每帧把这几记任务补回队列头部（`prioritize` 幂等，已在队列里就不挪，所以存档次序恒不变）。
      * ⚠️ 代价如实记：
-     *   · 队列非空时**其他全景一片都不发** ⇒ 开机那几秒里，离注视点最近、但不在存档前两颗的那面墙会多灰一会儿。
+     *   · 队列非空时**其他全景一片都不发** ⇒ 开机那几秒里，离注视点最近、但不在存档前 n 颗的那面墙会多灰一会儿。
      *   · 一颗「永远下不完」的瓦片（下载失败还没累计到判死）会压住队列；判死阈值是解码失败 3 次
-     *     （`_dead`），退避重试期间队首不落定 ⇒ 第 2 颗跟着延后。真实数据里缺片是「地址为空/404」，
+     *     （`_dead`），退避重试期间队首不落定 ⇒ 后面几颗跟着延后。真实数据里缺片是「地址为空/404」，
      *     404 走三次即判死、那一格拼合涂灰 ⇒ 队列照样出清。
-     *   · 这两颗全景若本来不在开机那一刻的名册里，它们的瓦片与拼合槽 RT 会被**提前**建出来
-     *     （现行口径每颗全景 2 槽 × 6144² ≈ 384MB 显存）—— 组在运行中不淘汰，走进这两个景点迟早要建。
+     *   · 这批全景若本来不在开机那一刻的名册里，它们的瓦片与拼合槽 RT 会被**提前**建出来
+     *     （现行口径每颗全景 2 槽 × 6144² ≈ 384MB 显存）—— 组在运行中不淘汰，走进这些景点迟早要建；
+     *     ⚠️ n = -1（全加载）时这一条按存档全景总数放大，显存与在途请求都跟着涨。
      * ⚠️ 形态判据读 `this._panoTexMode`（整图形态那一档一张全景只有一张整图，走 `_texCache` 那条路，
      *   走错档就是白下 32 片）⇒ 宿主若用自己那份形态变量（编辑器的 `store.panoTexMode`），
      *   要在调 `importData` 之前先 `setPanoTexMode` 推进来，编辑器那侧已按此接线。
      */
     prefetchHeadPanoramas(): void {
-        const n = Math.min(PANO_IMPORT_PRIORITY, this.textures.length);
+        const total = this.textures.length;
+        // -1 = 整份；0 = 一个都不提前（这一句直接空转，其余全景仍按距离名册排队 = 回到 10-29 之前的行为）
+        const n = this._panoPriorityCount < 0 ? total : Math.min(this._panoPriorityCount, total);
         // 正着点：0 号先入队 ⇒ 队首是它，落定后才轮到 1 号（`prioritize` 对已在队列里的键不挪位置）
         for (let i = 0; i < n; i++) {
             const info = this.textures[i];

package/MktMesh/imagePlane.d.ts

@@ -39,6 +39,10 @@ export declare class ImagePlane extends Mesh<PlaneGeometry, MeshBasicMaterial> {
     private _data;
     /** 内容是否已落定：4 格里至少有一格真的绑上了纹理。**只朝 true 翻一次**（之后逐张显影继续，但不再回退成「没内容」）。 */
     private _loaded;
+    /** 此刻是不是编辑器的选中态（决定上不上黄、边框亮不亮） */
+    private _selected;
+    /** 选中边框：懒建（预览/发布那一路从不选中 ⇒ 一颗都不建） */
+    private _outline;
     constructor(name?: string);
     get imageWidth(): number;
     get imageHeight(): number;
@@ -57,6 +61,16 @@ export declare class ImagePlane extends Mesh<PlaneGeometry, MeshBasicMaterial> {
     tilesBindingStamp(): string;
     highlight(): void;
     restoreColor(): void;
+    /**
+     * 选中态的三样东西一起算（颜色 + 边框），一处规则：
+     * - 黄只在**还没上传图**那一档：片元里贴图是乘进 diffuse 的（`diffuseColor *= imgTexel`），有图还套黄 ⇒ 整张图发黄。
+     * - 边框在有图/没图两档都亮：没图那四格是整格 `discard`（一个像素都不落），只靠黄等于没有反馈，看不见也找不着。
+     */
+    private _syncSelection;
+    /** 选中边框懒建：预览/发布那一路从不选中 ⇒ 一颗 LineSegments2 都不建（与模型槽那圈 `BoxLine2` 同口径） */
+    private _ensureOutline;
+    /** 四条边按当前几何的宽高铺在平面那一平面上（局部 z=0，中心为原点） */
+    private _layoutOutline;
     toData(): ImagePlaneData;
     applyData(d: ImagePlaneData): void;
     dispose(): void;

package/MktMesh/imagePlane.js

@@ -16,7 +16,10 @@
  *     而是直接 discrad 丢弃」⇒ 默认图与缺图灰两条都已删，没就绪就是透明没有。）
  * - UV 标准 [0,1]²（PlaneGeometry 自带），4 张瓦片按 2×2 象限铺满 ⇒ 不需要投影 shader，也不需要离屏 RT。
  */
-import { Color, DataTexture, FrontSide, Mesh, MeshBasicMaterial, PlaneGeometry, RGBAFormat, Vector4, } from "three";
+import { Color, DataTexture, FrontSide, Mesh, MeshBasicMaterial, PlaneGeometry, RGBAFormat, Vector2, Vector4, } from "three";
+import { LineMaterial } from "three/examples/jsm/lines/LineMaterial.js";
+import { LineSegments2 } from "three/examples/jsm/lines/LineSegments2.js";
+import { LineSegmentsGeometry } from "three/examples/jsm/lines/LineSegmentsGeometry.js";
 /*
  * ⭐ 2026-10-22 晚旨：图片平面**不用拼合器 RT**，直接把上传切好的 4 张瓦片纹理绑到材质，
  * 片元按 UV 象限选片 + 用每片 `rtStitchTileInset` 窗口采样（与上传切片共用同一份几何 ⇒ 接缝不回潮）。
@@ -61,6 +64,9 @@ const IMG_PLANE_MAP_FRAG = `
 const DEFAULT_WIDTH = 2;
 const DEFAULT_HEIGHT = 1.5;
 const HIGHLIGHT_COLOR = "#ffd24a";
+/** 选中边框：颜色/粗细与模型槽那圈 `BoxLine2` 的朝向相机的棱同一档（0x00ff00 / 2 屏幕像素） */
+const SELECT_LINE_COLOR = 0x00ff00;
+const SELECT_LINE_WIDTH_PX = 2;
 export class ImagePlane extends Mesh {
     _originalColor = "#ffffff";
     _uTiles;
@@ -72,6 +78,10 @@ export class ImagePlane extends Mesh {
     };
     /** 内容是否已落定：4 格里至少有一格真的绑上了纹理。**只朝 true 翻一次**（之后逐张显影继续，但不再回退成「没内容」）。 */
     _loaded = false;
+    /** 此刻是不是编辑器的选中态（决定上不上黄、边框亮不亮） */
+    _selected = false;
+    /** 选中边框：懒建（预览/发布那一路从不选中 ⇒ 一颗都不建） */
+    _outline = null;
     constructor(name) {
         const geo = new PlaneGeometry(DEFAULT_WIDTH, DEFAULT_HEIGHT);
         const mat = new MeshBasicMaterial({
@@ -115,6 +125,7 @@ export class ImagePlane extends Mesh {
     setPlaneSize(w, h) {
         this.geometry.dispose();
         this.geometry = new PlaneGeometry(w, h);
+        this._layoutOutline(); // 边框跟着宽高走，否则面板改完尺寸框还停在旧那一圈
     }
     setPlaneData(d) {
         this._data = { url: d.url, tiles: d.tiles, naturalW: d.naturalW, naturalH: d.naturalH };
@@ -125,6 +136,7 @@ export class ImagePlane extends Mesh {
     get naturalH() { return this._data.naturalH; }
     /** 把上传切好的 4 张瓦片纹理 + 每片 inset 绑到材质（缺图那片传 null ⇒ 那一片整格 discard，不落像素）。uTiles 用持久对象引用 ⇒ 改 value 实时生效 */
     setTileTextures(texs, insets) {
+        const hadContent = this._loaded;
         for (let i = 0; i < 4; i++) {
             const t = texs[i] || null;
             this._uTiles.value[i] = t || PLACEHOLDER_TEX;
@@ -136,6 +148,10 @@ export class ImagePlane extends Mesh {
             if (t)
                 this._loaded = true;
         }
+        // 上传前这颗是选中态（黄），第一张图一到就把黄摘掉 ⇒ 否则「有图不上色」只在再次选中时才生效，
+        // 而他报的正是「上传后」那一刻。
+        if (!hadContent && this._loaded)
+            this._syncSelection();
     }
     /** 只读「此刻材质里绑了什么」的戳记：4 格就绪位 + 已绑纹理的版本号。
      *  按需渲染的宿主拿它比对画面：逐帧绑定只写 uniform 值，⛔ 不动 `material.version`、也不动几何 ⇒ 场景指纹看不见这一变。 */
@@ -148,10 +164,66 @@ export class ImagePlane extends Mesh {
         return s;
     }
     highlight() {
-        this.material.color.set(HIGHLIGHT_COLOR);
+        this._selected = true;
+        this._syncSelection();
     }
     restoreColor() {
-        this.material.color.set(this._originalColor);
+        this._selected = false;
+        this._syncSelection();
+    }
+    /**
+     * 选中态的三样东西一起算（颜色 + 边框），一处规则：
+     * - 黄只在**还没上传图**那一档：片元里贴图是乘进 diffuse 的（`diffuseColor *= imgTexel`），有图还套黄 ⇒ 整张图发黄。
+     * - 边框在有图/没图两档都亮：没图那四格是整格 `discard`（一个像素都不落），只靠黄等于没有反馈，看不见也找不着。
+     */
+    _syncSelection() {
+        this.material.color.set(this._selected && !this._loaded ? HIGHLIGHT_COLOR : this._originalColor);
+        if (!this._selected) {
+            if (this._outline)
+                this._outline.visible = false;
+            return;
+        }
+        this._ensureOutline();
+        this._layoutOutline();
+    }
+    /** 选中边框懒建：预览/发布那一路从不选中 ⇒ 一颗 LineSegments2 都不建（与模型槽那圈 `BoxLine2` 同口径） */
+    _ensureOutline() {
+        if (this._outline)
+            return;
+        const material = new LineMaterial({
+            color: SELECT_LINE_COLOR,
+            worldUnits: false,
+            linewidth: SELECT_LINE_WIDTH_PX,
+            // ⚠️ `depthTest: false`：这一圈就躺在平面自己那一平面上，留着深度测试必与图打摆（闪烁）
+            depthTest: false,
+            resolution: new Vector2(1, 1),
+        });
+        const outline = new LineSegments2(new LineSegmentsGeometry(), material);
+        outline.name = `${this.name}-选中边框`;
+        outline.renderOrder = 100; // 与 `BoxLine2` 那圈同档：压在图/墙之后
+        outline.frustumCulled = false;
+        outline.userData.pickIgnored = true;
+        outline.raycast = () => { }; // 拾取打平面本体，边框不是可点的东西
+        outline.onBeforeRender = (renderer) => {
+            renderer.getSize(material.resolution); // 屏幕像素粗细要每帧拿画布尺寸
+        };
+        this.add(outline);
+        this._outline = outline;
+    }
+    /** 四条边按当前几何的宽高铺在平面那一平面上（局部 z=0，中心为原点） */
+    _layoutOutline() {
+        if (!this._outline)
+            return;
+        const w = this.imageWidth / 2;
+        const h = this.imageHeight / 2;
+        const c = [
+            [-w, -h, 0], [w, -h, 0],
+            [w, -h, 0], [w, h, 0],
+            [w, h, 0], [-w, h, 0],
+            [-w, h, 0], [-w, -h, 0],
+        ].flat();
+        this._outline.geometry.setPositions(c);
+        this._outline.visible = true;
     }
     toData() {
         return {
@@ -177,6 +249,10 @@ export class ImagePlane extends Mesh {
     dispose() {
         this.geometry.dispose();
         this.material.dispose();
+        if (this._outline) {
+            this._outline.geometry.dispose();
+            this._outline.material.dispose();
+        }
     }
 }
 export const IMAGE_PLANE_DEFAULTS = { width: DEFAULT_WIDTH, height: DEFAULT_HEIGHT };

package/MktMesh/imagePlane.ts

@@ -25,8 +25,13 @@ import {
     PlaneGeometry,
     RGBAFormat,
     Texture,
+    Vector2,
     Vector4,
+    WebGLRenderer,
 } from "three";
+import { LineMaterial } from "three/examples/jsm/lines/LineMaterial.js";
+import { LineSegments2 } from "three/examples/jsm/lines/LineSegments2.js";
+import { LineSegmentsGeometry } from "three/examples/jsm/lines/LineSegmentsGeometry.js";
 
 /*
  * ⭐ 2026-10-22 晚旨：图片平面**不用拼合器 RT**，直接把上传切好的 4 张瓦片纹理绑到材质，
@@ -92,6 +97,9 @@ export interface ImagePlaneData {
 const DEFAULT_WIDTH = 2;
 const DEFAULT_HEIGHT = 1.5;
 const HIGHLIGHT_COLOR = "#ffd24a";
+/** 选中边框：颜色/粗细与模型槽那圈 `BoxLine2` 的朝向相机的棱同一档（0x00ff00 / 2 屏幕像素） */
+const SELECT_LINE_COLOR = 0x00ff00;
+const SELECT_LINE_WIDTH_PX = 2;
 
 export class ImagePlane extends Mesh<PlaneGeometry, MeshBasicMaterial> {
     private _originalColor: string = "#ffffff";
@@ -104,6 +112,10 @@ export class ImagePlane extends Mesh<PlaneGeometry, MeshBasicMaterial> {
     };
     /** 内容是否已落定：4 格里至少有一格真的绑上了纹理。**只朝 true 翻一次**（之后逐张显影继续，但不再回退成「没内容」）。 */
     private _loaded = false;
+    /** 此刻是不是编辑器的选中态（决定上不上黄、边框亮不亮） */
+    private _selected = false;
+    /** 选中边框：懒建（预览/发布那一路从不选中 ⇒ 一颗都不建） */
+    private _outline: LineSegments2 | null = null;
 
     constructor(name?: string) {
         const geo = new PlaneGeometry(DEFAULT_WIDTH, DEFAULT_HEIGHT);
@@ -153,6 +165,7 @@ export class ImagePlane extends Mesh<PlaneGeometry, MeshBasicMaterial> {
     setPlaneSize(w: number, h: number): void {
         this.geometry.dispose();
         this.geometry = new PlaneGeometry(w, h);
+        this._layoutOutline(); // 边框跟着宽高走，否则面板改完尺寸框还停在旧那一圈
     }
 
     setPlaneData(d: Pick<ImagePlaneData, "url" | "tiles" | "naturalW" | "naturalH">): void {
@@ -166,6 +179,7 @@ export class ImagePlane extends Mesh<PlaneGeometry, MeshBasicMaterial> {
 
     /** 把上传切好的 4 张瓦片纹理 + 每片 inset 绑到材质（缺图那片传 null ⇒ 那一片整格 discard，不落像素）。uTiles 用持久对象引用 ⇒ 改 value 实时生效 */
     setTileTextures(texs: (Texture | null)[], insets: Vector4[]): void {
+        const hadContent = this._loaded;
         for (let i = 0; i < 4; i++) {
             const t = texs[i] || null;
             this._uTiles.value[i] = t || PLACEHOLDER_TEX;
@@ -175,6 +189,9 @@ export class ImagePlane extends Mesh<PlaneGeometry, MeshBasicMaterial> {
             // 「逐张就绪逐张显影」是本文件 10-22 晚定下的口径，等到全到齐会让先到的那几格白等几帧）。
             if (t) this._loaded = true;
         }
+        // 上传前这颗是选中态（黄），第一张图一到就把黄摘掉 ⇒ 否则「有图不上色」只在再次选中时才生效，
+        // 而他报的正是「上传后」那一刻。
+        if (!hadContent && this._loaded) this._syncSelection();
     }
 
     /** 只读「此刻材质里绑了什么」的戳记：4 格就绪位 + 已绑纹理的版本号。
@@ -189,11 +206,67 @@ export class ImagePlane extends Mesh<PlaneGeometry, MeshBasicMaterial> {
     }
 
     highlight(): void {
-        this.material.color.set(HIGHLIGHT_COLOR);
+        this._selected = true;
+        this._syncSelection();
     }
 
     restoreColor(): void {
-        this.material.color.set(this._originalColor);
+        this._selected = false;
+        this._syncSelection();
+    }
+
+    /**
+     * 选中态的三样东西一起算（颜色 + 边框），一处规则：
+     * - 黄只在**还没上传图**那一档：片元里贴图是乘进 diffuse 的（`diffuseColor *= imgTexel`），有图还套黄 ⇒ 整张图发黄。
+     * - 边框在有图/没图两档都亮：没图那四格是整格 `discard`（一个像素都不落），只靠黄等于没有反馈，看不见也找不着。
+     */
+    private _syncSelection(): void {
+        this.material.color.set(this._selected && !this._loaded ? HIGHLIGHT_COLOR : this._originalColor);
+        if (!this._selected) {
+            if (this._outline) this._outline.visible = false;
+            return;
+        }
+        this._ensureOutline();
+        this._layoutOutline();
+    }
+
+    /** 选中边框懒建：预览/发布那一路从不选中 ⇒ 一颗 LineSegments2 都不建（与模型槽那圈 `BoxLine2` 同口径） */
+    private _ensureOutline(): void {
+        if (this._outline) return;
+        const material = new LineMaterial({
+            color: SELECT_LINE_COLOR,
+            worldUnits: false,
+            linewidth: SELECT_LINE_WIDTH_PX,
+            // ⚠️ `depthTest: false`：这一圈就躺在平面自己那一平面上，留着深度测试必与图打摆（闪烁）
+            depthTest: false,
+            resolution: new Vector2(1, 1),
+        });
+        const outline = new LineSegments2(new LineSegmentsGeometry(), material);
+        outline.name = `${this.name}-选中边框`;
+        outline.renderOrder = 100; // 与 `BoxLine2` 那圈同档：压在图/墙之后
+        outline.frustumCulled = false;
+        outline.userData.pickIgnored = true;
+        outline.raycast = (): void => { }; // 拾取打平面本体，边框不是可点的东西
+        outline.onBeforeRender = (renderer: WebGLRenderer): void => {
+            renderer.getSize(material.resolution); // 屏幕像素粗细要每帧拿画布尺寸
+        };
+        this.add(outline);
+        this._outline = outline;
+    }
+
+    /** 四条边按当前几何的宽高铺在平面那一平面上（局部 z=0，中心为原点） */
+    private _layoutOutline(): void {
+        if (!this._outline) return;
+        const w = this.imageWidth / 2;
+        const h = this.imageHeight / 2;
+        const c = [
+            [-w, -h, 0], [w, -h, 0],
+            [w, -h, 0], [w, h, 0],
+            [w, h, 0], [-w, h, 0],
+            [-w, h, 0], [-w, -h, 0],
+        ].flat();
+        this._outline.geometry.setPositions(c);
+        this._outline.visible = true;
     }
 
     toData(): ImagePlaneData {
@@ -221,6 +294,10 @@ export class ImagePlane extends Mesh<PlaneGeometry, MeshBasicMaterial> {
     dispose(): void {
         this.geometry.dispose();
         this.material.dispose();
+        if (this._outline) {
+            this._outline.geometry.dispose();
+            this._outline.material.dispose();
+        }
     }
 }
 

package/MktMesh/modelSlot.d.ts

@@ -1,4 +1,6 @@
 import { Group } from "three";
+/** glb 地址 → 文件名（日志唯一口径：去掉查询串取最后一段；⛔ 别在打印点各写一份 split） */
+export declare function glbFileName(url: string): string;
 /** 模型槽的持久化数据（进 exportData / importData / 预览 loadData） */
 export interface ModelSlotData {
     name?: string;

package/MktMesh/modelSlot.js

@@ -32,6 +32,10 @@ import { Box3, BoxGeometry, Color, Group, Mesh, MeshBasicMaterial, Vector3, } fr
 import threeLoader from "../threeLoader";
 import threeUtils from "../threeUtils";
 import BoxLine2 from "./boxLine2";
+/** glb 地址 → 文件名（日志唯一口径：去掉查询串取最后一段；⛔ 别在打印点各写一份 split） */
+export function glbFileName(url) {
+    return url.split("?")[0].split("/").pop() || url;
+}
 /** 占位小立方体的棱长（米）—— 皇上要的是「小立方体」，比「加立方体」那颗 1m 的单位方块小一档 */
 export const MODEL_SLOT_PLACEHOLDER = 0.3;
 /** 默认尺寸档（米，最长边）：还没上传模型时占位方块用不上它；上传成功后 `useNativeSize()` 会把它填成模型原最长边 ⇒ 一比一 */
@@ -179,6 +183,9 @@ export class ModelSlot extends Group {
             this._loaded = true;
             return true;
         }
+        // 用户 2026-11-04「日志少打印点吧」⇒ 这一颗的取回入口⛔ 不出声：整层重建一次几十颗，逐颗一行会刷屏。
+        //   文件名改由两个批次入口各打一条 —— 单颗动作（上传/复制/换地址）在下面的 `setModelUrl`，
+        //   整层重建在 `MktMesh.setModels`（那边一条列全）⇒ 一颗不落，但一拍一条。
         // 取回失败（404 / 解析报错都从这一档走）：`threeLoader.loadModel` 是会 reject 的，⚠️ 必须当「落定在占位方块」处理
         //   —— 整层重建时这一颗是压着不亮的，不落定就永远隐形（旧写法里它至少还露得出占位方块）。
         let obj;
@@ -224,6 +231,11 @@ export class ModelSlot extends Group {
      * @returns 是否真的挂上了（地址无效/载入失败/这次结果已作废 ⇒ false；空地址 = 退回占位，返回 true）
      */
     async setModelUrl(url) {
+        // 用户 2026-11-04「日志少打印点吧」⇒ 逐颗一行从 `loadModel` 挪到这里：这一路一次动作只动一/几颗
+        //   （上传 .glb、复制模型、换同名 glb），一条就是他能对上号的那一颗；整层重建那几十颗由
+        //   `MktMesh.setModels` 攒成一条 ⇒ 文件名仍「一颗不落」，行数从 N 降到 1。空地址 = 退回占位，不打。
+        if (url)
+            console.log(`[MktMesh] 加载 glb「${this.name}」：${glbFileName(url)}`);
         if (!(await this.loadModel(url)))
             return false;
         if (this._staged)

package/MktMesh/modelSlot.ts

@@ -42,6 +42,11 @@ import threeLoader from "../threeLoader";
 import threeUtils from "../threeUtils";
 import BoxLine2 from "./boxLine2";
 
+/** glb 地址 → 文件名（日志唯一口径：去掉查询串取最后一段；⛔ 别在打印点各写一份 split） */
+export function glbFileName(url: string): string {
+    return url.split("?")[0].split("/").pop() || url;
+}
+
 /** 模型槽的持久化数据（进 exportData / importData / 预览 loadData） */
 export interface ModelSlotData {
     name?: string;
@@ -219,6 +224,9 @@ export class ModelSlot extends Group {
             this._loaded = true;
             return true;
         }
+        // 用户 2026-11-04「日志少打印点吧」⇒ 这一颗的取回入口⛔ 不出声：整层重建一次几十颗，逐颗一行会刷屏。
+        //   文件名改由两个批次入口各打一条 —— 单颗动作（上传/复制/换地址）在下面的 `setModelUrl`，
+        //   整层重建在 `MktMesh.setModels`（那边一条列全）⇒ 一颗不落，但一拍一条。
         // 取回失败（404 / 解析报错都从这一档走）：`threeLoader.loadModel` 是会 reject 的，⚠️ 必须当「落定在占位方块」处理
         //   —— 整层重建时这一颗是压着不亮的，不落定就永远隐形（旧写法里它至少还露得出占位方块）。
         let obj: Object3D | undefined;
@@ -263,6 +271,10 @@ export class ModelSlot extends Group {
      * @returns 是否真的挂上了（地址无效/载入失败/这次结果已作废 ⇒ false；空地址 = 退回占位，返回 true）
      */
     async setModelUrl(url: string): Promise<boolean> {
+        // 用户 2026-11-04「日志少打印点吧」⇒ 逐颗一行从 `loadModel` 挪到这里：这一路一次动作只动一/几颗
+        //   （上传 .glb、复制模型、换同名 glb），一条就是他能对上号的那一颗；整层重建那几十颗由
+        //   `MktMesh.setModels` 攒成一条 ⇒ 文件名仍「一颗不落」，行数从 N 降到 1。空地址 = 退回占位，不打。
+        if (url) console.log(`[MktMesh] 加载 glb「${this.name}」：${glbFileName(url)}`);
         if (!(await this.loadModel(url))) return false;
         if (this._staged) this.mountStaged();
         return true;

package/ThreeBase.js

@@ -971,10 +971,8 @@ export default class ThreeBase extends EventDispatcher {
             //   compare → R=全局 base 深度，G=最近一次 glow/stroke 选区的 select 深度。两路任一全白即该侧写入失败。
             //   judge   → R=base 原始深度、G=select 原始深度、B=判定结果(1=判为被遮挡应 discard)。
             //   strokeSelect     → 【描边步骤 1】选区本体深度（selectDepthTexture），白色=空背景、灰=物体本体。
-            //   strokeSelectBlur → 【描边步骤 5.5】描边外扩后的选区深度（selectDepthBlurTextureTarget），
-            //                      物体轮廓比本体档更胖一圈即外扩生效。
             // 通用控制台入口（任意页面可用，优先级高于面板属性）：
-            //   `window.__TB_DEBUG_DEPTH = "global" | "ao" | "compare" | "judge" | "strokeSelect" | "strokeSelectBlur"`，
+            //   `window.__TB_DEBUG_DEPTH = "global" | "ao" | "compare" | "judge" | "strokeSelect"`，
             //   设回 "none" 恢复。
             const dbgWin = window.__TB_DEBUG_DEPTH;
             const dbgMode = window.__BASE_DEPTH_VIS
@@ -1011,13 +1009,6 @@ export default class ThreeBase extends EventDispatcher {
                         debugDepthState.lastSelectDepth ?? this.baseDepthTexture;
                     fsQuad.render(this.renderer, baseDepthVisShader);
                 }
-                else if (dbgMode === "strokeSelectBlur") {
-                    // 描边步骤 5.5：外扩后的选区深度（RGBA8 目标，对数深度存在 .r 通道）。
-                    // 与本体档对比看：外扩生效时物体轮廓会「胖一圈」，被遮挡的外扩环则被判 discard 后不参与。
-                    baseDepthVisShader.uniforms.tDepth.value =
-                        debugDepthState.lastSelectBlurDepth ?? this.baseDepthTexture;
-                    fsQuad.render(this.renderer, baseDepthVisShader);
-                }
                 flushLensflareOverlays(this.renderer, camera);
                 return;
             }

package/ThreeBase.ts

@@ -1071,10 +1071,8 @@ export default class ThreeBase extends EventDispatcher<ThreeBaseEventTypeMap> {
             //   compare → R=全局 base 深度，G=最近一次 glow/stroke 选区的 select 深度。两路任一全白即该侧写入失败。
             //   judge   → R=base 原始深度、G=select 原始深度、B=判定结果(1=判为被遮挡应 discard)。
             //   strokeSelect     → 【描边步骤 1】选区本体深度（selectDepthTexture），白色=空背景、灰=物体本体。
-            //   strokeSelectBlur → 【描边步骤 5.5】描边外扩后的选区深度（selectDepthBlurTextureTarget），
-            //                      物体轮廓比本体档更胖一圈即外扩生效。
             // 通用控制台入口（任意页面可用，优先级高于面板属性）：
-            //   `window.__TB_DEBUG_DEPTH = "global" | "ao" | "compare" | "judge" | "strokeSelect" | "strokeSelectBlur"`，
+            //   `window.__TB_DEBUG_DEPTH = "global" | "ao" | "compare" | "judge" | "strokeSelect"`，
             //   设回 "none" 恢复。
             const dbgWin = (window as unknown as { __TB_DEBUG_DEPTH?: DebugDepthMode }).__TB_DEBUG_DEPTH;
             const dbgMode = (window as unknown as { __BASE_DEPTH_VIS?: boolean }).__BASE_DEPTH_VIS
@@ -1106,12 +1104,6 @@ export default class ThreeBase extends EventDispatcher<ThreeBaseEventTypeMap> {
                     baseDepthVisShader.uniforms.tDepth.value =
                         debugDepthState.lastSelectDepth ?? this.baseDepthTexture;
                     fsQuad.render(this.renderer, baseDepthVisShader);
-                } else if (dbgMode === "strokeSelectBlur") {
-                    // 描边步骤 5.5：外扩后的选区深度（RGBA8 目标，对数深度存在 .r 通道）。
-                    // 与本体档对比看：外扩生效时物体轮廓会「胖一圈」，被遮挡的外扩环则被判 discard 后不参与。
-                    baseDepthVisShader.uniforms.tDepth.value =
-                        debugDepthState.lastSelectBlurDepth ?? this.baseDepthTexture;
-                    fsQuad.render(this.renderer, baseDepthVisShader);
                 }
                 flushLensflareOverlays(this.renderer, camera);
                 return;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "three-base",
-  "version": "2.0.197",
+  "version": "2.0.198",
   "description": "A Three.js extension library providing common 3D components, animations, materials, and utilities",
   "author": "xiaosihan",
   "publishConfig": {

package/pass/debugDepthState.d.ts

@@ -1,4 +1,4 @@
-import type { DepthTexture, Texture } from "three";
+import type { DepthTexture } from "three";
 /**
  * 深度调试预览模式（面板按钮与控制台 `window.__TB_DEBUG_DEPTH` 共用同一枚举）：
  *   - "none"            ：正常渲染（默认）
@@ -7,22 +7,18 @@ import type { DepthTexture, Texture } from "three";
  *   - "compare"         ：R=base 深度、G=选区 select 深度（对数反解后归一化）
  *   - "judge"           ：R=base 原始深度、G=select 原始深度、B=判定结果(1=判为被遮挡应 discard)
  *   - "strokeSelect"    ：【描边步骤 1】选区本体深度（selectDepthTexture，mask 那趟光栅化顺带写入）
- *   - "strokeSelectBlur"：【描边步骤 5.5】描边外扩后的选区深度（selectDepthBlurTextureTarget，
- *                        RGBA8 的 R 通道存对数深度，外扩环取邻域最近深度）
  * ⚠️ 2026-10-18 皇上旨「所有的对象都要进入到深度图里面了，不需要用参数过滤掉了」⇒ 原 "excluded"
  *    档（把被排除的面叠红）连同 ssao_pass 的排除判据整条删除，已无「写不进深度图的面」可标。
+ * ⚠️ 2026-11-04 描边回到年初口径 ⇒ 原 "strokeSelectBlur" 档（步骤 5.5 外扩后的选区深度）连同
+ *    那条 min-blur 整条删除，管线里已无「外扩深度」可供显示。
  */
-export type DebugDepthMode = "none" | "global" | "ao" | "compare" | "judge" | "strokeSelect" | "strokeSelectBlur";
+export type DebugDepthMode = "none" | "global" | "ao" | "compare" | "judge" | "strokeSelect";
 /**
  * 调试用全局状态：记录最近一次 glow_pass / stroke_pass 渲染的「选区自身深度图」(selectDepth)。
  * 供 ThreeBase 渲染末尾的「辉光深度比对」调试视图读取（R=全局 base 深度，G=选区 select 深度），
  * 让用户一眼看出到底是「全局 base 深度没写进」还是「选区自身深度没写进」。
  * 由各 pass 在渲染完 selectDepth 后写入；每帧会被最后一个被处理的可见对象覆盖（调试够用）。
- *
- * lastSelectBlurDepth：描边专属（步骤 5.5 外扩后的选区深度）。它是 RGBA8 目标（不是 DepthTexture），
- * 深度值存在 .r 通道里 —— 可视化时同样取 .r 即可。glow/cover/frosted 没有这一步，故只有 stroke_pass 写。
  */
 export declare const debugDepthState: {
     lastSelectDepth: DepthTexture | null;
-    lastSelectBlurDepth: Texture | null;
 };

package/pass/debugDepthState.js

@@ -3,11 +3,7 @@
  * 供 ThreeBase 渲染末尾的「辉光深度比对」调试视图读取（R=全局 base 深度，G=选区 select 深度），
  * 让用户一眼看出到底是「全局 base 深度没写进」还是「选区自身深度没写进」。
  * 由各 pass 在渲染完 selectDepth 后写入；每帧会被最后一个被处理的可见对象覆盖（调试够用）。
- *
- * lastSelectBlurDepth：描边专属（步骤 5.5 外扩后的选区深度）。它是 RGBA8 目标（不是 DepthTexture），
- * 深度值存在 .r 通道里 —— 可视化时同样取 .r 即可。glow/cover/frosted 没有这一步，故只有 stroke_pass 写。
  */
 export const debugDepthState = {
     lastSelectDepth: null,
-    lastSelectBlurDepth: null,
 };

package/pass/debugDepthState.ts

@@ -1,4 +1,4 @@
-import type { DepthTexture, Texture } from "three";
+import type { DepthTexture } from "three";
 
 /**
  * 深度调试预览模式（面板按钮与控制台 `window.__TB_DEBUG_DEPTH` 共用同一枚举）：
@@ -8,10 +8,10 @@ import type { DepthTexture, Texture } from "three";
  *   - "compare"         ：R=base 深度、G=选区 select 深度（对数反解后归一化）
  *   - "judge"           ：R=base 原始深度、G=select 原始深度、B=判定结果(1=判为被遮挡应 discard)
  *   - "strokeSelect"    ：【描边步骤 1】选区本体深度（selectDepthTexture，mask 那趟光栅化顺带写入）
- *   - "strokeSelectBlur"：【描边步骤 5.5】描边外扩后的选区深度（selectDepthBlurTextureTarget，
- *                        RGBA8 的 R 通道存对数深度，外扩环取邻域最近深度）
  * ⚠️ 2026-10-18 皇上旨「所有的对象都要进入到深度图里面了，不需要用参数过滤掉了」⇒ 原 "excluded"
  *    档（把被排除的面叠红）连同 ssao_pass 的排除判据整条删除，已无「写不进深度图的面」可标。
+ * ⚠️ 2026-11-04 描边回到年初口径 ⇒ 原 "strokeSelectBlur" 档（步骤 5.5 外扩后的选区深度）连同
+ *    那条 min-blur 整条删除，管线里已无「外扩深度」可供显示。
  */
 export type DebugDepthMode =
     | "none"
@@ -19,22 +19,16 @@ export type DebugDepthMode =
     | "ao"
     | "compare"
     | "judge"
-    | "strokeSelect"
-    | "strokeSelectBlur";
+    | "strokeSelect";
 
 /**
  * 调试用全局状态：记录最近一次 glow_pass / stroke_pass 渲染的「选区自身深度图」(selectDepth)。
  * 供 ThreeBase 渲染末尾的「辉光深度比对」调试视图读取（R=全局 base 深度，G=选区 select 深度），
  * 让用户一眼看出到底是「全局 base 深度没写进」还是「选区自身深度没写进」。
  * 由各 pass 在渲染完 selectDepth 后写入；每帧会被最后一个被处理的可见对象覆盖（调试够用）。
- *
- * lastSelectBlurDepth：描边专属（步骤 5.5 外扩后的选区深度）。它是 RGBA8 目标（不是 DepthTexture），
- * 深度值存在 .r 通道里 —— 可视化时同样取 .r 即可。glow/cover/frosted 没有这一步，故只有 stroke_pass 写。
  */
 export const debugDepthState: {
     lastSelectDepth: DepthTexture | null;
-    lastSelectBlurDepth: Texture | null;
 } = {
     lastSelectDepth: null,
-    lastSelectBlurDepth: null,
 };

package/pass/stroke_pass.js

@@ -38,12 +38,6 @@ const selectDepthTestTextureTarget = new WebGLRenderTarget(1024, 1024, {
 });
 const blur1TextureTarget = new WebGLRenderTarget(1024, 1024, { minFilter: LinearFilter, magFilter: LinearFilter, format: RGBAFormat });
 const blur2TextureTarget = new WebGLRenderTarget(1024, 1024, { minFilter: LinearFilter, magFilter: LinearFilter, format: RGBAFormat });
-// 外扩深度临时/结果目标：depthMinBlurShader 把本体深度图随描边一起外扩，
-// 外扩区取邻域最近深度（忽略背景 1.0），使外扩区 selD<1.0，depthTest 才能正确判遮挡（不漏光）。
-const selectDepthBlurTmpTextureTarget = new WebGLRenderTarget(1024, 1024, { minFilter: LinearFilter, magFilter: LinearFilter, format: RGBAFormat });
-const selectDepthBlurTextureTarget = new WebGLRenderTarget(1024, 1024, { minFilter: LinearFilter, magFilter: LinearFilter, format: RGBAFormat });
-// 外扩描边经深度测试后的结果（步骤 5.6）：独立 target，避免回写 blur1 触发历史回归 bug
-const blurDepthTestTextureTarget = new WebGLRenderTarget(1024, 1024, { minFilter: LinearFilter, magFilter: LinearFilter, format: RGBAFormat });
 const size = new Vector2();
 const depthTestShader = new ShaderMaterial({
     uniforms: {
@@ -383,52 +377,6 @@ const strokeShader = new RawShaderMaterial({
     depthWrite: false,
     transparent: true
 });
-// 深度 min-blur（最近深度，忽略背景 1.0）：随描边一起把深度图向外扩，
-// 外扩区 selD = 物体最近深度(<1.0) 而非清屏 1.0，depthTest 在外扩区才能正确判遮挡（不漏光），
-// 同时本体区仍靠 depthTestShader 的 EPSILON 容差防自遮挡闪烁（无缝）。separable（direction 控制 H/V）。
-const depthMinBlurShader = new ShaderMaterial({
-    uniforms: {
-        tDepth: { value: null },
-        resolution: { value: new Vector2(1 / 512, 1 / 512) },
-        radius: { value: 1.0 },
-        direction: { value: new Vector2(1, 0) },
-    },
-    vertexShader: `
-        ${ShaderChunk.common}
-        ${ShaderChunk.logdepthbuf_pars_vertex}
-        varying vec2 vUv;
-        void main() {
-            vUv = uv;
-            gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
-            ${ShaderChunk.logdepthbuf_vertex}
-        }
-    `,
-    fragmentShader: `
-        ${ShaderChunk.logdepthbuf_pars_fragment}
-        uniform sampler2D tDepth;
-        uniform vec2 resolution;
-        uniform float radius;
-        uniform vec2 direction;
-        varying vec2 vUv;
-        void main() {
-            float minD = 1.0;
-            for (int i = -10; i <= 10; i++) {
-                float x = float(i);
-                vec2 off = direction * (x * radius * resolution);
-                float d = texture2D(tDepth, vUv + off).r;
-                if (d < 0.9999) {
-                    minD = min(minD, d);
-                }
-            }
-            gl_FragColor = vec4(minD, 0.0, 0.0, 1.0);
-            ${ShaderChunk.logdepthbuf_fragment}
-        }
-    `,
-    blending: NoBlending,
-    depthTest: false,
-    depthWrite: false,
-    transparent: true,
-});
 const filterSelectShader = new RawShaderMaterial({
     uniforms: {
         selectTexture: { value: null },
@@ -508,9 +456,6 @@ export default function stroke_pass(renderer, camera, object3d, baseDepthTexture
     selectDepthTestTextureTarget.setSize(size.x, size.y);
     blur1TextureTarget.setSize(size.x, size.y);
     blur2TextureTarget.setSize(size.x, size.y);
-    selectDepthBlurTmpTextureTarget.setSize(size.x, size.y);
-    selectDepthBlurTextureTarget.setSize(size.x, size.y);
-    blurDepthTestTextureTarget.setSize(size.x, size.y);
     // 1. 渲染物体本体 mask（灰度）。⭐ 本体深度由同一趟光栅化顺带写进 selectDepthTexture
     //   （挂在 selectTextureTarget 的 depth attachment 上）—— 原先这里还有第 2 趟「只渲深度」，
     //   同材质/同相机/同几何 ⇒ 深度逐位相同，纯重复遍历，2026-10-11 皇上旨简化时删除。
@@ -532,7 +477,8 @@ export default function stroke_pass(renderer, camera, object3d, baseDepthTexture
     depthTestShader.uniforms.cameraFar.value = camera.far;
     depthTestShader.uniforms.uDebugVis.value = (window.__STROKE_DEPTH_VIS) ? 1.0 : 0.0;
     fsQuad.render(renderer, depthTestShader);
-    // 4. 从「深度测试后的本体描边」开始外扩（外扩环自动继承本体遮挡判定 → 不漏光），
+    // 4. 从「深度测试后的本体描边」开始外扩（外扩的源头是本体判过的结果，被挡掉的本体不会再长出描边；
+    //    但外扩出来那圈像素本身不再判深度 ⇒ 贴着遮挡物时会压到遮挡物前面，见步骤 6 的代价点名），
     //    描边粗细由 stroke_width 控制的迭代次数决定。
     strokeShader.uniforms.resolution.value.set(1 / size.x, 1 / size.y);
     FXAAShaderMaterial.uniforms.resolution.value.set(1 / size.x, 1 / size.y);
@@ -557,42 +503,14 @@ export default function stroke_pass(renderer, camera, object3d, baseDepthTexture
     renderer.setRenderTarget(blur1TextureTarget);
     FXAAShaderMaterial.uniforms.tDiffuse.value = blur2TextureTarget.texture;
     fsQuad.render(renderer, FXAAShaderMaterial);
-    // 5.5 ⭐ 外扩环深度测试（补齐此前只定义未调用的死代码）：
-    //   本体深度随描边一起外扩（separable H/V，外扩区取邻域最近深度），
-    //   再用它对外扩后的描边做一次 depthTest。
-    //   缺了这一步，外扩环（描边的视觉主体）永远不参与遮挡判定 →
-    //   物体被挡住时描边依旧从遮挡物前方漏出来（"深度测试看起来失效"的真根因之一）。
-    depthMinBlurShader.uniforms.resolution.value.set(1 / size.x, 1 / size.y);
-    depthMinBlurShader.uniforms.radius.value = Math.max(1, stroke_width);
-    // H：直接采 DepthTexture（selectDepthTexture），其 .r 即对数深度
-    depthMinBlurShader.uniforms.direction.value.set(1, 0);
-    depthMinBlurShader.uniforms.tDepth.value = selectDepthTexture;
-    renderer.setRenderTarget(selectDepthBlurTmpTextureTarget);
-    fsQuad.render(renderer, depthMinBlurShader);
-    // V
-    depthMinBlurShader.uniforms.direction.value.set(0, 1);
-    depthMinBlurShader.uniforms.tDepth.value = selectDepthBlurTmpTextureTarget.texture;
-    renderer.setRenderTarget(selectDepthBlurTextureTarget);
-    fsQuad.render(renderer, depthMinBlurShader);
-    // 调试：记录「外扩后的选区深度」，供面板「深度图（分步）」的步骤 5.5 档读取。
-    // 它是 RGBA8 目标、对数深度存在 .r 里（与 DepthTexture 取 .r 的读法一致）。
-    debugDepthState.lastSelectBlurDepth = selectDepthBlurTextureTarget.texture;
-    // 5.6 对外扩后的描边判遮挡：被更近几何挡住的外扩环像素 discard。
-    //     ⚠️ 输出到独立 target，绝不回写 blur1（历史回归 bug：blur1 被 depthTest 结果覆盖
-    //        会导致步骤 6 相减归零、描边全不显示）。
-    renderer.setRenderTarget(blurDepthTestTextureTarget);
-    renderer.clear();
-    depthTestShader.uniforms.map.value = blur1TextureTarget.texture;
-    depthTestShader.uniforms.baseDepth.value = baseDepthTexture;
-    depthTestShader.uniforms.selectDepth.value = selectDepthBlurTextureTarget.texture;
-    depthTestShader.uniforms.cameraFar.value = camera.far;
-    depthTestShader.uniforms.uDebugVis.value = 0.0;
-    fsQuad.render(renderer, depthTestShader);
-    // 6. 合成：最终外扩描边(blurDepthTest，已判遮挡) 减去 深度测试后的本体描边
-    //    = 仅保留描边外扩环；本体被减掉。filterSelectShader 用 NormalBlending 叠到场景上。
+    // 6. 合成：FXAA 后的外扩描边(blur1) 减去 深度测试后的本体 = 仅保留描边外扩环；本体被减掉。
+    //    ⚠️ 2026-11-04 决定回到「年初口径」：原先这里有 5.5（本体深度随描边一起 separable min-blur 外扩）
+    //    与 5.6（用外扩后的深度再判一次遮挡）两趟，作用是外扩环也参与遮挡判定 ⇒ 物体被挡住时描边不漏光。
+    //    撤掉换来的是每个描边对象每帧全屏绘制 10 趟降 7 趟（min-blur 那两趟是 ±10 共 21 次采样/像素，最贵）；
+    //    代价点名：只有本体参与判遮挡，外扩环不参与 ⇒ 物体贴着遮挡物边缘时，一圈描边会压在遮挡物前面。
     renderer.setRenderTarget(originRenderTarget);
     filterSelectShader.uniforms.selectTexture.value = selectDepthTestTextureTarget.texture;
-    filterSelectShader.uniforms.blurTexture.value = blurDepthTestTextureTarget.texture;
+    filterSelectShader.uniforms.blurTexture.value = blur1TextureTarget.texture;
     filterSelectShader.blending = NormalBlending;
     fsQuad.render(renderer, filterSelectShader);
 }

package/pass/stroke_pass.ts

@@ -44,12 +44,6 @@ const selectDepthTestTextureTarget: WebGLRenderTarget = new WebGLRenderTarget(10
 const blur1TextureTarget: WebGLRenderTarget = new WebGLRenderTarget(1024, 1024, { minFilter: LinearFilter, magFilter: LinearFilter, format: RGBAFormat });
 
 const blur2TextureTarget: WebGLRenderTarget = new WebGLRenderTarget(1024, 1024, { minFilter: LinearFilter, magFilter: LinearFilter, format: RGBAFormat });
-// 外扩深度临时/结果目标：depthMinBlurShader 把本体深度图随描边一起外扩，
-// 外扩区取邻域最近深度（忽略背景 1.0），使外扩区 selD<1.0，depthTest 才能正确判遮挡（不漏光）。
-const selectDepthBlurTmpTextureTarget: WebGLRenderTarget = new WebGLRenderTarget(1024, 1024, { minFilter: LinearFilter, magFilter: LinearFilter, format: RGBAFormat });
-const selectDepthBlurTextureTarget: WebGLRenderTarget = new WebGLRenderTarget(1024, 1024, { minFilter: LinearFilter, magFilter: LinearFilter, format: RGBAFormat });
-// 外扩描边经深度测试后的结果（步骤 5.6）：独立 target，避免回写 blur1 触发历史回归 bug
-const blurDepthTestTextureTarget: WebGLRenderTarget = new WebGLRenderTarget(1024, 1024, { minFilter: LinearFilter, magFilter: LinearFilter, format: RGBAFormat });
 
 const size: Vector2 = new Vector2();
 
@@ -394,53 +388,6 @@ const strokeShader: RawShaderMaterial = new RawShaderMaterial({
     transparent: true
 });
 
-// 深度 min-blur（最近深度，忽略背景 1.0）：随描边一起把深度图向外扩，
-// 外扩区 selD = 物体最近深度(<1.0) 而非清屏 1.0，depthTest 在外扩区才能正确判遮挡（不漏光），
-// 同时本体区仍靠 depthTestShader 的 EPSILON 容差防自遮挡闪烁（无缝）。separable（direction 控制 H/V）。
-const depthMinBlurShader: ShaderMaterial = new ShaderMaterial({
-    uniforms: {
-        tDepth: { value: null },
-        resolution: { value: new Vector2(1 / 512, 1 / 512) },
-        radius: { value: 1.0 },
-        direction: { value: new Vector2(1, 0) },
-    },
-    vertexShader: `
-        ${ShaderChunk.common}
-        ${ShaderChunk.logdepthbuf_pars_vertex}
-        varying vec2 vUv;
-        void main() {
-            vUv = uv;
-            gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
-            ${ShaderChunk.logdepthbuf_vertex}
-        }
-    `,
-    fragmentShader: `
-        ${ShaderChunk.logdepthbuf_pars_fragment}
-        uniform sampler2D tDepth;
-        uniform vec2 resolution;
-        uniform float radius;
-        uniform vec2 direction;
-        varying vec2 vUv;
-        void main() {
-            float minD = 1.0;
-            for (int i = -10; i <= 10; i++) {
-                float x = float(i);
-                vec2 off = direction * (x * radius * resolution);
-                float d = texture2D(tDepth, vUv + off).r;
-                if (d < 0.9999) {
-                    minD = min(minD, d);
-                }
-            }
-            gl_FragColor = vec4(minD, 0.0, 0.0, 1.0);
-            ${ShaderChunk.logdepthbuf_fragment}
-        }
-    `,
-    blending: NoBlending,
-    depthTest: false,
-    depthWrite: false,
-    transparent: true,
-});
-
 const filterSelectShader: RawShaderMaterial = new RawShaderMaterial({
     uniforms: {
         selectTexture: { value: null },
@@ -536,9 +483,6 @@ export default function stroke_pass(
     selectDepthTestTextureTarget.setSize(size.x, size.y);
     blur1TextureTarget.setSize(size.x, size.y);
     blur2TextureTarget.setSize(size.x, size.y);
-    selectDepthBlurTmpTextureTarget.setSize(size.x, size.y);
-    selectDepthBlurTextureTarget.setSize(size.x, size.y);
-    blurDepthTestTextureTarget.setSize(size.x, size.y);
 
     // 1. 渲染物体本体 mask（灰度）。⭐ 本体深度由同一趟光栅化顺带写进 selectDepthTexture
     //   （挂在 selectTextureTarget 的 depth attachment 上）—— 原先这里还有第 2 趟「只渲深度」，
@@ -563,7 +507,8 @@ export default function stroke_pass(
     depthTestShader.uniforms.uDebugVis.value = ((window as unknown as { __STROKE_DEPTH_VIS?: boolean }).__STROKE_DEPTH_VIS) ? 1.0 : 0.0;
     fsQuad.render(renderer, depthTestShader);
 
-    // 4. 从「深度测试后的本体描边」开始外扩（外扩环自动继承本体遮挡判定 → 不漏光），
+    // 4. 从「深度测试后的本体描边」开始外扩（外扩的源头是本体判过的结果，被挡掉的本体不会再长出描边；
+    //    但外扩出来那圈像素本身不再判深度 ⇒ 贴着遮挡物时会压到遮挡物前面，见步骤 6 的代价点名），
     //    描边粗细由 stroke_width 控制的迭代次数决定。
     strokeShader.uniforms.resolution.value.set(1 / size.x, 1 / size.y);
     FXAAShaderMaterial.uniforms.resolution.value.set(1 / size.x, 1 / size.y);
@@ -590,45 +535,14 @@ export default function stroke_pass(
     FXAAShaderMaterial.uniforms.tDiffuse.value = blur2TextureTarget.texture;
     fsQuad.render(renderer, FXAAShaderMaterial);
 
-    // 5.5 ⭐ 外扩环深度测试（补齐此前只定义未调用的死代码）：
-    //   本体深度随描边一起外扩（separable H/V，外扩区取邻域最近深度），
-    //   再用它对外扩后的描边做一次 depthTest。
-    //   缺了这一步，外扩环（描边的视觉主体）永远不参与遮挡判定 →
-    //   物体被挡住时描边依旧从遮挡物前方漏出来（"深度测试看起来失效"的真根因之一）。
-    depthMinBlurShader.uniforms.resolution.value.set(1 / size.x, 1 / size.y);
-    depthMinBlurShader.uniforms.radius.value = Math.max(1, stroke_width);
-    // H：直接采 DepthTexture（selectDepthTexture），其 .r 即对数深度
-    depthMinBlurShader.uniforms.direction.value.set(1, 0);
-    depthMinBlurShader.uniforms.tDepth.value = selectDepthTexture;
-    renderer.setRenderTarget(selectDepthBlurTmpTextureTarget);
-    fsQuad.render(renderer, depthMinBlurShader);
-    // V
-    depthMinBlurShader.uniforms.direction.value.set(0, 1);
-    depthMinBlurShader.uniforms.tDepth.value = selectDepthBlurTmpTextureTarget.texture;
-    renderer.setRenderTarget(selectDepthBlurTextureTarget);
-    fsQuad.render(renderer, depthMinBlurShader);
-
-    // 调试：记录「外扩后的选区深度」，供面板「深度图（分步）」的步骤 5.5 档读取。
-    // 它是 RGBA8 目标、对数深度存在 .r 里（与 DepthTexture 取 .r 的读法一致）。
-    debugDepthState.lastSelectBlurDepth = selectDepthBlurTextureTarget.texture;
-
-    // 5.6 对外扩后的描边判遮挡：被更近几何挡住的外扩环像素 discard。
-    //     ⚠️ 输出到独立 target，绝不回写 blur1（历史回归 bug：blur1 被 depthTest 结果覆盖
-    //        会导致步骤 6 相减归零、描边全不显示）。
-    renderer.setRenderTarget(blurDepthTestTextureTarget);
-    renderer.clear();
-    depthTestShader.uniforms.map.value = blur1TextureTarget.texture;
-    depthTestShader.uniforms.baseDepth.value = baseDepthTexture;
-    depthTestShader.uniforms.selectDepth.value = selectDepthBlurTextureTarget.texture;
-    depthTestShader.uniforms.cameraFar.value = (camera as PerspectiveCamera).far;
-    depthTestShader.uniforms.uDebugVis.value = 0.0;
-    fsQuad.render(renderer, depthTestShader);
-
-    // 6. 合成：最终外扩描边(blurDepthTest，已判遮挡) 减去 深度测试后的本体描边
-    //    = 仅保留描边外扩环；本体被减掉。filterSelectShader 用 NormalBlending 叠到场景上。
+    // 6. 合成：FXAA 后的外扩描边(blur1) 减去 深度测试后的本体 = 仅保留描边外扩环；本体被减掉。
+    //    ⚠️ 2026-11-04 决定回到「年初口径」：原先这里有 5.5（本体深度随描边一起 separable min-blur 外扩）
+    //    与 5.6（用外扩后的深度再判一次遮挡）两趟，作用是外扩环也参与遮挡判定 ⇒ 物体被挡住时描边不漏光。
+    //    撤掉换来的是每个描边对象每帧全屏绘制 10 趟降 7 趟（min-blur 那两趟是 ±10 共 21 次采样/像素，最贵）；
+    //    代价点名：只有本体参与判遮挡，外扩环不参与 ⇒ 物体贴着遮挡物边缘时，一圈描边会压在遮挡物前面。
     renderer.setRenderTarget(originRenderTarget);
     filterSelectShader.uniforms.selectTexture.value = selectDepthTestTextureTarget.texture;
-    filterSelectShader.uniforms.blurTexture.value = blurDepthTestTextureTarget.texture;
+    filterSelectShader.uniforms.blurTexture.value = blur1TextureTarget.texture;
     filterSelectShader.blending = NormalBlending;
     fsQuad.render(renderer, filterSelectShader);
 }