three-base 2.0.134 → 2.0.142

package/pass/glow_pass.ts

@@ -0,0 +1,654 @@
+/*
+ * @Author: xiaosihan
+ * @Date: 2023-05-09 00:35:17
+ * @Last Modified by: xiaosihan
+ * @Last Modified time: 2025-01-28 04:13:16
+ */
+import { Color, DepthFormat, DepthTexture, LinearFilter, NoBlending, NormalBlending, AdditiveBlending, RGBAFormat, RawShaderMaterial, Scene, ShaderChunk, ShaderMaterial, UnsignedIntType, Vector2, WebGLRenderTarget, WebGLRenderer, Camera, PerspectiveCamera, Object3D } from "three";
+import fsQuad from "./fsQuad";
+import { EffectUserData } from "./effectUserData";
+import { debugDepthState } from "./debugDepthState";
+
+const selectDepthTexture: DepthTexture = (() => {
+    const baseDepthTexture = new DepthTexture(1024, 1024);
+    baseDepthTexture.format = DepthFormat;
+    baseDepthTexture.type = UnsignedIntType;
+    baseDepthTexture.anisotropy = 16;
+    return baseDepthTexture;
+})();
+
+const selectTextureTarget: WebGLRenderTarget = 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: WebGLRenderTarget = new WebGLRenderTarget(1024, 1024, {
+    minFilter: LinearFilter,
+    magFilter: LinearFilter,
+    format: RGBAFormat,
+    depthTexture: selectDepthTexture,
+    anisotropy: 16,
+});
+
+const selectDepthTestTextureTarget: WebGLRenderTarget = new WebGLRenderTarget(1024, 1024, {
+    minFilter: LinearFilter,
+    magFilter: LinearFilter,
+    format: RGBAFormat,
+    anisotropy: 16,
+    // 无 MSAA：深度测试 mask 无需抗锯齿，去掉以提速
+});
+
+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 把本体深度图随 mask 一起外扩，
+// 外扩区取邻域最近深度（忽略背景 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();
+
+const depthTestShader: ShaderMaterial = new ShaderMaterial({
+    uniforms: {
+        map: { value: null },
+        baseDepth: { value: null },
+        selectDepth: { value: null },
+        cameraFar: { value: 1000.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 map;
+        uniform sampler2D baseDepth;
+        uniform sampler2D selectDepth;
+        uniform float cameraFar;
+        varying vec2 vUv;
+        void main() {
+            float baseD = texture2D(baseDepth, vUv).r;
+            float selD = texture2D(selectDepth, vUv).r;
+            // 参考手写版 a27bdea 的朴素对数深度比对：DepthTexture 存对数深度，「更小=更近」，
+            // base 比 select 更近即被真实场景遮挡 → discard。背景像素 base≈1.0 不小于物体 selD(<1.0)
+            // → 不丢弃，浮空物体辉光正常显示（不整片吃掉）。加极小对数容差 bias(≈0.0006) 防
+            // 自身像素浮点 z-fit 锯齿；真实更近物体深度差远大于此，不受影响。用二值 discard 而非
+            // 软遮挡：相交场景 base 深度在地板/物体间亚像素抖，软遮挡半透明渐隐边缘一抖就明显闪，
+            // 二值硬边界经后续 blur + FXAA 柔化更干净。
+            const float bias = 0.0006;
+            if (baseD < selD - bias) {
+                discard;
+            }
+            gl_FragColor = texture2D(map, vUv);
+            ${ShaderChunk.logdepthbuf_fragment}
+        }
+    `,
+    blending: NoBlending,
+    depthTest: true,
+    depthWrite: true,
+    transparent: true,
+});
+
+const gaussianBlurHShader: RawShaderMaterial = new RawShaderMaterial({
+    uniforms: {
+        tDiffuse: { value: null },
+        resolution: { value: new Vector2(1 / 512, 1 / 512) },
+        radius: { value: 1.0 },
+        sigma: { value: 1.0 },
+    },
+    vertexShader: `
+		attribute vec3 position;
+		attribute vec2 uv;
+		varying vec2 vUv;
+		void main() {
+			vUv = uv;
+			gl_Position = vec4(position, 1.0);
+		}`,
+    fragmentShader: `
+		#ifdef GL_ES
+			precision highp float;
+		#endif
+		uniform sampler2D tDiffuse;
+		uniform vec2 resolution;
+		uniform float radius;
+		uniform float sigma;
+		varying vec2 vUv;
+		
+		float gaussian(float x, float sigma) {
+			return exp(-(x * x) / (2.0 * sigma * sigma));
+		}
+		
+		void main() {
+			vec4 color = vec4(0.0);
+			float totalWeight = 0.0;
+			
+			for (int i = -10; i <= 10; i++) {
+				float x = float(i);
+				float weight = gaussian(x, sigma);
+				vec2 offset = vec2(x * radius * resolution.x, 0.0);
+				color += texture2D(tDiffuse, vUv + offset) * weight;
+				totalWeight += weight;
+			}
+			
+			gl_FragColor = color / totalWeight;
+		}`,
+    blending: NoBlending,
+    depthTest: false,
+    depthWrite: false,
+    transparent: true,
+});
+
+const gaussianBlurVShader: RawShaderMaterial = new RawShaderMaterial({
+    uniforms: {
+        tDiffuse: { value: null },
+        resolution: { value: new Vector2(1 / 512, 1 / 512) },
+        radius: { value: 1.0 },
+        sigma: { value: 1.0 },
+    },
+    vertexShader: `
+		attribute vec3 position;
+		attribute vec2 uv;
+		varying vec2 vUv;
+		void main() {
+			vUv = uv;
+			gl_Position = vec4(position, 1.0);
+		}`,
+    fragmentShader: `
+		#ifdef GL_ES
+			precision highp float;
+		#endif
+		uniform sampler2D tDiffuse;
+		uniform vec2 resolution;
+		uniform float radius;
+		uniform float sigma;
+		varying vec2 vUv;
+		
+		float gaussian(float x, float sigma) {
+			return exp(-(x * x) / (2.0 * sigma * sigma));
+		}
+		
+		void main() {
+			vec4 color = vec4(0.0);
+			float totalWeight = 0.0;
+			
+			for (int i = -10; i <= 10; i++) {
+				float y = float(i);
+				float weight = gaussian(y, sigma);
+				vec2 offset = vec2(0.0, y * radius * resolution.y);
+				color += texture2D(tDiffuse, vUv + offset) * weight;
+				totalWeight += weight;
+			}
+			
+			gl_FragColor = color / totalWeight;
+		}`,
+    blending: NoBlending,
+    depthTest: false,
+    depthWrite: false,
+    transparent: true,
+});
+
+// 深度 min-blur（最近深度，忽略背景 1.0）：随 mask 一起把深度图向外扩，
+// 外扩区 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 glowCompositeShader: RawShaderMaterial = new RawShaderMaterial({
+    uniforms: {
+        tDiffuse: { value: null },
+        color: { value: new Color("#0f0") },
+        opacity: { value: 1.0 },
+        threshold: { value: 0.0 },
+        intensity: { value: 1.0 },
+    },
+    vertexShader: `
+		attribute vec3 position;
+		attribute vec2 uv;
+		varying vec2 vUv;
+		void main() {
+			vUv = uv;
+			gl_Position = vec4(position, 1.0);
+		}`,
+    fragmentShader: `
+		#ifdef GL_ES
+			precision highp float;
+		#endif
+		uniform sampler2D tDiffuse;
+		uniform vec3 color;
+		uniform float opacity;
+		uniform float threshold;
+		uniform float intensity;
+		varying vec2 vUv;
+
+		void main() {
+			vec4 texColor = texture2D(tDiffuse, vUv);
+			float alpha = texColor.a;
+
+			if (alpha < threshold) {
+				gl_FragColor = vec4(0.0);
+				return;
+			}
+
+			alpha = min(1.0, alpha * 2.0);
+
+			// intensity 让颜色亮度可超 1（配合 glow_additive 加性混合呈发光感，很亮那种）
+			gl_FragColor = vec4(color * intensity, alpha * opacity);
+		}`,
+    blending: NoBlending,
+    depthTest: false,
+    depthWrite: false,
+    transparent: true,
+});
+
+// 薄高亮层合成：对本体 mask 做 1 次像素扩张（24 方向偏移 width 像素采样），
+// 扩张区 − 本体 = 贴着物体边缘的一圈薄亮环（rim）。上 glow 颜色，跟随 glow_additive 叠加，
+// 与外圈柔光晕（filterSelect 结果）并存 → 选中态边缘有「实亮轮廓 + 外柔光」。
+// ⚠️ 默认关闭（glow_highlight=false），只有对象显式开启才会执行，避免干扰既有发光合成。
+const thinHighlightShader: RawShaderMaterial = new RawShaderMaterial({
+    uniforms: {
+        tMask: { value: null },
+        color: { value: new Color("#0f0") },
+        uWidth: { value: 1.0 },
+        opacity: { value: 1.0 },
+        intensity: { value: 1.0 },
+        resolution: { value: new Vector2(1 / 512, 1 / 512) },
+        uDebugVis: { value: 0.0 },
+        offset: {
+            value: [
+                new Vector2(0.000, 1.000),
+                new Vector2(0.259, 0.966),
+                new Vector2(0.500, 0.866),
+                new Vector2(0.707, 0.707),
+                new Vector2(0.866, 0.500),
+                new Vector2(0.966, 0.259),
+                new Vector2(1.000, 0.000),
+                new Vector2(0.966, -0.259),
+                new Vector2(0.866, -0.500),
+                new Vector2(0.707, -0.707),
+                new Vector2(0.500, -0.866),
+                new Vector2(0.259, -0.966),
+                new Vector2(0.000, -1.000),
+                new Vector2(-0.259, -0.966),
+                new Vector2(-0.500, -0.866),
+                new Vector2(-0.707, -0.707),
+                new Vector2(-0.866, -0.500),
+                new Vector2(-0.966, -0.259),
+                new Vector2(-1.000, -0.000),
+                new Vector2(-0.966, 0.259),
+                new Vector2(-0.866, 0.500),
+                new Vector2(-0.707, 0.707),
+                new Vector2(-0.500, 0.866),
+                new Vector2(-0.259, 0.966)
+            ]
+        }
+    },
+    vertexShader: `
+		attribute vec3 position;
+		attribute vec2 uv;
+		varying vec2 vUv;
+		void main() {
+			vUv = uv;
+			gl_Position = vec4(position, 1.0);
+		}`,
+    fragmentShader: `
+		#ifdef GL_ES
+			precision highp float;
+		#endif
+		uniform sampler2D tMask;
+		uniform vec3 color;
+		uniform float uWidth;
+		uniform float opacity;
+		uniform float intensity;
+		uniform vec2 resolution;
+		uniform float uDebugVis;
+		uniform vec2 offset[24];
+		varying vec2 vUv;
+
+		void main() {
+			// ⚠️ piexl 必须 main 内局部初始化（不能在全局用 uniform 初始化，某些 driver 会静默置 0）。
+			vec2 piexl = resolution * uWidth;
+			vec4 self = texture2D(tMask, vUv);
+			float hit = 0.0;
+			for (int i = 0; i < 24; i++) {
+				vec4 c = texture2D(tMask, vUv + offset[i] * piexl);
+				if (c.a > 0.0) {
+					hit = 1.0;
+				}
+			}
+			// 扩张区 − 本体 = 物体外一圈薄亮环（贴边轮廓）
+			float rim = clamp(hit - self.a, 0.0, 1.0);
+
+			// 调试可视化（window.__GLOW_HIGHLIGHT_VIS=true 开启）：
+			// R=扩张命中区(hit) G=本体(self.a) B=最终 rim(薄亮环)
+			// 正常应看到：物体内部 G=1（绿），物体外紧贴一圈 B=1（蓝细环），其余全黑。
+			// 若整片有颜色 → mask/扩张参数异常。
+			if (uDebugVis > 0.5) {
+				gl_FragColor = vec4(hit, self.a, rim, 1.0);
+				return;
+			}
+
+			if (rim < 0.001) {
+				gl_FragColor = vec4(0.0);
+				return;
+			}
+			// 薄高亮层：只需比外圈辉光"稍亮"即可凸显，过曝会偏白、丢掉辉光本色。
+			// 向白色混合 0.3（保留 7 成辉光本色）+ 亮度乘 1.2：轮廓清晰可辨，又不抢辉光的色。
+			vec3 hl = mix(color, vec3(1.0), 0.3) * 1.2;
+			gl_FragColor = vec4(hl, rim * opacity);
+		}`,
+    blending: NoBlending,
+    depthTest: false,
+    depthWrite: false,
+    transparent: true
+});
+
+const filterSelectShader: RawShaderMaterial = new RawShaderMaterial({
+    uniforms: {
+        selectTexture: { value: null },
+        blurTexture: { value: null },
+        opacity: { value: 1 },
+    },
+    vertexShader: `
+		attribute vec3 position;
+		attribute vec2 uv;
+		varying vec2 vUv;
+		void main() {
+			vUv = uv;
+			gl_Position = vec4(position, 1.0);
+		}
+	`,
+    fragmentShader: `
+		#ifdef GL_ES
+			precision highp float;
+		#endif
+		uniform sampler2D selectTexture;
+		uniform sampler2D blurTexture;
+		uniform float opacity;
+		varying vec2 vUv;
+
+		void main() {
+			vec4 blurColor = texture2D(blurTexture, vUv);
+			vec4 selectColor = texture2D(selectTexture, vUv);
+			
+			vec4 glowColor = blurColor - selectColor;
+			glowColor.a = max(0.0, glowColor.a);
+			
+			glowColor.a *= opacity;
+			
+			gl_FragColor = glowColor;
+		}
+	`,
+    blending: NormalBlending,
+    depthTest: false,
+    depthWrite: false,
+    transparent: true,
+});
+
+const copyShader: ShaderMaterial = new ShaderMaterial({
+    uniforms: {
+        map: { value: null },
+    },
+    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 map;
+        varying vec2 vUv;
+        void main() {
+            gl_FragColor = texture2D(map, vUv);
+            ${ShaderChunk.logdepthbuf_fragment}
+        }
+    `,
+    depthTest: true,
+    depthWrite: true,
+    transparent: true,
+});
+
+const scene: Scene = new Scene();
+
+export default function glow_pass(
+    renderer: WebGLRenderer,
+    camera: Camera,
+    object3d: Object3D,
+    baseDepthTexture: DepthTexture,
+    devicePixelRatio: number
+): void {
+    const {
+        glow_enable = false,
+        glow_color = "#04fa12",
+        glow_width = 1,
+        glow_opacity = 1,
+        glow_sigma = 2.0,
+        glow_threshold = 0.0,
+        glow_iterations = 10,
+        glow_intensity = 1.0,
+        glow_additive = false,
+        glow_highlight_width = 2, // 薄高亮层粗细（像素，默认 2）；设为 0 则不画薄高亮层
+    } = object3d.userData as EffectUserData;
+
+    if (!glow_enable || glow_width === 0) {
+        return;
+    }
+
+    const originRenderTarget = renderer.getRenderTarget();
+
+    // 灰度图渲染目标跟随主画面尺寸（= width × effectiveRatio），与 baseRenderTarget 完全一致，
+    // 消除灰度图与主画面尺寸不一致导致的放大重采样摩尔纹
+    renderer.getSize(size);
+    size.multiplyScalar(devicePixelRatio);
+    selectTextureTarget.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);
+
+    // 2. 渲染物体本体深度（无 MSAA，供 min-blur 外扩用）
+    renderer.setRenderTarget(selectDepthTextureTarget);
+    scene.children = [object3d];
+    renderer.clear();
+    renderer.render(scene, camera);
+    // 调试：把本次渲染的选区深度记到全局调试状态，供面板「辉光深度比对」读取
+    debugDepthState.lastSelectDepth = selectDepthTexture;
+
+    // 3. 深度测试（用本体 mask）：被真实更近物体挡住的「本体辉光」部分 discard。
+    //    背景像素 baseDepth≈1.0（最远）永远不小于物体深度 → 不丢弃，浮空物体辉光正常显示。
+    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 as PerspectiveCamera).far;
+    fsQuad.render(renderer, depthTestShader);
+
+    // 4. 从「深度测试后的本体辉光」开始高斯模糊外扩（外扩环自动继承本体遮挡判定 → 不漏光）
+    const blurRadius: number = glow_width * 2.0;
+    gaussianBlurHShader.uniforms.resolution.value.set(1 / size.x, 1 / size.y);
+    gaussianBlurVShader.uniforms.resolution.value.set(1 / size.x, 1 / size.y);
+    gaussianBlurHShader.uniforms.radius.value = blurRadius;
+    gaussianBlurVShader.uniforms.radius.value = blurRadius;
+    gaussianBlurHShader.uniforms.sigma.value = glow_sigma;
+    gaussianBlurVShader.uniforms.sigma.value = glow_sigma;
+    renderer.setRenderTarget(blur1TextureTarget);
+    renderer.clear();
+    gaussianBlurHShader.uniforms.tDiffuse.value = selectDepthTestTextureTarget.texture;
+    fsQuad.render(renderer, gaussianBlurHShader);
+    renderer.setRenderTarget(blur2TextureTarget);
+    renderer.clear();
+    gaussianBlurVShader.uniforms.tDiffuse.value = blur1TextureTarget.texture;
+    fsQuad.render(renderer, gaussianBlurVShader);
+    if (glow_iterations > 1) {
+        for (let i: number = 1; i < glow_iterations; i++) {
+            renderer.setRenderTarget(blur1TextureTarget);
+            renderer.clear();
+            gaussianBlurHShader.uniforms.tDiffuse.value = blur2TextureTarget.texture;
+            fsQuad.render(renderer, gaussianBlurHShader);
+            renderer.setRenderTarget(blur2TextureTarget);
+            renderer.clear();
+            gaussianBlurVShader.uniforms.tDiffuse.value = blur1TextureTarget.texture;
+            fsQuad.render(renderer, gaussianBlurVShader);
+        }
+    }
+
+    // 5. 辉光合成（上色「最终外扩辉光」blur2 → blur1）
+    renderer.setRenderTarget(blur1TextureTarget);
+    renderer.clear();
+    glowCompositeShader.uniforms.tDiffuse.value = blur2TextureTarget.texture;
+    glowCompositeShader.uniforms.color.value.set(glow_color);
+    glowCompositeShader.uniforms.opacity.value = 1.0;
+    glowCompositeShader.uniforms.threshold.value = glow_threshold;
+    glowCompositeShader.uniforms.intensity.value = glow_intensity;
+    fsQuad.render(renderer, glowCompositeShader);
+
+    // 5.5 ⭐ 外扩环深度测试（补齐此前只定义未调用的死代码，与 stroke_pass 同一修复）：
+    //   本体深度随辉光一起外扩（separable H/V，外扩区取邻域最近深度），
+    //   再用它对外扩后的辉光做一次 depthTest —— 否则外扩环永远不参与遮挡判定，
+    //   物体被挡住时辉光依旧从遮挡物前方漏出来。
+    depthMinBlurShader.uniforms.resolution.value.set(1 / size.x, 1 / size.y);
+    depthMinBlurShader.uniforms.radius.value = Math.max(1, blurRadius);
+    depthMinBlurShader.uniforms.direction.value.set(1, 0);
+    depthMinBlurShader.uniforms.tDepth.value = selectDepthTexture;
+    renderer.setRenderTarget(selectDepthBlurTmpTextureTarget);
+    renderer.clear();
+    fsQuad.render(renderer, depthMinBlurShader);
+    depthMinBlurShader.uniforms.direction.value.set(0, 1);
+    depthMinBlurShader.uniforms.tDepth.value = selectDepthBlurTmpTextureTarget.texture;
+    renderer.setRenderTarget(selectDepthBlurTextureTarget);
+    renderer.clear();
+    fsQuad.render(renderer, depthMinBlurShader);
+
+    // 5.6 对外扩后的辉光判遮挡（输出到独立 target，绝不回写 blur1，避免步骤 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;
+    fsQuad.render(renderer, depthTestShader);
+
+    // 6. 合成到屏幕：filterSelect(blur=上色后且已判遮挡的最终外扩辉光, select=深度测试后本体辉光)
+    //    = 仅保留辉光外扩环；本体被减掉。⚠️ blur 必须是最终外扩辉光，绝不能被 depthTest 结果覆盖
+    //    （早期回归：误把 depthTest 结果上色进 blur1 → filterSelect 相减归零 → 辉光全不显示）。
+    renderer.setRenderTarget(originRenderTarget);
+    filterSelectShader.uniforms.selectTexture.value = selectDepthTestTextureTarget.texture;
+    filterSelectShader.uniforms.blurTexture.value = blurDepthTestTextureTarget.texture;
+    filterSelectShader.uniforms.opacity.value = glow_opacity;
+    // glow_additive=true 时用加性混合，光晕叠加到画面呈发光感（很亮那种）；否则普通半透明覆盖（默认）
+    filterSelectShader.blending = glow_additive ? AdditiveBlending : NormalBlending;
+    fsQuad.render(renderer, filterSelectShader);
+
+    // 7. 薄高亮层：贴物体边缘的细亮环（rim），与外圈柔光晕并存 —— glow 的**默认行为，始终绘制、无开关参数**。
+    //    用本体 mask（selectDepthTestTextureTarget，深度测试后）做 1 次像素扩张 → 扩张区减本体 = 贴边薄环。
+    //    唯一可调项 glow_highlight_width（默认 2px）：控制薄环粗细；=0 时扩张像素为 0，自然无可见环。
+    {
+        thinHighlightShader.uniforms.tMask.value = selectDepthTestTextureTarget.texture;
+        thinHighlightShader.uniforms.color.value.set(glow_color);
+        thinHighlightShader.uniforms.uWidth.value = glow_highlight_width;
+        thinHighlightShader.uniforms.opacity.value = glow_opacity;
+        thinHighlightShader.uniforms.intensity.value = glow_intensity;
+        thinHighlightShader.uniforms.resolution.value.set(1 / size.x, 1 / size.y);
+        // 调试：window.__GLOW_HIGHLIGHT_VIS = true 时输出 rim 可视化（R=扩张区 G=本体 B=薄亮环）
+        thinHighlightShader.uniforms.uDebugVis.value = ((window as unknown as { __GLOW_HIGHLIGHT_VIS?: boolean }).__GLOW_HIGHLIGHT_VIS) ? 1.0 : 0.0;
+        // 跟随 glow_additive：加性时薄亮环也发光叠加，否则半透明覆盖
+        thinHighlightShader.blending = glow_additive ? AdditiveBlending : NormalBlending;
+        renderer.setRenderTarget(originRenderTarget);
+        fsQuad.render(renderer, thinHighlightShader);
+    }
+}

package/pass/screen_bloom_pass.d.ts

@@ -0,0 +1,11 @@
+import { WebGLRenderTarget, WebGLRenderer } from "three";
+interface ScreenBloomConfig {
+    /** 叠加强度 */
+    strength: number;
+    /** 模糊扩散（0~1）：映射高斯偏移步长，越大越柔 */
+    radius: number;
+    /** 亮部软阈值（0~1）：仅亮度高于此值的像素参与辉光 */
+    threshold: number;
+}
+export default function screenBloomPass(renderer: WebGLRenderer, sourceRenderTarget: WebGLRenderTarget, config: ScreenBloomConfig): void;
+export {};