three-base 2.0.137 → 2.0.145

package/pass/bloom_pass.js

@@ -4,39 +4,54 @@
  * @Last Modified by: xiaosihan
  * @Last Modified time: 2025-01-28 05:05:49
  */
-import { DepthTexture, DepthFormat, LinearFilter, RGBAFormat, UnsignedShortType, WebGLRenderTarget, Scene, Vector2, ShaderChunk, NoBlending, ShaderMaterial, AdditiveBlending } from "three";
+import { DepthTexture, DepthFormat, LinearFilter, RGBAFormat, UnsignedIntType, WebGLRenderTarget, Scene, Vector2, ShaderChunk, NoBlending, ShaderMaterial, AdditiveBlending } from "three";
 import { UnrealBloomPass } from "three/examples/jsm/postprocessing/UnrealBloomPass";
 import copyShader from "../shaders/copyShader";
 import fsQuad from "./fsQuad";
-// 选中对象的深度纹理
 const selectDepthTexture = (() => {
-    const baseDepthTexture = new DepthTexture(4096, 4096);
+    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 边缘平滑而深度硬 → depthTest 判定边界与 mask 视觉边缘错位，bloom 边缘锯齿/摩尔纹。
+    // 边缘抗锯齿统一由终处理 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,
+});
+// 独立的 bloom 合成目标：避免 UnrealBloomPass 与 readBuffer 共用同一目标
+// （本版本 UnrealBloomPass 内部把 bloom 叠加回 readBuffer，传入独立 write 目标可规避同目标读写隐患）
+const bloomWriteTarget = new WebGLRenderTarget(1024, 1024, {
     minFilter: LinearFilter,
     magFilter: LinearFilter,
     format: RGBAFormat,
     anisotropy: 16,
 });
-//深度比对纹理
 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 },
     },
     vertexShader: `
         ${ShaderChunk.common}
@@ -53,19 +68,31 @@ const depthTestShader = new ShaderMaterial({
         uniform sampler2D map;
         uniform sampler2D baseDepth;
         uniform sampler2D selectDepth;
+        uniform float cameraFar;
         varying vec2 vUv;
         void main() {
-            if(texture2D(baseDepth, vUv).r < texture2D(selectDepth, vUv).r){
+            float baseD = texture2D(baseDepth, vUv).r;
+            float selD = texture2D(selectDepth, vUv).r;
+            // 对数深度反解为线性视图深度后再比对。
+            float zBase = pow(cameraFar + 1.0, baseD) - 1.0;
+            float zSel  = pow(cameraFar + 1.0, selD)  - 1.0;
+            float bias = max(zSel, 1.0) * 0.0015;
+            // 该像素没有泛光对象（selectDepth 仍是清屏值 1.0 → zSel == cameraFar）→ 不参与合成。
+            // ⚠️ 旧实现让背景像素「不参与丢弃」，导致没有对象的像素同样输出 map，
+            // 而本 shader 输出后由 AdditiveBlending 叠回主画面 → 整个场景被泛光覆盖
+            // （与 frosted_glass_pass 的「整屏模糊」是同一个模板 bug）。
+            if (zSel >= cameraFar) {
                 discard;
             }
-            if(texture2D(baseDepth, vUv).r == 1.0){
+            // 仅丢弃被更近场景几何遮挡的部分（zBase 比 zSel 更近）
+            if (zBase < zSel - bias) {
                 discard;
             }
             gl_FragColor = texture2D(map, vUv);
             ${ShaderChunk.logdepthbuf_fragment}
         }
     `,
-    blending: NoBlending, // 渲染时不与背景融合计算 直接替换
+    blending: NoBlending,
     depthTest: true,
     depthWrite: true,
     transparent: true,
@@ -73,52 +100,112 @@ const depthTestShader = new ShaderMaterial({
 const blendMaterial = copyShader.clone();
 blendMaterial.blending = AdditiveBlending;
 const size = new Vector2();
-// 场景对象
 const scene = new Scene();
 const bloomPass = new UnrealBloomPass(new Vector2(1024, 1024), 1.5, 0.4, 0.85);
-// bloomPass.threshold = params.threshold;
-// bloomPass.strength = params.strength;
-// bloomPass.radius = params.radius;
-// 发光后期通道
 export default function bloom_pass(renderer, camera, object3d, baseRenderTarget, baseDepthTexture, devicePixelRatio) {
     const { bloom_enable = false, bloom_threshold = 1.5, bloom_strength = 0.4, bloom_radius = 0.85, } = object3d.userData;
-    // 不满足条件就不渲染发光效果
     if (!bloom_enable || (bloom_strength === 0) || (bloom_radius === 0)) {
         return;
     }
     bloomPass.threshold = bloom_threshold;
     bloomPass.strength = bloom_strength;
     bloomPass.radius = bloom_radius;
-    // 保存原帧缓冲区
     const originRenderTarget = renderer.getRenderTarget();
-    // 设置选中目标的帧缓冲区
+    // 灰度图渲染目标跟随主画面尺寸（= width × effectiveRatio），与 baseRenderTarget 完全一致，
+    // 消除灰度图与主画面尺寸不一致导致的放大重采样摩尔纹
     renderer.getSize(size);
     size.multiplyScalar(devicePixelRatio);
     bloomPass.setSize(size.x, size.y);
     selectTextureTarget.setSize(size.x, size.y);
-    selectDethpTestTextureTarget.setSize(size.x, size.y);
-    renderer.setRenderTarget(selectTextureTarget);
-    scene.children = [object3d];
-    renderer.clear();
-    renderer.render(scene, camera);
-    //使用深度纹理提取选中的对象未被遮挡的像素点
-    renderer.setRenderTarget(selectDethpTestTextureTarget);
+    selectDepthTextureTarget.setSize(size.x, size.y);
+    // 缺陷②修复：three r167 的 WebGLRenderTarget.setSize 不会同步 depthTexture，
+    // 需手动把 selectDepthTexture 的尺寸与全屏 baseDepth 对齐，否则深度比例错位导致 bloom 被全部 discard
+    selectDepthTexture.image.width = size.x;
+    selectDepthTexture.image.height = size.y;
+    selectDepthTexture.needsUpdate = true;
+    selectDepthTestTextureTarget.setSize(size.x, size.y);
+    bloomWriteTarget.setSize(size.x, size.y);
+    // 缺陷①修复：离屏单独渲染 object3d 时临时 scene 没有灯光，
+    // 而 Text3D 默认材质 metalness:1 无环境贴图，无光照会渲染成全黑，bloom 提取不到亮度。
+    // 做法：① 安全挂载并还原 object3d 的 parent（渲染后放回原 parent，避免影响主场景的 matrixWorld）；
+    //       ② 把材质临时切到"自发光显色"（emissive = color, emissiveIntensity = 1），
+    //          让被 bloom 的对象按其可见原色参与 bloom，且不受 MeshStandardMaterial 的 metalness 影响，必定可见。
+    const parent = object3d.parent;
+    scene.add(object3d);
+    // object3d 可能是单 Mesh，也可能是 Group（如 InstancedChild 选择代理含多个代理 Mesh）。
+    // 统一遍历其下所有网格子节点，收集材质（数组展开、去重、排除 undefined），
+    // 避免 Group 无 material 属性时访问 undefined.emissive 抛错。
+    const mats = [];
+    object3d.traverse((node) => {
+        const nodeMesh = node;
+        if (nodeMesh.isMesh) {
+            const nodeMat = nodeMesh.material;
+            if (Array.isArray(nodeMat)) {
+                for (const m of nodeMat)
+                    if (m)
+                        mats.push(m);
+            }
+            else if (nodeMat) {
+                mats.push(nodeMat);
+            }
+        }
+    });
+    const uniqueMats = Array.from(new Set(mats));
+    // 暂存每个材质的原 emissive / emissiveIntensity，渲染后还原
+    const emissiveBackup = uniqueMats.map((mat) => {
+        const m = mat;
+        return {
+            material: mat,
+            emissive: m.emissive ? m.emissive.clone() : null,
+            emissiveIntensity: m.emissiveIntensity ?? 0,
+        };
+    });
+    uniqueMats.forEach((mat) => {
+        const m = mat;
+        if (m.emissive && m.color) {
+            m.emissive.copy(m.color);
+            m.emissiveIntensity = 1;
+        }
+    });
+    try {
+        renderer.setRenderTarget(selectTextureTarget);
+        renderer.clear();
+        renderer.render(scene, camera);
+        // 单独渲染对象深度到无 MSAA 目标，供 depthTestShader 做遮挡判定（与材质/父节点还原同生命周期）
+        renderer.setRenderTarget(selectDepthTextureTarget);
+        renderer.clear();
+        renderer.render(scene, camera);
+    }
+    finally {
+        // 还原材质 emissive
+        emissiveBackup.forEach(({ material, emissive, emissiveIntensity }) => {
+            const m = material;
+            if (m.emissive) {
+                if (emissive) {
+                    m.emissive.copy(emissive);
+                }
+                m.emissiveIntensity = emissiveIntensity;
+            }
+        });
+        // 还原 parent，避免影响主场景里该对象的 matrixWorld
+        if (parent) {
+            parent.add(object3d);
+        }
+        else {
+            scene.remove(object3d);
+        }
+    }
+    renderer.setRenderTarget(selectDepthTestTextureTarget);
     renderer.clear();
     depthTestShader.uniforms.map.value = baseRenderTarget.texture;
     depthTestShader.uniforms.baseDepth.value = baseDepthTexture;
     depthTestShader.uniforms.selectDepth.value = selectDepthTexture;
+    depthTestShader.uniforms.cameraFar.value = camera.far;
     fsQuad.render(renderer, depthTestShader);
-    // 渲染辉光
-    bloomPass.render(renderer, selectDethpTestTextureTarget, selectDethpTestTextureTarget, 0, false);
-    // 将发光效果与原始帧缓冲区混合
+    // 修复：使用独立 write 目标，避免 UnrealBloomPass 就地读写同一目标导致不出图
+    bloomPass.render(renderer, bloomWriteTarget, selectDepthTestTextureTarget, 0, false);
     renderer.setRenderTarget(originRenderTarget);
     renderer.clearDepth();
-    blendMaterial.uniforms.map.value = selectDethpTestTextureTarget.texture;
+    blendMaterial.uniforms.map.value = selectDepthTestTextureTarget.texture;
     fsQuad.render(renderer, blendMaterial);
-    // 调试代码
-    // renderer.setRenderTarget(null);
-    // renderer.clearDepth();
-    // copyShader.uniforms.map.value = blur2TextureTarget.texture;
-    // fsQuad.render(renderer, copyShader);
-    // return;
 }

package/pass/bloom_pass.ts

@@ -0,0 +1,243 @@
+/*
+ * @Author: xiaosihan
+ * @Date: 2024-09-23 21:51:29
+ * @Last Modified by: xiaosihan
+ * @Last Modified time: 2025-01-28 05:05:49
+ */
+import { DepthTexture, DepthFormat, LinearFilter, RGBAFormat, UnsignedIntType, WebGLRenderTarget, Scene, Vector2, ShaderChunk, NoBlending, ShaderMaterial, AdditiveBlending, WebGLRenderer, Camera, PerspectiveCamera, Object3D, Color, Material, Mesh } from "three";
+import { UnrealBloomPass } from "three/examples/jsm/postprocessing/UnrealBloomPass";
+import copyShader from "../shaders/copyShader";
+import fsQuad from "./fsQuad";
+import { EffectUserData } from "./effectUserData";
+
+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 边缘平滑而深度硬 → depthTest 判定边界与 mask 视觉边缘错位，bloom 边缘锯齿/摩尔纹。
+    // 边缘抗锯齿统一由终处理 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,
+});
+
+// 独立的 bloom 合成目标：避免 UnrealBloomPass 与 readBuffer 共用同一目标
+// （本版本 UnrealBloomPass 内部把 bloom 叠加回 readBuffer，传入独立 write 目标可规避同目标读写隐患）
+const bloomWriteTarget: WebGLRenderTarget = new WebGLRenderTarget(1024, 1024, {
+    minFilter: LinearFilter,
+    magFilter: LinearFilter,
+    format: RGBAFormat,
+    anisotropy: 16,
+});
+
+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;
+            // 对数深度反解为线性视图深度后再比对。
+            float zBase = pow(cameraFar + 1.0, baseD) - 1.0;
+            float zSel  = pow(cameraFar + 1.0, selD)  - 1.0;
+            float bias = max(zSel, 1.0) * 0.0015;
+            // 该像素没有泛光对象（selectDepth 仍是清屏值 1.0 → zSel == cameraFar）→ 不参与合成。
+            // ⚠️ 旧实现让背景像素「不参与丢弃」，导致没有对象的像素同样输出 map，
+            // 而本 shader 输出后由 AdditiveBlending 叠回主画面 → 整个场景被泛光覆盖
+            // （与 frosted_glass_pass 的「整屏模糊」是同一个模板 bug）。
+            if (zSel >= cameraFar) {
+                discard;
+            }
+            // 仅丢弃被更近场景几何遮挡的部分（zBase 比 zSel 更近）
+            if (zBase < zSel - bias) {
+                discard;
+            }
+            gl_FragColor = texture2D(map, vUv);
+            ${ShaderChunk.logdepthbuf_fragment}
+        }
+    `,
+    blending: NoBlending,
+    depthTest: true,
+    depthWrite: true,
+    transparent: true,
+});
+
+const blendMaterial: ShaderMaterial = copyShader.clone();
+blendMaterial.blending = AdditiveBlending;
+
+const size: Vector2 = new Vector2();
+
+const scene: Scene = new Scene();
+
+const bloomPass: UnrealBloomPass = new UnrealBloomPass(new Vector2(1024, 1024), 1.5, 0.4, 0.85);
+
+export default function bloom_pass(
+    renderer: WebGLRenderer,
+    camera: Camera,
+    object3d: Object3D,
+    baseRenderTarget: WebGLRenderTarget,
+    baseDepthTexture: DepthTexture,
+    devicePixelRatio: number
+): void {
+    const {
+        bloom_enable = false,
+        bloom_threshold = 1.5,
+        bloom_strength = 0.4,
+        bloom_radius = 0.85,
+    } = object3d.userData as EffectUserData;
+
+    if (!bloom_enable || (bloom_strength === 0) || (bloom_radius === 0)) {
+        return;
+    }
+
+    bloomPass.threshold = bloom_threshold;
+    bloomPass.strength = bloom_strength;
+    bloomPass.radius = bloom_radius;
+
+    const originRenderTarget = renderer.getRenderTarget();
+
+    // 灰度图渲染目标跟随主画面尺寸（= width × effectiveRatio），与 baseRenderTarget 完全一致，
+    // 消除灰度图与主画面尺寸不一致导致的放大重采样摩尔纹
+    renderer.getSize(size);
+    size.multiplyScalar(devicePixelRatio);
+    bloomPass.setSize(size.x, size.y);
+    selectTextureTarget.setSize(size.x, size.y);
+    selectDepthTextureTarget.setSize(size.x, size.y);
+    // 缺陷②修复：three r167 的 WebGLRenderTarget.setSize 不会同步 depthTexture，
+    // 需手动把 selectDepthTexture 的尺寸与全屏 baseDepth 对齐，否则深度比例错位导致 bloom 被全部 discard
+    selectDepthTexture.image.width = size.x;
+    selectDepthTexture.image.height = size.y;
+    selectDepthTexture.needsUpdate = true;
+    selectDepthTestTextureTarget.setSize(size.x, size.y);
+    bloomWriteTarget.setSize(size.x, size.y);
+
+    // 缺陷①修复：离屏单独渲染 object3d 时临时 scene 没有灯光，
+    // 而 Text3D 默认材质 metalness:1 无环境贴图，无光照会渲染成全黑，bloom 提取不到亮度。
+    // 做法：① 安全挂载并还原 object3d 的 parent（渲染后放回原 parent，避免影响主场景的 matrixWorld）；
+    //       ② 把材质临时切到"自发光显色"（emissive = color, emissiveIntensity = 1），
+    //          让被 bloom 的对象按其可见原色参与 bloom，且不受 MeshStandardMaterial 的 metalness 影响，必定可见。
+    const parent = object3d.parent;
+    scene.add(object3d);
+
+    // object3d 可能是单 Mesh，也可能是 Group（如 InstancedChild 选择代理含多个代理 Mesh）。
+    // 统一遍历其下所有网格子节点，收集材质（数组展开、去重、排除 undefined），
+    // 避免 Group 无 material 属性时访问 undefined.emissive 抛错。
+    const mats: Material[] = [];
+    object3d.traverse((node: Object3D) => {
+        const nodeMesh = node as Mesh;
+        if (nodeMesh.isMesh) {
+            const nodeMat = nodeMesh.material;
+            if (Array.isArray(nodeMat)) {
+                for (const m of nodeMat) if (m) mats.push(m);
+            } else if (nodeMat) {
+                mats.push(nodeMat);
+            }
+        }
+    });
+    const uniqueMats = Array.from(new Set(mats));
+
+    // 暂存每个材质的原 emissive / emissiveIntensity，渲染后还原
+    const emissiveBackup = uniqueMats.map((mat) => {
+        const m = mat as unknown as { emissive?: Color; emissiveIntensity?: number };
+        return {
+            material: mat,
+            emissive: m.emissive ? m.emissive.clone() : null,
+            emissiveIntensity: m.emissiveIntensity ?? 0,
+        };
+    });
+
+    uniqueMats.forEach((mat) => {
+        const m = mat as unknown as { color?: Color; emissive?: Color; emissiveIntensity?: number };
+        if (m.emissive && m.color) {
+            m.emissive.copy(m.color);
+            m.emissiveIntensity = 1;
+        }
+    });
+
+    try {
+        renderer.setRenderTarget(selectTextureTarget);
+        renderer.clear();
+        renderer.render(scene, camera);
+
+        // 单独渲染对象深度到无 MSAA 目标，供 depthTestShader 做遮挡判定（与材质/父节点还原同生命周期）
+        renderer.setRenderTarget(selectDepthTextureTarget);
+        renderer.clear();
+        renderer.render(scene, camera);
+    } finally {
+        // 还原材质 emissive
+        emissiveBackup.forEach(({ material, emissive, emissiveIntensity }) => {
+            const m = material as unknown as { emissive?: Color; emissiveIntensity?: number };
+            if (m.emissive) {
+                if (emissive) {
+                    m.emissive.copy(emissive);
+                }
+                m.emissiveIntensity = emissiveIntensity;
+            }
+        });
+        // 还原 parent，避免影响主场景里该对象的 matrixWorld
+        if (parent) {
+            parent.add(object3d);
+        } else {
+            scene.remove(object3d);
+        }
+    }
+
+    renderer.setRenderTarget(selectDepthTestTextureTarget);
+    renderer.clear();
+    depthTestShader.uniforms.map.value = baseRenderTarget.texture;
+    depthTestShader.uniforms.baseDepth.value = baseDepthTexture;
+    depthTestShader.uniforms.selectDepth.value = selectDepthTexture;
+    depthTestShader.uniforms.cameraFar.value = (camera as PerspectiveCamera).far;
+    fsQuad.render(renderer, depthTestShader);
+
+    // 修复：使用独立 write 目标，避免 UnrealBloomPass 就地读写同一目标导致不出图
+    bloomPass.render(renderer, bloomWriteTarget, selectDepthTestTextureTarget, 0, false);
+
+    renderer.setRenderTarget(originRenderTarget);
+    renderer.clearDepth();
+    blendMaterial.uniforms.map.value = selectDepthTestTextureTarget.texture;
+    fsQuad.render(renderer, blendMaterial);
+}

package/pass/cover_pass.d.ts

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

package/pass/cover_pass.js

@@ -10,45 +10,54 @@
  * @Last Modified by: xiaosihan
  * @Last Modified time: 2023-05-09 02:33:28
  */
-import { Color, DepthFormat, DepthTexture, LinearFilter, RGBAFormat, Scene, ShaderChunk, ShaderMaterial, UnsignedShortType, Vector2, WebGLRenderTarget } from "three";
+import { Color, DepthFormat, DepthTexture, LinearFilter, RGBAFormat, Scene, ShaderChunk, ShaderMaterial, UnsignedIntType, Vector2, WebGLRenderTarget } from "three";
 import fsQuad from "./fsQuad";
-// 选中对象的深度纹理
+import { debugDepthState } from "./debugDepthState";
 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 视觉边缘错位，覆盖边缘锯齿。
+    // 边缘抗锯齿统一由终处理 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, {
+const blur1TextureTarget = new WebGLRenderTarget(1024, 1024, {
     minFilter: LinearFilter,
     magFilter: LinearFilter,
     format: RGBAFormat,
 });
 const size = new Vector2();
-//深度比对纹理
 const depthTestShader = new ShaderMaterial({
     uniforms: {
-        color: { value: new Color("#440000") }, //颜色
-        opacity: { value: 1 }, // 透明度
-        depthTest: { value: true }, // 开启深度测试
-        baseDepth: { value: null }, // 整个场景的深度纹理
-        selectDepth: { value: null }, // 选中的对象深度纹理
+        color: { value: new Color("#440000") },
+        opacity: { value: 1 },
+        depthTest: { value: true },
+        baseDepth: { value: null },
+        selectDepth: { value: null },
+        cameraFar: { value: 1000.0 },
     },
     vertexShader: `
         ${ShaderChunk.common}
@@ -56,8 +65,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}
         }
@@ -69,13 +76,25 @@ const depthTestShader = new ShaderMaterial({
         uniform bool depthTest;
         uniform sampler2D baseDepth;
         uniform sampler2D selectDepth;
+        uniform float cameraFar;
         varying vec2 vUv;
         void main() {
             if( depthTest ){
-                if(texture2D(baseDepth, vUv).r + 0.0001 < texture2D(selectDepth, vUv).r){
+                float coverBaseD = texture2D(baseDepth, vUv).r;
+                float coverSelD = texture2D(selectDepth, vUv).r;
+                // 对数深度反解成线性视图深度，线性空间做遮挡判定。
+                float zBase = pow(cameraFar + 1.0, coverBaseD) - 1.0;
+                float zSel  = pow(cameraFar + 1.0, coverSelD) - 1.0;
+                float bias = max(zSel, 1.0) * 0.0015;
+                // 该像素没有覆盖对象（selectDepth 仍是清屏值 1.0 → zSel == cameraFar）→ 不参与合成。
+                // ⚠️ 旧实现让背景像素「直接保留覆盖色」，导致没有对象的像素同样输出覆盖色
+                // → 整个场景被覆盖色染一层（与 frosted_glass / bloom 是同一个模板 bug）。
+                // 语义与下方 depthTest=false 分支的「selectDepth < 1.0 才输出」保持一致。
+                if (zSel >= cameraFar) {
                     discard;
                 }
-                if(texture2D(baseDepth, vUv).r == 1.0){
+                // 仅丢弃被更近场景几何遮挡的部分
+                if (zBase < zSel - bias) {
                     discard;
                 }
                 gl_FragColor = vec4(color, opacity);
@@ -94,28 +113,37 @@ const depthTestShader = new ShaderMaterial({
     depthWrite: true,
     transparent: true,
 });
-// 场景对象
 const scene = new Scene();
-// 给模型覆盖一层颜色 后处理通道
 export default function cover_pass(renderer, camera, object3d, baseDepthTexture, devicePixelRatio) {
-    const { cover_enable = false, cover_color = "#04fa12", cover_opacity = 1, cover_depth_test = true, // 颜色叠加是否开启深度测试
-     } = object3d.userData;
+    const { cover_enable = false, cover_color = "#04fa12", cover_opacity = 1, cover_depth_test = true, } = object3d.userData;
     if (!cover_enable || cover_opacity === 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);
     renderer.setRenderTarget(selectTextureTarget);
     scene.children = [object3d];
     renderer.clear();
     renderer.render(scene, camera);
-    //更具深度测试绘制叠加颜色
+    // 单独渲染对象深度到无 MSAA 目标，供 depthTestShader 做遮挡判定
+    renderer.setRenderTarget(selectDepthTextureTarget);
+    scene.children = [object3d];
+    renderer.clear();
+    renderer.render(scene, camera);
+    // 调试：记录选区深度，供面板「深度判定图 / 辉光深度比对」排查 cover 的遮挡判定
+    debugDepthState.lastSelectDepth = selectDepthTexture;
     renderer.setRenderTarget(originRenderTarget);
     renderer.clearDepth();
     depthTestShader.uniforms.color.value.set(cover_color);
@@ -123,11 +151,6 @@ export default function cover_pass(renderer, camera, object3d, baseDepthTexture,
     depthTestShader.uniforms.depthTest.value = cover_depth_test;
     depthTestShader.uniforms.baseDepth.value = baseDepthTexture;
     depthTestShader.uniforms.selectDepth.value = selectDepthTexture;
+    depthTestShader.uniforms.cameraFar.value = camera.far;
     fsQuad.render(renderer, depthTestShader);
-    // 调试代码
-    // renderer.setRenderTarget(null);
-    // renderer.clearDepth();
-    // copyShader.uniforms.map.value = blur2TextureTarget.texture;
-    // fsQuad.render(renderer, copyShader);
-    // return;
 }