three-base 2.0.137 → 2.0.145

package/pass/stroke_pass.d.ts

@@ -1,2 +1,2 @@
-import { Camera, DepthTexture, Object3D, WebGLRenderer } from "three";
+import { DepthTexture, WebGLRenderer, Camera, Object3D } from "three";
 export default function stroke_pass(renderer: WebGLRenderer, camera: Camera, object3d: Object3D, baseDepthTexture: DepthTexture, devicePixelRatio: number): void;

package/pass/stroke_pass.js

@@ -4,42 +4,57 @@
  * @Last Modified by: xiaosihan
  * @Last Modified time: 2025-01-28 04:02:16
  */
-import { Color, DepthFormat, DepthTexture, LinearFilter, NoBlending, NormalBlending, RGBAFormat, RawShaderMaterial, Scene, ShaderChunk, ShaderMaterial, UnsignedShortType, Vector2, WebGLRenderTarget } from "three";
+import { Color, DepthFormat, DepthTexture, LinearFilter, NoBlending, NormalBlending, RGBAFormat, RawShaderMaterial, Scene, ShaderChunk, ShaderMaterial, UnsignedIntType, Vector2, WebGLRenderTarget } from "three";
 import fsQuad from "./fsQuad";
-// 选中对象的深度纹理
+import { debugDepthState } from "./debugDepthState";
+import { DEPTH_TEST_BIAS } from "./depthTestBias";
 const selectDepthTexture = (() => {
     const baseDepthTexture = new DepthTexture(1024, 1024);
     baseDepthTexture.format = DepthFormat;
-    baseDepthTexture.type = UnsignedShortType;
+    baseDepthTexture.type = UnsignedIntType;
     baseDepthTexture.anisotropy = 16;
     return baseDepthTexture;
 })();
-// 选中对象的纹理
-const selectTextureTarget = new WebGLRenderTarget(512, 512, {
+const selectTextureTarget = new WebGLRenderTarget(1024, 1024, {
+    minFilter: LinearFilter,
+    magFilter: LinearFilter,
+    format: RGBAFormat,
+    anisotropy: 16,
+    // 无 MSAA：mask 颜色与下方 selectDepthTextureTarget（深度）必须同为硬边缘，
+    // 否则 mask 边缘平滑而深度硬 → depthTestShader 判定边界与 mask 视觉边缘错位，描边边缘锯齿。
+    // 边缘抗锯齿统一由 mask 内部 FXAA + 终处理 FXAA 兜底。
+});
+// 无 MSAA 的深度专用目标：仅用于导出对象深度，供 depthTestShader 做遮挡判定（深度无需抗锯齿）
+const selectDepthTextureTarget = new WebGLRenderTarget(1024, 1024, {
     minFilter: LinearFilter,
     magFilter: LinearFilter,
     format: RGBAFormat,
     depthTexture: selectDepthTexture,
     anisotropy: 16,
 });
-// 深度测试后的选中纹理
-const selectDethpTestTextureTarget = new WebGLRenderTarget(512, 512, {
+const selectDepthTestTextureTarget = new WebGLRenderTarget(1024, 1024, {
     minFilter: LinearFilter,
     magFilter: LinearFilter,
     format: RGBAFormat,
     anisotropy: 16,
+    // 无 MSAA：深度测试 mask 无需抗锯齿，去掉以提速
 });
-// 由于不能同时读写自己的纹理 
-const blur1TextureTarget = new WebGLRenderTarget(512, 512, { minFilter: LinearFilter, magFilter: LinearFilter, format: RGBAFormat });
-// 所以需要用2个模糊纹理相互读写
-const blur2TextureTarget = new WebGLRenderTarget(512, 512, { minFilter: LinearFilter, magFilter: LinearFilter, format: RGBAFormat });
+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: {
-        map: { value: null }, // 贴图纹理
-        baseDepth: { value: null }, // 整个场景的深度纹理
-        selectDepth: { value: null }, // 选中的对象深度纹理
+        map: { value: null },
+        baseDepth: { value: null },
+        selectDepth: { value: null },
+        cameraFar: { value: 1000.0 },
+        uDebugVis: { value: 0.0 },
     },
     vertexShader: `
         ${ShaderChunk.common}
@@ -47,8 +62,6 @@ const depthTestShader = new ShaderMaterial({
         varying vec2 vUv;
         void main() {
             vUv = uv;
-            // gl_Position = vec4(position, 1.0);
-            // gl_Position = projectionMatrix * modelViewMatrix * instanceMatrix * vec4(position, 1.0);
             gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
             ${ShaderChunk.logdepthbuf_vertex}
         }
@@ -58,27 +71,46 @@ const depthTestShader = new ShaderMaterial({
         uniform sampler2D map;
         uniform sampler2D baseDepth;
         uniform sampler2D selectDepth;
+        uniform float cameraFar;
+        uniform float uDebugVis;
         varying vec2 vUv;
-        void main() {
-            if(texture2D(baseDepth, vUv).r < texture2D(selectDepth, vUv).r){
-                discard;
-            }
-            if(texture2D(baseDepth, vUv).r == 1.0){
-                discard;
-            }
-            gl_FragColor = texture2D(map, vUv);
-            ${ShaderChunk.logdepthbuf_fragment}
+    void main() {
+        float baseD = texture2D(baseDepth, vUv).r;
+        float selD = texture2D(selectDepth, vUv).r;
+        // 调试可视化：R=base 线性深度归一化，G=select 线性深度归一化（背景≈1.0）。
+        // 全白(R=G≈1)→两路深度全是 clear 值 1.0（没写进数据）；全黑→异常。
+        if (uDebugVis > 0.5) {
+            float vb = pow(cameraFar + 1.0, baseD) - 1.0;
+            float vs = pow(cameraFar + 1.0, selD) - 1.0;
+            gl_FragColor = vec4(vb / cameraFar, vs / cameraFar, 0.0, 1.0);
+            return;
         }
+        // 参考手写版 a27bdea 的朴素对数深度比对：DepthTexture 存的是对数深度，
+        // 「更小 = 更近」，base 比 select 更近即被真实场景遮挡 → discard。
+        // 背景像素 base≈1.0（最远）永远不小于物体深度 selD(<1.0) → 不丢弃，
+        // 浮空物体的描边正常显示（不会被天空/空背景整片吃掉，这是早期回归 bug 已修的点）。
+        // 加一个极小对数空间容差 bias（≈0.0006）防「选中对象自身像素」因浮点精度被误判遮挡
+        // （z-fit 锯齿）；真实更近物体的深度差远大于此，不受影响。
+        // 用二值 discard 而非软遮挡：相交场景里 base 深度在地板/物体间亚像素抖，
+        // 软遮挡的半透明渐隐边缘一抖就明显闪；二值硬边界经后续 4 次 blur + FXAA 柔化更干净。
+        // 容差取自单一常量源 DEPTH_TEST_BIAS（调试用 debugDepthJudgeShader 用同一常量，
+        // 保证调试视图与真实判定永远一致，不会各写各的导致排查结论错误）。
+        const float bias = ${DEPTH_TEST_BIAS};
+        if (baseD < selD - bias) {
+            discard;
+        }
+        gl_FragColor = texture2D(map, vUv);
+        ${ShaderChunk.logdepthbuf_fragment}
+    }
     `,
-    blending: NoBlending, // 渲染时不与背景融合计算 直接替换
+    blending: NoBlending,
     depthTest: true,
     depthWrite: true,
     transparent: true
 });
-// 抗锯齿着色器
 const FXAAShaderMaterial = new ShaderMaterial({
     uniforms: {
-        tDiffuse: { value: null }, // 贴图纹理
+        tDiffuse: { value: null },
         resolution: { value: new Vector2(1 / 1024, 1 / 1024) }
     },
     vertexShader: `
@@ -102,14 +134,6 @@ const FXAAShaderMaterial = new ShaderMaterial({
         varying vec2 vUv;
     
         #ifndef FXAA_DISCARD
-                //
-                // Only valid for PC OpenGL currently.
-                // Probably will not work when FXAA_GREEN_AS_LUMA = 1.
-                //
-                // 1 = Use discard on pixels which don't need AA.
-                //     For APIs which enable concurrent TEX+ROP from same surface.
-                // 0 = Return unchanged color on pixels which don't need AA.
-                //
                 #define FXAA_DISCARD 0
         #endif
     
@@ -120,7 +144,6 @@ const FXAAShaderMaterial = new ShaderMaterial({
     
         #define NUM_SAMPLES 5
     
-        // assumes colors have premultipliedAlpha, so that the calculated color contrast is scaled by alpha
         float contrast( vec4 a, vec4 b ) {
                 vec4 diff = abs( a - b );
                 return max( max( max( diff.r, diff.g ), diff.b ), diff.a );
@@ -145,9 +168,6 @@ const FXAAShaderMaterial = new ShaderMaterial({
                 vec4 rgbaE = FxaaTexOff(tex, posM, vec2( 1.0, 0.0), fxaaQualityRcpFrame.xy);
                 vec4 rgbaN = FxaaTexOff(tex, posM, vec2( 0.0,-1.0), fxaaQualityRcpFrame.xy);
                 vec4 rgbaW = FxaaTexOff(tex, posM, vec2(-1.0, 0.0), fxaaQualityRcpFrame.xy);
-                // . S .
-                // W M E
-                // . N .
     
                 bool earlyExit = max( max( max(
                         contrast( rgbaM, rgbaN ),
@@ -155,9 +175,6 @@ const FXAAShaderMaterial = new ShaderMaterial({
                         contrast( rgbaM, rgbaE ) ),
                         contrast( rgbaM, rgbaW ) )
                         < fxaaQualityEdgeThreshold;
-                // . 0 .
-                // 0 0 0
-                // . 0 .
     
                 #if (FXAA_DISCARD == 1)
                         if(earlyExit) FxaaDiscard;
@@ -174,44 +191,22 @@ const FXAAShaderMaterial = new ShaderMaterial({
                 relativeVContrast *= fxaaQualityinvEdgeThreshold;
     
                 bool horzSpan = relativeVContrast > 0.;
-                // . 1 .
-                // 0 0 0
-                // . 1 .
     
-                // 45 deg edge detection and corners of objects, aka V/H contrast is too similar
                 if( abs( relativeVContrast ) < .3 ) {
-                        // locate the edge
                         vec2 dirToEdge;
                         dirToEdge.x = contrastE > contrastW ? 1. : -1.;
                         dirToEdge.y = contrastS > contrastN ? 1. : -1.;
-                        // . 2 .      . 1 .
-                        // 1 0 2  ~=  0 0 1
-                        // . 1 .      . 0 .
-    
-                        // tap 2 pixels and see which ones are "outside" the edge, to
-                        // determine if the edge is vertical or horizontal
     
                         vec4 rgbaAlongH = FxaaTexOff(tex, posM, vec2( dirToEdge.x, -dirToEdge.y ), fxaaQualityRcpFrame.xy);
                         float matchAlongH = contrast( rgbaM, rgbaAlongH );
-                        // . 1 .
-                        // 0 0 1
-                        // . 0 H
     
                         vec4 rgbaAlongV = FxaaTexOff(tex, posM, vec2( -dirToEdge.x, dirToEdge.y ), fxaaQualityRcpFrame.xy);
                         float matchAlongV = contrast( rgbaM, rgbaAlongV );
-                        // V 1 .
-                        // 0 0 1
-                        // . 0 .
     
                         relativeVContrast = matchAlongV - matchAlongH;
                         relativeVContrast *= fxaaQualityinvEdgeThreshold;
     
-                        if( abs( relativeVContrast ) < .3 ) { // 45 deg edge
-                                // 1 1 .
-                                // 0 0 1
-                                // . 0 1
-    
-                                // do a simple blur
+                        if( abs( relativeVContrast ) < .3 ) {
                                 return mix(
                                         rgbaM,
                                         (rgbaN + rgbaS + rgbaE + rgbaW) * .25,
@@ -224,9 +219,6 @@ const FXAAShaderMaterial = new ShaderMaterial({
     
                 if(!horzSpan) rgbaN = rgbaW;
                 if(!horzSpan) rgbaS = rgbaE;
-                // . 0 .      1
-                // 1 0 1  ->  0
-                // . 0 .      1
     
                 bool pairN = contrast( rgbaM, rgbaN ) > contrast( rgbaM, rgbaS );
                 if(!pairN) rgbaN = rgbaS;
@@ -272,15 +264,13 @@ const FXAAShaderMaterial = new ShaderMaterial({
                 }
     
     
-                if ( !doneP && !doneN ) return rgbaM; // failed to find end of edge
+                if ( !doneP && !doneN ) return rgbaM;
     
                 float dist = min(
                         doneN ? float( iterationsUsedN ) / float( NUM_SAMPLES - 1 ) : 1.,
                         doneP ? float( iterationsUsedP ) / float( NUM_SAMPLES - 1 ) : 1.
                 );
     
-                // hacky way of reduces blurriness of mostly diagonal edges
-                // but reduces AA quality
                 dist = pow(dist, .5);
     
                 dist = 1. - dist;
@@ -300,25 +290,24 @@ const FXAAShaderMaterial = new ShaderMaterial({
                         vUv,
                         tDiffuse,
                         resolution,
-                        edgeDetectionQuality, // [0,1] contrast needed, otherwise early discard
+                        edgeDetectionQuality,
                         invEdgeDetectionQuality
                 );
             ${ShaderChunk.logdepthbuf_fragment}
         }
     `,
-    blending: NoBlending, // 渲染时不与背景融合计算 直接替换
+    blending: NoBlending,
     depthTest: false,
     depthWrite: false,
     transparent: true
 });
-// 描边着色器
 const strokeShader = new RawShaderMaterial({
     uniforms: {
         tDiffuse: { value: null },
-        color: { value: new Color("#0f0") }, // 没有被挡住的地方的颜色绿色
+        color: { value: new Color("#0f0") },
         width: { value: 1.0 },
         opacity: { value: 1.0 },
-        resolution: { value: new Vector2(1 / 512, 1 / 512) }, // 渲染器的分辨率
+        resolution: { value: new Vector2(1 / 512, 1 / 512) },
         offset: {
             value: [
                 new Vector2(0.000, 1.000),
@@ -367,7 +356,7 @@ const strokeShader = new RawShaderMaterial({
 		uniform vec2 resolution;
 		uniform vec2 offset[24];
 		varying vec2 vUv;
-		vec2 piexl = resolution * width; // 描边厚度
+		vec2 piexl = resolution * width;
 
 		vec4 stroke(){
 			vec4 blurColor = vec4(0.0);
@@ -392,12 +381,57 @@ const strokeShader = new RawShaderMaterial({
 				gl_FragColor = stroke();
 			}
 		}`,
-    blending: NoBlending, // 渲染时不与背景融合计算 直接替换
+    blending: NoBlending,
     depthTest: false,
     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 },
@@ -425,14 +459,14 @@ const filterSelectShader = new RawShaderMaterial({
 			gl_FragColor.a -= (texture2D(selectTexture, vUv).a);
 		}
 	`,
-    blending: NoBlending, // 渲染时不与背景融合计算 直接替换
+    blending: NoBlending,
     depthTest: false,
     depthWrite: false,
     transparent: true
 });
 const copyShader = new ShaderMaterial({
     uniforms: {
-        map: { value: null }, // 贴图纹理
+        map: { value: null },
     },
     vertexShader: `
         ${ShaderChunk.common}
@@ -440,8 +474,6 @@ const copyShader = new ShaderMaterial({
         varying vec2 vUv;
         void main() {
             vUv = uv;
-            // gl_Position = vec4(position, 1.0);
-            // gl_Position = projectionMatrix * modelViewMatrix * instanceMatrix * vec4(position, 1.0);
             gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
             ${ShaderChunk.logdepthbuf_vertex}
         }
@@ -459,72 +491,111 @@ const copyShader = new ShaderMaterial({
     depthWrite: true,
     transparent: true
 });
-// 场景对象
 const scene = new Scene();
-// 对象描边
 export default function stroke_pass(renderer, camera, object3d, baseDepthTexture, devicePixelRatio) {
     const { stroke_enable = false, stroke_color = "#04fa12", stroke_width = 1 } = object3d.userData;
     if (!stroke_enable || stroke_width === 0) {
         return;
     }
-    // 保存原帧缓冲区
     const originRenderTarget = renderer.getRenderTarget();
-    // 设置选中目标的帧缓冲区
+    // 灰度图渲染目标跟随主画面尺寸（= width × effectiveRatio），与 baseRenderTarget 完全一致，
+    // 消除灰度图与主画面尺寸不一致导致的放大重采样摩尔纹
     renderer.getSize(size);
     size.multiplyScalar(devicePixelRatio);
     selectTextureTarget.setSize(size.x, size.y);
-    selectDethpTestTextureTarget.setSize(size.x, size.y);
+    selectDepthTextureTarget.setSize(size.x, size.y);
+    // 缺陷修复：three r167 的 WebGLRenderTarget.setSize 不会同步 depthTexture，
+    // 需手动把 selectDepthTexture 尺寸与全屏 baseDepth 对齐，否则深度比例错位导致描边被错误 discard
+    selectDepthTexture.image.width = size.x;
+    selectDepthTexture.image.height = size.y;
+    selectDepthTexture.needsUpdate = true;
+    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（灰度）
     renderer.setRenderTarget(selectTextureTarget);
     scene.children = [object3d];
     renderer.clear();
     renderer.render(scene, camera);
-    // 设置描边着色器的分辨率
-    strokeShader.uniforms.resolution.value.set(1 / size.x, 1 / size.y);
-    // 设置抗锯齿着色器的分辨率
-    FXAAShaderMaterial.uniforms.resolution.value.set(1 / size.x, 1 / size.y);
-    //描边颜色
-    strokeShader.uniforms.color.value.set(stroke_color);
-    strokeShader.uniforms.width.value = 1;
-    //深度测试
-    renderer.setRenderTarget(selectDethpTestTextureTarget);
+    // 2. 渲染物体本体深度（无 MSAA，供 depthTest 判定遮挡）
+    renderer.setRenderTarget(selectDepthTextureTarget);
+    scene.children = [object3d];
+    renderer.clear();
+    renderer.render(scene, camera);
+    // 调试：把本次渲染的选区深度记到全局调试状态，供面板「辉光深度比对」读取
+    debugDepthState.lastSelectDepth = selectDepthTexture;
+    // 3. 深度测试（用本体 mask）：被真实更近物体挡住的「本体描边」部分 discard。
+    //    背景像素 baseDepth≈1.0（最远）永远不小于物体深度 → 不丢弃，浮空物体描边正常显示。
+    //    选中对象自身像素 baseD≈selD → 不丢弃，本体描边保留。
+    renderer.setRenderTarget(selectDepthTestTextureTarget);
     renderer.clear();
     depthTestShader.uniforms.map.value = selectTextureTarget.texture;
     depthTestShader.uniforms.baseDepth.value = baseDepthTexture;
     depthTestShader.uniforms.selectDepth.value = selectDepthTexture;
+    depthTestShader.uniforms.cameraFar.value = camera.far;
+    depthTestShader.uniforms.uDebugVis.value = (window.__STROKE_DEPTH_VIS) ? 1.0 : 0.0;
     fsQuad.render(renderer, depthTestShader);
-    //一次描边
+    // 4. 从「深度测试后的本体描边」开始外扩（外扩环自动继承本体遮挡判定 → 不漏光），
+    //    描边粗细由 stroke_width 控制的迭代次数决定。
+    strokeShader.uniforms.resolution.value.set(1 / size.x, 1 / size.y);
+    FXAAShaderMaterial.uniforms.resolution.value.set(1 / size.x, 1 / size.y);
+    strokeShader.uniforms.color.value.set(stroke_color);
+    strokeShader.uniforms.width.value = 1;
     renderer.setRenderTarget(blur1TextureTarget);
-    strokeShader.uniforms.tDiffuse.value = selectDethpTestTextureTarget.texture;
+    strokeShader.uniforms.tDiffuse.value = selectDepthTestTextureTarget.texture;
     fsQuad.render(renderer, strokeShader);
-    //二次描边
     renderer.setRenderTarget(blur2TextureTarget);
     strokeShader.uniforms.tDiffuse.value = blur1TextureTarget.texture;
     fsQuad.render(renderer, strokeShader);
+    // 迭代外扩（stroke_width 控制粗细）
     for (let i = 0; i < stroke_width - 2; i++) {
-        //一次描边
         renderer.setRenderTarget(blur1TextureTarget);
         strokeShader.uniforms.tDiffuse.value = blur2TextureTarget.texture;
         fsQuad.render(renderer, strokeShader);
-        //二次描边
         renderer.setRenderTarget(blur2TextureTarget);
         strokeShader.uniforms.tDiffuse.value = blur1TextureTarget.texture;
         fsQuad.render(renderer, strokeShader);
     }
+    // 5. 最后抗锯齿
     renderer.setRenderTarget(blur1TextureTarget);
-    copyShader.uniforms.map.value = blur2TextureTarget.texture;
-    fsQuad.render(renderer, copyShader);
-    // 还原帧缓冲区 减去原始纹理保留描边
+    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.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 叠到场景上。
     renderer.setRenderTarget(originRenderTarget);
-    filterSelectShader.uniforms.selectTexture.value = selectDethpTestTextureTarget.texture;
-    filterSelectShader.uniforms.blurTexture.value = blur1TextureTarget.texture;
-    filterSelectShader.blending = NormalBlending; // 与有的纹理融合计算 保留前面通道传递下来的纹理
+    filterSelectShader.uniforms.selectTexture.value = selectDepthTestTextureTarget.texture;
+    filterSelectShader.uniforms.blurTexture.value = blurDepthTestTextureTarget.texture;
+    filterSelectShader.blending = NormalBlending;
     fsQuad.render(renderer, filterSelectShader);
-    // 调试代码
-    // renderer.setRenderTarget(null);
-    // renderer.clearDepth();
-    // copyShader.uniforms.tDiffuse.value = blur2TextureTarget.texture;
-    // fsQuad.render(renderer, copyShader);
-    // return;
 }