three-base 2.0.172 → 2.0.180

package/Ground1/Ground1.ts

@@ -2,45 +2,40 @@
  * @Author: xiaosihan
  * @Date: 2022-09-20 23:06:00
  * @Last Modified by: xiaosihan
- * @Last Modified time: 2024-08-17 02:16:56
+ * @Last Modified time: 2026-10-12 00:00:00
  *
- * ⭐ 2026-09-20 皇上旨两改：
- *   ① 原「科技感装饰地板」（三张格子贴图 + 紫色扩散动画 `#8D108E` + 格子线 `#263C56`）
- *      → 深灰地板（每帧 3 次贴图采样、贴图平铺无各向异性 → 摩尔纹 + home 页卡顿元凶之一）。
- *   ② 皇上再旨「地板就是**随机渐变**的深灰色、**不透明**」：
- *      → 深灰区间内用 **value noise 做随机渐变**（无贴图、零采样，天然无摩尔纹）；
- *      → `transparent: false`、alpha 恒 1（不透明）。
+ * ⭐ 装饰地板 = 科技感格子贴图 + 紫色扩散动画（2026-10-12 皇上旨「整条退回旧科技感地板」+「装饰地板需要透明」）。
+ *   历史：2026-09-20 皇上曾两旨把它改成「随机渐变的深灰、不透明」，理由是每帧 3 次贴图采样 +
+ *   平铺无各向异性 → 摩尔纹，且是 home 页卡顿元凶之一。**当年那个摩尔纹根因现在已经在
+ *   `threeLoader.getTexture` 里根治了**（anisotropy=16 + generateMipmaps + LinearMipmapLinear），
+ *   所以贴图路线的重画成本比 09-20 那版低一档，本次按皇上旨意恢复旧外观。
  *
- *   ⚠️ 不透明带来的变化与对策：
- *   - 原靠「径向 alpha 淡出」柔化 500×500 地板的边界；不透明后改用**径向压暗**（乘 0.72~1.0）
- *     弱化硬边 —— 若哪天皇上要「边界完全消失」，只能改回 alpha 淡出（即恢复 transparent）。
- *   - 调试线（FPScontrol）两条口径分家（2026-09-25 皇上逐条定案）：**10 条射线辅助线开深度测试**，
- *     正是靠本地板「不透明 + depthWrite:true」才挡得住埋进地里的那半截线；**8/9 两条回弹向量线
- *     保持穿透显示**（关深度测试 + renderOrder:9999），照旧常显在最前。
- *     ⚠️ 若哪天把本地板改回 transparent + depthWrite:false，射线辅助线会重新穿地浮出来。
+ *   ⭐ 2026-10-12 皇上旨「装饰地板需要透明」⇒ 恢复旧版的**外观**口径（逐字照抄 09-20 之前的写法）：
+ *   - `transparent: true` + 径向 alpha 淡出 `mapColor.a = 1 - dist(center)*2`（中心实、外缘全透）。
+ *   - **但 `depthWrite: true` 保留**（旧版本来就是 transparent + depthWrite:true）：主渲染的深度缓冲
+ *     照写 ⇒ FPScontrol 那 10 条射线辅助线仍被地板挡住埋进地里的那半截（09-25 定案口径不受影响）。
  *
- *   ⚠️ 改动红线（这几条被别处依赖，**不许顺手改**）：
- *   - `userData.fpsCollision = true`：FPScontrol 把地板当碰撞体（见 FPScontrol.ts 地面处理段）。
- *   - ⚠️ 2026-10-11 皇上旨「物体的深度都要进深度图」⇒ 原第三条红线 `userData.aoFloor = true`
- *     （把地板从可见深度图里排除的那条例外）**整条拆除**：它的前提是地板半透明可透视，与本文件
- *     ② 的「不透明改造」自相矛盾。地板现在按普通实心面写进深度图，被它挡住的描边/辉光/覆盖色/
- *     磨砂会被裁掉。见 three-base/pass/ssao_pass.ts 文件头。
- *   - ShaderMaterial 必须含 logdepthbuf chunk；linear 输出必须 `#include <colorspace_fragment>`；
- *     否则末端 sRGB 编码会二次编码 → 发白。
+ *   ⭐ 2026-10-18 皇上旨「所有的对象都要进入到深度图里面了，不需要用参数过滤掉了」⇒ 当年为「可透视
+ *   地板」加的 `userData.aoFloor`（把地板从后处理的可见深度图里排除）连同 ssao_pass 里那整条过滤判据
+ *   一并删除。现在地板两张深度图都写 ⇒ 透过地板看到的实体，其描边/辉光/覆盖色/磨砂会被地板裁掉，
+ *   包括外缘 alpha≈0 那圈「看得见空、看不见地板」的区域。判据出处 three-base/pass/ssao_pass.ts 文件头，
+ *   护栏 test/depthDebug.test.js J 组。
  */
-import { Color, DoubleSide, Matrix4, Mesh, PlaneGeometry, ShaderChunk, ShaderMaterial } from "three";
+import { Clock, Color, DoubleSide, BufferGeometry, Camera, Group, Material, Matrix4, Mesh, PlaneGeometry, Scene, ShaderChunk, ShaderMaterial, Vector2, WebGLRenderer } from "three";
 import { MathUtils } from "three";
 const { degToRad } = MathUtils;
+import floorMap1PNG from "./floorMap1.png";
+import floorMap2PNG from "./floorMap2.png";
+import floorMap3PNG from "./floorMap3.png";
+import threeLoader from "../threeLoader";
 
-/** 装饰地板（随机渐变的深灰、不透明） */
+/** 装饰地板（科技感格子贴图 + 紫色扩散动画，半透明可透视外观） */
 export default class Ground1 extends Mesh {
     tempMatrix: Matrix4 = new Matrix4();
     constructor() {
         super();
         // 标记为自己参与 FPS 碰撞检测
         this.userData.fpsCollision = true;
-        // ⚠️ 这里原来还有 `this.userData.aoFloor = true;`（把本地板从可见深度图里排除的特例标记），
-        // 2026-10-11 皇上旨「物体的深度都要进深度图」⇒ 连同 ssao_pass 的特例分支一起整条删除。
     }
     renderOrder: number = -1;
     geometry: PlaneGeometry = (() => {
@@ -52,14 +47,22 @@ export default class Ground1 extends Mesh {
     setSize(width: number, height: number): void {
         this.scale.set(width, 1, height);
     }
+    clock: Clock = new Clock();
+    onBeforeRender: (renderer: WebGLRenderer, scene: Scene, camera: Camera, geometry: BufferGeometry, material: Material, group: Group) => void = (renderer, scene, camera, geometry, material, group) => {
+        const elapsedTime: number = this.clock.getElapsedTime();
+        this.material.uniforms.speed.value = (elapsedTime * 0.1) % 0.6;
+        this.material.uniforms.speed2.value = ((elapsedTime * 0.1) % 0.6) - 0.1;
+    };
     material: ShaderMaterial = new ShaderMaterial({
         uniforms: {
-            /** 随机渐变的**暗端**深灰（three 的 Color 存 linear，末端 colorspace_fragment 编码回 sRGB） */
-            colorDark: { value: new Color("#2A2E33") },
-            /** 随机渐变的**亮端**深灰 */
-            colorLight: { value: new Color("#3D434B") },
-            /** 低频噪声格数（越大斑块越碎；9 → 500×500 地板上每块约 55m 的大块渐变） */
-            noiseScale: { value: 9 },
+            size: { value: new Vector2(10, 10) }, // 格子平铺格数
+            speed: { value: 0 }, // 扩散值0-1
+            speed2: { value: 0 }, // 扩散值0-1
+            speedColor: { value: new Color("#8D108E") }, // 格子扩散颜色
+            lineColor: { value: new Color("#263C56") }, // 格子线的颜色
+            map1: { value: threeLoader.getTexture(floorMap1PNG) }, // 贴图纹理
+            map2: { value: threeLoader.getTexture(floorMap2PNG) }, // 贴图纹理
+            map3: { value: threeLoader.getTexture(floorMap3PNG) }, // 贴图纹理
         },
         vertexShader: `
             ${ShaderChunk.common}
@@ -73,42 +76,59 @@ export default class Ground1 extends Mesh {
         `,
         fragmentShader: `
             ${ShaderChunk.logdepthbuf_pars_fragment}
-            uniform vec3 colorDark;
-            uniform vec3 colorLight;
-            uniform float noiseScale;
+            uniform sampler2D map1;
+            uniform sampler2D map2;
+            uniform sampler2D map3;
+            uniform vec2 size;
+            uniform vec3 lineColor;
+            uniform float speed;
+            uniform float speed2;
+            uniform vec3 speedColor;
             varying vec2 vUv;
+            void main() {
 
-            // 伪随机 hash → value noise：无贴图、零采样，天然没有平铺摩尔纹
-            float hash21(vec2 p) {
-                return fract(sin(dot(p, vec2(127.1, 311.7))) * 43758.5453123);
-            }
-            float valueNoise(vec2 p) {
-                vec2 i = floor(p);
-                vec2 f = fract(p);
-                vec2 u = f * f * (3.0 - 2.0 * f); // smoothstep 插值 → 柔和渐变，不是硬格子
-                return mix(mix(hash21(i), hash21(i + vec2(1.0, 0.0)), u.x),
-                           mix(hash21(i + vec2(0.0, 1.0)), hash21(i + vec2(1.0, 1.0)), u.x), u.y);
-            }
+                // 中心点
+                vec2 center = vec2(0.5,0.5);
 
-            void main() {
-                // 两个八度叠加：低频大块渐变 + 中频细节 → 深灰区间内的**随机渐变**
-                float n = valueNoise(vUv * noiseScale) * 0.65
-                        + valueNoise(vUv * noiseScale * 3.1) * 0.35;
-                vec3 col = mix(colorDark, colorLight, clamp(n, 0.0, 1.0));
+                vec4 map1Color = texture2D(map1, fract( vUv * size) );
+
+                // 格子中心渐变颜色
+                if(distance( vUv , center ) < speed){
+                    map1Color = mix(map1Color, vec4(speedColor, 1.0),  clamp((1.0 - (distance(distance( vUv , center ), speed) * 8.0) ) * map1Color.a, 0.0, 1.0 ) );
+                }
+
+                vec4 map2Color = texture2D(map2, fract( vUv * size) );
+
+                vec4 map3Color = texture2D(map3, fract( vUv * size) );
+
+                // 正方形装饰中心渐变颜色
+                if(distance( vUv , center ) < speed2){
+                    map3Color = mix(map3Color, map3Color * 3.0,  clamp((1.0 - (distance(distance( vUv , center ), speed) * 4.0) ) * map3Color.a, 0.0, 1.0 ) );
+                }
+
+                vec4 mapColor = mix(map1Color, map2Color, map2Color.a);
+
+                mapColor = mix(mapColor, map3Color, map3Color.a);
+
+                //添加背景色
+                mapColor = mix(mapColor, vec4(lineColor.rgb, 1.0 ), 1.0 - mapColor.a);
+
+                // 设置透明度（中心实、外缘全透的径向淡出 —— 500×500 大地板的硬边靠它消失）
+                mapColor.a = 1.0 - (distance( vUv , center ) * 2.0);
 
-                // ⚠️ 不透明地板无法用 alpha 淡出边界 → 改用径向压暗弱化 500×500 的硬边
-                float edge = 1.0 - smoothstep(0.34, 0.5, distance(vUv, vec2(0.5, 0.5)));
-                col *= mix(0.72, 1.0, edge);
+                gl_FragColor = mapColor;
 
-                gl_FragColor = vec4(col, 1.0); // 不透明
                 ${ShaderChunk.logdepthbuf_fragment}
                 #include <colorspace_fragment>
             }
         `,
         depthTest: true,
         depthWrite: true,
-        // ⭐ 皇上 2026-09-20 旨：地板**不透明**
-        transparent: false,
+        // ⭐ 皇上 2026-10-12 旨「装饰地板需要透明」：恢复旧版 transparent:true（半透可透视）。
+        // ⚠️ depthWrite 保持 true —— 主渲染的深度缓冲照写，FPScontrol 的 10 条射线辅助线才挡得住
+        //    埋进地里的那半截（09-25 定案）。后处理特效的遮挡判定走 baseDepthTexture，2026-10-18
+        //    皇上旨「所有的对象都要进入到深度图里面了」⇒ 地板也写进那张图，会裁掉身后特效。
+        transparent: true,
         side: DoubleSide,
     });
 }

package/Mirror.js

@@ -9,10 +9,6 @@ import { Color, DoubleSide, HalfFloatType, Matrix4, Mesh, PerspectiveCamera, Pla
 export default class Mirror extends Mesh {
     constructor(geometry = Mirror.geometry) {
         super(geometry);
-        // 镜子虽标了 transparent:true（为渲染顺序），但 fragment shader 实际输出 alpha=1.0，
-        // 是实心反射面、并非可透视表面 → 必须参与 AO 与描边/辉光的深度遮挡。
-        // SSAO 的 AO 数据准备会排除所有 transparent 物体，故此处显式声明保留。
-        this.userData.aoOpaque = true;
     }
     // 正方形网格
     static geometry = (() => {

package/Mirror.ts

@@ -10,10 +10,6 @@ import { Color, DoubleSide, HalfFloatType, Matrix4, Mesh, PerspectiveCamera, Pla
 export default class Mirror extends Mesh {
     constructor(geometry: BufferGeometry = Mirror.geometry) {
         super(geometry);
-        // 镜子虽标了 transparent:true（为渲染顺序），但 fragment shader 实际输出 alpha=1.0，
-        // 是实心反射面、并非可透视表面 → 必须参与 AO 与描边/辉光的深度遮挡。
-        // SSAO 的 AO 数据准备会排除所有 transparent 物体，故此处显式声明保留。
-        this.userData.aoOpaque = true;
     }
 
     // 正方形网格

package/MktMesh/MktMesh.d.ts

@@ -61,8 +61,9 @@ export default class MktMesh extends Mesh<BufferGeometry, ShaderMaterial> {
      *    ⇒ 与编辑态 `mktMeshEditRenderer._slotPanos` **同一份算法、同一个常数**（预览看到的那几张 = 编辑器里的那几张，均为 8 个全景槽）。
      *    存**对象引用**不存下标（删点会让下标整体前移，引用不会认错人）。
      *    消费方 = `feedFaceMapping`（墙 8 格）；⭐ 10-03 旨② 后预览立方体与墙**共用同一份材质**，
-     *    立方体几何无 `aPanoIndex` ⇒ `vPanoIndex ≡ 0` ⇒ 它显示的就是 0 号槽那张（墙与立方体天然同源，
-     *    原来那条「把中心那几张抄给立方体单全景材质」的 `currentTiles` 旁路已整条删除）。
+     *    ⭐ 10-12 旨后立方体**逐颗自带序号**（`InstancedChild.panoIndex` → 逐实例 `aPanoIndex`），
+     *    不再是从前那句「几何没这条 attribute ⇒ `vPanoIndex ≡ 0` ⇒ 全体看 0 号槽那张」；
+     *    原来那条「把中心那几张抄给立方体单全景材质」的 `currentTiles` 旁路已整条删除。
      */
     private _slotPanos;
     /**

package/MktMesh/MktMesh.js

@@ -107,8 +107,9 @@ export default class MktMesh extends Mesh {
      *    ⇒ 与编辑态 `mktMeshEditRenderer._slotPanos` **同一份算法、同一个常数**（预览看到的那几张 = 编辑器里的那几张，均为 8 个全景槽）。
      *    存**对象引用**不存下标（删点会让下标整体前移，引用不会认错人）。
      *    消费方 = `feedFaceMapping`（墙 8 格）；⭐ 10-03 旨② 后预览立方体与墙**共用同一份材质**，
-     *    立方体几何无 `aPanoIndex` ⇒ `vPanoIndex ≡ 0` ⇒ 它显示的就是 0 号槽那张（墙与立方体天然同源，
-     *    原来那条「把中心那几张抄给立方体单全景材质」的 `currentTiles` 旁路已整条删除）。
+     *    ⭐ 10-12 旨后立方体**逐颗自带序号**（`InstancedChild.panoIndex` → 逐实例 `aPanoIndex`），
+     *    不再是从前那句「几何没这条 attribute ⇒ `vPanoIndex ≡ 0` ⇒ 全体看 0 号槽那张」；
+     *    原来那条「把中心那几张抄给立方体单全景材质」的 `currentTiles` 旁路已整条删除。
      */
     _slotPanos = [];
     /**
@@ -801,6 +802,10 @@ export default class MktMesh extends Mesh {
      *  ⭐ `rt:` 虚拟键（32 瓦片拼合槽）走拼合器 peek；⛔ 不在这里 pump（每帧驱动点唯一，见 `updateTexture`，
      *    否则一帧画好几格 = 把「每帧只载入一张新纹理」那道闸从后门拆了）。 */
     _peekTileAt(key, original) {
+        // ⭐ 2026-10-25：空地址 = 「这个点还没设图片」，不是一条能加载的 URL ⇒ 直接判没有。
+        //    放过去会让 ensureTileTexture 拿空串请求当前文档地址、失败后每帧重试。
+        if (!key)
+            return null;
         if (isRtStitchKey(key)) {
             const p = rtStitchKeyParts(key);
             if (!p)
@@ -838,6 +843,9 @@ export default class MktMesh extends Mesh {
      *  ⚠️ 皇上旨 2026-09-28「加载瓦片的时候, 瓦片纹理不需要添加 oss 的参数」⇒ 真瓦片（`original=true`，现行 32 片/全景）走原图，
      *     整图档才按 ossSize 档缩（`resolveOssUrl`）。 */
     ensureTileTexture(key, original = false) {
+        // ⭐ 2026-10-25：空地址直接判「没有」，不起载（与编辑态 ensureFloorTexture 同一道闸）。
+        if (!key)
+            return null;
         const cached = this._texCache.get(key);
         if (cached)
             return cached;
@@ -887,8 +895,9 @@ export default class MktMesh extends Mesh {
             if (this._glRenderer)
                 this._glRenderer.initTexture(tex);
         }
-        catch (e) {
-            console.warn("[MktMesh] 瓦片预上传失败，交给常规渲染路径自行上传：", e);
+        catch {
+            // 皇上旨 2026-10-12「日志都去掉」⇒ 这里不再出声；降级路径本身不变（下面照记「已处理」，
+            // 最坏退回 three 在绑定那一帧自己上传的老路径）。
         }
         // ⚠️ 成败都记「已处理」。不记 ⇒ 这张永远进不了 `_texUploaded` ⇒ 那一格永远换不上新图，
         //    比「卡一下」严重得多；记了最坏也只是退回 three 在绑定那一帧自己上传的老路径。
@@ -932,6 +941,18 @@ export default class MktMesh extends Mesh {
                 continue;
             }
             idxU[s] = this.textures.indexOf(info);
+            // ⭐ 2026-10-25 皇上旨「把默认图去掉，图片没有加载的时候就显示纯灰色」：
+            //    这个点**没设图片**（url 空且没有切片）⇒ 按空槽喂料，权重 0 ⇒ 片元回落 uFaceMissingColor 中性灰。
+            //    ⛔ 别把空地址放下去：空 key 会走到 `_peekTileAt` → `ensureTileTexture("")` 发一次空请求
+            //    （解析成当前文档地址），失败后下一帧再试 = 每帧一个废请求。序号照留（归属还在，只是没图）。
+            const hasSource = !!info.url || !!(info.tiles && info.tiles.length > 0);
+            if (!hasSource) {
+                for (let k = 0; k < RT_STITCH_SLOT_COUNT; k++)
+                    panos[base + k] = this._placeholder;
+                mats[s].identity();
+                ws[s] = 0;
+                continue;
+            }
             // 各槽喂什么地址 = 「用户选的形态 + 该点有没有切过片」共同决定（whole 或无 tiles ⇒ 各槽同为一张整图）
             const tiles = mktPanoTexUrls(info.url, info.tiles, this._panoTexMode);
             // ⚠️ 「是不是真瓦片」只算一次：喂地址（走不走 OSS 尺寸档）与写 uPanoTiled 共用同一个值
@@ -1042,12 +1063,10 @@ export default class MktMesh extends Mesh {
         // setWallPoints 已按位置重算过映射（旧为空 → 全 -1），此处用存档里的逐面指派覆盖。
         // 几何拓扑由同一份 wallPoints 重建，面索引与导出时一致 ⇒ 逐面写入即可对齐。
         // ⭐ 皇上旨 2026-10-03「补」：长度不符**不再整份丢弃**——按较小长度逐面灌回（存档多出的面丢掉，
-        //   墙变长多出来的那些面保持 setWallPoints 按位置继承到的值），并把两个数 warn 出来（不静默吞）。
+        //   墙变长多出来的那些面保持 setWallPoints 按位置继承到的值）。
+        //   2026-10-12 旨「日志都去掉」⇒ 这一条不再 warn，差值只按较小者静默还原。
         const imported = (data.panoFaceMapping && data.panoFaceMapping.length ? data.panoFaceMapping : []);
         const faceCount = this.panoFaceMapping.length;
-        if (imported.length && imported.length !== faceCount) {
-            console.warn(`[MktMesh] 存档序号映射面数 ${imported.length} ≠ 当前墙体面数 ${faceCount}，按较小者逐面还原（差值来自墙点/墙高变化）`);
-        }
         const restore = Math.min(imported.length, faceCount);
         if (restore > 0) {
             for (let f = 0; f < restore; f++)

package/MktMesh/MktMesh.ts

@@ -130,8 +130,9 @@ export default class MktMesh extends Mesh<BufferGeometry, ShaderMaterial> {
      *    ⇒ 与编辑态 `mktMeshEditRenderer._slotPanos` **同一份算法、同一个常数**（预览看到的那几张 = 编辑器里的那几张，均为 8 个全景槽）。
      *    存**对象引用**不存下标（删点会让下标整体前移，引用不会认错人）。
      *    消费方 = `feedFaceMapping`（墙 8 格）；⭐ 10-03 旨② 后预览立方体与墙**共用同一份材质**，
-     *    立方体几何无 `aPanoIndex` ⇒ `vPanoIndex ≡ 0` ⇒ 它显示的就是 0 号槽那张（墙与立方体天然同源，
-     *    原来那条「把中心那几张抄给立方体单全景材质」的 `currentTiles` 旁路已整条删除）。
+     *    ⭐ 10-12 旨后立方体**逐颗自带序号**（`InstancedChild.panoIndex` → 逐实例 `aPanoIndex`），
+     *    不再是从前那句「几何没这条 attribute ⇒ `vPanoIndex ≡ 0` ⇒ 全体看 0 号槽那张」；
+     *    原来那条「把中心那几张抄给立方体单全景材质」的 `currentTiles` 旁路已整条删除。
      */
     private _slotPanos: (MktTextureInfo | undefined)[] = [];
     /**
@@ -833,6 +834,9 @@ export default class MktMesh extends Mesh<BufferGeometry, ShaderMaterial> {
      *  ⭐ `rt:` 虚拟键（32 瓦片拼合槽）走拼合器 peek；⛔ 不在这里 pump（每帧驱动点唯一，见 `updateTexture`，
      *    否则一帧画好几格 = 把「每帧只载入一张新纹理」那道闸从后门拆了）。 */
     private _peekTileAt(key: string, original: boolean): Texture | null {
+        // ⭐ 2026-10-25：空地址 = 「这个点还没设图片」，不是一条能加载的 URL ⇒ 直接判没有。
+        //    放过去会让 ensureTileTexture 拿空串请求当前文档地址、失败后每帧重试。
+        if (!key) return null;
         if (isRtStitchKey(key)) {
             const p = rtStitchKeyParts(key);
             if (!p) return null;
@@ -869,6 +873,8 @@ export default class MktMesh extends Mesh<BufferGeometry, ShaderMaterial> {
      *  ⚠️ 皇上旨 2026-09-28「加载瓦片的时候, 瓦片纹理不需要添加 oss 的参数」⇒ 真瓦片（`original=true`，现行 32 片/全景）走原图，
      *     整图档才按 ossSize 档缩（`resolveOssUrl`）。 */
     private ensureTileTexture(key: string, original = false): Texture | null {
+        // ⭐ 2026-10-25：空地址直接判「没有」，不起载（与编辑态 ensureFloorTexture 同一道闸）。
+        if (!key) return null;
         const cached = this._texCache.get(key);
         if (cached) return cached;
         if (cached === null) return null; // 加载中
@@ -915,8 +921,9 @@ export default class MktMesh extends Mesh<BufferGeometry, ShaderMaterial> {
             // `_glRenderer` 还没被 `onBeforeRender` 捕获到（构造后尚未渲染过一帧）⇒ 跳过预上传，
             // 交给 three 在绑定那一帧自己上传 —— 那是改造前的老路径，不会报错，只是那一张没享受「错峰」。
             if (this._glRenderer) this._glRenderer.initTexture(tex);
-        } catch (e) {
-            console.warn("[MktMesh] 瓦片预上传失败，交给常规渲染路径自行上传：", e);
+        } catch {
+            // 皇上旨 2026-10-12「日志都去掉」⇒ 这里不再出声；降级路径本身不变（下面照记「已处理」，
+            // 最坏退回 three 在绑定那一帧自己上传的老路径）。
         }
         // ⚠️ 成败都记「已处理」。不记 ⇒ 这张永远进不了 `_texUploaded` ⇒ 那一格永远换不上新图，
         //    比「卡一下」严重得多；记了最坏也只是退回 three 在绑定那一帧自己上传的老路径。
@@ -959,6 +966,17 @@ export default class MktMesh extends Mesh<BufferGeometry, ShaderMaterial> {
                 continue;
             }
             idxU[s] = this.textures.indexOf(info);
+            // ⭐ 2026-10-25 皇上旨「把默认图去掉，图片没有加载的时候就显示纯灰色」：
+            //    这个点**没设图片**（url 空且没有切片）⇒ 按空槽喂料，权重 0 ⇒ 片元回落 uFaceMissingColor 中性灰。
+            //    ⛔ 别把空地址放下去：空 key 会走到 `_peekTileAt` → `ensureTileTexture("")` 发一次空请求
+            //    （解析成当前文档地址），失败后下一帧再试 = 每帧一个废请求。序号照留（归属还在，只是没图）。
+            const hasSource = !!info.url || !!(info.tiles && info.tiles.length > 0);
+            if (!hasSource) {
+                for (let k = 0; k < RT_STITCH_SLOT_COUNT; k++) panos[base + k] = this._placeholder;
+                mats[s].identity();
+                ws[s] = 0;
+                continue;
+            }
             // 各槽喂什么地址 = 「用户选的形态 + 该点有没有切过片」共同决定（whole 或无 tiles ⇒ 各槽同为一张整图）
             const tiles = mktPanoTexUrls(info.url, info.tiles, this._panoTexMode);
             // ⚠️ 「是不是真瓦片」只算一次：喂地址（走不走 OSS 尺寸档）与写 uPanoTiled 共用同一个值
@@ -1075,12 +1093,10 @@ export default class MktMesh extends Mesh<BufferGeometry, ShaderMaterial> {
         // setWallPoints 已按位置重算过映射（旧为空 → 全 -1），此处用存档里的逐面指派覆盖。
         // 几何拓扑由同一份 wallPoints 重建，面索引与导出时一致 ⇒ 逐面写入即可对齐。
         // ⭐ 皇上旨 2026-10-03「补」：长度不符**不再整份丢弃**——按较小长度逐面灌回（存档多出的面丢掉，
-        //   墙变长多出来的那些面保持 setWallPoints 按位置继承到的值），并把两个数 warn 出来（不静默吞）。
+        //   墙变长多出来的那些面保持 setWallPoints 按位置继承到的值）。
+        //   2026-10-12 旨「日志都去掉」⇒ 这一条不再 warn，差值只按较小者静默还原。
         const imported = (data.panoFaceMapping && data.panoFaceMapping.length ? data.panoFaceMapping : []) as number[];
         const faceCount = this.panoFaceMapping.length;
-        if (imported.length && imported.length !== faceCount) {
-            console.warn(`[MktMesh] 存档序号映射面数 ${imported.length} ≠ 当前墙体面数 ${faceCount}，按较小者逐面还原（差值来自墙点/墙高变化）`);
-        }
         const restore = Math.min(imported.length, faceCount);
         if (restore > 0) {
             for (let f = 0; f < restore; f++) this.panoFaceMapping[f] = imported[f];

package/MktMesh/boxLine2.d.ts

@@ -0,0 +1,42 @@
+import { BoxGeometry, BufferGeometry, Camera, Group, Material, Mesh, MeshBasicMaterial, NormalBufferAttributes, Raycaster, Scene, Vector3, WebGLRenderer } from "three";
+import { LineMaterial } from "three/examples/jsm/lines/LineMaterial.js";
+import { LineSegments2 } from "three/examples/jsm/lines/LineSegments2.js";
+export default class BoxLine2 extends Mesh {
+    constructor();
+    /** 控制台识别用（本仓约定：对象要能被认出来是谁的哪一份） */
+    type: string;
+    frustumCulled: boolean;
+    size: Vector3;
+    T1: Vector3;
+    T2: Vector3;
+    T3: Vector3;
+    T4: Vector3;
+    B1: Vector3;
+    B2: Vector3;
+    B3: Vector3;
+    B4: Vector3;
+    frontLineMaterial: LineMaterial;
+    backLineMaterial: LineMaterial;
+    createLine(name: string): LineSegments2;
+    T1_line: LineSegments2;
+    T2_line: LineSegments2;
+    T3_line: LineSegments2;
+    T4_line: LineSegments2;
+    M1_line: LineSegments2;
+    M2_line: LineSegments2;
+    M3_line: LineSegments2;
+    M4_line: LineSegments2;
+    B1_line: LineSegments2;
+    B2_line: LineSegments2;
+    B3_line: LineSegments2;
+    B4_line: LineSegments2;
+    /** 射线靶子（比框小一圈）：`alphaTest: 1.1` ⇒ 一个像素都不画，只给下面的遮挡判据打 */
+    boxMesh: Mesh<BoxGeometry, MeshBasicMaterial, import("three").Object3DEventMap>;
+    /** 代理盒单边内缩量：米级盒子照参考实现减 0.1；薄一片/占位方块那种小尺寸钳到自身的一半，⛔ 不出负数 */
+    private _insetSize;
+    setSize(v: Vector3): void;
+    raycaster: Raycaster;
+    onBeforeRender: (renderer: WebGLRenderer, _scene: Scene, camera: Camera, _geometry: BufferGeometry<NormalBufferAttributes>, _material: Material, _group: Group) => void;
+    /** 释放：12 份线段几何 + 代理盒几何 + 两份 LineMaterial + 代理盒材质（模型槽删除/换框时调用） */
+    dispose(): void;
+}

package/MktMesh/boxLine2.js

@@ -0,0 +1,185 @@
+/*
+ * @Description: 选中设备的包围盒高亮框 —— 皇上旨 2026-10-22「选中设备的时候，设备还需要有一个高亮的框，
+ *   你参考旁边 archives2026 项目」⇒ 整搬那边的 `srcWeb/pages/LargeScreen/component3d/BoxLine2.ts`
+ *   （12 条棱 fat-line：朝向相机那几棱**绿色实线**，被盒子自己挡住的那几棱**红色虚线**）。
+ *
+ * 为什么不直接用现成的 `EdgesGeometry + LineBasicMaterial`（也就是本仓旧版那圈细线）：
+ * - 旧那圈是 `GL_LINES`，`linewidth` 在 WebGL/ANGLE 下是**死旋钮** ⇒ 永远 1 像素，深色模型上几乎看不见
+ *   （仓内同族早已踩过：墙线/立方体边框 10-05、10-07 两旨都换成了 `LineSegments2 + LineMaterial`）。
+ * - fat-line 的粗细是**屏幕像素**（`worldUnits:false`）⇒ 远近一样粗，这正是「高亮框」要的效果。
+ *
+ * 遮挡那一刀怎么来的（照搬，⛔ 不是臣自己发明的判据）：八顶点各自从相机朝该角发一条射线，打这份**内嵌代理盒**
+ * —— 打得着 = 这条视线被盒子自己截住了 = 那个角在背面 ⇒ 凡是含背角的棱改用红色虚线材质。
+ * 代理盒本身 `alphaTest: 1.1` ⇒ 一个像素都不出、也不写深度，只当射线靶子用。
+ *
+ * ⚠️ 相对参考实现改了五处，每处都只为了贴合本仓：
+ *   ① 代理盒内缩量钳到「不小于原尺寸的 50%」（`_insetSize`）：那边设备都是米级大物件，`v - 0.1` 恒正；
+ *      本仓的模型槽可能是薄一片（画作/展牌）或 0.3 m 的占位方块，`v - 0.1` 会出负数拿到一份翻面的几何。
+ *   ② 整棵子树标 `userData.pickIgnored = true`：本仓编辑器拾取模型走 `intersectObjects(this.models, true)`
+ *      （递归打进槽本体），一个实心代理盒挂在槽下面会把「框内的空地」也点成选中这只槽 —— 旧版那圈细线是靠
+ *      `raycast = noop` 躲开的，这里换成标记，由 `_pickModel` 跳过（⛔ 类内部的遮挡射线不受影响，它打的是
+ *      自己那份 `boxMesh`，与本仓的拾取射线是两把尺）。
+ *   ③ 加 `dispose()`：本仓模型槽删除/换模型要释放那 12 份线段几何与两份 LineMaterial，否则删一只漏一份显存。
+ *   ④ 没搬那边那四颗 `setDepthTest` / `setLinewidth` / 两个 getter —— 在 archives2026 全仓 **0 处调用**
+ *      （而且那两个私有字段的初值 `false`/`1` 与两份材质真正用的 `depthTest:true`/`linewidth:2` 本来就不一致，
+ *      只有从没被调过才没露馅）。真正生效的就是下面材质构造里那两个数，⛔ 不留没人拧的旋钮。
+ *   ⑤ 12 条棱各自 `raycast = noop`：那边从不把线框交给射线，本仓的拾取射线会**递归**进槽子树打到它们，
+ *      而 `LineSegments2.raycast` 在 `worldUnits:false` 那一路要先读 `raycaster.camera`（编辑器那把没设）
+ *      ⇒ 先 `console.error` 再撞 `camera.projectionMatrix` 抛异常。详见 `createLine` 里那句注释。
+ */
+import { BoxGeometry, DoubleSide, Mesh, MeshBasicMaterial, Raycaster, Vector2, Vector3, } 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";
+/** 朝向相机那几棱：绿色实线 */
+const FRONT_COLOR = 0x00ff00;
+/** 被盒子挡住的那几棱：红色虚线（dash/gap 各 5，与参考实现同档） */
+const BACK_COLOR = 0xff0000;
+/** 棱线粗细（屏幕像素，`worldUnits:false` ⇒ 远近一样粗） */
+const LINE_WIDTH_PX = 2;
+export default class BoxLine2 extends Mesh {
+    constructor() {
+        super();
+        // 拾取/射线都不该把高亮框算进来（见文件头 ⚠️②）；内部遮挡判据另打 `this.boxMesh`，不走这条
+        this.traverse((o) => { o.userData.pickIgnored = true; });
+    }
+    /** 控制台识别用（本仓约定：对象要能被认出来是谁的哪一份） */
+    type = "boxLine2";
+    frustumCulled = false;
+    size = new Vector3(1, 1, 1);
+    T1 = new Vector3();
+    T2 = new Vector3();
+    T3 = new Vector3();
+    T4 = new Vector3();
+    B1 = new Vector3();
+    B2 = new Vector3();
+    B3 = new Vector3();
+    B4 = new Vector3();
+    frontLineMaterial = new LineMaterial({
+        color: FRONT_COLOR,
+        worldUnits: false,
+        linewidth: LINE_WIDTH_PX,
+        depthTest: true,
+        resolution: new Vector2(1, 1),
+    });
+    backLineMaterial = new LineMaterial({
+        color: BACK_COLOR,
+        worldUnits: false,
+        dashed: true,
+        dashSize: 5,
+        gapSize: 5,
+        linewidth: LINE_WIDTH_PX,
+        depthTest: true,
+        resolution: new Vector2(1, 1),
+    });
+    createLine(name) {
+        const segmentsGeometry = new LineSegmentsGeometry();
+        segmentsGeometry.setPositions([-0.5, 0, 0, 0.5, 0, 0]);
+        const line = new LineSegments2(segmentsGeometry, this.frontLineMaterial);
+        line.name = name;
+        line.renderOrder = 100;
+        // ⚠️ 本仓必改（参考那边没有这一行）：`LineSegments2.raycast` 在 `worldUnits:false` 那一路要读
+        //   `raycaster.camera`（屏幕空间投影），而编辑器拾取模型用的是 `intersectObjects(models, true)` 递归打到这里、
+        //   那把射线没设 camera ⇒ three 自己 `console.error` 之后紧接着碰 `camera.projectionMatrix` 直接抛 ⇒ 选中点不动。
+        //   线段本身不是「可点的东西」，置空最省事；那颗代理盒的 `raycast` 必须留着（遮挡判据打它）。
+        line.raycast = () => { };
+        line.computeLineDistances();
+        this.add(line);
+        return line;
+    }
+    T1_line = this.createLine("T1,T2");
+    T2_line = this.createLine("T2,T3");
+    T3_line = this.createLine("T3,T4");
+    T4_line = this.createLine("T4,T1");
+    M1_line = this.createLine("T1,B1");
+    M2_line = this.createLine("T2,B2");
+    M3_line = this.createLine("T3,B3");
+    M4_line = this.createLine("T4,B4");
+    B1_line = this.createLine("B1,B2");
+    B2_line = this.createLine("B2,B3");
+    B3_line = this.createLine("B3,B4");
+    B4_line = this.createLine("B4,B1");
+    /** 射线靶子（比框小一圈）：`alphaTest: 1.1` ⇒ 一个像素都不画，只给下面的遮挡判据打 */
+    boxMesh = (() => {
+        const boxGeometry = new BoxGeometry(1, 1, 1);
+        const boxMesh = new Mesh(boxGeometry, new MeshBasicMaterial({
+            color: "#ff0000", side: DoubleSide, wireframe: true, alphaTest: 1.1,
+        }));
+        boxMesh.name = "遮挡判据代理盒";
+        this.add(boxMesh);
+        return boxMesh;
+    })();
+    /** 代理盒单边内缩量：米级盒子照参考实现减 0.1；薄一片/占位方块那种小尺寸钳到自身的一半，⛔ 不出负数 */
+    _insetSize(v) {
+        return Math.max(v - 0.1, v * 0.5);
+    }
+    setSize(v) {
+        this.size.set(v.x, v.y, v.z);
+        this.boxMesh.geometry.dispose();
+        this.boxMesh.geometry = new BoxGeometry(this._insetSize(v.x), this._insetSize(v.y), this._insetSize(v.z));
+        this.T1.set(v.x / -2, v.y / 2, v.z / -2);
+        this.T2.set(v.x / -2, v.y / 2, v.z / 2);
+        this.T3.set(v.x / 2, v.y / 2, v.z / 2);
+        this.T4.set(v.x / 2, v.y / 2, v.z / -2);
+        this.B1.set(v.x / -2, v.y / -2, v.z / -2);
+        this.B2.set(v.x / -2, v.y / -2, v.z / 2);
+        this.B3.set(v.x / 2, v.y / -2, v.z / 2);
+        this.B4.set(v.x / 2, v.y / -2, v.z / -2);
+        const lines = [
+            { line: this.T1_line, p1: this.T1, p2: this.T2 },
+            { line: this.T2_line, p1: this.T2, p2: this.T3 },
+            { line: this.T3_line, p1: this.T3, p2: this.T4 },
+            { line: this.T4_line, p1: this.T4, p2: this.T1 },
+            { line: this.M1_line, p1: this.T1, p2: this.B1 },
+            { line: this.M2_line, p1: this.T2, p2: this.B2 },
+            { line: this.M3_line, p1: this.T3, p2: this.B3 },
+            { line: this.M4_line, p1: this.T4, p2: this.B4 },
+            { line: this.B1_line, p1: this.B1, p2: this.B2 },
+            { line: this.B2_line, p1: this.B2, p2: this.B3 },
+            { line: this.B3_line, p1: this.B3, p2: this.B4 },
+            { line: this.B4_line, p1: this.B4, p2: this.B1 },
+        ];
+        lines.forEach(({ line, p1, p2 }) => {
+            line.geometry.setPositions([p1.x, p1.y, p1.z, p2.x, p2.y, p2.z]);
+            line.computeLineDistances();
+        });
+    }
+    raycaster = new Raycaster();
+    onBeforeRender = (renderer, _scene, camera, _geometry, _material, _group) => {
+        renderer.getSize(this.frontLineMaterial.resolution);
+        renderer.getSize(this.backLineMaterial.resolution);
+        const farVectorName = [];
+        const farVectorNames = ["T1", "T2", "T3", "T4", "B1", "B2", "B3", "B4"];
+        this.raycaster.ray.origin.copy(camera.position);
+        [this.T1, this.T2, this.T3, this.T4, this.B1, this.B2, this.B3, this.B4].forEach((v, i) => {
+            const direction = v.clone().applyMatrix4(this.matrixWorld).sub(camera.position);
+            this.raycaster.ray.direction.copy(direction).normalize();
+            this.raycaster.far = direction.length();
+            const intersect = this.raycaster.intersectObject(this.boxMesh);
+            if (intersect.length > 0) {
+                farVectorName.push(farVectorNames[i]);
+            }
+        });
+        [
+            this.T1_line, this.T2_line, this.T3_line, this.T4_line,
+            this.M1_line, this.M2_line, this.M3_line, this.M4_line,
+            this.B1_line, this.B2_line, this.B3_line, this.B4_line,
+        ].forEach((line) => {
+            const has = farVectorName.some((name) => line.name.includes(name));
+            line.material = has ? this.backLineMaterial : this.frontLineMaterial;
+        });
+    };
+    /** 释放：12 份线段几何 + 代理盒几何 + 两份 LineMaterial + 代理盒材质（模型槽删除/换框时调用） */
+    dispose() {
+        for (const line of [
+            this.T1_line, this.T2_line, this.T3_line, this.T4_line,
+            this.M1_line, this.M2_line, this.M3_line, this.M4_line,
+            this.B1_line, this.B2_line, this.B3_line, this.B4_line,
+        ])
+            line.geometry.dispose();
+        this.boxMesh.geometry.dispose();
+        this.boxMesh.material.dispose();
+        this.frontLineMaterial.dispose();
+        this.backLineMaterial.dispose();
+    }
+}