three-base 2.0.172 → 2.0.175

package/pass/ssao_pass.js

@@ -1,84 +1,41 @@
-import { Color, DataTexture, DoubleSide, LinearFilter, MeshBasicMaterial, NoBlending, RGBAFormat, RawShaderMaterial, RepeatWrapping, Vector2, Vector3, WebGLRenderTarget, Matrix4, MultiplyBlending, PerspectiveCamera, OrthographicCamera } from "three";
+import { Color, DataTexture, LinearFilter, NoBlending, RGBAFormat, RawShaderMaterial, RepeatWrapping, Vector2, Vector3, WebGLRenderTarget, Matrix4, MultiplyBlending, PerspectiveCamera, OrthographicCamera } from "three";
 import fsQuad from "./fsQuad";
+// ---------------------------------------------------------------------------
+// AO 数据准备 pass（深度 / 法线）
+// 这些逻辑原本散落在 ThreeBase.render() 里，现收敛到此模块，ThreeBase 只调用下面两个函数。
+// ⭐ 2026-10-18 皇上旨「所有的对象都要进入到深度图里面了，不需要用参数过滤掉了」⇒ 本模块原本的排除
+//   逻辑**整条删除**（含 excludeTransparent 参数、按材质 transparent 的判据、userData.aoFloor /
+//   aoTransparent / aoOpaque 三个标记、sprite/线条/点的无条件排除），两张深度图都收全场景对象。
+//   历史上这些排除是给 AO 兜底的，删掉后已知代价（皇上看过源码依据后确认接受）：
+//   - 半透明面（玻璃、霓虹灯管、光晕、特效载体）也参与 AO → 透过它们看到的实体可能被乘黑；
+//   - sprite / 线条 / 点在 MeshNormalMaterial override 下法线不可信 → 该区域 AO 可能出黑块；
+//   - 地板（Ground1）重新写进可见深度图 → 透过地板看到的实体，其描边/辉光/覆盖色/磨砂会被裁掉。
+//     10-12 旨「装饰地板需要透明」这次只保留**外观**（transparent + 径向 alpha 淡出 + depthWrite），
+//     遮挡侧的 aoFloor 例外随本旨拆除。
+//   出问题时用面板「深度调试 → 全局深度图 / AO深度图」两档定位是哪一侧。护栏：test/depthDebug.test.js J 组。
+// 两张图仍然都存在、不能合并（现在两者渲染范围一致，差别只剩「用什么材质渲染」）：
+//   - 可见深度（renderVisibleDepthPass，用各物体**自身材质**渲染）：自身材质 ⇒ 单面墙只记正面、
+//     alpha 抠图（树叶、带 discard 的自定义 shader）只记真正可见的像素 —— 特效遮挡必须吃这份保真度。
+//   - AO 深度（normalRenderTarget 的 depth attachment，法线 pass 顺带白拿）：override 材质是
+//     DoubleSide 且不做物体自己的 alpha discard，只能配法线给 GTAO 用；合成时靠 outputShader 那条
+//     「AO 侧比可见深度更近 → 作废该像素 AO」的守卫兜住两套渲染结果的错位（别当死代码删）。
+// ---------------------------------------------------------------------------
 /**
- * 判断是否为「可透视的半透明表面」——这类表面不该在世界空间 AO 里充当实体。
- * 让它进入深度/法线图，被它遮挡的区域会发黑，成因分两种：
- *   a) transparent:true + opacity<1（毛玻璃、透明装饰）：深度图与法线图都落在半透明表面上，
- *      GTAO 在其表面算自遮蔽（褶皱、紧贴其它几何的窄缝）→ 这份 AO 被乘到「透过它看到的
- *      实体」上 → 该区域发黑。
- *   b) transparent:true + depthWrite:false（霓虹灯管、光晕、叠加面）：深度图保留身后几何（远），
- *      但法线 pass 用 overrideMaterial（MeshNormalMaterial 默认 depthWrite:true）会强行把它的
- *      法线写进去（近）→ 深度与法线指的不是同一个点 → GTAO 几乎必然算错发黑。
- * 故 AO 那一趟统一隐藏这些面：该像素的法线即身后不透明几何，AO 由真实可见几何决定；
- * 身后是背景时深度为 1.0，shader 守卫直接判「无遮蔽」(=1)，不会发黑。
- *
- * 判据只看 material.transparent 本身，不再依赖 opacity / depthWrite（2026-08-30 修正）：
- * 大量半透明是自定义 ShaderMaterial，alpha 由 shader 算出来，而材质的 opacity 仍是默认 1、
- * depthWrite 仍是 true —— 典型如聚光灯光斑、effectMaterial1，靠材质属性完全读不出来，
- * 会被漏判并继续污染 AO。
- * 代价：Mirror 这类「标了 transparent 但 shader 实际输出 alpha=1.0」的实心反射面会被误排除，
- * 故 Mirror 在构造函数里显式标记 userData.aoOpaque = true 保留（见各 Mirror 实现）。
- * 其余特例同样可用 userData.aoTransparent=true 强制排除 / userData.aoOpaque=true 强制保留。
- *
- * @param excludeTransparent 两道 pass 的唯一差别，取值就是它名字的含义：
- *   - false（可见深度 / 描边/辉光/毛玻璃/覆盖色遮挡判定）：透明面**当实体**参与遮挡。
- *     ⚠️ 关键（2026-09-06 回归根因）：three-base 大量面（玻璃、特效载体、alpha 贴图实体、
- *     半透明墙）都标了 transparent:true；若在此排除，它们就不再遮挡身后特效，所有依赖
- *     baseDepthTexture 的深度测试全部失效、一律显示在前面。
- *   - true（AO 深度 + 法线）：透明面排除，避免 GTAO 在其上算错发黑。
- *   ⚠️ 2026-10-11 起此参数原名 includeFloor（地板特例已整条拆除，见文件头），别再当"地板开关"读。
- */
-const isSeeThroughSurface = (obj, excludeTransparent = false) => {
-    const o = obj;
-    const userData = o.userData;
-    if (userData && userData.aoOpaque === true)
-        return false;
-    if (userData && userData.aoTransparent === true)
-        return true;
-    const mat = o.material;
-    if (!mat)
-        return false;
-    const list = Array.isArray(mat) ? mat : [mat];
-    const transparent = list.some((m) => m !== null && m.transparent === true);
-    return excludeTransparent && transparent;
-};
-const isNonSurface = (obj, excludeTransparent = false) => {
-    const o = obj;
-    if (o.isSprite === true || o.isLine === true || o.isLine2 === true || o.isLineSegments2 === true || o.isPoints === true) {
-        return true;
-    }
-    return isSeeThroughSurface(obj, excludeTransparent);
-};
-const hideNonSurface = (scene, excludeTransparent = false) => {
-    const list = [];
-    scene.traverse((obj) => {
-        if (isNonSurface(obj, excludeTransparent)) {
-            list.push({ obj, prev: obj.visible });
-            obj.visible = false;
-        }
-    });
-    return list;
-};
-const restoreVisibility = (list) => {
-    list.forEach(({ obj, prev }) => (obj.visible = prev));
-};
-/**
- * 可见深度 pass：固定排除非实体表面后，用**各物体自身的材质**把场景深度渲染到 depthRenderTarget。
+ * 可见深度 pass：用**各物体自身的材质**把整个场景的深度渲染到 depthRenderTarget。
  * depthRenderTarget.depthTexture 即 baseDepthTexture，供描边 / 发光 / 覆盖 / 磨砂的遮挡判定，
  * 也是 SSAO 合成时「真实可见表面」的参考。
- * 排除的非实体对象（sprite/线条/点）在深度图保留 clear 深度(1.0=远)，与背景一致；排除的
- * 半透明对象则保留其身后不透明几何的深度（身后无几何时同样为 1.0）。均不影响颜色通道渲染。
+ * 2026-10-18 起**不排除任何对象**（皇上旨「所有的对象都要进入到深度图里面了，不需要用参数过滤掉了」）：
+ * 场景里所有对象都参与这一趟，只有使用者自己 `visible = false` 的对象除外（那是显隐意图，本 pass 不碰）。
  * ⚠️ 名字里的 ao 已不适用（2026-10-11 改名自 renderAoDepthPass）：它产出的是**可见深度**，
- *   AO 自己的深度挂在法线 pass 上（见 renderAoNormalPass），两者只差 excludeTransparent 一个开关。
+ *   AO 自己的深度挂在法线 pass 上（见 renderAoNormalPass）。
  */
-export function renderVisibleDepthPass(renderer, camera, scene, depthRenderTarget, excludeTransparent = false) {
-    const hidden = hideNonSurface(scene, excludeTransparent);
-    // ⚠️ 深度预通道铁律：必须让所有「未被排除」的可见表面都写入深度，深度图才有真实的几何遮挡信息。
+export function renderVisibleDepthPass(renderer, camera, scene, depthRenderTarget) {
+    // ⚠️ 深度预通道铁律：必须让所有可见表面都写入深度，深度图才有真实的几何遮挡信息。
     // 透明材质（特效载体、半透明墙、alpha 贴图实体等）大多 transparent:true 且 depthWrite:false，
     // 若不强转，它们不会写进 baseDepthTexture → 深度图只剩不透明几何 → 描边/辉光/毛玻璃/覆盖色
-    // 依赖 baseDepthTexture 的遮挡判定全部失效、一律显示在前（即本次回归根因）。
-    // 被显式标记的面（userData.aoTransparent）已在 hideNonSurface 中隐藏，
-    // 此处根本不会触及，故不影响 see-through 设计；其余透明面强制写深度 = 作为实体参与遮挡，符合预期。
+    // 依赖 baseDepthTexture 的遮挡判定全部失效、一律显示在前（即 2026-09-06 那次回归根因）。
+    // 只强转 Mesh：sprite / 线条 / 点的材质默认就是 depthWrite:true，且叠加式光晕一旦强写深度会在
+    // 深度图上打洞、错误遮挡身后特效，故沿用原判据范围，不扩大。
     const depthWriteRestore = [];
     scene.traverse((obj) => {
         const mesh = obj;
@@ -98,60 +55,16 @@ export function renderVisibleDepthPass(renderer, camera, scene, depthRenderTarge
     renderer.render(scene, camera);
     // 还原 depthWrite，避免污染后续颜色通道渲染的透明混合
     depthWriteRestore.forEach(({ mat, val }) => { mat.depthWrite = val; });
-    restoreVisibility(hidden);
     renderer.setRenderTarget(prevRenderTarget);
 }
 /**
- * 调试用：把「被排除出可见深度图」的表面单独渲成红色 mask。
- *
- * 这些面在 renderVisibleDepthPass 里被 hideNonSurface 隐藏，因此**不会写进 baseDepthTexture**，
- * 也就永远挡不住描边/辉光/毛玻璃/覆盖色 —— 这正是"深度测试看起来失效"最常见的成因
- * （用户以为是 bug，其实是该面被设计成可透视：sprite/线条/点、userData.aoTransparent）。
- * ⚠️ 地板不在此列：2026-10-11 起 Ground1 是实心不透明面，正常写进可见深度图。
- * 面板「深度调试 → 排除面标记」叠加显示：灰=能挡住的真实遮挡面，红=被排除、挡不住任何东西。
- *
- * 只渲染 Mesh：sprite / Line2 / Points 在 MeshBasicMaterial override 下渲染异常（见文件头注释），
- * 且它们数量少、用户关心的遮挡体基本都是 Mesh，故跳过。
- */
-export function renderExcludedMaskPass(renderer, camera, scene, maskRenderTarget, excludeTransparent = false) {
-    const maskMaterial = new MeshBasicMaterial({
-        color: 0xff0000,
-        depthTest: false,
-        depthWrite: false,
-        side: DoubleSide,
-    });
-    const prevVisible = [];
-    scene.traverse((obj) => {
-        const isMesh = obj.isMesh === true;
-        prevVisible.push({ obj, prev: obj.visible });
-        // 只显示「被排除的 Mesh」：其余一律隐藏，得到纯黑底 + 红面的 mask
-        obj.visible = isMesh && isNonSurface(obj, excludeTransparent);
-    });
-    const prevOverride = scene.overrideMaterial;
-    const prevTarget = renderer.getRenderTarget();
-    const prevClear = renderer.getClearColor(new Color());
-    const prevAlpha = renderer.getClearAlpha();
-    scene.overrideMaterial = maskMaterial;
-    renderer.setRenderTarget(maskRenderTarget);
-    renderer.setClearColor(0x000000, 1);
-    renderer.clear();
-    renderer.render(scene, camera);
-    renderer.setClearColor(prevClear, prevAlpha);
-    renderer.setRenderTarget(prevTarget);
-    scene.overrideMaterial = prevOverride;
-    restoreVisibility(prevVisible);
-    maskMaterial.dispose();
-}
-/**
- * 法线 pass（仅 SSAO 开启时需要）：固定排除非实体表面后，以中性灰清屏 + normalMaterial
- * override 将视图空间法线渲染到 normalRenderTarget，供 GTAO 风格 SSAO 使用。
- * 排除对象在法线图保留中性灰清屏色 → unpackRGBToNormal(0.5,0.5,0.5)=(0,0,0) →
- * SSAO 退化法线守卫判"无遮蔽"(=1)，避免精灵弹窗被 AO 乘黑。清屏色用后即还原。
+ * 法线 pass（仅 SSAO 开启时需要）：以中性灰清屏 + normalMaterial override 将整个场景的
+ * 视图空间法线渲染到 normalRenderTarget，供 GTAO 风格 SSAO 使用。
+ * 2026-10-18 起同样不排除任何对象（与 renderVisibleDepthPass 一致，见文件头那道旨及其代价清单）。
  * 深度白拿：normalRenderTarget 挂着 aoDepthTexture 作 depth attachment，这一趟的深度由光栅器
  * 顺带写入 → 就是 AO 用的深度，无需再单独渲一遍（2026-09-14）。
  */
-export function renderAoNormalPass(renderer, camera, scene, normalRenderTarget, normalMaterial, excludeTransparent = false) {
-    const hidden = hideNonSurface(scene, excludeTransparent);
+export function renderAoNormalPass(renderer, camera, scene, normalRenderTarget, normalMaterial) {
     // ⚠️ 2026-10-11 删掉了这里原有的「强制 depthWrite=true」整段遍历：scene.overrideMaterial 生效后，
     // three 用的是 **override 材质**的渲染状态（WebGLRenderer.renderObjects：
     // `material = overrideMaterial === null ? renderItem.material : overrideMaterial`，setDepthState 吃它），
@@ -167,7 +80,6 @@ export function renderAoNormalPass(renderer, camera, scene, normalRenderTarget,
     scene.overrideMaterial = normalMaterial;
     renderer.render(scene, camera);
     scene.overrideMaterial = null;
-    restoreVisibility(hidden);
     renderer.setClearColor(prevClearColor, prevClearAlpha);
     renderer.setRenderTarget(prevRenderTarget);
 }
@@ -667,8 +579,10 @@ const outputShader = new RawShaderMaterial({
       // （override 材质：DoubleSide、不做物体自己的 alpha discard）记到一个**屏幕上根本不可见**的面
       // —— 典型如树叶抠图的空隙、单面墙的背面。此时深度与法线指的不是人眼看到的那个点，
       // GTAO 算出的 AO 不可信 → 视为无遮蔽(=1)。
-      // ⚠️ 2026-10-11：本守卫原本主要防「可透视地板挡住身后实体」，那条特例已随地板进深度图而作废，
-      //   现在它守的是上面这类 override/自身材质两套渲染结果的错位，别当死代码删。
+      // ⚠️ 2026-10-18：两张图的渲染范围已统一（皇上旨「所有的对象都要进入到深度图里面了」⇒ excludeTransparent
+      //      参数与 aoFloor 特例整条拆除），本守卫不再承担「地板的接触 AO 别乘黑身后实体」这类职责，
+      //      它守的是上面那类 override 材质 / 自身材质两套渲染结果的错位（抠图空隙、单面墙背面、
+      //      DoubleSide 记到背面），别当死代码删。
       // 仅在最终合成时生效；debug 模式直接看 GTAO 原始 AO 图，便于排查。
       float dColor = texture2D(tColorDepth, vUv).r;
       float dAo = texture2D(tAoDepth, vUv).r;
@@ -701,15 +615,14 @@ export default function ssao_pass(renderer, camera, scene, depthRenderTarget, no
     // 故 AO 直接乘进 base，描边/发光/覆盖/磨砂都叠在 AO 之上不被压暗；末尾统一 FXAA 输出到屏幕，
     // 覆盖 SSAO 自身的硬边。改动调用顺序时，本 pass 无需修改（输出到"绑定的那个目标"即可）。
     const originRenderTarget = renderer.getRenderTarget();
-    // 法线 pass（excludeTransparent=true）：隐式透明面不参与 AO，免得 GTAO 在其上算自遮蔽把
-    // 身后实体乘黑；地板/其它不透明面照常保留 —— 接触 AO 需要地板的视图空间法线。
+    // 法线 pass：整个场景都渲（2026-10-18 起不再按 transparent / aoFloor 排除任何面，见文件头那道旨）。
     // ⭐ 深度白拿（2026-09-14 优化）：normalRenderTarget 挂着 aoDepthTexture 作 depth attachment，
     // 这一次渲染的深度由光栅器顺带写入 → 直接就是 AO 深度，**不再单独渲一遍深度 pass**。
-    // （原先法线 pass 之后还要再渲一遍「AO 深度」——它与法线 pass 的排除集完全相同，
+    // （原先法线 pass 之后还要再渲一遍「AO 深度」——它与法线 pass 的渲染集完全相同，
     //   属于重复遍历全场景，2026-09-14 已删。）
     // ⚠️ 这一趟的深度是 override 材质写的（DoubleSide、不做物体自己的 alpha discard），
     //   所以只能给 AO 用；特效遮挡吃的是下面那张「用自身材质渲染」的可见深度。
-    renderAoNormalPass(renderer, camera, scene, normalRenderTarget, normalMaterial, true);
+    renderAoNormalPass(renderer, camera, scene, normalRenderTarget, normalMaterial);
     // 可见深度（用各物体自身材质渲染，含地板）= baseDepthTexture：描边/辉光/毛玻璃/覆盖色的遮挡参考，
     // 也是复合守卫里「真实可见表面」的参考。
     const colorDepthTexture = depthRenderTarget.depthTexture;

package/pass/ssao_pass.ts

@@ -1,123 +1,48 @@
-import { Color, DataTexture, DoubleSide, LinearFilter, Material, MeshBasicMaterial, MeshNormalMaterial, NoBlending, Object3D, RGBAFormat, RawShaderMaterial, RepeatWrapping, Scene, Vector2, Vector3, WebGLRenderTarget, Matrix4, MultiplyBlending, WebGLRenderer, Camera, PerspectiveCamera, OrthographicCamera, DepthTexture, Texture } from "three";
+import { Color, DataTexture, LinearFilter, Material, MeshNormalMaterial, NoBlending, Object3D, RGBAFormat, RawShaderMaterial, RepeatWrapping, Scene, Vector2, Vector3, WebGLRenderTarget, Matrix4, MultiplyBlending, WebGLRenderer, Camera, PerspectiveCamera, OrthographicCamera, DepthTexture, Texture } from "three";
 import fsQuad from "./fsQuad";
 
 // ---------------------------------------------------------------------------
 // AO 数据准备 pass（深度 / 法线）
 // 这些逻辑原本散落在 ThreeBase.render() 里，现收敛到此模块，ThreeBase 只调用下面两个函数。
-// 固定排除两类不参与世界空间 AO 的对象，它们若写进深度/法线图，SSAO 会在其区域算错
-// AO 被乘黑：
-//   1) 非实体表面：sprite 及其子类、线条类（Line / Line2 等 fat-line）、点类（Points）。
-//      - sprite 是广告牌式 UI，不该写世界空间深度，且会错误遮挡身后几何；
-//      - 线条/点类在 MeshNormalMaterial override 下渲染异常（fat-line 实例段属性未处理、
-//        Points 无面法线），法线错乱 → GTAO 算出近 0 AO 被 Multiply 乘黑。
-//   2) 可透视的半透明表面（详见 isSeeThroughSurface）：会让「被它遮挡的区域」发黑。
-// 故在深度/法线 pass 前临时隐藏，pass 后恢复（记录 prev visible 避免误改用户隐藏的 UI）。
-//
-// ⭐ 2026-10-11 皇上旨「物体的深度都要进深度图」：原先地板（Ground1 标 userData.aoFloor）被
-// 特例从可见深度图里排除 —— 那是因为它当年是「径向 alpha 淡出的半透明地板」，透过去看到的实体
-// 不该被它挡住。但 2026-09-20 二旨早已把 Ground1 改成 transparent:false 的实心深灰地板，那条例外
-// 的理由随之作废（判据还走在 material.transparent 之前，读不出来），故整条拆除：
-//   现在地板在两张图里都是实体 —— 可见深度图（特效遮挡判定）与 AO 深度图都有它，
-//   被地板挡住的描边/辉光/覆盖色/磨砂会被正确裁掉（=皇上要的行为）。
-// 两张图仍然都存在，但差别只剩「材质标了 transparent 的面」，且各自都是必须的，不能合并：
-//   - 可见深度（renderVisibleDepthPass，用各物体**自身材质**渲染）：透明面当实体（否则 2026-09-06
-//     那类「所有深度测试一律显示在前面」的回归复发）；自身材质渲染 ⇒ 单面墙只记正面、
+// ⭐ 2026-10-18 皇上旨「所有的对象都要进入到深度图里面了，不需要用参数过滤掉了」⇒ 本模块原本的排除
+//   逻辑**整条删除**（含 excludeTransparent 参数、按材质 transparent 的判据、userData.aoFloor /
+//   aoTransparent / aoOpaque 三个标记、sprite/线条/点的无条件排除），两张深度图都收全场景对象。
+//   历史上这些排除是给 AO 兜底的，删掉后已知代价（皇上看过源码依据后确认接受）：
+//   - 半透明面（玻璃、霓虹灯管、光晕、特效载体）也参与 AO → 透过它们看到的实体可能被乘黑；
+//   - sprite / 线条 / 点在 MeshNormalMaterial override 下法线不可信 → 该区域 AO 可能出黑块；
+//   - 地板（Ground1）重新写进可见深度图 → 透过地板看到的实体，其描边/辉光/覆盖色/磨砂会被裁掉。
+//     10-12 旨「装饰地板需要透明」这次只保留**外观**（transparent + 径向 alpha 淡出 + depthWrite），
+//     遮挡侧的 aoFloor 例外随本旨拆除。
+//   出问题时用面板「深度调试 → 全局深度图 / AO深度图」两档定位是哪一侧。护栏：test/depthDebug.test.js J 组。
+// 两张图仍然都存在、不能合并（现在两者渲染范围一致，差别只剩「用什么材质渲染」）：
+//   - 可见深度（renderVisibleDepthPass，用各物体**自身材质**渲染）：自身材质 ⇒ 单面墙只记正面、
 //     alpha 抠图（树叶、带 discard 的自定义 shader）只记真正可见的像素 —— 特效遮挡必须吃这份保真度。
-//   - AO 深度（normalRenderTarget 的 depth attachment，法线 pass 顺带白拿）：隐式透明面被排除，
-//     免得 GTAO 在半透明面上算自遮蔽把身后实体乘黑；法线必须由片元着色器写，这一趟省不掉。
-// 用 isSprite / isLine / isLine2 / isLineSegments2 / isPoints 属性判断而非 instanceof：
-// 避免 three 子类场景下 instanceof 命中不到（如 SpriteText 等自定义 sprite 子类、
-// Line2 继承自 Mesh 非 Line）。
+//   - AO 深度（normalRenderTarget 的 depth attachment，法线 pass 顺带白拿）：override 材质是
+//     DoubleSide 且不做物体自己的 alpha discard，只能配法线给 GTAO 用；合成时靠 outputShader 那条
+//     「AO 侧比可见深度更近 → 作废该像素 AO」的守卫兜住两套渲染结果的错位（别当死代码删）。
 // ---------------------------------------------------------------------------
 
-type HiddenEntry = { obj: Object3D; prev: boolean };
-
-/**
- * 判断是否为「可透视的半透明表面」——这类表面不该在世界空间 AO 里充当实体。
- * 让它进入深度/法线图，被它遮挡的区域会发黑，成因分两种：
- *   a) transparent:true + opacity<1（毛玻璃、透明装饰）：深度图与法线图都落在半透明表面上，
- *      GTAO 在其表面算自遮蔽（褶皱、紧贴其它几何的窄缝）→ 这份 AO 被乘到「透过它看到的
- *      实体」上 → 该区域发黑。
- *   b) transparent:true + depthWrite:false（霓虹灯管、光晕、叠加面）：深度图保留身后几何（远），
- *      但法线 pass 用 overrideMaterial（MeshNormalMaterial 默认 depthWrite:true）会强行把它的
- *      法线写进去（近）→ 深度与法线指的不是同一个点 → GTAO 几乎必然算错发黑。
- * 故 AO 那一趟统一隐藏这些面：该像素的法线即身后不透明几何，AO 由真实可见几何决定；
- * 身后是背景时深度为 1.0，shader 守卫直接判「无遮蔽」(=1)，不会发黑。
- *
- * 判据只看 material.transparent 本身，不再依赖 opacity / depthWrite（2026-08-30 修正）：
- * 大量半透明是自定义 ShaderMaterial，alpha 由 shader 算出来，而材质的 opacity 仍是默认 1、
- * depthWrite 仍是 true —— 典型如聚光灯光斑、effectMaterial1，靠材质属性完全读不出来，
- * 会被漏判并继续污染 AO。
- * 代价：Mirror 这类「标了 transparent 但 shader 实际输出 alpha=1.0」的实心反射面会被误排除，
- * 故 Mirror 在构造函数里显式标记 userData.aoOpaque = true 保留（见各 Mirror 实现）。
- * 其余特例同样可用 userData.aoTransparent=true 强制排除 / userData.aoOpaque=true 强制保留。
- *
- * @param excludeTransparent 两道 pass 的唯一差别，取值就是它名字的含义：
- *   - false（可见深度 / 描边/辉光/毛玻璃/覆盖色遮挡判定）：透明面**当实体**参与遮挡。
- *     ⚠️ 关键（2026-09-06 回归根因）：three-base 大量面（玻璃、特效载体、alpha 贴图实体、
- *     半透明墙）都标了 transparent:true；若在此排除，它们就不再遮挡身后特效，所有依赖
- *     baseDepthTexture 的深度测试全部失效、一律显示在前面。
- *   - true（AO 深度 + 法线）：透明面排除，避免 GTAO 在其上算错发黑。
- *   ⚠️ 2026-10-11 起此参数原名 includeFloor（地板特例已整条拆除，见文件头），别再当"地板开关"读。
- */
-const isSeeThroughSurface = (obj: Object3D, excludeTransparent = false): boolean => {
-    const o = obj as Object3D & { material?: Material | Material[] };
-    const userData = o.userData as { aoTransparent?: boolean; aoOpaque?: boolean } | undefined;
-    if (userData && userData.aoOpaque === true) return false;
-    if (userData && userData.aoTransparent === true) return true;
-    const mat = o.material;
-    if (!mat) return false;
-    const list: Material[] = Array.isArray(mat) ? mat : [mat];
-    const transparent = list.some((m) => m !== null && m.transparent === true);
-    return excludeTransparent && transparent;
-};
-
-const isNonSurface = (obj: Object3D, excludeTransparent = false): boolean => {
-    const o = obj as { isSprite?: boolean; isLine?: boolean; isLine2?: boolean; isLineSegments2?: boolean; isPoints?: boolean };
-    if (o.isSprite === true || o.isLine === true || o.isLine2 === true || o.isLineSegments2 === true || o.isPoints === true) {
-        return true;
-    }
-    return isSeeThroughSurface(obj, excludeTransparent);
-};
-
-const hideNonSurface = (scene: Object3D, excludeTransparent = false): HiddenEntry[] => {
-    const list: HiddenEntry[] = [];
-    scene.traverse((obj: Object3D) => {
-        if (isNonSurface(obj, excludeTransparent)) {
-            list.push({ obj, prev: obj.visible });
-            obj.visible = false;
-        }
-    });
-    return list;
-};
-
-const restoreVisibility = (list: HiddenEntry[]): void => {
-    list.forEach(({ obj, prev }) => (obj.visible = prev));
-};
-
 /**
- * 可见深度 pass：固定排除非实体表面后，用**各物体自身的材质**把场景深度渲染到 depthRenderTarget。
+ * 可见深度 pass：用**各物体自身的材质**把整个场景的深度渲染到 depthRenderTarget。
  * depthRenderTarget.depthTexture 即 baseDepthTexture，供描边 / 发光 / 覆盖 / 磨砂的遮挡判定，
  * 也是 SSAO 合成时「真实可见表面」的参考。
- * 排除的非实体对象（sprite/线条/点）在深度图保留 clear 深度(1.0=远)，与背景一致；排除的
- * 半透明对象则保留其身后不透明几何的深度（身后无几何时同样为 1.0）。均不影响颜色通道渲染。
+ * 2026-10-18 起**不排除任何对象**（皇上旨「所有的对象都要进入到深度图里面了，不需要用参数过滤掉了」）：
+ * 场景里所有对象都参与这一趟，只有使用者自己 `visible = false` 的对象除外（那是显隐意图，本 pass 不碰）。
  * ⚠️ 名字里的 ao 已不适用（2026-10-11 改名自 renderAoDepthPass）：它产出的是**可见深度**，
- *   AO 自己的深度挂在法线 pass 上（见 renderAoNormalPass），两者只差 excludeTransparent 一个开关。
+ *   AO 自己的深度挂在法线 pass 上（见 renderAoNormalPass）。
  */
 export function renderVisibleDepthPass(
     renderer: WebGLRenderer,
     camera: Camera,
     scene: Scene,
-    depthRenderTarget: WebGLRenderTarget,
-    excludeTransparent = false
+    depthRenderTarget: WebGLRenderTarget
 ): void {
-    const hidden = hideNonSurface(scene, excludeTransparent);
-    // ⚠️ 深度预通道铁律：必须让所有「未被排除」的可见表面都写入深度，深度图才有真实的几何遮挡信息。
+    // ⚠️ 深度预通道铁律：必须让所有可见表面都写入深度，深度图才有真实的几何遮挡信息。
     // 透明材质（特效载体、半透明墙、alpha 贴图实体等）大多 transparent:true 且 depthWrite:false，
     // 若不强转，它们不会写进 baseDepthTexture → 深度图只剩不透明几何 → 描边/辉光/毛玻璃/覆盖色
-    // 依赖 baseDepthTexture 的遮挡判定全部失效、一律显示在前（即本次回归根因）。
-    // 被显式标记的面（userData.aoTransparent）已在 hideNonSurface 中隐藏，
-    // 此处根本不会触及，故不影响 see-through 设计；其余透明面强制写深度 = 作为实体参与遮挡，符合预期。
+    // 依赖 baseDepthTexture 的遮挡判定全部失效、一律显示在前（即 2026-09-06 那次回归根因）。
+    // 只强转 Mesh：sprite / 线条 / 点的材质默认就是 depthWrite:true，且叠加式光晕一旦强写深度会在
+    // 深度图上打洞、错误遮挡身后特效，故沿用原判据范围，不扩大。
     const depthWriteRestore: { mat: Material; val: boolean }[] = [];
     scene.traverse((obj: Object3D) => {
         const mesh = obj as Object3D & { isMesh?: boolean; material?: Material | Material[] };
@@ -136,66 +61,13 @@ export function renderVisibleDepthPass(
     renderer.render(scene, camera);
     // 还原 depthWrite，避免污染后续颜色通道渲染的透明混合
     depthWriteRestore.forEach(({ mat, val }) => { mat.depthWrite = val; });
-    restoreVisibility(hidden);
     renderer.setRenderTarget(prevRenderTarget);
 }
 
 /**
- * 调试用：把「被排除出可见深度图」的表面单独渲成红色 mask。
- *
- * 这些面在 renderVisibleDepthPass 里被 hideNonSurface 隐藏，因此**不会写进 baseDepthTexture**，
- * 也就永远挡不住描边/辉光/毛玻璃/覆盖色 —— 这正是"深度测试看起来失效"最常见的成因
- * （用户以为是 bug，其实是该面被设计成可透视：sprite/线条/点、userData.aoTransparent）。
- * ⚠️ 地板不在此列：2026-10-11 起 Ground1 是实心不透明面，正常写进可见深度图。
- * 面板「深度调试 → 排除面标记」叠加显示：灰=能挡住的真实遮挡面，红=被排除、挡不住任何东西。
- *
- * 只渲染 Mesh：sprite / Line2 / Points 在 MeshBasicMaterial override 下渲染异常（见文件头注释），
- * 且它们数量少、用户关心的遮挡体基本都是 Mesh，故跳过。
- */
-export function renderExcludedMaskPass(
-    renderer: WebGLRenderer,
-    camera: Camera,
-    scene: Scene,
-    maskRenderTarget: WebGLRenderTarget,
-    excludeTransparent = false
-): void {
-    const maskMaterial = new MeshBasicMaterial({
-        color: 0xff0000,
-        depthTest: false,
-        depthWrite: false,
-        side: DoubleSide,
-    });
-    const prevVisible: HiddenEntry[] = [];
-    scene.traverse((obj: Object3D) => {
-        const isMesh = (obj as Object3D & { isMesh?: boolean }).isMesh === true;
-        prevVisible.push({ obj, prev: obj.visible });
-        // 只显示「被排除的 Mesh」：其余一律隐藏，得到纯黑底 + 红面的 mask
-        obj.visible = isMesh && isNonSurface(obj, excludeTransparent);
-    });
-
-    const prevOverride = scene.overrideMaterial;
-    const prevTarget = renderer.getRenderTarget();
-    const prevClear = renderer.getClearColor(new Color());
-    const prevAlpha = renderer.getClearAlpha();
-
-    scene.overrideMaterial = maskMaterial;
-    renderer.setRenderTarget(maskRenderTarget);
-    renderer.setClearColor(0x000000, 1);
-    renderer.clear();
-    renderer.render(scene, camera);
-
-    renderer.setClearColor(prevClear, prevAlpha);
-    renderer.setRenderTarget(prevTarget);
-    scene.overrideMaterial = prevOverride;
-    restoreVisibility(prevVisible);
-    maskMaterial.dispose();
-}
-
-/**
- * 法线 pass（仅 SSAO 开启时需要）：固定排除非实体表面后，以中性灰清屏 + normalMaterial
- * override 将视图空间法线渲染到 normalRenderTarget，供 GTAO 风格 SSAO 使用。
- * 排除对象在法线图保留中性灰清屏色 → unpackRGBToNormal(0.5,0.5,0.5)=(0,0,0) →
- * SSAO 退化法线守卫判"无遮蔽"(=1)，避免精灵弹窗被 AO 乘黑。清屏色用后即还原。
+ * 法线 pass（仅 SSAO 开启时需要）：以中性灰清屏 + normalMaterial override 将整个场景的
+ * 视图空间法线渲染到 normalRenderTarget，供 GTAO 风格 SSAO 使用。
+ * 2026-10-18 起同样不排除任何对象（与 renderVisibleDepthPass 一致，见文件头那道旨及其代价清单）。
  * 深度白拿：normalRenderTarget 挂着 aoDepthTexture 作 depth attachment，这一趟的深度由光栅器
  * 顺带写入 → 就是 AO 用的深度，无需再单独渲一遍（2026-09-14）。
  */
@@ -204,10 +76,8 @@ export function renderAoNormalPass(
     camera: Camera,
     scene: Scene,
     normalRenderTarget: WebGLRenderTarget,
-    normalMaterial: MeshNormalMaterial,
-    excludeTransparent = false
+    normalMaterial: MeshNormalMaterial
 ): void {
-    const hidden = hideNonSurface(scene, excludeTransparent);
     // ⚠️ 2026-10-11 删掉了这里原有的「强制 depthWrite=true」整段遍历：scene.overrideMaterial 生效后，
     // three 用的是 **override 材质**的渲染状态（WebGLRenderer.renderObjects：
     // `material = overrideMaterial === null ? renderItem.material : overrideMaterial`，setDepthState 吃它），
@@ -223,7 +93,6 @@ export function renderAoNormalPass(
     scene.overrideMaterial = normalMaterial;
     renderer.render(scene, camera);
     scene.overrideMaterial = null;
-    restoreVisibility(hidden);
     renderer.setClearColor(prevClearColor, prevClearAlpha);
     renderer.setRenderTarget(prevRenderTarget);
 }
@@ -734,8 +603,10 @@ const outputShader: RawShaderMaterial = new RawShaderMaterial({
       // （override 材质：DoubleSide、不做物体自己的 alpha discard）记到一个**屏幕上根本不可见**的面
       // —— 典型如树叶抠图的空隙、单面墙的背面。此时深度与法线指的不是人眼看到的那个点，
       // GTAO 算出的 AO 不可信 → 视为无遮蔽(=1)。
-      // ⚠️ 2026-10-11：本守卫原本主要防「可透视地板挡住身后实体」，那条特例已随地板进深度图而作废，
-      //   现在它守的是上面这类 override/自身材质两套渲染结果的错位，别当死代码删。
+      // ⚠️ 2026-10-18：两张图的渲染范围已统一（皇上旨「所有的对象都要进入到深度图里面了」⇒ excludeTransparent
+      //      参数与 aoFloor 特例整条拆除），本守卫不再承担「地板的接触 AO 别乘黑身后实体」这类职责，
+      //      它守的是上面那类 override 材质 / 自身材质两套渲染结果的错位（抠图空隙、单面墙背面、
+      //      DoubleSide 记到背面），别当死代码删。
       // 仅在最终合成时生效；debug 模式直接看 GTAO 原始 AO 图，便于排查。
       float dColor = texture2D(tColorDepth, vUv).r;
       float dAo = texture2D(tAoDepth, vUv).r;
@@ -804,15 +675,14 @@ export default function ssao_pass(
     // 覆盖 SSAO 自身的硬边。改动调用顺序时，本 pass 无需修改（输出到"绑定的那个目标"即可）。
     const originRenderTarget = renderer.getRenderTarget();
 
-    // 法线 pass（excludeTransparent=true）：隐式透明面不参与 AO，免得 GTAO 在其上算自遮蔽把
-    // 身后实体乘黑；地板/其它不透明面照常保留 —— 接触 AO 需要地板的视图空间法线。
+    // 法线 pass：整个场景都渲（2026-10-18 起不再按 transparent / aoFloor 排除任何面，见文件头那道旨）。
     // ⭐ 深度白拿（2026-09-14 优化）：normalRenderTarget 挂着 aoDepthTexture 作 depth attachment，
     // 这一次渲染的深度由光栅器顺带写入 → 直接就是 AO 深度，**不再单独渲一遍深度 pass**。
-    // （原先法线 pass 之后还要再渲一遍「AO 深度」——它与法线 pass 的排除集完全相同，
+    // （原先法线 pass 之后还要再渲一遍「AO 深度」——它与法线 pass 的渲染集完全相同，
     //   属于重复遍历全场景，2026-09-14 已删。）
     // ⚠️ 这一趟的深度是 override 材质写的（DoubleSide、不做物体自己的 alpha discard），
     //   所以只能给 AO 用；特效遮挡吃的是下面那张「用自身材质渲染」的可见深度。
-    renderAoNormalPass(renderer, camera, scene, normalRenderTarget, normalMaterial, true);
+    renderAoNormalPass(renderer, camera, scene, normalRenderTarget, normalMaterial);
 
     // 可见深度（用各物体自身材质渲染，含地板）= baseDepthTexture：描边/辉光/毛玻璃/覆盖色的遮挡参考，
     // 也是复合守卫里「真实可见表面」的参考。

package/pass/stroke_pass.js

@@ -574,6 +574,9 @@ export default function stroke_pass(renderer, camera, object3d, baseDepthTexture
     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 相减归零、描边全不显示）。

package/pass/stroke_pass.ts

@@ -608,6 +608,10 @@ export default function stroke_pass(
     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 相减归零、描边全不显示）。

package/shaders/debugDepthCompareShader.d.ts

@@ -2,7 +2,7 @@ import { ShaderMaterial } from "three";
 /**
  * 调试用：把「全局 base 深度」与「最近一次 glow/stroke 选区的 select 深度」并排显示，
  * 用于排查"深度测试全部失效"根因：
- *   R = 全局 base 深度（baseDepthTexture，排除地板）
+ *   R = 全局 base 深度（baseDepthTexture，2026-10-18 起含全部对象、含地板）
  *   G = 选区自身深度（selectDepthTexture，由 glow_pass/stroke_pass 渲染后写入 debugDepthState）
  * 两路都用 `pow(cameraFar+1, d)-1` 反推到近似线性视深再归一化（背景≈1 → 黄白）。
  *   - R 全白、G 也有内容 → 全局 base 深度没写进（renderVisibleDepthPass 失效），但选区深度正常；

package/shaders/debugDepthCompareShader.js

@@ -2,7 +2,7 @@ import { ShaderChunk, ShaderMaterial } from "three";
 /**
  * 调试用：把「全局 base 深度」与「最近一次 glow/stroke 选区的 select 深度」并排显示，
  * 用于排查"深度测试全部失效"根因：
- *   R = 全局 base 深度（baseDepthTexture，排除地板）
+ *   R = 全局 base 深度（baseDepthTexture，2026-10-18 起含全部对象、含地板）
  *   G = 选区自身深度（selectDepthTexture，由 glow_pass/stroke_pass 渲染后写入 debugDepthState）
  * 两路都用 `pow(cameraFar+1, d)-1` 反推到近似线性视深再归一化（背景≈1 → 黄白）。
  *   - R 全白、G 也有内容 → 全局 base 深度没写进（renderVisibleDepthPass 失效），但选区深度正常；

package/shaders/debugDepthCompareShader.ts

@@ -3,7 +3,7 @@ import { ShaderChunk, ShaderMaterial } from "three";
 /**
  * 调试用：把「全局 base 深度」与「最近一次 glow/stroke 选区的 select 深度」并排显示，
  * 用于排查"深度测试全部失效"根因：
- *   R = 全局 base 深度（baseDepthTexture，排除地板）
+ *   R = 全局 base 深度（baseDepthTexture，2026-10-18 起含全部对象、含地板）
  *   G = 选区自身深度（selectDepthTexture，由 glow_pass/stroke_pass 渲染后写入 debugDepthState）
  * 两路都用 `pow(cameraFar+1, d)-1` 反推到近似线性视深再归一化（背景≈1 → 黄白）。
  *   - R 全白、G 也有内容 → 全局 base 深度没写进（renderVisibleDepthPass 失效），但选区深度正常；

package/shaders/debugDepthJudgeShader.d.ts

@@ -3,7 +3,7 @@ import { ShaderMaterial } from "three";
  * 调试用：把「深度测试判定」本身画出来，用于定位"后处理深度测试全部失效"。
  *
  * 通道语义（全部为**原始**深度值，不做对数反解，避免饱和丢信息）：
- *   R = 全局 base 深度（baseDepthTexture，排除地板）
+ *   R = 全局 base 深度（baseDepthTexture，2026-10-18 起含全部对象、含地板）
  *   G = 选区自身深度（selectDepthTexture，glow/stroke 渲染后写入 debugDepthState）
  *   B = 判定结果：baseD < selD - bias ? 1 : 0
  *       与 stroke_pass 的 depthTestShader 同一判定式（bias = 0.0006）：

package/shaders/debugDepthJudgeShader.js

@@ -4,7 +4,7 @@ import { DEPTH_TEST_BIAS } from "../pass/depthTestBias";
  * 调试用：把「深度测试判定」本身画出来，用于定位"后处理深度测试全部失效"。
  *
  * 通道语义（全部为**原始**深度值，不做对数反解，避免饱和丢信息）：
- *   R = 全局 base 深度（baseDepthTexture，排除地板）
+ *   R = 全局 base 深度（baseDepthTexture，2026-10-18 起含全部对象、含地板）
  *   G = 选区自身深度（selectDepthTexture，glow/stroke 渲染后写入 debugDepthState）
  *   B = 判定结果：baseD < selD - bias ? 1 : 0
  *       与 stroke_pass 的 depthTestShader 同一判定式（bias = 0.0006）：

package/shaders/debugDepthJudgeShader.ts

@@ -5,7 +5,7 @@ import { DEPTH_TEST_BIAS } from "../pass/depthTestBias";
  * 调试用：把「深度测试判定」本身画出来，用于定位"后处理深度测试全部失效"。
  *
  * 通道语义（全部为**原始**深度值，不做对数反解，避免饱和丢信息）：
- *   R = 全局 base 深度（baseDepthTexture，排除地板）
+ *   R = 全局 base 深度（baseDepthTexture，2026-10-18 起含全部对象、含地板）
  *   G = 选区自身深度（selectDepthTexture，glow/stroke 渲染后写入 debugDepthState）
  *   B = 判定结果：baseD < selD - bias ? 1 : 0
  *       与 stroke_pass 的 depthTestShader 同一判定式（bias = 0.0006）：

package/PipeMesh/PathGeometry.d.ts

@@ -1,44 +0,0 @@
-import { Usage } from 'three/src/constants.js';
-import type { PathPointList } from './PathPointList.js';
-import { BufferGeometry } from 'three/src/core/BufferGeometry.js';
-export interface Options {
-    radius?: number;
-    width?: number;
-    progress?: number;
-    radialSegments?: number;
-    startRad?: number;
-    arrow?: boolean;
-    side?: 'both' | 'left' | 'right';
-}
-export interface PathGeometryParam {
-    pathPointList: PathPointList;
-    options: Options;
-    usage: Usage;
-    transparent: boolean;
-}
-/**
- * PathGeometry
- */
-declare class PathGeometry extends BufferGeometry {
-    /**
-     * @param {Object|Number} initData - If initData is number, geometry init by empty data and set it as the max vertex. If initData is Object, it contains pathPointList and options.
-     * @param {Boolean} [generateUv2=false]
-     */
-    constructor(initData: PathGeometryParam, generateUv2?: boolean);
-    _initByMaxVertex(maxVertex: number, generateUv2: boolean): void;
-    _initByData(pathPointList: PathPointList, options: Options, usage: Usage, generateUv2: boolean): void;
-    /**
-     * Update geometry by PathPointList instance
-     * @param {PathPointList} pathPointList
-     * @param {Object} options
-     * @param {Number} [options.width=0.1]
-     * @param {Number} [options.progress=1]
-     * @param {Boolean} [options.arrow=true]
-     * @param {String} [options.side='both'] - "left"/"right"/"both"
-     */
-    update(pathPointList: PathPointList, options: Options): void;
-    _resizeAttribute(name: string, len: number): void;
-    _resizeIndex(len: number): void;
-    _updateAttributes(position: Array<number>, normal: Array<number>, uv: Array<number>, uv2: Array<number> | null, indices: Array<number>): void;
-}
-export { PathGeometry };