lythreeframe 1.2.57 → 1.2.59

package/dist/bundle.cjs.js

@@ -3,13 +3,14 @@
 var webgpu = require('three/webgpu');
 var Addons_js = require('three/examples/jsm/Addons.js');
 var tsl = require('three/tsl');
-var DepthOfFieldNode_js = require('three/addons/tsl/display/DepthOfFieldNode.js');
+var DepthOfFieldNode_js = require('three/examples/jsm/tsl/display/DepthOfFieldNode.js');
 var BloomNode_js = require('three/examples/jsm/tsl/display/BloomNode.js');
 var DenoiseNode_js = require('three/examples/jsm/tsl/display/DenoiseNode.js');
 var FXAANode_js = require('three/examples/jsm/tsl/display/FXAANode.js');
 var GTAONode_js = require('three/examples/jsm/tsl/display/GTAONode.js');
 var OutlineNode_js = require('three/examples/jsm/tsl/display/OutlineNode.js');
 var SMAANode_js = require('three/examples/jsm/tsl/display/SMAANode.js');
+var SSRNode_js = require('three/examples/jsm/tsl/display/SSRNode.js');
 var gsap = require('gsap');
 var three = require('three');
 var SkyMesh_js = require('three/examples/jsm/objects/SkyMesh.js');
@@ -1430,12 +1431,14 @@ class WebGPUPostProcessFactory {
     static constructDOFPass(scenePass, params) {
         const scenePassColor = scenePass.getTextureNode('output');
         const scenePassViewZ = scenePass.getViewZNode();
-        return DepthOfFieldNode_js.dof(scenePassColor, scenePassViewZ, tsl.uniform(params.focus), tsl.uniform(params.aperture), tsl.uniform(params.maxblur));
+        const dofPass = DepthOfFieldNode_js.dof(scenePassColor, scenePassViewZ, tsl.uniform(1), tsl.uniform(0.01), tsl.uniform(0.01));
+        WebGPUPostProcessFactory.updateDOFPass(dofPass, params);
+        return dofPass;
     }
     static updateDOFPass(dofPass, params) {
-        dofPass.focus.value = params.focus;
-        dofPass.aperture.value = params.aperture;
-        dofPass.maxblur.value = params.maxblur;
+        dofPass.focusDistanceNode.value = params.focus;
+        dofPass.focalLengthNode.value = params.aperture;
+        dofPass.bokehScaleNode.value = params.maxblur;
     }
     // motion blur
     // static constructMotionBlurPass(lastNode:NodeRepresentation, scenePass: ShaderNodeObject<PassNode>, param:MotionBlurParam): ShaderNodeObject<Node>
@@ -1447,20 +1450,19 @@ class WebGPUPostProcessFactory {
     //     return motionBlurPass
     // }
     // ssr
-    static constructSSRPass(scenePass, param) {
+    static constructSSRPass(scenePass, params) {
         WebGPUPostProcessFactory.updateScenePass(scenePass, {
             output: tsl.output,
             normal: tsl.transformedNormalView,
             metalness: tsl.metalness
         });
-        let ssrPass = null;
-        scenePass.getTextureNode('output');
-        scenePass.getTextureNode('depth');
-        scenePass.getTextureNode('normal');
-        //const scenePassMetalness      = scenePass.getTextureNode('metalness');
-        // const ssrPass                 = ssr(scenePassColor, scenePassDepth, scenePassNormal, scenePassMetalness, scenePass.camera)
-        //       ssrPass.resolutionScale = 1.0;
-        //WebGPUPostProcessFactory.updateSSRPass(ssrPass, param);
+        const scenePassColor = scenePass.getTextureNode('output');
+        const scenePassDepth = scenePass.getTextureNode('depth');
+        const scenePassNormal = scenePass.getTextureNode('normal');
+        const scenePassMetalness = scenePass.getTextureNode('metalness');
+        const ssrPass = SSRNode_js.ssr(scenePassColor, scenePassDepth, scenePassNormal, scenePassMetalness, scenePass.camera);
+        ssrPass.resolutionScale = 1.0;
+        WebGPUPostProcessFactory.updateSSRPass(ssrPass, params);
         return ssrPass;
     }
     static updateSSRPass(ssrPass, params) {
@@ -1527,9 +1529,10 @@ class WebGPUPostProcessFactory {
     static constructOutlinePass(scene, camera, outlineObjects, param) {
         const outlinePass = OutlineNode_js.outline(scene, camera, {
             selectedObjects: outlineObjects,
-            edgeGlow: param.edgeGlow,
-            edgeThickness: param.edgeThickness
+            edgeGlow: tsl.uniform(1),
+            edgeThickness: tsl.uniform(1)
         });
+        WebGPUPostProcessFactory.updateOutlinePass(outlinePass, outlineObjects, param);
         return outlinePass;
     }
     static updateOutlinePass(outlinePass, outlineObjects, params) {
@@ -1563,6 +1566,9 @@ class PostProcessManager {
     }
     updateCamera(camera) {
         this.camera = camera;
+        if (this.postProcessing) {
+            this.setup();
+        }
     }
     setup() {
         if (this.postProcessParam.steps.length === 0) {
@@ -1570,9 +1576,10 @@ class PostProcessManager {
             this.markDirty();
             return;
         }
-        if (!this.postProcessing) {
-            this.postProcessing = new webgpu.PostProcessing(this.renderer);
+        if (this.postProcessing) {
+            this.postProcessing.dispose();
         }
+        this.postProcessing = new webgpu.PostProcessing(this.renderer);
         const scenePass = WebGPUPostProcessFactory.constructScenePass(this.scene, this.camera);
         let finalNode = scenePass.getTextureNode('output');
         this.postProcessParam.steps.forEach((step) => {
@@ -1585,18 +1592,32 @@ class PostProcessManager {
                     }
                 case exports.PostProcessStepType.DepthOfField:
                     {
-                        const dofPass = WebGPUPostProcessFactory.constructDOFPass(scenePass, step);
-                        finalNode = finalNode.add(dofPass);
+                        finalNode = WebGPUPostProcessFactory.constructDOFPass(scenePass, step);
                         break;
                     }
                 case exports.PostProcessStepType.ScreenSpaceReflection:
                     {
-                        console.warn("[PostProcess] SSR 目前存在技术问题，暂不支持。");
+                        const ssrParam = step;
+                        const ssrPass = WebGPUPostProcessFactory.constructSSRPass(scenePass, ssrParam);
+                        if (ssrPass) {
+                            finalNode = finalNode.add(ssrPass);
+                        }
+                        else {
+                            console.warn("[PostProcess] SSR 目前存在技术问题，暂不支持。");
+                        }
                         break;
                     }
                 case exports.PostProcessStepType.GroundTruthAmbientOcclusion:
                     {
-                        console.warn("[PostProcess] AO 目前存在技术问题，暂不支持。");
+                        const gtaoParam = step;
+                        const gtaoPass = WebGPUPostProcessFactory.constructGTAOPass(scenePass, gtaoParam);
+                        if (gtaoParam.denoised) {
+                            const denoisePass = WebGPUPostProcessFactory.constructGTAODenoisePass(scenePass, gtaoPass, gtaoParam);
+                            finalNode = finalNode.mul(denoisePass);
+                        }
+                        else {
+                            finalNode = finalNode.mul(gtaoPass);
+                        }
                         break;
                     }
                 case exports.PostProcessStepType.Outline:
@@ -1605,7 +1626,8 @@ class PostProcessManager {
                         const outlinePass = WebGPUPostProcessFactory.constructOutlinePass(this.scene, scenePass.camera, this.outlineObjects, outlineParam);
                         const { visibleEdge, hiddenEdge } = outlinePass;
                         const pulsePeriod = tsl.uniform(outlineParam.pulsePeriod);
-                        const period = tsl.time.div(pulsePeriod).mul(2);
+                        const safePulsePeriod = pulsePeriod.greaterThan(0).select(pulsePeriod, tsl.uniform(1));
+                        const period = tsl.time.div(safePulsePeriod).mul(2);
                         const osc = tsl.oscSine(period).mul(.5).add(.5);
                         const outlineColor = visibleEdge
                             .mul(tsl.uniform(new webgpu.Color(outlineParam.visibleEdgeColor)))

package/dist/bundle.esm.js

@@ -1,13 +1,14 @@
 import { MathUtils, Object3D, Vector3, Box3, Quaternion, Euler, Matrix4, Mesh, LoadingManager, BufferGeometry, Texture, FileLoader, Material, NearestFilter, PostProcessing, Color, WebGPURenderer, Vector2, Raycaster, OrthographicCamera, PerspectiveCamera, Clock, DirectionalLight, AmbientLight, MeshStandardMaterial, BoxGeometry, MeshBasicMaterial, PlaneGeometry, SphereGeometry } from 'three/webgpu';
 import { GLTFLoader, DRACOLoader, CSS2DRenderer, OrbitControls } from 'three/examples/jsm/Addons.js';
 import { pass, mrt, output, uniform, metalness, transformedNormalView, time, oscSine } from 'three/tsl';
-import { dof } from 'three/addons/tsl/display/DepthOfFieldNode.js';
+import { dof } from 'three/examples/jsm/tsl/display/DepthOfFieldNode.js';
 import { bloom } from 'three/examples/jsm/tsl/display/BloomNode.js';
 import { denoise } from 'three/examples/jsm/tsl/display/DenoiseNode.js';
 import { fxaa } from 'three/examples/jsm/tsl/display/FXAANode.js';
 import { ao } from 'three/examples/jsm/tsl/display/GTAONode.js';
 import { outline } from 'three/examples/jsm/tsl/display/OutlineNode.js';
 import { smaa } from 'three/examples/jsm/tsl/display/SMAANode.js';
+import { ssr } from 'three/examples/jsm/tsl/display/SSRNode.js';
 import { gsap } from 'gsap';
 import { Scene } from 'three';
 import { SkyMesh } from 'three/examples/jsm/objects/SkyMesh.js';
@@ -1428,12 +1429,14 @@ class WebGPUPostProcessFactory {
     static constructDOFPass(scenePass, params) {
         const scenePassColor = scenePass.getTextureNode('output');
         const scenePassViewZ = scenePass.getViewZNode();
-        return dof(scenePassColor, scenePassViewZ, uniform(params.focus), uniform(params.aperture), uniform(params.maxblur));
+        const dofPass = dof(scenePassColor, scenePassViewZ, uniform(1), uniform(0.01), uniform(0.01));
+        WebGPUPostProcessFactory.updateDOFPass(dofPass, params);
+        return dofPass;
     }
     static updateDOFPass(dofPass, params) {
-        dofPass.focus.value = params.focus;
-        dofPass.aperture.value = params.aperture;
-        dofPass.maxblur.value = params.maxblur;
+        dofPass.focusDistanceNode.value = params.focus;
+        dofPass.focalLengthNode.value = params.aperture;
+        dofPass.bokehScaleNode.value = params.maxblur;
     }
     // motion blur
     // static constructMotionBlurPass(lastNode:NodeRepresentation, scenePass: ShaderNodeObject<PassNode>, param:MotionBlurParam): ShaderNodeObject<Node>
@@ -1445,20 +1448,19 @@ class WebGPUPostProcessFactory {
     //     return motionBlurPass
     // }
     // ssr
-    static constructSSRPass(scenePass, param) {
+    static constructSSRPass(scenePass, params) {
         WebGPUPostProcessFactory.updateScenePass(scenePass, {
             output: output,
             normal: transformedNormalView,
             metalness: metalness
         });
-        let ssrPass = null;
-        scenePass.getTextureNode('output');
-        scenePass.getTextureNode('depth');
-        scenePass.getTextureNode('normal');
-        //const scenePassMetalness      = scenePass.getTextureNode('metalness');
-        // const ssrPass                 = ssr(scenePassColor, scenePassDepth, scenePassNormal, scenePassMetalness, scenePass.camera)
-        //       ssrPass.resolutionScale = 1.0;
-        //WebGPUPostProcessFactory.updateSSRPass(ssrPass, param);
+        const scenePassColor = scenePass.getTextureNode('output');
+        const scenePassDepth = scenePass.getTextureNode('depth');
+        const scenePassNormal = scenePass.getTextureNode('normal');
+        const scenePassMetalness = scenePass.getTextureNode('metalness');
+        const ssrPass = ssr(scenePassColor, scenePassDepth, scenePassNormal, scenePassMetalness, scenePass.camera);
+        ssrPass.resolutionScale = 1.0;
+        WebGPUPostProcessFactory.updateSSRPass(ssrPass, params);
         return ssrPass;
     }
     static updateSSRPass(ssrPass, params) {
@@ -1525,9 +1527,10 @@ class WebGPUPostProcessFactory {
     static constructOutlinePass(scene, camera, outlineObjects, param) {
         const outlinePass = outline(scene, camera, {
             selectedObjects: outlineObjects,
-            edgeGlow: param.edgeGlow,
-            edgeThickness: param.edgeThickness
+            edgeGlow: uniform(1),
+            edgeThickness: uniform(1)
         });
+        WebGPUPostProcessFactory.updateOutlinePass(outlinePass, outlineObjects, param);
         return outlinePass;
     }
     static updateOutlinePass(outlinePass, outlineObjects, params) {
@@ -1561,6 +1564,9 @@ class PostProcessManager {
     }
     updateCamera(camera) {
         this.camera = camera;
+        if (this.postProcessing) {
+            this.setup();
+        }
     }
     setup() {
         if (this.postProcessParam.steps.length === 0) {
@@ -1568,9 +1574,10 @@ class PostProcessManager {
             this.markDirty();
             return;
         }
-        if (!this.postProcessing) {
-            this.postProcessing = new PostProcessing(this.renderer);
+        if (this.postProcessing) {
+            this.postProcessing.dispose();
         }
+        this.postProcessing = new PostProcessing(this.renderer);
         const scenePass = WebGPUPostProcessFactory.constructScenePass(this.scene, this.camera);
         let finalNode = scenePass.getTextureNode('output');
         this.postProcessParam.steps.forEach((step) => {
@@ -1583,18 +1590,32 @@ class PostProcessManager {
                     }
                 case PostProcessStepType.DepthOfField:
                     {
-                        const dofPass = WebGPUPostProcessFactory.constructDOFPass(scenePass, step);
-                        finalNode = finalNode.add(dofPass);
+                        finalNode = WebGPUPostProcessFactory.constructDOFPass(scenePass, step);
                         break;
                     }
                 case PostProcessStepType.ScreenSpaceReflection:
                     {
-                        console.warn("[PostProcess] SSR 目前存在技术问题，暂不支持。");
+                        const ssrParam = step;
+                        const ssrPass = WebGPUPostProcessFactory.constructSSRPass(scenePass, ssrParam);
+                        if (ssrPass) {
+                            finalNode = finalNode.add(ssrPass);
+                        }
+                        else {
+                            console.warn("[PostProcess] SSR 目前存在技术问题，暂不支持。");
+                        }
                         break;
                     }
                 case PostProcessStepType.GroundTruthAmbientOcclusion:
                     {
-                        console.warn("[PostProcess] AO 目前存在技术问题，暂不支持。");
+                        const gtaoParam = step;
+                        const gtaoPass = WebGPUPostProcessFactory.constructGTAOPass(scenePass, gtaoParam);
+                        if (gtaoParam.denoised) {
+                            const denoisePass = WebGPUPostProcessFactory.constructGTAODenoisePass(scenePass, gtaoPass, gtaoParam);
+                            finalNode = finalNode.mul(denoisePass);
+                        }
+                        else {
+                            finalNode = finalNode.mul(gtaoPass);
+                        }
                         break;
                     }
                 case PostProcessStepType.Outline:
@@ -1603,7 +1624,8 @@ class PostProcessManager {
                         const outlinePass = WebGPUPostProcessFactory.constructOutlinePass(this.scene, scenePass.camera, this.outlineObjects, outlineParam);
                         const { visibleEdge, hiddenEdge } = outlinePass;
                         const pulsePeriod = uniform(outlineParam.pulsePeriod);
-                        const period = time.div(pulsePeriod).mul(2);
+                        const safePulsePeriod = pulsePeriod.greaterThan(0).select(pulsePeriod, uniform(1));
+                        const period = time.div(safePulsePeriod).mul(2);
                         const osc = oscSine(period).mul(.5).add(.5);
                         const outlineColor = visibleEdge
                             .mul(uniform(new Color(outlineParam.visibleEdgeColor)))

package/dist/lythreeframe/Frame/Controller.d.ts

@@ -1,5 +1,5 @@
 import { ThreeJsApp } from "../ThreeJsApp";
-import { Euler, Intersection, OrthographicCamera, PerspectiveCamera, Quaternion, Vector3 } from "three/webgpu";
+import { Euler, Intersection, OrthographicCamera, PerspectiveCamera, Quaternion, Raycaster, Vector2, Vector3 } from "three/webgpu";
 import { World } from "./World";
 import { Viewport } from "./Viewport";
 import { Pawn } from "../Object/PawnV2/Pawn";
@@ -36,29 +36,33 @@ export interface ComponentPointerDownEvent {
 export declare class Controller {
     protected _app: ThreeJsApp;
     protected _pawn: Pawn | null;
-    private raycaster;
-    private prepareClickComponent;
-    private prepareClickHit;
-    private prepareClickModifiers;
-    private hoveringComponent;
-    private _pointButtonIsDown;
-    private _onClickNothingDelegate;
-    private _onComponentClickDelegate;
-    private _onComponentDoubleClickDelegate;
-    private _onComponentHoverBeginDelegate;
-    private _onComponentHoverEndDelegate;
-    private _onComponentPointerDownDelegate;
-    private pointerPosition;
-    private pointerLeftDownPosition;
-    private readonly _tempVec2;
-    private readonly _raycastVec2;
-    private readonly doubleClickDelay;
-    private leftClickTimer;
-    private onPointerMove;
-    private onPointerEnter;
-    private onPointerLeave;
-    private onPointerUp;
-    private onPointerDown;
+    protected raycaster: Raycaster;
+    protected prepareClickComponent: SceneComponent | null;
+    protected prepareClickHit: Intersection | null;
+    protected prepareClickModifiers: {
+        ctrlKey: boolean;
+        shiftKey: boolean;
+        altKey: boolean;
+    };
+    protected hoveringComponent: SceneComponent | null;
+    protected _pointButtonIsDown: Set<number>;
+    protected _onClickNothingDelegate: Delegate<[void]>;
+    protected _onComponentClickDelegate: Delegate<[ComponentInteractionEvent]>;
+    protected _onComponentDoubleClickDelegate: Delegate<[ComponentInteractionEvent]>;
+    protected _onComponentHoverBeginDelegate: Delegate<[ComponentHoverEvent]>;
+    protected _onComponentHoverEndDelegate: Delegate<[ComponentHoverEvent]>;
+    protected _onComponentPointerDownDelegate: Delegate<[ComponentPointerDownEvent]>;
+    protected pointerPosition: Vector2;
+    protected pointerLeftDownPosition: Vector2;
+    protected readonly _tempVec2: Vector2;
+    protected readonly _raycastVec2: Vector2;
+    protected readonly doubleClickDelay: number;
+    protected leftClickTimer: number | null;
+    protected onPointerMove: (event: MouseEvent) => void;
+    protected onPointerEnter: (event: MouseEvent) => void;
+    protected onPointerLeave: (event: MouseEvent) => void;
+    protected onPointerUp: (event: MouseEvent) => void;
+    protected onPointerDown: (event: MouseEvent) => void;
     get camera(): PerspectiveCamera | OrthographicCamera;
     get world(): World;
     get viewPort(): Viewport;
@@ -75,20 +79,24 @@ export declare class Controller {
     updateCamera(): void;
     tick(deltaTime: number): void;
     destroy(): void;
-    onPointerMoveEvent(event: MouseEvent): void;
-    private clearHoveringComponent;
-    private fireHoverEvent;
-    onPointerUpEvent(event: MouseEvent): void;
-    private handleFirstClick;
-    private handleDoubleClick;
-    private fireClickEvent;
-    private clearClickTimer;
-    onPointerDownEvent(event: MouseEvent): void;
-    private firePointerDownEvent;
-    onPointerEnterEvent(_event: MouseEvent): void;
-    onPointerLeaveEvent(_event: MouseEvent): void;
-    private addCorePointerListeners;
-    private removeCorePointerListeners;
+    protected onPointerMoveEvent(event: MouseEvent): void;
+    protected clearHoveringComponent(): void;
+    protected fireHoverEvent(component: SceneComponent, hit: Intersection | null, isBegin: boolean): void;
+    protected onPointerUpEvent(event: MouseEvent): void;
+    protected handleFirstClick(): void;
+    protected handleDoubleClick(): void;
+    protected fireClickEvent(component: SceneComponent, hit: Intersection, isDoubleClick: boolean, modifiers: {
+        ctrlKey: boolean;
+        shiftKey: boolean;
+        altKey: boolean;
+    }): void;
+    protected clearClickTimer(): void;
+    protected onPointerDownEvent(event: MouseEvent): void;
+    protected firePointerDownEvent(component: SceneComponent, hit: Intersection, button: number): void;
+    protected onPointerEnterEvent(_event: MouseEvent): void;
+    protected onPointerLeaveEvent(_event: MouseEvent): void;
+    protected addCorePointerListeners(): void;
+    protected removeCorePointerListeners(): void;
     getHitResultUnderCursor(): Intersection | null;
     getHitResultFromScreenPoint(x: number, y: number): Intersection | null;
     focusTo(targetPos: Vector3, targetQuat: Quaternion | Euler, distance: number, time: number, onGoing?: (() => void) | null, onFinished?: (() => void) | null): void;

package/dist/lythreeframe/PostProcess/WebGPUPostProcessFactory.d.ts

@@ -5,32 +5,33 @@ import { DOFParam } from "./Param/DOF";
 import { GTAOParam } from "./Param/GTAO";
 import { SSRParam } from "./Param/SSR";
 import { DenoiseParam } from './Param/GTAO';
-import { ShaderNodeObject, NodeRepresentation } from 'three/tsl';
-import DepthOfFieldNode from 'three/addons/tsl/display/DepthOfFieldNode.js';
+import DepthOfFieldNode from 'three/examples/jsm/tsl/display/DepthOfFieldNode.js';
 import BloomNode from 'three/examples/jsm/tsl/display/BloomNode.js';
 import DenoiseNode from 'three/examples/jsm/tsl/display/DenoiseNode.js';
+import FXAANode from 'three/examples/jsm/tsl/display/FXAANode.js';
 import GTAONode from 'three/examples/jsm/tsl/display/GTAONode.js';
 import OutlineNode from 'three/examples/jsm/tsl/display/OutlineNode.js';
 import SSRNode from 'three/examples/jsm/tsl/display/SSRNode.js';
+import type { TempNode } from 'three/webgpu';
 export declare class WebGPUPostProcessFactory {
-    static constructScenePass(scene: Scene, camera: Camera): ShaderNodeObject<PassNode>;
-    static updateScenePass(scenePass: ShaderNodeObject<PassNode>, outputNodes: {
+    static constructScenePass(scene: Scene, camera: Camera): PassNode;
+    static updateScenePass(scenePass: PassNode, outputNodes: {
         [name: string]: Node;
     }): void;
-    static constructBloomPass(scenePass: ShaderNodeObject<PassNode>, params: BloomParam): ShaderNodeObject<BloomNode>;
-    static updateBloomPass(bloomPass: ShaderNodeObject<BloomNode>, params: BloomParam): void;
-    static constructDOFPass(scenePass: ShaderNodeObject<PassNode>, params: DOFParam): ShaderNodeObject<DepthOfFieldNode>;
-    static updateDOFPass(dofPass: ShaderNodeObject<DepthOfFieldNode>, params: DOFParam): void;
-    static constructSSRPass(scenePass: ShaderNodeObject<PassNode>, param: SSRParam): ShaderNodeObject<SSRNode> | null;
-    static updateSSRPass(ssrPass: ShaderNodeObject<SSRNode>, params: SSRParam): void;
-    static constructGTAOPass(scenePass: ShaderNodeObject<PassNode>, params: GTAOParam): ShaderNodeObject<GTAONode>;
-    static updateGTAOPass(gtaoPass: ShaderNodeObject<GTAONode>, params: GTAOParam): void;
-    static constructDenoisePass(scenePass: ShaderNodeObject<PassNode>, inputNode: NodeRepresentation, params: DenoiseParam): ShaderNodeObject<DenoiseNode>;
-    static updateDenoisePass(denoisePass: ShaderNodeObject<DenoiseNode>, params: DenoiseParam): void;
-    static constructGTAODenoisePass(scenePass: ShaderNodeObject<PassNode>, gtaoPass: ShaderNodeObject<GTAONode>, params: GTAOParam): ShaderNodeObject<DenoiseNode>;
-    static updateGTAODenoisePass(denoisePass: ShaderNodeObject<DenoiseNode>, params: GTAOParam): void;
-    static constructOutlinePass(scene: Scene, camera: Camera, outlineObjects: Object3D[], param: OutlineParams): ShaderNodeObject<OutlineNode>;
-    static updateOutlinePass(outlinePass: ShaderNodeObject<OutlineNode>, outlineObjects: Object3D[], params: OutlineParams): void;
-    static constructFXAAPass(inputNode: NodeRepresentation): ShaderNodeObject<import("three/examples/jsm/tsl/display/FXAANode.js").default>;
-    static constructSMAAPass(inputNode: NodeRepresentation): ShaderNodeObject<import("three/examples/jsm/tsl/display/SMAANode.js").SMAANode>;
+    static constructBloomPass(scenePass: PassNode, params: BloomParam): BloomNode;
+    static updateBloomPass(bloomPass: BloomNode, params: BloomParam): void;
+    static constructDOFPass(scenePass: PassNode, params: DOFParam): DepthOfFieldNode;
+    static updateDOFPass(dofPass: DepthOfFieldNode, params: DOFParam): void;
+    static constructSSRPass(scenePass: PassNode, params: SSRParam): SSRNode;
+    static updateSSRPass(ssrPass: SSRNode, params: SSRParam): void;
+    static constructGTAOPass(scenePass: PassNode, params: GTAOParam): GTAONode;
+    static updateGTAOPass(gtaoPass: GTAONode, params: GTAOParam): void;
+    static constructDenoisePass(scenePass: PassNode, inputNode: Node, params: DenoiseParam): DenoiseNode;
+    static updateDenoisePass(denoisePass: DenoiseNode, params: DenoiseParam): void;
+    static constructGTAODenoisePass(scenePass: PassNode, gtaoPass: GTAONode, params: GTAOParam): DenoiseNode;
+    static updateGTAODenoisePass(denoisePass: DenoiseNode, params: GTAOParam): void;
+    static constructOutlinePass(scene: Scene, camera: Camera, outlineObjects: Object3D[], param: OutlineParams): OutlineNode;
+    static updateOutlinePass(outlinePass: OutlineNode, outlineObjects: Object3D[], params: OutlineParams): void;
+    static constructFXAAPass(inputNode: Node): FXAANode;
+    static constructSMAAPass(inputNode: Node): TempNode;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lythreeframe",
-  "version": "1.2.57",
+  "version": "1.2.59",
   "description": "Three.js 封装",
   "main": "dist/bundle.cjs.js",
   "module": "dist/bundle.esm.js",
@@ -11,7 +11,7 @@
     "prepublishOnly": "npm run build"
   },
   "peerDependencies": {
-    "@types/three": "^0.180.0",
+    "@types/three": "^0.181.0",
     "gsap": "^3.12.2",
     "three": "^0.180.0"
   },