lythreeframe 1.2.21 → 1.2.23

package/dist/bundle.cjs.js

@@ -3,16 +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 BloomNode_js = require('three/examples/jsm/tsl/display/BloomNode.js');
 var DenoiseNode_js = require('three/examples/jsm/tsl/display/DenoiseNode.js');
-var DepthOfFieldNode_js = require('three/examples/jsm/tsl/display/DepthOfFieldNode.js');
+var FXAANode_js = require('three/examples/jsm/tsl/display/FXAANode.js');
 var GTAONode_js = require('three/examples/jsm/tsl/display/GTAONode.js');
-var SSRNode_js = require('three/examples/jsm/tsl/display/SSRNode.js');
-var LensflareNode_js = require('three/examples/jsm/tsl/display/LensflareNode.js');
 var OutlineNode_js = require('three/examples/jsm/tsl/display/OutlineNode.js');
-var MotionBlur_js = require('three/examples/jsm/tsl/display/MotionBlur.js');
-var FXAANode_js = require('three/examples/jsm/tsl/display/FXAANode.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');
@@ -1263,68 +1261,18 @@ class Delegate {
     }
 }
 
-const DefaultSSRParam = {
-    isEnabled: false,
-    maxDistance: 0.5,
-    opacity: 1,
-    thickness: 0.015,
-};
-
-const DefaultDenoiseParam = {
-    denoiseRadius: 5,
-    lumaPhi: 5,
-    depthPhi: 5,
-    normalPhi: 5
-};
-
-const DefaultGTAOParam = {
-    isEnabled: false,
-    distanceExponent: 1,
-    distanceFallOff: 1,
-    radius: 0.25,
-    scale: 1,
-    thickness: 1,
-    denoised: true,
-    denoiseParam: DefaultDenoiseParam,
-};
-
-const DefaultBloomParam = {
-    isEnabled: false,
-    threshold: 0,
-    strength: 1,
-    radius: 0,
-};
-
-const DefaultDOFParam = {
-    isEnabled: false,
-    focus: 500.0,
-    aperture: 5,
-    maxblur: 0.01
-};
-
-const DefaultOutlineParams = {
-    isEnabled: false,
-    edgeStrength: 3.0,
-    edgeGlow: 1.0,
-    edgeThickness: 1.0,
-    pulsePeriod: 0.0,
-    visibleEdgeColor: 0xffffff,
-    hiddenEdgeColor: 0xffffff,
-};
-
-const DefaultAAParams = {
-    isEnabled: false,
-    type: "fxaa",
-};
-
 const DefaultPostProcessParam = {
-    bloom: Object.assign({}, DefaultBloomParam),
-    dof: Object.assign({}, DefaultDOFParam),
-    ssr: Object.assign({}, DefaultSSRParam),
-    gtao: Object.assign({}, DefaultGTAOParam),
-    outline: Object.assign({}, DefaultOutlineParams),
-    aa: Object.assign({}, DefaultAAParams)
+    steps: []
 };
+exports.PostProcessStepType = void 0;
+(function (PostProcessStepType) {
+    PostProcessStepType[PostProcessStepType["Bloom"] = 0] = "Bloom";
+    PostProcessStepType[PostProcessStepType["DepthOfField"] = 1] = "DepthOfField";
+    PostProcessStepType[PostProcessStepType["ScreenSpaceReflection"] = 2] = "ScreenSpaceReflection";
+    PostProcessStepType[PostProcessStepType["GroundTruthAmbientOcclusion"] = 3] = "GroundTruthAmbientOcclusion";
+    PostProcessStepType[PostProcessStepType["Outline"] = 4] = "Outline";
+    PostProcessStepType[PostProcessStepType["Antialiasing"] = 5] = "Antialiasing";
+})(exports.PostProcessStepType || (exports.PostProcessStepType = {}));
 
 class World {
     get scene() {
@@ -1409,7 +1357,6 @@ class WebGPUPostProcessFactory {
         else {
             scenePass.setMRT(newMRT);
         }
-        console.log(scenePass.getMRT(), "MRTTTTTTT");
     }
     // bloom pass
     static constructBloomPass(scenePass, params) {
@@ -1427,21 +1374,22 @@ 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).mul(0.00001), tsl.uniform(params.maxblur));
+        return DepthOfFieldNode_js.dof(scenePassColor, scenePassViewZ, tsl.uniform(params.focus), tsl.uniform(params.aperture), tsl.uniform(params.maxblur));
     }
     static updateDOFPass(dofPass, params) {
         dofPass.focus.value = params.focus;
-        dofPass.aperture.value = params.aperture * 0.00001;
+        dofPass.aperture.value = params.aperture;
         dofPass.maxblur.value = params.maxblur;
     }
     // motion blur
-    static constructMotionBlurPass(lastNode, scenePass, param) {
-        WebGPUPostProcessFactory.updateScenePass(scenePass, { velocity: tsl.velocity });
-        const scenePassVelocity = scenePass.getTextureNode('velocity').mul(param.blurAmount);
-        const scenePassColor = scenePass.getTextureNode('output');
-        const motionBlurPass = MotionBlur_js.motionBlur(scenePassColor, scenePassVelocity);
-        return motionBlurPass;
-    }
+    // static constructMotionBlurPass(lastNode:NodeRepresentation, scenePass: ShaderNodeObject<PassNode>, param:MotionBlurParam): ShaderNodeObject<Node>
+    // {
+    //     WebGPUPostProcessFactory.updateScenePass(scenePass, {velocity})
+    //     const scenePassVelocity = scenePass.getTextureNode( 'velocity' ).mul( param.blurAmount );
+    //     const scenePassColor          = scenePass.getTextureNode('output');
+    //     const motionBlurPass = motionBlur( scenePassColor, scenePassVelocity );
+    //     return motionBlurPass
+    // }
     // ssr
     static constructSSRPass(scenePass, param) {
         WebGPUPostProcessFactory.updateScenePass(scenePass, {
@@ -1503,19 +1451,21 @@ class WebGPUPostProcessFactory {
     static updateGTAODenoisePass(denoisePass, params) {
         WebGPUPostProcessFactory.updateDenoisePass(denoisePass, params.denoiseParam);
     }
-    static constructLensFlarePass(inputNode, params) {
-        const lensflarePass = LensflareNode_js.lensflare(inputNode, {
-            threshold: tsl.uniform(params.threshold),
-            ghostAttenuationFactor: tsl.uniform(params.ghostAttenuationFactor),
-            ghostSpacing: tsl.uniform(params.ghostSpacing),
-        });
-        return lensflarePass;
-    }
-    static updateLensFlarPass(lensflarePass, params) {
-        lensflarePass.thresholdNode.value = params.threshold;
-        lensflarePass.ghostSpacingNode.value = params.ghostSpacing;
-        lensflarePass.ghostAttenuationFactorNode.value = params.ghostAttenuationFactor;
-    }
+    // static constructLensFlarePass(inputNode: NodeRepresentation, params: LensFlareParam): ShaderNodeObject<LensflareNode>
+    // {
+    //     const lensflarePass = lensflare(inputNode, {
+    //         threshold             : uniform(params.threshold),
+    //         ghostAttenuationFactor: uniform(params.ghostAttenuationFactor),
+    //         ghostSpacing          : uniform(params.ghostSpacing),
+    //     });
+    //     return lensflarePass;
+    // }
+    // static updateLensFlarPass(lensflarePass: ShaderNodeObject<LensflareNode>, params: LensFlareParam)
+    // {
+    //     lensflarePass.thresholdNode.value              = params.threshold
+    //     lensflarePass.ghostSpacingNode.value           = params.ghostSpacing
+    //     lensflarePass.ghostAttenuationFactorNode.value = params.ghostAttenuationFactor
+    // }
     static constructOutlinePass(scene, camera, outlineObjects, param) {
         const outlinePass = OutlineNode_js.outline(scene, camera, {
             selectedObjects: outlineObjects,
@@ -1563,17 +1513,6 @@ class Viewport {
         this._canvas = null;
         this.isRenderStateDirty = true;
         this.postProcessing = null;
-        this.scenePass = null;
-        this.bloomPass = null;
-        this.dofPass = null;
-        this.GTAOPass = null;
-        this.denoiseGTAOPass = null;
-        this.ssrPass = null;
-        this.outlinePass = null;
-        this.fxaaPass = null;
-        this.smaaPass = null;
-        // private motionBlurPass: ShaderNodeObject<Node> | null      = null;
-        // private denoiseOutlinePass: ShaderNodeObject<DenoiseNode> | null = null;
         this.outlineObjects = [];
         this.postProcessParam = Object.assign({}, postProcessParam);
         this._app = app;
@@ -1635,205 +1574,140 @@ class Viewport {
         this.setupPostProcess();
     }
     setupPostProcess() {
-        // 检查各个效果是否启用
-        const isBloomEnabled = this.postProcessParam.bloom.isEnabled;
-        const isDOFEnabled = this.postProcessParam.dof.isEnabled;
-        const isSSREnabled = this.postProcessParam.ssr.isEnabled;
-        const isGTAOEnabled = this.postProcessParam.gtao.isEnabled;
-        const isOutlineEnabled = this.postProcessParam.outline.isEnabled;
-        const isAAEnabled = this.postProcessParam.aa.isEnabled;
-        if (!(isBloomEnabled) && !(isDOFEnabled) && !(isSSREnabled) && !(isGTAOEnabled) && !(isOutlineEnabled) && !(isAAEnabled)) {
+        if (this.postProcessParam.steps.length === 0) {
             this.destroyPostProcess();
+            this.markRenderStateDirty();
             return;
         }
         if (!this.postProcessing) {
             this.postProcessing = new webgpu.PostProcessing(this.renderer);
         }
-        if (!this.scenePass) {
-            this.scenePass = WebGPUPostProcessFactory.constructScenePass(this.app.world.scene, this.app.camera);
-        }
-        let finalNode = this.scenePass.getTextureNode('output');
-        // bloom
-        if (isBloomEnabled) {
-            if (!this.bloomPass) {
-                this.bloomPass = WebGPUPostProcessFactory.constructBloomPass(this.scenePass, this.postProcessParam.bloom);
-            }
-            else {
-                WebGPUPostProcessFactory.updateBloomPass(this.bloomPass, this.postProcessParam.bloom);
-            }
-            finalNode = finalNode.add(this.bloomPass);
-        }
-        else {
-            if (this.bloomPass) {
-                this.bloomPass.dispose();
-                this.bloomPass = null;
-            }
-        }
-        // DOF
-        if (isDOFEnabled) {
-            if (!this.dofPass) {
-                this.dofPass = WebGPUPostProcessFactory.constructDOFPass(this.scenePass, this.postProcessParam.dof);
-            }
-            else {
-                WebGPUPostProcessFactory.updateDOFPass(this.dofPass, this.postProcessParam.dof);
-            }
-            finalNode = this.dofPass;
-        }
-        else {
-            if (this.dofPass) {
-                this.dofPass.dispose();
-                this.dofPass = null;
-            }
-        }
-        // ssr
-        if (isSSREnabled) {
-            if (!this.ssrPass) {
-                this.ssrPass = WebGPUPostProcessFactory.constructSSRPass(this.scenePass, this.postProcessParam.ssr);
-            }
-            else {
-                WebGPUPostProcessFactory.updateSSRPass(this.ssrPass, this.postProcessParam.ssr);
-            }
-            finalNode = tsl.blendColor(finalNode, this.ssrPass);
-        }
-        // GTAO
-        if (isGTAOEnabled) {
-            if (!this.GTAOPass) {
-                this.GTAOPass = WebGPUPostProcessFactory.constructGTAOPass(this.scenePass, this.postProcessParam.gtao);
-            }
-            else {
-                WebGPUPostProcessFactory.updateGTAOPass(this.GTAOPass, this.postProcessParam.gtao);
-            }
-            if (this.postProcessParam.gtao.denoised) {
-                if (!this.denoiseGTAOPass) {
-                    this.denoiseGTAOPass = WebGPUPostProcessFactory.constructGTAODenoisePass(this.scenePass, this.GTAOPass, this.postProcessParam.gtao);
-                }
-                else {
-                    WebGPUPostProcessFactory.updateGTAOPass(this.GTAOPass, this.postProcessParam.gtao);
-                }
-                finalNode = this.denoiseGTAOPass.mul(finalNode);
-            }
-            else {
-                finalNode = this.GTAOPass.getTextureNode().mul(finalNode);
-                if (this.denoiseGTAOPass) {
-                    this.denoiseGTAOPass.dispose();
-                    this.denoiseGTAOPass = null;
-                }
-            }
-        }
-        else {
-            if (this.GTAOPass) {
-                this.GTAOPass.dispose();
-                this.GTAOPass = null;
-            }
-            if (this.denoiseGTAOPass) {
-                this.denoiseGTAOPass.dispose();
-                this.denoiseGTAOPass = null;
-            }
-        }
-        // outline
-        if (isOutlineEnabled) {
-            if (!this.outlinePass) {
-                this.outlinePass = WebGPUPostProcessFactory.constructOutlinePass(this.app.world.scene, this.scenePass.camera, this.outlineObjects, this.postProcessParam.outline);
-            }
-            else {
-                WebGPUPostProcessFactory.updateOutlinePass(this.outlinePass, this.outlineObjects, this.postProcessParam.outline);
-            }
-            const { visibleEdge, hiddenEdge } = this.outlinePass;
-            const pulsePeriod = tsl.uniform(this.postProcessParam.outline.pulsePeriod);
-            const period = tsl.time.div(pulsePeriod).mul(2);
-            const osc = tsl.oscSine(period).mul(.5).add(.5);
-            const outlineColor = visibleEdge.mul(tsl.uniform(new webgpu.Color(this.postProcessParam.outline.visibleEdgeColor))).add(hiddenEdge.mul(tsl.uniform(new webgpu.Color(this.postProcessParam.outline.hiddenEdgeColor)))).mul(this.postProcessParam.outline.edgeStrength);
-            const outlinePulse = pulsePeriod.greaterThan(0).select(outlineColor.mul(osc), outlineColor);
-            // if(!this.denoiseOutlinePass)
-            // {
-            //     this.denoiseOutlinePass = WebGPUPostProcessFactory.constructDenoisePass(this.scenePass, outlinePulse, DefaultDenoiseParam);
-            // }
-            // outlinePulse = this.denoiseOutlinePass.mul(outlinePulse)
-            // finalNode = this.denoiseOutlinePass.mul(outlinePulse).add(finalNode);
-            finalNode = outlinePulse.add(finalNode);
-            // finalNode = this.denoiseOutlinePass.mul(outlinePulse).add(finalNode);
-        }
-        else {
-            if (this.outlinePass) {
-                this.outlinePass.dispose();
-                this.outlinePass = null;
-            }
-        }
-        if (isAAEnabled) {
-            if (this.postProcessParam.aa.type === "fxaa") {
-                this.fxaaPass = WebGPUPostProcessFactory.constructFXAAPass(finalNode);
-                finalNode = this.fxaaPass;
-            }
-            if (this.postProcessParam.aa.type === "smaa") {
-                this.smaaPass = WebGPUPostProcessFactory.constructSMAAPass(finalNode);
-                finalNode = this.smaaPass;
-            }
-        }
-        else {
-            if (this.fxaaPass) {
-                this.fxaaPass.dispose();
-                this.fxaaPass = null;
-            }
-            if (this.smaaPass) {
-                this.smaaPass.dispose();
-                this.smaaPass = null;
+        const scenePass = WebGPUPostProcessFactory.constructScenePass(this.app.world.scene, this.app.camera);
+        let finalNode = scenePass.getTextureNode('output');
+        this.postProcessParam.steps.forEach((step) => {
+            switch (step.type) {
+                case exports.PostProcessStepType.Bloom:
+                    {
+                        const bloomPass = WebGPUPostProcessFactory.constructBloomPass(scenePass, step);
+                        console.log("[PostProcess] BloomPass 构建完成");
+                        finalNode = finalNode.add(bloomPass);
+                        break;
+                    }
+                case exports.PostProcessStepType.DepthOfField:
+                    {
+                        const dofPass = WebGPUPostProcessFactory.constructDOFPass(scenePass, step);
+                        console.log("[PostProcess] DOFPass 构建完成");
+                        finalNode = finalNode.add(dofPass);
+                        break;
+                    }
+                case exports.PostProcessStepType.ScreenSpaceReflection:
+                    {
+                        const ssrPass = WebGPUPostProcessFactory.constructSSRPass(scenePass, step);
+                        console.log("[PostProcess] SSRPass 构建完成");
+                        finalNode = tsl.blendColor(finalNode, ssrPass);
+                        break;
+                    }
+                case exports.PostProcessStepType.GroundTruthAmbientOcclusion:
+                    {
+                        const stepParam = step;
+                        const GTAOPass = WebGPUPostProcessFactory.constructGTAOPass(scenePass, stepParam);
+                        console.log("[PostProcess] GTAOPass 构建完成");
+                        if (stepParam.denoised) {
+                            const denoiseGTAOPass = WebGPUPostProcessFactory.constructGTAODenoisePass(scenePass, GTAOPass, stepParam);
+                            console.log("[PostProcess] GTAODenoisePass 构建完成");
+                            finalNode = denoiseGTAOPass.mul(finalNode);
+                        }
+                        else {
+                            finalNode = GTAOPass.getTextureNode().mul(finalNode);
+                        }
+                        break;
+                    }
+                case exports.PostProcessStepType.Outline:
+                    {
+                        const outlineParam = step;
+                        const outlinePass = WebGPUPostProcessFactory.constructOutlinePass(this.app.world.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 osc = tsl.oscSine(period).mul(.5).add(.5);
+                        const outlineColor = visibleEdge.mul(tsl.uniform(new webgpu.Color(outlineParam.visibleEdgeColor))).add(hiddenEdge.mul(tsl.uniform(new webgpu.Color(outlineParam.hiddenEdgeColor)))).mul(outlineParam.edgeStrength);
+                        const outlinePulse = pulsePeriod.greaterThan(0).select(outlineColor.mul(osc), outlineColor);
+                        // if(!this.denoiseOutlinePass)
+                        // {
+                        //     this.denoiseOutlinePass = WebGPUPostProcessFactory.constructDenoisePass(this.scenePass, outlinePulse, DefaultDenoiseParam);
+                        // }
+                        // outlinePulse = this.denoiseOutlinePass.mul(outlinePulse)
+                        // finalNode = this.denoiseOutlinePass.mul(outlinePulse).add(finalNode);
+                        finalNode = outlinePulse.add(finalNode);
+                        console.log("[PostProcess] OutlinePass 构建完成");
+                        break;
+                    }
+                case exports.PostProcessStepType.Antialiasing:
+                    {
+                        const aaParam = step;
+                        if (aaParam.method === "fxaa") {
+                            finalNode = WebGPUPostProcessFactory.constructFXAAPass(finalNode);
+                            console.log("[PostProcess] FXAAPass 构建完成");
+                        }
+                        if (aaParam.method === "smaa") {
+                            finalNode = WebGPUPostProcessFactory.constructSMAAPass(finalNode);
+                            console.log("[PostProcess] SMAAPass 构建完成");
+                        }
+                        break;
+                    }
             }
-        }
+        });
         this.postProcessing.outputNode = finalNode;
+        this.postProcessing.needsUpdate = true;
+        console.log("[PostProcess] setup complete", this.postProcessParam.steps);
         this.markRenderStateDirty();
     }
-    updateBloomPass(params) {
-        this.postProcessParam.bloom = Object.assign({}, params);
-        this.setupPostProcess();
-    }
-    updateGTAOParam(params) {
-        this.postProcessParam.gtao = Object.assign({}, params);
-        this.setupPostProcess();
-    }
-    updateDOFParam(params) {
-        this.postProcessParam.dof = Object.assign({}, params);
-        this.setupPostProcess();
-    }
-    updateSSRParam(params) {
-        this.postProcessParam.ssr = Object.assign({}, params);
-        this.setupPostProcess();
-    }
-    updateOutlineParam(params) {
-        this.postProcessParam.outline = Object.assign({}, params);
-        this.setupPostProcess();
-    }
-    updateAAParam(params) {
-        this.postProcessParam.aa = Object.assign({}, params);
+    updatePostProcess(steps) {
+        this.postProcessParam.steps = steps;
         this.setupPostProcess();
     }
+    // updateBloomPass(params: BloomParam)
+    // {
+    //     this.postProcessParam.bloom = { ...params };
+    //     this.setupPostProcess();
+    // }
+    // updateGTAOParam(params: GTAOParam)
+    // {
+    //     this.postProcessParam.gtao = { ...params };
+    //     this.setupPostProcess();
+    // }
+    // updateDOFParam(params: DOFParam) 
+    // {
+    //     this.postProcessParam.dof = { ...params };
+    //     this.setupPostProcess();
+    // }
+    // updateSSRParam(params: SSRParam)
+    // {
+    //     this.postProcessParam.ssr = { ...params };
+    //     this.setupPostProcess();
+    // }
+    // updateOutlineParam(params: OutlineParams)
+    // {
+    //     this.postProcessParam.outline = { ...params }
+    //     this.setupPostProcess();
+    // }
+    // updateAAParam(params: AAParams)
+    // {
+    //     this.postProcessParam.aa = { ...params };
+    //     this.setupPostProcess();
+    // }
     addOutlineObject(obj) {
         if (!this.outlineObjects.includes(obj)) {
             this.outlineObjects.push(obj);
         }
-        if (!this.postProcessParam.outline) {
-            this.postProcessParam.outline = DefaultOutlineParams;
-            this.setupPostProcess();
-        }
-        else {
-            this.markRenderStateDirty();
-        }
+        this.markRenderStateDirty();
     }
     setOutlineObjects(objects) {
         this.outlineObjects.length = 0;
         this.outlineObjects.push(...objects);
-        if (!this.postProcessParam.outline) {
-            this.postProcessParam.outline = DefaultOutlineParams;
-            this.setupPostProcess();
-        }
-        else {
-            this.markRenderStateDirty();
-        }
+        this.markRenderStateDirty();
     }
     removeOutlineObject(obj) {
-        if (!this.postProcessParam.outline) {
-            this.outlineObjects = [];
-            return;
-        }
         const index = this.outlineObjects.indexOf(obj);
         if (index > -1) {
             this.outlineObjects.splice(index, 1);
@@ -1841,35 +1715,7 @@ class Viewport {
         this.markRenderStateDirty();
     }
     destroyPostProcess() {
-        if (this.bloomPass) {
-            this.bloomPass.dispose();
-            this.bloomPass = null;
-        }
-        if (this.dofPass) {
-            this.dofPass.dispose();
-            this.dofPass = null;
-        }
-        if (this.GTAOPass) {
-            this.GTAOPass.dispose();
-            this.GTAOPass = null;
-        }
-        if (this.denoiseGTAOPass) {
-            this.denoiseGTAOPass.dispose();
-            this.denoiseGTAOPass = null;
-        }
-        if (this.ssrPass) {
-            this.ssrPass.dispose();
-            this.ssrPass = null;
-        }
-        if (this.outlinePass) {
-            this.outlinePass.dispose();
-            this.outlinePass = null;
-        }
         this.outlineObjects = [];
-        if (this.scenePass) {
-            this.scenePass.dispose();
-            this.scenePass = null;
-        }
         if (this.postProcessing) {
             this.postProcessing.dispose();
             this.postProcessing = null;
@@ -3210,6 +3056,59 @@ class LabelComponent extends SceneComponent {
 // labelStyle.style.fontSize        = "10px";
 // labelStyle.style.pointerEvents   = 'auto';
 
+const DefaultBloomParam = {
+    type: exports.PostProcessStepType.Bloom,
+    threshold: 0,
+    strength: 1,
+    radius: 0,
+};
+
+const DefaultDenoiseParam = {
+    denoiseRadius: 5,
+    lumaPhi: 5,
+    depthPhi: 5,
+    normalPhi: 5
+};
+const DefaultGTAOParam = {
+    type: exports.PostProcessStepType.GroundTruthAmbientOcclusion,
+    distanceExponent: 1,
+    distanceFallOff: 1,
+    radius: 0.25,
+    scale: 1,
+    thickness: 1,
+    denoised: true,
+    denoiseParam: DefaultDenoiseParam,
+};
+
+const DefaultDOFParam = {
+    type: exports.PostProcessStepType.DepthOfField,
+    focus: 500.0,
+    aperture: 5,
+    maxblur: 0.01
+};
+
+const DefaultOutlineParams = {
+    type: exports.PostProcessStepType.Outline,
+    edgeStrength: 3.0,
+    edgeGlow: 1.0,
+    edgeThickness: 1.0,
+    pulsePeriod: 0.0,
+    visibleEdgeColor: 0xffffff,
+    hiddenEdgeColor: 0xffffff,
+};
+
+const DefaultSSRParam = {
+    type: exports.PostProcessStepType.ScreenSpaceReflection,
+    maxDistance: 0.5,
+    opacity: 1,
+    thickness: 0.015,
+};
+
+const DefaultAAParams = {
+    type: exports.PostProcessStepType.Antialiasing,
+    method: "fxaa"
+};
+
 class FirstPerson extends Pawn {
     constructor(controller) {
         super(controller);