three-base 2.0.142 → 2.0.166

package/shaders/FXAAShaderMaterial.js

@@ -1,15 +1,15 @@
-/*
- * @Author: xiaosihan
- * @Date: 2024-01-20 05:10:37
- * @Last Modified by: xiaosihan
- * @Last Modified time: 2024-01-20 05:10:57
- */
-import { NoBlending, ShaderChunk, ShaderMaterial, Vector2 } from "three";
-const FXAAShaderMaterial = new ShaderMaterial({
-    uniforms: {
-        tDiffuse: { value: null },
-        resolution: { value: new Vector2(1 / 1024, 1 / 1024) }
-    },
+/*
+ * @Author: xiaosihan
+ * @Date: 2024-01-20 05:10:37
+ * @Last Modified by: xiaosihan
+ * @Last Modified time: 2024-01-20 05:10:57
+ */
+import { NoBlending, ShaderChunk, ShaderMaterial, Vector2 } from "three";
+const FXAAShaderMaterial = new ShaderMaterial({
+    uniforms: {
+        tDiffuse: { value: null },
+        resolution: { value: new Vector2(1 / 1024, 1 / 1024) }
+    },
     vertexShader: `
         ${ShaderChunk.common}
         ${ShaderChunk.logdepthbuf_pars_vertex}
@@ -19,7 +19,7 @@ const FXAAShaderMaterial = new ShaderMaterial({
             gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
             ${ShaderChunk.logdepthbuf_vertex}
         }
-    `,
+    `,
     fragmentShader: `
         ${ShaderChunk.logdepthbuf_pars_fragment}
         precision highp float;
@@ -192,10 +192,10 @@ const FXAAShaderMaterial = new ShaderMaterial({
                 );
             ${ShaderChunk.logdepthbuf_fragment}
         }
-    `,
-    blending: NoBlending,
-    depthTest: false,
-    depthWrite: false,
-    transparent: true
-});
-export default FXAAShaderMaterial;
+    `,
+    blending: NoBlending,
+    depthTest: false,
+    depthWrite: false,
+    transparent: true
+});
+export default FXAAShaderMaterial;

package/shaders/baseDepthVisShader.d.ts

@@ -1,11 +1,11 @@
-import { ShaderMaterial } from "three";
-/**
- * 调试用：把 baseDepthTexture（可见深度图）直接以灰度输出到屏幕。
- * 对数深度：近=0(黑) 远=1(白)。
- *   - 全屏纯白  → 深度图为空（全 clear 1.0），说明 renderAoDepthPass 没把深度写进 baseDepthTexture；
- *                 此时所有依赖深度遮挡的后处理(stroke/glow/cover/frosted)都会"一律显示在前"。
- *   - 有灰阶/明暗  → 深度图正常，问题在比对侧(selectDepth / depthTestShader)。
- * 触发：在控制台执行 `window.__BASE_DEPTH_VIS = true` 后画面即切到该视图。
- */
-declare const baseDepthVisShader: ShaderMaterial;
-export default baseDepthVisShader;
+import { ShaderMaterial } from "three";
+/**
+ * 调试用：把 baseDepthTexture（可见深度图）直接以灰度输出到屏幕。
+ * 对数深度：近=0(黑) 远=1(白)。
+ *   - 全屏纯白  → 深度图为空（全 clear 1.0），说明 renderAoDepthPass 没把深度写进 baseDepthTexture；
+ *                 此时所有依赖深度遮挡的后处理(stroke/glow/cover/frosted)都会"一律显示在前"。
+ *   - 有灰阶/明暗  → 深度图正常，问题在比对侧(selectDepth / depthTestShader)。
+ * 触发：在控制台执行 `window.__BASE_DEPTH_VIS = true` 后画面即切到该视图。
+ */
+declare const baseDepthVisShader: ShaderMaterial;
+export default baseDepthVisShader;

package/shaders/baseDepthVisShader.js

@@ -1,36 +1,36 @@
-import { ShaderChunk, ShaderMaterial } from "three";
-/**
- * 调试用：把 baseDepthTexture（可见深度图）直接以灰度输出到屏幕。
- * 对数深度：近=0(黑) 远=1(白)。
- *   - 全屏纯白  → 深度图为空（全 clear 1.0），说明 renderAoDepthPass 没把深度写进 baseDepthTexture；
- *                 此时所有依赖深度遮挡的后处理(stroke/glow/cover/frosted)都会"一律显示在前"。
- *   - 有灰阶/明暗  → 深度图正常，问题在比对侧(selectDepth / depthTestShader)。
- * 触发：在控制台执行 `window.__BASE_DEPTH_VIS = true` 后画面即切到该视图。
- */
-const baseDepthVisShader = new ShaderMaterial({
-    uniforms: {
-        tDepth: { 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: `
-        uniform sampler2D tDepth;
-        varying vec2 vUv;
-        void main() {
-            float d = texture2D(tDepth, vUv).r;
-            gl_FragColor = vec4(d, d, d, 1.0);
-        }
-    `,
-    depthTest: false,
-    depthWrite: false,
-    transparent: true,
-});
-export default baseDepthVisShader;
+import { ShaderChunk, ShaderMaterial } from "three";
+/**
+ * 调试用：把 baseDepthTexture（可见深度图）直接以灰度输出到屏幕。
+ * 对数深度：近=0(黑) 远=1(白)。
+ *   - 全屏纯白  → 深度图为空（全 clear 1.0），说明 renderAoDepthPass 没把深度写进 baseDepthTexture；
+ *                 此时所有依赖深度遮挡的后处理(stroke/glow/cover/frosted)都会"一律显示在前"。
+ *   - 有灰阶/明暗  → 深度图正常，问题在比对侧(selectDepth / depthTestShader)。
+ * 触发：在控制台执行 `window.__BASE_DEPTH_VIS = true` 后画面即切到该视图。
+ */
+const baseDepthVisShader = new ShaderMaterial({
+    uniforms: {
+        tDepth: { 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: `
+        uniform sampler2D tDepth;
+        varying vec2 vUv;
+        void main() {
+            float d = texture2D(tDepth, vUv).r;
+            gl_FragColor = vec4(d, d, d, 1.0);
+        }
+    `,
+    depthTest: false,
+    depthWrite: false,
+    transparent: true,
+});
+export default baseDepthVisShader;

package/shaders/baseDepthVisShader.ts

@@ -1,36 +1,36 @@
-import { ShaderChunk, ShaderMaterial } from "three";
-/**
- * 调试用：把 baseDepthTexture（可见深度图）直接以灰度输出到屏幕。
- * 对数深度：近=0(黑) 远=1(白)。
- *   - 全屏纯白  → 深度图为空（全 clear 1.0），说明 renderAoDepthPass 没把深度写进 baseDepthTexture；
- *                 此时所有依赖深度遮挡的后处理(stroke/glow/cover/frosted)都会"一律显示在前"。
- *   - 有灰阶/明暗  → 深度图正常，问题在比对侧(selectDepth / depthTestShader)。
- * 触发：在控制台执行 `window.__BASE_DEPTH_VIS = true` 后画面即切到该视图。
- */
-const baseDepthVisShader = new ShaderMaterial({
-    uniforms: {
-        tDepth: { value: null as unknown as import("three").Texture },
-    },
-    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: `
-        uniform sampler2D tDepth;
-        varying vec2 vUv;
-        void main() {
-            float d = texture2D(tDepth, vUv).r;
-            gl_FragColor = vec4(d, d, d, 1.0);
-        }
-    `,
-    depthTest: false,
-    depthWrite: false,
-    transparent: true,
-});
-export default baseDepthVisShader;
+import { ShaderChunk, ShaderMaterial } from "three";
+/**
+ * 调试用：把 baseDepthTexture（可见深度图）直接以灰度输出到屏幕。
+ * 对数深度：近=0(黑) 远=1(白)。
+ *   - 全屏纯白  → 深度图为空（全 clear 1.0），说明 renderAoDepthPass 没把深度写进 baseDepthTexture；
+ *                 此时所有依赖深度遮挡的后处理(stroke/glow/cover/frosted)都会"一律显示在前"。
+ *   - 有灰阶/明暗  → 深度图正常，问题在比对侧(selectDepth / depthTestShader)。
+ * 触发：在控制台执行 `window.__BASE_DEPTH_VIS = true` 后画面即切到该视图。
+ */
+const baseDepthVisShader = new ShaderMaterial({
+    uniforms: {
+        tDepth: { value: null as unknown as import("three").Texture },
+    },
+    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: `
+        uniform sampler2D tDepth;
+        varying vec2 vUv;
+        void main() {
+            float d = texture2D(tDepth, vUv).r;
+            gl_FragColor = vec4(d, d, d, 1.0);
+        }
+    `,
+    depthTest: false,
+    depthWrite: false,
+    transparent: true,
+});
+export default baseDepthVisShader;

package/shaders/baseTextureToRenderShader.d.ts

@@ -1,2 +1,2 @@
-import { ShaderMaterial } from "three";
-export declare const baseTextureToRenderShader: ShaderMaterial;
+import { ShaderMaterial } from "three";
+export declare const baseTextureToRenderShader: ShaderMaterial;

package/shaders/baseTextureToRenderShader.js

@@ -1,11 +1,11 @@
-import { ShaderMaterial, Vector2, ShaderChunk, NoBlending } from "three";
-export const baseTextureToRenderShader = new ShaderMaterial({
-    uniforms: {
-        tDiffuse: { value: null },
-        resolution: { value: new Vector2(1 / 1024, 1 / 1024) },
-        /** 抖动强度：1.0 = 标准 ±0.5 LSB（总跨度 1/255），0 = 关闭（A/B 对比用） */
-        uDitherStrength: { value: 1.0 }
-    },
+import { ShaderMaterial, Vector2, ShaderChunk, NoBlending } from "three";
+export const baseTextureToRenderShader = new ShaderMaterial({
+    uniforms: {
+        tDiffuse: { value: null },
+        resolution: { value: new Vector2(1 / 1024, 1 / 1024) },
+        /** 抖动强度：1.0 = 标准 ±0.5 LSB（总跨度 1/255），0 = 关闭（A/B 对比用） */
+        uDitherStrength: { value: 1.0 }
+    },
     vertexShader: `
         ${ShaderChunk.common}
         ${ShaderChunk.logdepthbuf_pars_vertex}
@@ -15,7 +15,7 @@ export const baseTextureToRenderShader = new ShaderMaterial({
             gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
             ${ShaderChunk.logdepthbuf_vertex}
         }
-    `,
+    `,
     fragmentShader: `
         ${ShaderChunk.logdepthbuf_pars_fragment}
         precision highp float;
@@ -220,13 +220,13 @@ export const baseTextureToRenderShader = new ShaderMaterial({
                 gl_FragColor = vec4(srgbColor.rgb + dither, srgbColor.a);
             ${ShaderChunk.logdepthbuf_fragment}
         }
-    `,
-    blending: NoBlending,
-    depthTest: false,
-    depthWrite: false,
-    transparent: true,
-    // 终处理：手写 sRGBTransferOETF 已是唯一一次 sRGB 编码；关闭 three 的自动 tonemap/colorspace 注入，
-    // 防止渲染到屏幕时被 three 再编码一次（本 ShaderMaterial 不写 include 块，three 本就不会注入，
-    // 这里显式置 false 仅是防御，保证颜色空间语义单一可控）。
-    toneMapped: false,
-});
+    `,
+    blending: NoBlending,
+    depthTest: false,
+    depthWrite: false,
+    transparent: true,
+    // 终处理：手写 sRGBTransferOETF 已是唯一一次 sRGB 编码；关闭 three 的自动 tonemap/colorspace 注入，
+    // 防止渲染到屏幕时被 three 再编码一次（本 ShaderMaterial 不写 include 块，three 本就不会注入，
+    // 这里显式置 false 仅是防御，保证颜色空间语义单一可控）。
+    toneMapped: false,
+});

package/shaders/copyShader.d.ts

@@ -1,3 +1,3 @@
-import { ShaderMaterial } from "three";
-declare const copyShader: ShaderMaterial;
-export default copyShader;
+import { ShaderMaterial } from "three";
+declare const copyShader: ShaderMaterial;
+export default copyShader;

package/shaders/copyShader.js

@@ -1,9 +1,9 @@
-import { ShaderChunk, ShaderMaterial } from "three";
-const copyShader = new ShaderMaterial({
-    uniforms: {
-        map: { value: null },
-        opacity: { value: 1 },
-    },
+import { ShaderChunk, ShaderMaterial } from "three";
+const copyShader = new ShaderMaterial({
+    uniforms: {
+        map: { value: null },
+        opacity: { value: 1 },
+    },
     vertexShader: `
           ${ShaderChunk.common}
           ${ShaderChunk.logdepthbuf_pars_vertex}
@@ -13,7 +13,7 @@ const copyShader = new ShaderMaterial({
               gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
               ${ShaderChunk.logdepthbuf_vertex}
           }
-      `,
+      `,
     fragmentShader: `
           ${ShaderChunk.logdepthbuf_pars_fragment}
           uniform float opacity;
@@ -24,9 +24,9 @@ const copyShader = new ShaderMaterial({
               gl_FragColor.a *= opacity;
               ${ShaderChunk.logdepthbuf_fragment}
           }
-      `,
-    depthTest: true,
-    depthWrite: true,
-    transparent: true,
-});
-export default copyShader;
+      `,
+    depthTest: true,
+    depthWrite: true,
+    transparent: true,
+});
+export default copyShader;

package/shaders/debugDepthCompareShader.d.ts

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

package/shaders/debugDepthCompareShader.js

@@ -1,49 +1,49 @@
-import { ShaderChunk, ShaderMaterial } from "three";
-/**
- * 调试用：把「全局 base 深度」与「最近一次 glow/stroke 选区的 select 深度」并排显示，
- * 用于排查"深度测试全部失效"根因：
- *   R = 全局 base 深度（baseDepthTexture，排除地板）
- *   G = 选区自身深度（selectDepthTexture，由 glow_pass/stroke_pass 渲染后写入 debugDepthState）
- * 两路都用 `pow(cameraFar+1, d)-1` 反推到近似线性视深再归一化（背景≈1 → 黄白）。
- *   - R 全白、G 也有内容 → 全局 base 深度没写进（renderAoDepthPass 失效），但选区深度正常；
- *   - R、G 都全白       → 两路深度都没写进；
- *   - R 有灰阶、G 全白   → 选区深度没写进（glow/stroke 自身的深度 pass 失效）；
- *   - R、G 都有灰阶      → 深度正常，问题在 depthTestShader 比对侧。
- */
-const debugDepthCompareShader = new ShaderMaterial({
-    uniforms: {
-        tBase: { value: null },
-        tSelect: { 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 tBase;
-        uniform sampler2D tSelect;
-        uniform float cameraFar;
-        varying vec2 vUv;
-        void main() {
-            float baseD = texture2D(tBase, vUv).r;
-            float selD = texture2D(tSelect, vUv).r;
-            // 与 stroke_pass 的 __STROKE_DEPTH_VIS 同一反推公式，保证两座视图语义一致
-            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);
-            ${ShaderChunk.logdepthbuf_fragment}
-        }
-    `,
-    depthTest: false,
-    depthWrite: false,
-    transparent: true,
-});
-export default debugDepthCompareShader;
+import { ShaderChunk, ShaderMaterial } from "three";
+/**
+ * 调试用：把「全局 base 深度」与「最近一次 glow/stroke 选区的 select 深度」并排显示，
+ * 用于排查"深度测试全部失效"根因：
+ *   R = 全局 base 深度（baseDepthTexture，排除地板）
+ *   G = 选区自身深度（selectDepthTexture，由 glow_pass/stroke_pass 渲染后写入 debugDepthState）
+ * 两路都用 `pow(cameraFar+1, d)-1` 反推到近似线性视深再归一化（背景≈1 → 黄白）。
+ *   - R 全白、G 也有内容 → 全局 base 深度没写进（renderAoDepthPass 失效），但选区深度正常；
+ *   - R、G 都全白       → 两路深度都没写进；
+ *   - R 有灰阶、G 全白   → 选区深度没写进（glow/stroke 自身的深度 pass 失效）；
+ *   - R、G 都有灰阶      → 深度正常，问题在 depthTestShader 比对侧。
+ */
+const debugDepthCompareShader = new ShaderMaterial({
+    uniforms: {
+        tBase: { value: null },
+        tSelect: { 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 tBase;
+        uniform sampler2D tSelect;
+        uniform float cameraFar;
+        varying vec2 vUv;
+        void main() {
+            float baseD = texture2D(tBase, vUv).r;
+            float selD = texture2D(tSelect, vUv).r;
+            // 与 stroke_pass 的 __STROKE_DEPTH_VIS 同一反推公式，保证两座视图语义一致
+            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);
+            ${ShaderChunk.logdepthbuf_fragment}
+        }
+    `,
+    depthTest: false,
+    depthWrite: false,
+    transparent: true,
+});
+export default debugDepthCompareShader;

package/shaders/debugDepthCompareShader.ts

@@ -1,50 +1,50 @@
-import { ShaderChunk, ShaderMaterial } from "three";
-
-/**
- * 调试用：把「全局 base 深度」与「最近一次 glow/stroke 选区的 select 深度」并排显示，
- * 用于排查"深度测试全部失效"根因：
- *   R = 全局 base 深度（baseDepthTexture，排除地板）
- *   G = 选区自身深度（selectDepthTexture，由 glow_pass/stroke_pass 渲染后写入 debugDepthState）
- * 两路都用 `pow(cameraFar+1, d)-1` 反推到近似线性视深再归一化（背景≈1 → 黄白）。
- *   - R 全白、G 也有内容 → 全局 base 深度没写进（renderAoDepthPass 失效），但选区深度正常；
- *   - R、G 都全白       → 两路深度都没写进；
- *   - R 有灰阶、G 全白   → 选区深度没写进（glow/stroke 自身的深度 pass 失效）；
- *   - R、G 都有灰阶      → 深度正常，问题在 depthTestShader 比对侧。
- */
-const debugDepthCompareShader = new ShaderMaterial({
-    uniforms: {
-        tBase: { value: null as unknown as import("three").Texture },
-        tSelect: { value: null as unknown as import("three").Texture },
-        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 tBase;
-        uniform sampler2D tSelect;
-        uniform float cameraFar;
-        varying vec2 vUv;
-        void main() {
-            float baseD = texture2D(tBase, vUv).r;
-            float selD = texture2D(tSelect, vUv).r;
-            // 与 stroke_pass 的 __STROKE_DEPTH_VIS 同一反推公式，保证两座视图语义一致
-            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);
-            ${ShaderChunk.logdepthbuf_fragment}
-        }
-    `,
-    depthTest: false,
-    depthWrite: false,
-    transparent: true,
-});
-export default debugDepthCompareShader;
+import { ShaderChunk, ShaderMaterial } from "three";
+
+/**
+ * 调试用：把「全局 base 深度」与「最近一次 glow/stroke 选区的 select 深度」并排显示，
+ * 用于排查"深度测试全部失效"根因：
+ *   R = 全局 base 深度（baseDepthTexture，排除地板）
+ *   G = 选区自身深度（selectDepthTexture，由 glow_pass/stroke_pass 渲染后写入 debugDepthState）
+ * 两路都用 `pow(cameraFar+1, d)-1` 反推到近似线性视深再归一化（背景≈1 → 黄白）。
+ *   - R 全白、G 也有内容 → 全局 base 深度没写进（renderAoDepthPass 失效），但选区深度正常；
+ *   - R、G 都全白       → 两路深度都没写进；
+ *   - R 有灰阶、G 全白   → 选区深度没写进（glow/stroke 自身的深度 pass 失效）；
+ *   - R、G 都有灰阶      → 深度正常，问题在 depthTestShader 比对侧。
+ */
+const debugDepthCompareShader = new ShaderMaterial({
+    uniforms: {
+        tBase: { value: null as unknown as import("three").Texture },
+        tSelect: { value: null as unknown as import("three").Texture },
+        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 tBase;
+        uniform sampler2D tSelect;
+        uniform float cameraFar;
+        varying vec2 vUv;
+        void main() {
+            float baseD = texture2D(tBase, vUv).r;
+            float selD = texture2D(tSelect, vUv).r;
+            // 与 stroke_pass 的 __STROKE_DEPTH_VIS 同一反推公式，保证两座视图语义一致
+            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);
+            ${ShaderChunk.logdepthbuf_fragment}
+        }
+    `,
+    depthTest: false,
+    depthWrite: false,
+    transparent: true,
+});
+export default debugDepthCompareShader;

package/shaders/debugDepthJudgeShader.d.ts

@@ -1,18 +1,18 @@
-import { ShaderMaterial } from "three";
-/**
- * 调试用：把「深度测试判定」本身画出来，用于定位"后处理深度测试全部失效"。
- *
- * 通道语义（全部为**原始**深度值，不做对数反解，避免饱和丢信息）：
- *   R = 全局 base 深度（baseDepthTexture，排除地板）
- *   G = 选区自身深度（selectDepthTexture，glow/stroke 渲染后写入 debugDepthState）
- *   B = 判定结果：baseD < selD - bias ? 1 : 0
- *       与 stroke_pass 的 depthTestShader 同一判定式（bias = 0.0006）：
- *       1(蓝) = 判为被更近物体挡住 → 该像素应 discard；0(黑) = 不丢弃。
- *
- * 判读：
- *   - 物体区域（G 明显暗于 1.0 的像素）B 全黑   → 判定从不触发，后处理必"一律显示在最前"；
- *     再看该区域 R 与 G 谁大：R 反而比 G 大（base 比 select 还远）→ base 深度图里缺了遮挡物。
- *   - 物体区域 B 有蓝 → 判定本身正常，问题在后续合成（叠加顺序/混合）。
- */
-declare const debugDepthJudgeShader: ShaderMaterial;
-export default debugDepthJudgeShader;
+import { ShaderMaterial } from "three";
+/**
+ * 调试用：把「深度测试判定」本身画出来，用于定位"后处理深度测试全部失效"。
+ *
+ * 通道语义（全部为**原始**深度值，不做对数反解，避免饱和丢信息）：
+ *   R = 全局 base 深度（baseDepthTexture，排除地板）
+ *   G = 选区自身深度（selectDepthTexture，glow/stroke 渲染后写入 debugDepthState）
+ *   B = 判定结果：baseD < selD - bias ? 1 : 0
+ *       与 stroke_pass 的 depthTestShader 同一判定式（bias = 0.0006）：
+ *       1(蓝) = 判为被更近物体挡住 → 该像素应 discard；0(黑) = 不丢弃。
+ *
+ * 判读：
+ *   - 物体区域（G 明显暗于 1.0 的像素）B 全黑   → 判定从不触发，后处理必"一律显示在最前"；
+ *     再看该区域 R 与 G 谁大：R 反而比 G 大（base 比 select 还远）→ base 深度图里缺了遮挡物。
+ *   - 物体区域 B 有蓝 → 判定本身正常，问题在后续合成（叠加顺序/混合）。
+ */
+declare const debugDepthJudgeShader: ShaderMaterial;
+export default debugDepthJudgeShader;