three-base 2.0.142 → 2.0.166

package/pass/debugDepthState.js

@@ -1,9 +1,9 @@
-/**
- * 调试用全局状态：记录最近一次 glow_pass / stroke_pass 渲染的「选区自身深度图」(selectDepth)。
- * 供 ThreeBase 渲染末尾的「辉光深度比对」调试视图读取（R=全局 base 深度，G=选区 select 深度），
- * 让用户一眼看出到底是「全局 base 深度没写进」还是「选区自身深度没写进」。
- * 由各 pass 在渲染完 selectDepth 后写入；每帧会被最后一个被处理的可见对象覆盖（调试够用）。
- */
-export const debugDepthState = {
-    lastSelectDepth: null,
-};
+/**
+ * 调试用全局状态：记录最近一次 glow_pass / stroke_pass 渲染的「选区自身深度图」(selectDepth)。
+ * 供 ThreeBase 渲染末尾的「辉光深度比对」调试视图读取（R=全局 base 深度，G=选区 select 深度），
+ * 让用户一眼看出到底是「全局 base 深度没写进」还是「选区自身深度没写进」。
+ * 由各 pass 在渲染完 selectDepth 后写入；每帧会被最后一个被处理的可见对象覆盖（调试够用）。
+ */
+export const debugDepthState = {
+    lastSelectDepth: null,
+};

package/pass/debugDepthState.ts

@@ -1,22 +1,22 @@
-import type { DepthTexture } from "three";
-
-/**
- * 深度调试预览模式（面板按钮与控制台 `window.__TB_DEBUG_DEPTH` 共用同一枚举）：
- *   - "none"    ：正常渲染（默认）
- *   - "global"  ：全局深度图（baseDepthTexture，排除地板）
- *   - "ao"      ：AO 深度图（aoDepthTexture，含地板）
- *   - "compare" ：R=base 深度、G=选区 select 深度（对数反解后归一化）
- *   - "judge"   ：R=base 原始深度、G=select 原始深度、B=判定结果(1=判为被遮挡应 discard)
- *   - "excluded"：深度图灰度 + 「被排除出深度图的面」叠红（红=挡不住任何后处理）
- */
-export type DebugDepthMode = "none" | "global" | "ao" | "compare" | "judge" | "excluded";
-
-/**
- * 调试用全局状态：记录最近一次 glow_pass / stroke_pass 渲染的「选区自身深度图」(selectDepth)。
- * 供 ThreeBase 渲染末尾的「辉光深度比对」调试视图读取（R=全局 base 深度，G=选区 select 深度），
- * 让用户一眼看出到底是「全局 base 深度没写进」还是「选区自身深度没写进」。
- * 由各 pass 在渲染完 selectDepth 后写入；每帧会被最后一个被处理的可见对象覆盖（调试够用）。
- */
-export const debugDepthState: { lastSelectDepth: DepthTexture | null } = {
-    lastSelectDepth: null,
-};
+import type { DepthTexture } from "three";
+
+/**
+ * 深度调试预览模式（面板按钮与控制台 `window.__TB_DEBUG_DEPTH` 共用同一枚举）：
+ *   - "none"    ：正常渲染（默认）
+ *   - "global"  ：全局深度图（baseDepthTexture，排除地板）
+ *   - "ao"      ：AO 深度图（aoDepthTexture，含地板）
+ *   - "compare" ：R=base 深度、G=选区 select 深度（对数反解后归一化）
+ *   - "judge"   ：R=base 原始深度、G=select 原始深度、B=判定结果(1=判为被遮挡应 discard)
+ *   - "excluded"：深度图灰度 + 「被排除出深度图的面」叠红（红=挡不住任何后处理）
+ */
+export type DebugDepthMode = "none" | "global" | "ao" | "compare" | "judge" | "excluded";
+
+/**
+ * 调试用全局状态：记录最近一次 glow_pass / stroke_pass 渲染的「选区自身深度图」(selectDepth)。
+ * 供 ThreeBase 渲染末尾的「辉光深度比对」调试视图读取（R=全局 base 深度，G=选区 select 深度），
+ * 让用户一眼看出到底是「全局 base 深度没写进」还是「选区自身深度没写进」。
+ * 由各 pass 在渲染完 selectDepth 后写入；每帧会被最后一个被处理的可见对象覆盖（调试够用）。
+ */
+export const debugDepthState: { lastSelectDepth: DepthTexture | null } = {
+    lastSelectDepth: null,
+};

package/pass/depthTestBias.d.ts

@@ -1,12 +1,12 @@
-/**
- * 深度遮挡判定容差（对数深度空间）—— 单一常量源。
- *
- * 语义：`baseD < selD - DEPTH_TEST_BIAS` 时判定「该像素被更近的真实几何挡住」→ discard。
- * （DepthTexture 存的是对数深度，值越小越近。）
- *
- * ⚠️ 必须单一源：stroke_pass 的 depthTestShader 与调试用的 debugDepthJudgeShader
- * 都依赖它。若两边各写一份字面量，改一边忘另一边 → 调试视图与真实判定不一致，
- * 排查时会得出完全错误的结论（本次深度排查已踩过这类"两处漂移"的坑）。
- * 护栏见 test/depthDebug.test.js C 组。
- */
-export declare const DEPTH_TEST_BIAS = 0.0006;
+/**
+ * 深度遮挡判定容差（对数深度空间）—— 单一常量源。
+ *
+ * 语义：`baseD < selD - DEPTH_TEST_BIAS` 时判定「该像素被更近的真实几何挡住」→ discard。
+ * （DepthTexture 存的是对数深度，值越小越近。）
+ *
+ * ⚠️ 必须单一源：stroke_pass 的 depthTestShader 与调试用的 debugDepthJudgeShader
+ * 都依赖它。若两边各写一份字面量，改一边忘另一边 → 调试视图与真实判定不一致，
+ * 排查时会得出完全错误的结论（本次深度排查已踩过这类"两处漂移"的坑）。
+ * 护栏见 test/depthDebug.test.js C 组。
+ */
+export declare const DEPTH_TEST_BIAS = 0.0006;

package/pass/depthTestBias.js

@@ -1,12 +1,12 @@
-/**
- * 深度遮挡判定容差（对数深度空间）—— 单一常量源。
- *
- * 语义：`baseD < selD - DEPTH_TEST_BIAS` 时判定「该像素被更近的真实几何挡住」→ discard。
- * （DepthTexture 存的是对数深度，值越小越近。）
- *
- * ⚠️ 必须单一源：stroke_pass 的 depthTestShader 与调试用的 debugDepthJudgeShader
- * 都依赖它。若两边各写一份字面量，改一边忘另一边 → 调试视图与真实判定不一致，
- * 排查时会得出完全错误的结论（本次深度排查已踩过这类"两处漂移"的坑）。
- * 护栏见 test/depthDebug.test.js C 组。
- */
-export const DEPTH_TEST_BIAS = 0.0006;
+/**
+ * 深度遮挡判定容差（对数深度空间）—— 单一常量源。
+ *
+ * 语义：`baseD < selD - DEPTH_TEST_BIAS` 时判定「该像素被更近的真实几何挡住」→ discard。
+ * （DepthTexture 存的是对数深度，值越小越近。）
+ *
+ * ⚠️ 必须单一源：stroke_pass 的 depthTestShader 与调试用的 debugDepthJudgeShader
+ * 都依赖它。若两边各写一份字面量，改一边忘另一边 → 调试视图与真实判定不一致，
+ * 排查时会得出完全错误的结论（本次深度排查已踩过这类"两处漂移"的坑）。
+ * 护栏见 test/depthDebug.test.js C 组。
+ */
+export const DEPTH_TEST_BIAS = 0.0006;

package/pass/depthTestBias.ts

@@ -1,12 +1,12 @@
-/**
- * 深度遮挡判定容差（对数深度空间）—— 单一常量源。
- *
- * 语义：`baseD < selD - DEPTH_TEST_BIAS` 时判定「该像素被更近的真实几何挡住」→ discard。
- * （DepthTexture 存的是对数深度，值越小越近。）
- *
- * ⚠️ 必须单一源：stroke_pass 的 depthTestShader 与调试用的 debugDepthJudgeShader
- * 都依赖它。若两边各写一份字面量，改一边忘另一边 → 调试视图与真实判定不一致，
- * 排查时会得出完全错误的结论（本次深度排查已踩过这类"两处漂移"的坑）。
- * 护栏见 test/depthDebug.test.js C 组。
- */
-export const DEPTH_TEST_BIAS = 0.0006;
+/**
+ * 深度遮挡判定容差（对数深度空间）—— 单一常量源。
+ *
+ * 语义：`baseD < selD - DEPTH_TEST_BIAS` 时判定「该像素被更近的真实几何挡住」→ discard。
+ * （DepthTexture 存的是对数深度，值越小越近。）
+ *
+ * ⚠️ 必须单一源：stroke_pass 的 depthTestShader 与调试用的 debugDepthJudgeShader
+ * 都依赖它。若两边各写一份字面量，改一边忘另一边 → 调试视图与真实判定不一致，
+ * 排查时会得出完全错误的结论（本次深度排查已踩过这类"两处漂移"的坑）。
+ * 护栏见 test/depthDebug.test.js C 组。
+ */
+export const DEPTH_TEST_BIAS = 0.0006;

package/pass/effectUserData.d.ts

@@ -1,27 +1,27 @@
-/** 特效与鼠标事件共用的 userData 字段 */
-export interface EffectUserData {
-    stroke_enable?: boolean;
-    stroke_color?: string;
-    stroke_width?: number;
-    glow_enable?: boolean;
-    glow_color?: string;
-    glow_width?: number;
-    glow_opacity?: number;
-    glow_sigma?: number;
-    glow_threshold?: number;
-    glow_iterations?: number;
-    glow_intensity?: number;
-    glow_additive?: boolean;
-    glow_highlight_width?: number;
-    cover_enable?: boolean;
-    cover_color?: string;
-    cover_opacity?: number;
-    cover_depth_test?: boolean;
-    bloom_enable?: boolean;
-    bloom_threshold?: number;
-    bloom_strength?: number;
-    bloom_radius?: number;
-    frosted_glass_enable?: boolean;
-    cursor?: string;
-    enableEvent?: boolean;
-}
+/** 特效与鼠标事件共用的 userData 字段 */
+export interface EffectUserData {
+    stroke_enable?: boolean;
+    stroke_color?: string;
+    stroke_width?: number;
+    glow_enable?: boolean;
+    glow_color?: string;
+    glow_width?: number;
+    glow_opacity?: number;
+    glow_sigma?: number;
+    glow_threshold?: number;
+    glow_iterations?: number;
+    glow_intensity?: number;
+    glow_additive?: boolean;
+    glow_highlight_width?: number;
+    cover_enable?: boolean;
+    cover_color?: string;
+    cover_opacity?: number;
+    cover_depth_test?: boolean;
+    bloom_enable?: boolean;
+    bloom_threshold?: number;
+    bloom_strength?: number;
+    bloom_radius?: number;
+    frosted_glass_enable?: boolean;
+    cursor?: string;
+    enableEvent?: boolean;
+}

package/pass/effectUserData.js

@@ -1 +1 @@
-export {};
+export {};

package/pass/effectUserData.ts

@@ -1,46 +1,46 @@
-/*
- * @Author: software-engineer（寇豆码）
- * @Description: 特效相关 userData 字段的统一类型定义。
- * 覆盖 stroke / glow / cover / bloom / frosted_glass 等 pass 读取的全部开关字段，
- * 以及 ThreeMouse 事件开关（cursor / enableEvent），供各 pass 用 `as EffectUserData`
- * 取代各自内联的 `as { ... }`，避免类型散落与漂移。
- */
-/** 特效与鼠标事件共用的 userData 字段 */
-export interface EffectUserData {
-    // ── stroke（描边）──
-    stroke_enable?: boolean;
-    stroke_color?: string;
-    stroke_width?: number;
-
-    // ── glow（辉光）──
-    glow_enable?: boolean;
-    glow_color?: string;
-    glow_width?: number;
-    glow_opacity?: number;
-    glow_sigma?: number;
-    glow_threshold?: number;
-    glow_iterations?: number;
-    glow_intensity?: number;   // 亮度倍增，可 >1 让光晕很亮（配合 glow_additive 发光叠加更明显）
-    glow_additive?: boolean;   // true=加性混合（发光叠加到画面），false=普通半透明覆盖（默认）
-    glow_highlight_width?: number; // 薄高亮层粗细（像素，默认 2）；始终绘制（=0 时扩张宽为 0、无可见环），无开关参数。
-                                   // 薄高亮层是 glow 的默认行为（贴物体边缘一圈更亮的细线），无需开启参数。
-
-    // ── cover（覆盖）──
-    cover_enable?: boolean;
-    cover_color?: string;
-    cover_opacity?: number;
-    cover_depth_test?: boolean;
-
-    // ── bloom（泛光）──
-    bloom_enable?: boolean;
-    bloom_threshold?: number;
-    bloom_strength?: number;
-    bloom_radius?: number;
-
-    // ── frosted glass（毛玻璃）──
-    frosted_glass_enable?: boolean;
-
-    // ── 鼠标事件开关（ThreeMouse）──
-    cursor?: string;
-    enableEvent?: boolean;
-}
+/*
+ * @Author: software-engineer（寇豆码）
+ * @Description: 特效相关 userData 字段的统一类型定义。
+ * 覆盖 stroke / glow / cover / bloom / frosted_glass 等 pass 读取的全部开关字段，
+ * 以及 ThreeMouse 事件开关（cursor / enableEvent），供各 pass 用 `as EffectUserData`
+ * 取代各自内联的 `as { ... }`，避免类型散落与漂移。
+ */
+/** 特效与鼠标事件共用的 userData 字段 */
+export interface EffectUserData {
+    // ── stroke（描边）──
+    stroke_enable?: boolean;
+    stroke_color?: string;
+    stroke_width?: number;
+
+    // ── glow（辉光）──
+    glow_enable?: boolean;
+    glow_color?: string;
+    glow_width?: number;
+    glow_opacity?: number;
+    glow_sigma?: number;
+    glow_threshold?: number;
+    glow_iterations?: number;
+    glow_intensity?: number;   // 亮度倍增，可 >1 让光晕很亮（配合 glow_additive 发光叠加更明显）
+    glow_additive?: boolean;   // true=加性混合（发光叠加到画面），false=普通半透明覆盖（默认）
+    glow_highlight_width?: number; // 薄高亮层粗细（像素，默认 2）；始终绘制（=0 时扩张宽为 0、无可见环），无开关参数。
+                                   // 薄高亮层是 glow 的默认行为（贴物体边缘一圈更亮的细线），无需开启参数。
+
+    // ── cover（覆盖）──
+    cover_enable?: boolean;
+    cover_color?: string;
+    cover_opacity?: number;
+    cover_depth_test?: boolean;
+
+    // ── bloom（泛光）──
+    bloom_enable?: boolean;
+    bloom_threshold?: number;
+    bloom_strength?: number;
+    bloom_radius?: number;
+
+    // ── frosted glass（毛玻璃）──
+    frosted_glass_enable?: boolean;
+
+    // ── 鼠标事件开关（ThreeMouse）──
+    cursor?: string;
+    enableEvent?: boolean;
+}

package/pass/frosted_glass_pass.d.ts

@@ -1,2 +1,2 @@
-import { DepthTexture, Scene, WebGLRenderTarget, WebGLRenderer, Camera } from "three";
-export default function frosted_glass_pass(renderer: WebGLRenderer, camera: Camera, scene: Scene, baseRenderTarget: WebGLRenderTarget, baseDepthTexture: DepthTexture, devicePixelRatio: number): void;
+import { DepthTexture, Scene, WebGLRenderTarget, WebGLRenderer, Camera } from "three";
+export default function frosted_glass_pass(renderer: WebGLRenderer, camera: Camera, scene: Scene, baseRenderTarget: WebGLRenderTarget, baseDepthTexture: DepthTexture, devicePixelRatio: number): void;

package/pass/frosted_glass_pass.js

@@ -1,56 +1,56 @@
-/*
- * @Author: xiaosihan
- * @Date: 2026-04-21 00:00:00
- * @Last Modified by: xiaosihan
- * @Last Modified time: 2026-04-21 00:00:00
- */
-import { DepthFormat, DepthTexture, LinearFilter, RGBAFormat, Scene, ShaderChunk, ShaderMaterial, UnsignedIntType, Vector2, WebGLRenderTarget } from "three";
-import fsQuad from "./fsQuad";
-import { debugDepthState } from "./debugDepthState";
-const maskTextureTarget = new WebGLRenderTarget(1024, 1024, {
-    minFilter: LinearFilter,
-    magFilter: LinearFilter,
-    format: RGBAFormat,
-    anisotropy: 16,
-});
-const blurTextureTarget = new WebGLRenderTarget(1024, 1024, {
-    minFilter: LinearFilter,
-    magFilter: LinearFilter,
-    format: RGBAFormat,
-    anisotropy: 16,
-});
-const tempBlurTextureTarget = new WebGLRenderTarget(1024, 1024, {
-    minFilter: LinearFilter,
-    magFilter: LinearFilter,
-    format: RGBAFormat,
-    anisotropy: 16,
-});
-// 选中对象的遮罩渲染目标 + 配套深度纹理 + 临时场景：模块级复用，避免每帧 new/dispose 造成 GC 抖动与
-// GPU 资源反复创建销毁（原先在函数内每帧 new 一个 WebGLRenderTarget + DepthTexture + Scene，开销大且不稳）。
-const selectDepthTexture = new DepthTexture(1024, 1024);
-selectDepthTexture.format = DepthFormat;
-selectDepthTexture.type = UnsignedIntType;
-const selectTextureTarget = new WebGLRenderTarget(1024, 1024, {
-    minFilter: LinearFilter,
-    magFilter: LinearFilter,
-    format: RGBAFormat,
-    depthTexture: selectDepthTexture,
-});
-// 临时场景：仅用于把「毛玻璃对象」单独渲进 selectTextureTarget 做遮罩，常驻复用（不每帧 new）。
-const tempScene = new Scene();
-const size = new Vector2();
-const horizontalBlurShader = new ShaderMaterial({
-    uniforms: {
-        tDiffuse: { value: null },
-        h: { value: 1.0 / 512.0 },
-    },
+/*
+ * @Author: xiaosihan
+ * @Date: 2026-04-21 00:00:00
+ * @Last Modified by: xiaosihan
+ * @Last Modified time: 2026-04-21 00:00:00
+ */
+import { DepthFormat, DepthTexture, LinearFilter, RGBAFormat, Scene, ShaderChunk, ShaderMaterial, UnsignedIntType, Vector2, WebGLRenderTarget } from "three";
+import fsQuad from "./fsQuad";
+import { debugDepthState } from "./debugDepthState";
+const maskTextureTarget = new WebGLRenderTarget(1024, 1024, {
+    minFilter: LinearFilter,
+    magFilter: LinearFilter,
+    format: RGBAFormat,
+    anisotropy: 16,
+});
+const blurTextureTarget = new WebGLRenderTarget(1024, 1024, {
+    minFilter: LinearFilter,
+    magFilter: LinearFilter,
+    format: RGBAFormat,
+    anisotropy: 16,
+});
+const tempBlurTextureTarget = new WebGLRenderTarget(1024, 1024, {
+    minFilter: LinearFilter,
+    magFilter: LinearFilter,
+    format: RGBAFormat,
+    anisotropy: 16,
+});
+// 选中对象的遮罩渲染目标 + 配套深度纹理 + 临时场景：模块级复用，避免每帧 new/dispose 造成 GC 抖动与
+// GPU 资源反复创建销毁（原先在函数内每帧 new 一个 WebGLRenderTarget + DepthTexture + Scene，开销大且不稳）。
+const selectDepthTexture = new DepthTexture(1024, 1024);
+selectDepthTexture.format = DepthFormat;
+selectDepthTexture.type = UnsignedIntType;
+const selectTextureTarget = new WebGLRenderTarget(1024, 1024, {
+    minFilter: LinearFilter,
+    magFilter: LinearFilter,
+    format: RGBAFormat,
+    depthTexture: selectDepthTexture,
+});
+// 临时场景：仅用于把「毛玻璃对象」单独渲进 selectTextureTarget 做遮罩，常驻复用（不每帧 new）。
+const tempScene = new Scene();
+const size = new Vector2();
+const horizontalBlurShader = new ShaderMaterial({
+    uniforms: {
+        tDiffuse: { value: null },
+        h: { value: 1.0 / 512.0 },
+    },
     vertexShader: `
         varying vec2 vUv;
         void main() {
             vUv = uv;
             gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
         }
-    `,
+    `,
     fragmentShader: `
         uniform sampler2D tDiffuse;
         uniform float h;
@@ -68,23 +68,23 @@ const horizontalBlurShader = new ShaderMaterial({
             sum += texture2D( tDiffuse, vec2( vUv.x + 4.0 * h, vUv.y ) ) * 0.051;
             gl_FragColor = sum;
         }
-    `,
-    depthTest: false,
-    depthWrite: false,
-    transparent: true,
-});
-const verticalBlurShader = new ShaderMaterial({
-    uniforms: {
-        tDiffuse: { value: null },
-        v: { value: 1.0 / 512.0 },
-    },
+    `,
+    depthTest: false,
+    depthWrite: false,
+    transparent: true,
+});
+const verticalBlurShader = new ShaderMaterial({
+    uniforms: {
+        tDiffuse: { value: null },
+        v: { value: 1.0 / 512.0 },
+    },
     vertexShader: `
         varying vec2 vUv;
         void main() {
             vUv = uv;
             gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
         }
-    `,
+    `,
     fragmentShader: `
         uniform sampler2D tDiffuse;
         uniform float v;
@@ -102,17 +102,17 @@ const verticalBlurShader = new ShaderMaterial({
             sum += texture2D( tDiffuse, vec2( vUv.x, vUv.y + 4.0 * v ) ) * 0.051;
             gl_FragColor = sum;
         }
-    `,
-    depthTest: false,
-    depthWrite: false,
-    transparent: true,
-});
-const depthTestShader = new ShaderMaterial({
-    uniforms: {
-        baseDepth: { value: null },
-        selectDepth: { value: null },
-        cameraFar: { value: 1000.0 },
-    },
+    `,
+    depthTest: false,
+    depthWrite: false,
+    transparent: true,
+});
+const depthTestShader = new ShaderMaterial({
+    uniforms: {
+        baseDepth: { value: null },
+        selectDepth: { value: null },
+        cameraFar: { value: 1000.0 },
+    },
     vertexShader: `
         ${ShaderChunk.common}
         ${ShaderChunk.logdepthbuf_pars_vertex}
@@ -122,7 +122,7 @@ const depthTestShader = new ShaderMaterial({
             gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
             ${ShaderChunk.logdepthbuf_vertex}
         }
-    `,
+    `,
     fragmentShader: `
         ${ShaderChunk.logdepthbuf_pars_fragment}
         uniform sampler2D baseDepth;
@@ -150,23 +150,23 @@ const depthTestShader = new ShaderMaterial({
             gl_FragColor = vec4(1.0, 1.0, 1.0, 1.0);
             ${ShaderChunk.logdepthbuf_fragment}
         }
-    `,
-    depthTest: true,
-    depthWrite: true,
-    transparent: true,
-});
-const frostedGlassShader = new ShaderMaterial({
-    uniforms: {
-        blurTexture: { value: null },
-        maskTexture: { value: null },
-    },
+    `,
+    depthTest: true,
+    depthWrite: true,
+    transparent: true,
+});
+const frostedGlassShader = new ShaderMaterial({
+    uniforms: {
+        blurTexture: { value: null },
+        maskTexture: { value: null },
+    },
     vertexShader: `
         varying vec2 vUv;
         void main() {
             vUv = uv;
             gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
         }
-    `,
+    `,
     fragmentShader: `
         uniform sampler2D blurTexture;
         uniform sampler2D maskTexture;
@@ -185,72 +185,72 @@ const frostedGlassShader = new ShaderMaterial({
             // 否则线性值被编码两次 sRGB，毛玻璃区域整体发白，与 screenCopy 的无损拷贝颜色空间不一致。
             gl_FragColor = texture2D(blurTexture, vUv);
         }
-    `,
-    depthTest: true,
-    depthWrite: true,
-    transparent: false,
-});
-export default function frosted_glass_pass(renderer, camera, scene, baseRenderTarget, baseDepthTexture, devicePixelRatio) {
-    const enabledObjects = [];
-    scene.traverseVisible((obj) => {
-        if (obj.userData.frosted_glass_enable && obj.isMesh) {
-            enabledObjects.push(obj);
-        }
-    });
-    if (enabledObjects.length === 0) {
-        return;
-    }
-    const originRenderTarget = renderer.getRenderTarget();
-    // 灰度图渲染目标跟随主画面尺寸（= width × effectiveRatio），与 baseRenderTarget 完全一致，
-    // 消除灰度图与主画面尺寸不一致导致的放大重采样摩尔纹
-    renderer.getSize(size);
-    size.multiplyScalar(devicePixelRatio);
-    maskTextureTarget.setSize(size.x, size.y);
-    blurTextureTarget.setSize(size.x, size.y);
-    tempBlurTextureTarget.setSize(size.x, size.y);
-    selectTextureTarget.setSize(size.x, size.y);
-    renderer.setRenderTarget(tempBlurTextureTarget);
-    renderer.clear();
-    horizontalBlurShader.uniforms.tDiffuse.value = baseRenderTarget.texture;
-    horizontalBlurShader.uniforms.h.value = 2.5 / size.x;
-    fsQuad.render(renderer, horizontalBlurShader);
-    renderer.setRenderTarget(blurTextureTarget);
-    renderer.clear();
-    verticalBlurShader.uniforms.tDiffuse.value = tempBlurTextureTarget.texture;
-    verticalBlurShader.uniforms.v.value = 2.5 / size.y;
-    fsQuad.render(renderer, verticalBlurShader);
-    renderer.setRenderTarget(tempBlurTextureTarget);
-    renderer.clear();
-    horizontalBlurShader.uniforms.tDiffuse.value = blurTextureTarget.texture;
-    horizontalBlurShader.uniforms.h.value = 2.0 / size.x;
-    fsQuad.render(renderer, horizontalBlurShader);
-    renderer.setRenderTarget(blurTextureTarget);
-    renderer.clear();
-    verticalBlurShader.uniforms.tDiffuse.value = tempBlurTextureTarget.texture;
-    verticalBlurShader.uniforms.v.value = 2.0 / size.y;
-    fsQuad.render(renderer, verticalBlurShader);
-    const parents = enabledObjects.map(obj => obj.parent);
-    // selectTextureTarget / selectDepthTexture / tempScene 已在模块级复用，仅跟随主画面尺寸 resize，不每帧 new。
-    enabledObjects.forEach(obj => tempScene.add(obj));
-    renderer.setRenderTarget(selectTextureTarget);
-    renderer.clear();
-    renderer.render(tempScene, camera);
-    // 调试：记录选区深度，供面板「深度判定图 / 辉光深度比对」排查 frosted 的遮挡判定
-    debugDepthState.lastSelectDepth = selectDepthTexture;
-    renderer.setRenderTarget(maskTextureTarget);
-    renderer.clear();
-    depthTestShader.uniforms.baseDepth.value = baseDepthTexture;
-    depthTestShader.uniforms.selectDepth.value = selectTextureTarget.depthTexture;
-    depthTestShader.uniforms.cameraFar.value = camera.far;
-    fsQuad.render(renderer, depthTestShader);
-    enabledObjects.forEach((obj, i) => {
-        if (parents[i]) {
-            parents[i].add(obj);
-        }
-    });
-    renderer.setRenderTarget(originRenderTarget);
-    renderer.clearDepth();
-    frostedGlassShader.uniforms.blurTexture.value = blurTextureTarget.texture;
-    frostedGlassShader.uniforms.maskTexture.value = maskTextureTarget.texture;
-    fsQuad.render(renderer, frostedGlassShader);
-}
+    `,
+    depthTest: true,
+    depthWrite: true,
+    transparent: false,
+});
+export default function frosted_glass_pass(renderer, camera, scene, baseRenderTarget, baseDepthTexture, devicePixelRatio) {
+    const enabledObjects = [];
+    scene.traverseVisible((obj) => {
+        if (obj.userData.frosted_glass_enable && obj.isMesh) {
+            enabledObjects.push(obj);
+        }
+    });
+    if (enabledObjects.length === 0) {
+        return;
+    }
+    const originRenderTarget = renderer.getRenderTarget();
+    // 灰度图渲染目标跟随主画面尺寸（= width × effectiveRatio），与 baseRenderTarget 完全一致，
+    // 消除灰度图与主画面尺寸不一致导致的放大重采样摩尔纹
+    renderer.getSize(size);
+    size.multiplyScalar(devicePixelRatio);
+    maskTextureTarget.setSize(size.x, size.y);
+    blurTextureTarget.setSize(size.x, size.y);
+    tempBlurTextureTarget.setSize(size.x, size.y);
+    selectTextureTarget.setSize(size.x, size.y);
+    renderer.setRenderTarget(tempBlurTextureTarget);
+    renderer.clear();
+    horizontalBlurShader.uniforms.tDiffuse.value = baseRenderTarget.texture;
+    horizontalBlurShader.uniforms.h.value = 2.5 / size.x;
+    fsQuad.render(renderer, horizontalBlurShader);
+    renderer.setRenderTarget(blurTextureTarget);
+    renderer.clear();
+    verticalBlurShader.uniforms.tDiffuse.value = tempBlurTextureTarget.texture;
+    verticalBlurShader.uniforms.v.value = 2.5 / size.y;
+    fsQuad.render(renderer, verticalBlurShader);
+    renderer.setRenderTarget(tempBlurTextureTarget);
+    renderer.clear();
+    horizontalBlurShader.uniforms.tDiffuse.value = blurTextureTarget.texture;
+    horizontalBlurShader.uniforms.h.value = 2.0 / size.x;
+    fsQuad.render(renderer, horizontalBlurShader);
+    renderer.setRenderTarget(blurTextureTarget);
+    renderer.clear();
+    verticalBlurShader.uniforms.tDiffuse.value = tempBlurTextureTarget.texture;
+    verticalBlurShader.uniforms.v.value = 2.0 / size.y;
+    fsQuad.render(renderer, verticalBlurShader);
+    const parents = enabledObjects.map(obj => obj.parent);
+    // selectTextureTarget / selectDepthTexture / tempScene 已在模块级复用，仅跟随主画面尺寸 resize，不每帧 new。
+    enabledObjects.forEach(obj => tempScene.add(obj));
+    renderer.setRenderTarget(selectTextureTarget);
+    renderer.clear();
+    renderer.render(tempScene, camera);
+    // 调试：记录选区深度，供面板「深度判定图 / 辉光深度比对」排查 frosted 的遮挡判定
+    debugDepthState.lastSelectDepth = selectDepthTexture;
+    renderer.setRenderTarget(maskTextureTarget);
+    renderer.clear();
+    depthTestShader.uniforms.baseDepth.value = baseDepthTexture;
+    depthTestShader.uniforms.selectDepth.value = selectTextureTarget.depthTexture;
+    depthTestShader.uniforms.cameraFar.value = camera.far;
+    fsQuad.render(renderer, depthTestShader);
+    enabledObjects.forEach((obj, i) => {
+        if (parents[i]) {
+            parents[i].add(obj);
+        }
+    });
+    renderer.setRenderTarget(originRenderTarget);
+    renderer.clearDepth();
+    frostedGlassShader.uniforms.blurTexture.value = blurTextureTarget.texture;
+    frostedGlassShader.uniforms.maskTexture.value = maskTextureTarget.texture;
+    fsQuad.render(renderer, frostedGlassShader);
+}