three-base 2.0.129 → 2.0.134

package/pass/cover_pass.js

@@ -1,55 +1,55 @@
-/*
- * @Author: xiaosihan
- * @Date: 2024-09-23 21:07:06
- * @Last Modified by: xiaosihan
- * @Last Modified time: 2025-01-28 04:01:58
- */
-/*
- * @Author: xiaosihan
- * @Date: 2023-05-09 00:35:17
- * @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 fsQuad from "./fsQuad";
-// 选中对象的深度纹理
-const selectDepthTexture = (() => {
-    const baseDepthTexture = new DepthTexture(1024, 1024);
-    baseDepthTexture.format = DepthFormat;
-    baseDepthTexture.type = UnsignedShortType;
-    baseDepthTexture.anisotropy = 16;
-    return baseDepthTexture;
-})();
-// 选中对象的纹理
-const selectTextureTarget = new WebGLRenderTarget(512, 512, {
-    minFilter: LinearFilter,
-    magFilter: LinearFilter,
-    format: RGBAFormat,
-    depthTexture: selectDepthTexture,
-    anisotropy: 16,
-});
-// 深度测试后的选中纹理
-const selectDethpTestTextureTarget = new WebGLRenderTarget(512, 512, {
-    minFilter: LinearFilter,
-    magFilter: LinearFilter,
-    format: RGBAFormat,
-    anisotropy: 16,
-});
-const blur1TextureTarget = new WebGLRenderTarget(512, 512, {
-    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 }, // 选中的对象深度纹理
-    },
+/*
+ * @Author: xiaosihan
+ * @Date: 2024-09-23 21:07:06
+ * @Last Modified by: xiaosihan
+ * @Last Modified time: 2025-01-28 04:01:58
+ */
+/*
+ * @Author: xiaosihan
+ * @Date: 2023-05-09 00:35:17
+ * @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 fsQuad from "./fsQuad";
+// 选中对象的深度纹理
+const selectDepthTexture = (() => {
+    const baseDepthTexture = new DepthTexture(1024, 1024);
+    baseDepthTexture.format = DepthFormat;
+    baseDepthTexture.type = UnsignedShortType;
+    baseDepthTexture.anisotropy = 16;
+    return baseDepthTexture;
+})();
+// 选中对象的纹理
+const selectTextureTarget = new WebGLRenderTarget(512, 512, {
+    minFilter: LinearFilter,
+    magFilter: LinearFilter,
+    format: RGBAFormat,
+    depthTexture: selectDepthTexture,
+    anisotropy: 16,
+});
+// 深度测试后的选中纹理
+const selectDethpTestTextureTarget = new WebGLRenderTarget(512, 512, {
+    minFilter: LinearFilter,
+    magFilter: LinearFilter,
+    format: RGBAFormat,
+    anisotropy: 16,
+});
+const blur1TextureTarget = new WebGLRenderTarget(512, 512, {
+    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 }, // 选中的对象深度纹理
+    },
     vertexShader: `
         ${ShaderChunk.common}
         ${ShaderChunk.logdepthbuf_pars_vertex}
@@ -61,7 +61,7 @@ const depthTestShader = new ShaderMaterial({
             gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
             ${ShaderChunk.logdepthbuf_vertex}
         }
-    `,
+    `,
     fragmentShader: `
         ${ShaderChunk.logdepthbuf_pars_fragment}
         uniform vec3 color;
@@ -89,45 +89,45 @@ const depthTestShader = new ShaderMaterial({
 
             ${ShaderChunk.logdepthbuf_fragment}
         }
-    `,
-    depthTest: true,
-    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;
-    if (!cover_enable || cover_opacity === 0) {
-        return;
-    }
-    // 保存原帧缓冲区
-    const originRenderTarget = renderer.getRenderTarget();
-    // 设置选中目标的帧缓冲区
-    renderer.getSize(size);
-    size.multiplyScalar(devicePixelRatio);
-    selectTextureTarget.setSize(size.x, size.y);
-    selectDethpTestTextureTarget.setSize(size.x, size.y);
-    blur1TextureTarget.setSize(size.x, size.y);
-    renderer.setRenderTarget(selectTextureTarget);
-    scene.children = [object3d];
-    renderer.clear();
-    renderer.render(scene, camera);
-    //更具深度测试绘制叠加颜色
-    renderer.setRenderTarget(originRenderTarget);
-    renderer.clearDepth();
-    depthTestShader.uniforms.color.value.set(cover_color);
-    depthTestShader.uniforms.opacity.value = cover_opacity;
-    depthTestShader.uniforms.depthTest.value = cover_depth_test;
-    depthTestShader.uniforms.baseDepth.value = baseDepthTexture;
-    depthTestShader.uniforms.selectDepth.value = selectDepthTexture;
-    fsQuad.render(renderer, depthTestShader);
-    // 调试代码
-    // renderer.setRenderTarget(null);
-    // renderer.clearDepth();
-    // copyShader.uniforms.map.value = blur2TextureTarget.texture;
-    // fsQuad.render(renderer, copyShader);
-    // return;
-}
+    `,
+    depthTest: true,
+    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;
+    if (!cover_enable || cover_opacity === 0) {
+        return;
+    }
+    // 保存原帧缓冲区
+    const originRenderTarget = renderer.getRenderTarget();
+    // 设置选中目标的帧缓冲区
+    renderer.getSize(size);
+    size.multiplyScalar(devicePixelRatio);
+    selectTextureTarget.setSize(size.x, size.y);
+    selectDethpTestTextureTarget.setSize(size.x, size.y);
+    blur1TextureTarget.setSize(size.x, size.y);
+    renderer.setRenderTarget(selectTextureTarget);
+    scene.children = [object3d];
+    renderer.clear();
+    renderer.render(scene, camera);
+    //更具深度测试绘制叠加颜色
+    renderer.setRenderTarget(originRenderTarget);
+    renderer.clearDepth();
+    depthTestShader.uniforms.color.value.set(cover_color);
+    depthTestShader.uniforms.opacity.value = cover_opacity;
+    depthTestShader.uniforms.depthTest.value = cover_depth_test;
+    depthTestShader.uniforms.baseDepth.value = baseDepthTexture;
+    depthTestShader.uniforms.selectDepth.value = selectDepthTexture;
+    fsQuad.render(renderer, depthTestShader);
+    // 调试代码
+    // renderer.setRenderTarget(null);
+    // renderer.clearDepth();
+    // copyShader.uniforms.map.value = blur2TextureTarget.texture;
+    // fsQuad.render(renderer, copyShader);
+    // return;
+}

package/pass/frosted_glass_pass.d.ts

@@ -0,0 +1,2 @@
+import { Camera, DepthTexture, Scene, WebGLRenderTarget, WebGLRenderer } 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

@@ -0,0 +1,275 @@
+/*
+ * @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, UnsignedShortType, Vector2, WebGLRenderTarget } from "three";
+import fsQuad from "./fsQuad";
+// 深度测试后的毛玻璃遮罩纹理
+const maskTextureTarget = new WebGLRenderTarget(512, 512, {
+    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,
+});
+const size = new Vector2();
+// 水平模糊着色器（使用 three.js 风格的高斯模糊）
+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;
+        varying vec2 vUv;
+        void main() {
+            vec4 sum = vec4( 0.0 );
+            sum += texture2D( tDiffuse, vec2( vUv.x - 4.0 * h, vUv.y ) ) * 0.051;
+            sum += texture2D( tDiffuse, vec2( vUv.x - 3.0 * h, vUv.y ) ) * 0.0918;
+            sum += texture2D( tDiffuse, vec2( vUv.x - 2.0 * h, vUv.y ) ) * 0.12245;
+            sum += texture2D( tDiffuse, vec2( vUv.x - 1.0 * h, vUv.y ) ) * 0.1531;
+            sum += texture2D( tDiffuse, vec2( vUv.x, vUv.y ) ) * 0.1633;
+            sum += texture2D( tDiffuse, vec2( vUv.x + 1.0 * h, vUv.y ) ) * 0.1531;
+            sum += texture2D( tDiffuse, vec2( vUv.x + 2.0 * h, vUv.y ) ) * 0.12245;
+            sum += texture2D( tDiffuse, vec2( vUv.x + 3.0 * h, vUv.y ) ) * 0.0918;
+            sum += texture2D( tDiffuse, vec2( vUv.x + 4.0 * h, vUv.y ) ) * 0.051;
+            gl_FragColor = sum;
+        }
+    `,
+    depthTest: false,
+    depthWrite: false,
+    transparent: true,
+});
+// 垂直模糊着色器（使用 three.js 风格的高斯模糊）
+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;
+        varying vec2 vUv;
+        void main() {
+            vec4 sum = vec4( 0.0 );
+            sum += texture2D( tDiffuse, vec2( vUv.x, vUv.y - 4.0 * v ) ) * 0.051;
+            sum += texture2D( tDiffuse, vec2( vUv.x, vUv.y - 3.0 * v ) ) * 0.0918;
+            sum += texture2D( tDiffuse, vec2( vUv.x, vUv.y - 2.0 * v ) ) * 0.12245;
+            sum += texture2D( tDiffuse, vec2( vUv.x, vUv.y - 1.0 * v ) ) * 0.1531;
+            sum += texture2D( tDiffuse, vec2( vUv.x, vUv.y ) ) * 0.1633;
+            sum += texture2D( tDiffuse, vec2( vUv.x, vUv.y + 1.0 * v ) ) * 0.1531;
+            sum += texture2D( tDiffuse, vec2( vUv.x, vUv.y + 2.0 * v ) ) * 0.12245;
+            sum += texture2D( tDiffuse, vec2( vUv.x, vUv.y + 3.0 * v ) ) * 0.0918;
+            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 }, // 毛玻璃对象的深度纹理
+    },
+    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 baseDepth;
+        uniform sampler2D selectDepth;
+        varying vec2 vUv;
+        void main() {
+            // 毛玻璃对象深度
+            float selectDepthValue = texture2D(selectDepth, vUv).r;
+            // 场景深度
+            float baseDepthValue = texture2D(baseDepth, vUv).r;
+
+            // 背景是空的时候丢弃（没有场景物体可模糊）
+            if(baseDepthValue >= 1.0){
+                discard;
+            }
+            // 毛玻璃对象深度远于场景深度时丢弃（被场景物体遮挡的部分不显示）
+            if(selectDepthValue > baseDepthValue){
+                discard;
+            }
+            // 输出白色遮罩，alpha=1
+            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 }, // 深度遮罩纹理
+    },
+    vertexShader: `
+        varying vec2 vUv;
+        void main() {
+            vUv = uv;
+            gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
+        }
+    `,
+    fragmentShader: `
+        uniform sampler2D blurTexture;
+        uniform sampler2D maskTexture;
+        varying vec2 vUv;
+
+        void main() {
+            // 采样遮罩纹理
+            vec4 mask = texture2D(maskTexture, vUv);
+
+            // 遮罩区域为空时丢弃（非毛玻璃区域）
+            if(mask.a < 0.01){
+                discard;
+            }
+
+            // 在遮罩区域使用模糊后的纹理
+            gl_FragColor = sRGBTransferOETF(texture2D(blurTexture, vUv));
+        }
+    `,
+    depthTest: true,
+    depthWrite: true,
+    transparent: false,
+});
+// 毛玻璃后处理通道
+export default function frosted_glass_pass(renderer, camera, scene, baseRenderTarget, baseDepthTexture, devicePixelRatio) {
+    // 收集所有启用了毛玻璃特效的 Mesh 对象
+    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();
+    // 按实际渲染尺寸调整所有 RenderTarget
+    renderer.getSize(size);
+    size.multiplyScalar(devicePixelRatio);
+    maskTextureTarget.setSize(size.x, size.y);
+    blurTextureTarget.setSize(size.x, size.y);
+    tempBlurTextureTarget.setSize(size.x, size.y);
+    // ========== 第一步：对全场景纹理做高斯模糊（两遍，增强模糊效果） ==========
+    // 1. 第一阶段水平模糊
+    renderer.setRenderTarget(tempBlurTextureTarget);
+    renderer.clear();
+    horizontalBlurShader.uniforms.tDiffuse.value = baseRenderTarget.texture;
+    horizontalBlurShader.uniforms.h.value = 2.5 / size.x;
+    fsQuad.render(renderer, horizontalBlurShader);
+    // 2. 第一阶段垂直模糊
+    renderer.setRenderTarget(blurTextureTarget);
+    renderer.clear();
+    verticalBlurShader.uniforms.tDiffuse.value = tempBlurTextureTarget.texture;
+    verticalBlurShader.uniforms.v.value = 2.5 / size.y;
+    fsQuad.render(renderer, verticalBlurShader);
+    // 3. 第二阶段水平模糊
+    renderer.setRenderTarget(tempBlurTextureTarget);
+    renderer.clear();
+    horizontalBlurShader.uniforms.tDiffuse.value = blurTextureTarget.texture;
+    horizontalBlurShader.uniforms.h.value = 2.0 / size.x;
+    fsQuad.render(renderer, horizontalBlurShader);
+    // 4. 第二阶段垂直模糊
+    renderer.setRenderTarget(blurTextureTarget);
+    renderer.clear();
+    verticalBlurShader.uniforms.tDiffuse.value = tempBlurTextureTarget.texture;
+    verticalBlurShader.uniforms.v.value = 2.0 / size.y;
+    fsQuad.render(renderer, verticalBlurShader);
+    // ========== 第二步：渲染毛玻璃对象，提取深度遮罩 ==========
+    // 记录原始 parent，渲染完恢复
+    const parents = enabledObjects.map(obj => obj.parent);
+    // 临时 RenderTarget 用于渲染毛玻璃对象（需要深度纹理）
+    const selectDepthTexture = new DepthTexture(Math.round(size.x), Math.round(size.y));
+    selectDepthTexture.format = DepthFormat;
+    selectDepthTexture.type = UnsignedShortType;
+    const selectTextureTarget = new WebGLRenderTarget(Math.round(size.x), Math.round(size.y), {
+        minFilter: LinearFilter,
+        magFilter: LinearFilter,
+        format: RGBAFormat,
+        depthTexture: selectDepthTexture,
+    });
+    const tempScene = new Scene();
+    enabledObjects.forEach(obj => tempScene.add(obj));
+    renderer.setRenderTarget(selectTextureTarget);
+    renderer.clear();
+    renderer.render(tempScene, camera);
+    // 用深度测试 shader 生成遮罩
+    renderer.setRenderTarget(maskTextureTarget);
+    renderer.clear();
+    depthTestShader.uniforms.baseDepth.value = baseDepthTexture;
+    depthTestShader.uniforms.selectDepth.value = selectTextureTarget.depthTexture;
+    fsQuad.render(renderer, depthTestShader);
+    // 恢复所有对象的 parent
+    enabledObjects.forEach((obj, i) => {
+        if (parents[i]) {
+            parents[i].add(obj);
+        }
+    });
+    // 释放临时的 RenderTarget
+    selectTextureTarget.dispose();
+    // ========== 第三步：合成毛玻璃效果 ==========
+    renderer.setRenderTarget(originRenderTarget);
+    renderer.clearDepth();
+    frostedGlassShader.uniforms.blurTexture.value = blurTextureTarget.texture;
+    frostedGlassShader.uniforms.maskTexture.value = maskTextureTarget.texture;
+    fsQuad.render(renderer, frostedGlassShader);
+    // 调试代码：直接输出模糊纹理
+    // renderer.setRenderTarget(originRenderTarget);
+    // renderer.clear();
+    // baseTextureToRenderShader.uniforms.tDiffuse.value = blurTextureTarget.texture;
+    // fsQuad.render(renderer, baseTextureToRenderShader);
+    // return;
+    // 调试代码：直接输出遮罩纹理
+    // renderer.setRenderTarget(originRenderTarget);
+    // renderer.clear();
+    // baseTextureToRenderShader.uniforms.tDiffuse.value = maskTextureTarget.texture;
+    // fsQuad.render(renderer, baseTextureToRenderShader);
+    // return;
+}

package/pass/fsQuad.d.ts

@@ -1,9 +1,9 @@
-import { BufferGeometry, Material, Mesh, OrthographicCamera, Scene, WebGLRenderer } from "three";
-declare class FullScreenQuad extends Scene {
-    constructor();
-    mesh: Mesh<BufferGeometry<import("three").NormalBufferAttributes>, Material, import("three").Object3DEventMap>;
-    orthographicCamera: OrthographicCamera;
-    render(renderer: WebGLRenderer, material: Material): void;
-}
-declare const fsQuad: FullScreenQuad;
-export default fsQuad;
+import { BufferGeometry, Material, Mesh, OrthographicCamera, Scene, WebGLRenderer } from "three";
+declare class FullScreenQuad extends Scene {
+    constructor();
+    mesh: Mesh<BufferGeometry<import("three").NormalBufferAttributes>, Material, import("three").Object3DEventMap>;
+    orthographicCamera: OrthographicCamera;
+    render(renderer: WebGLRenderer, material: Material): void;
+}
+declare const fsQuad: FullScreenQuad;
+export default fsQuad;

package/pass/fsQuad.js

@@ -1,28 +1,28 @@
-/*
- * @Author: xiaosihan
- * @Date: 2023-05-09 01:36:35
- * @Last Modified by: xiaosihan
- * @Last Modified time: 2025-01-28 04:04:33
- */
-import { BufferGeometry, Float32BufferAttribute, Mesh, MeshBasicMaterial, OrthographicCamera, Scene } from "three";
-class FullScreenQuad extends Scene {
-    constructor() {
-        super();
-    }
-    mesh = (() => {
-        const geometry = new BufferGeometry();
-        geometry.setAttribute("position", new Float32BufferAttribute([-1, 3, 0, -1, -1, 0, 3, -1, 0], 3));
-        geometry.setAttribute("uv", new Float32BufferAttribute([0, 2, 0, 0, 2, 0], 2));
-        const mesh = new Mesh(geometry, new MeshBasicMaterial());
-        this.add(mesh);
-        return mesh;
-    })();
-    orthographicCamera = new OrthographicCamera(-1, 1, 1, -1, 0, 1);
-    render(renderer, material) {
-        this.mesh.material = material;
-        renderer.render(this, this.orthographicCamera);
-    }
-}
-// 创建一个渲染工具 用于处理纹理
-const fsQuad = new FullScreenQuad(); // 渲染辅助器
-export default fsQuad;
+/*
+ * @Author: xiaosihan
+ * @Date: 2023-05-09 01:36:35
+ * @Last Modified by: xiaosihan
+ * @Last Modified time: 2025-01-28 04:04:33
+ */
+import { BufferGeometry, Float32BufferAttribute, Mesh, MeshBasicMaterial, OrthographicCamera, Scene } from "three";
+class FullScreenQuad extends Scene {
+    constructor() {
+        super();
+    }
+    mesh = (() => {
+        const geometry = new BufferGeometry();
+        geometry.setAttribute("position", new Float32BufferAttribute([-1, 3, 0, -1, -1, 0, 3, -1, 0], 3));
+        geometry.setAttribute("uv", new Float32BufferAttribute([0, 2, 0, 0, 2, 0], 2));
+        const mesh = new Mesh(geometry, new MeshBasicMaterial());
+        this.add(mesh);
+        return mesh;
+    })();
+    orthographicCamera = new OrthographicCamera(-1, 1, 1, -1, 0, 1);
+    render(renderer, material) {
+        this.mesh.material = material;
+        renderer.render(this, this.orthographicCamera);
+    }
+}
+// 创建一个渲染工具 用于处理纹理
+const fsQuad = new FullScreenQuad(); // 渲染辅助器
+export default fsQuad;

package/pass/glow_pass.d.ts

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