@onerjs/core 8.28.3 → 8.28.5

package/PostProcesses/RenderPipeline/Pipelines/ssao2RenderingPipeline.js

@@ -3,8 +3,6 @@ import { __decorate } from "../../../tslib.es6.js";
 import { Logger } from "../../../Misc/logger.js";
 import { serialize } from "../../../Misc/decorators.js";
 import { SerializationHelper } from "../../../Misc/decorators.serialization.js";
-import { Vector3, TmpVectors, Vector2 } from "../../../Maths/math.vector.js";
-import { Camera } from "../../../Cameras/camera.js";
 import { Texture } from "../../../Materials/Textures/texture.js";
 import { PostProcess } from "../../../PostProcesses/postProcess.js";
 import { PostProcessRenderPipeline } from "../../../PostProcesses/RenderPipeline/postProcessRenderPipeline.js";
@@ -15,35 +13,61 @@ import { EngineStore } from "../../../Engines/engineStore.js";
 import { SSAO2Configuration } from "../../../Rendering/ssao2Configuration.js";
 import { GeometryBufferRenderer } from "../../../Rendering/geometryBufferRenderer.js";
 
-import { RandomRange } from "../../../Maths/math.scalar.functions.js";
-import { RawTexture } from "../../../Materials/Textures/rawTexture.js";
 import "../../../PostProcesses/RenderPipeline/postProcessRenderPipelineManagerSceneComponent.js";
+import { ThinSSAO2RenderingPipeline } from "./thinSSAO2RenderingPipeline.js";
+import { ThinSSAO2PostProcess } from "../../thinSSAO2PostProcess.js";
+import { ThinSSAO2BlurPostProcess } from "../../thinSSAO2BlurPostProcess.js";
+import { ThinSSAO2CombinePostProcess } from "../../thinSSAO2CombinePostProcess.js";
 /**
  * Render pipeline to produce ssao effect
  */
 export class SSAO2RenderingPipeline extends PostProcessRenderPipeline {
+    /**
+     * The output strength of the SSAO post-process. Default value is 1.0.
+     */
+    get totalStrength() {
+        return this._thinSSAORenderingPipeline.totalStrength;
+    }
+    set totalStrength(value) {
+        this._thinSSAORenderingPipeline.totalStrength = value;
+    }
+    /**
+     * Maximum depth value to still render AO. A smooth falloff makes the dimming more natural, so there will be no abrupt shading change.
+     */
+    get maxZ() {
+        return this._thinSSAORenderingPipeline.maxZ;
+    }
+    set maxZ(value) {
+        this._thinSSAORenderingPipeline.maxZ = value;
+    }
+    /**
+     * In order to save performances, SSAO radius is clamped on close geometry. This ratio changes by how much.
+     */
+    get minZAspect() {
+        return this._thinSSAORenderingPipeline.minZAspect;
+    }
+    set minZAspect(value) {
+        this._thinSSAORenderingPipeline.minZAspect = value;
+    }
     /**
      * Used in SSAO calculations to compensate for accuracy issues with depth values. Default 0.02.
      *
      * Normally you do not need to change this value, but you can experiment with it if you get a lot of in false self-occlusion on flat surfaces when using fewer than 16 samples. Useful range is normally [0..0.1] but higher values is allowed.
      */
     set epsilon(n) {
-        this._epsilon = n;
-        this._ssaoPostProcess.updateEffect(this._getDefinesForSSAO());
+        this._thinSSAORenderingPipeline.epsilon = n;
     }
     get epsilon() {
-        return this._epsilon;
+        return this._thinSSAORenderingPipeline.epsilon;
     }
     /**
      * Number of samples used for the SSAO calculations. Default value is 8.
      */
     set samples(n) {
-        this._samples = n;
-        this._ssaoPostProcess.updateEffect(this._getDefinesForSSAO());
-        this._sampleSphere = this._generateHemisphere();
+        this._thinSSAORenderingPipeline.samples = n;
     }
     get samples() {
-        return this._samples;
+        return this._thinSSAORenderingPipeline.samples;
     }
     /**
      * Number of samples to use for antialiasing.
@@ -72,20 +96,35 @@ export class SSAO2RenderingPipeline extends PostProcessRenderPipeline {
         }
         return this._scene.prePassRenderer;
     }
+    /**
+     * The radius around the analyzed pixel used by the SSAO post-process. Default value is 2.0
+     */
+    get radius() {
+        return this._thinSSAORenderingPipeline.radius;
+    }
+    set radius(value) {
+        this._thinSSAORenderingPipeline.radius = value;
+    }
+    /**
+     * The base color of the SSAO post-process
+     * The final result is "base + ssao" between [0, 1]
+     */
+    get base() {
+        return this._thinSSAORenderingPipeline.base;
+    }
+    set base(value) {
+        this._thinSSAORenderingPipeline.base = value;
+    }
     /**
      * Skips the denoising (blur) stage of the SSAO calculations.
      *
      * Useful to temporarily set while experimenting with the other SSAO2 settings.
      */
     set bypassBlur(b) {
-        const defines = this._getDefinesForBlur(this.expensiveBlur, b);
-        const samplers = this._getSamplersForBlur(b);
-        this._blurHPostProcess.updateEffect(defines.h, null, samplers);
-        this._blurVPostProcess.updateEffect(defines.v, null, samplers);
-        this._bypassBlur = b;
+        this._thinSSAORenderingPipeline.bypassBlur = b;
     }
     get bypassBlur() {
-        return this._bypassBlur;
+        return this._thinSSAORenderingPipeline.bypassBlur;
     }
     /**
      * Enables the configurable bilateral denoising (blurring) filter. Default is true.
@@ -95,13 +134,51 @@ export class SSAO2RenderingPipeline extends PostProcessRenderPipeline {
      * configured in several ways to fit your scene.
      */
     set expensiveBlur(b) {
-        const defines = this._getDefinesForBlur(b, this._bypassBlur);
-        this._blurHPostProcess.updateEffect(defines.h);
-        this._blurVPostProcess.updateEffect(defines.v);
-        this._expensiveBlur = b;
+        this._thinSSAORenderingPipeline.expensiveBlur = b;
     }
     get expensiveBlur() {
-        return this._expensiveBlur;
+        return this._thinSSAORenderingPipeline.expensiveBlur;
+    }
+    /**
+     * The number of samples the bilateral filter uses in both dimensions when denoising the SSAO calculations. Default value is 16.
+     *
+     * A higher value should result in smoother shadows but will use more processing time in the shaders.
+     *
+     * A high value can cause the shadows to get to blurry or create visible artifacts (bands) near sharp details in the geometry. The artifacts can sometimes be mitigated by increasing the bilateralSoften setting.
+     */
+    get bilateralSamples() {
+        return this._thinSSAORenderingPipeline.bilateralSamples;
+    }
+    set bilateralSamples(n) {
+        this._thinSSAORenderingPipeline.bilateralSamples = n;
+    }
+    /**
+     * Controls the shape of the denoising kernel used by the bilateral filter. Default value is 0.
+     *
+     * By default the bilateral filter acts like a box-filter, treating all samples on the same depth with equal weights. This is effective to maximize the denoising effect given a limited set of samples. However, it also often results in visible ghosting around sharp shadow regions and can spread out lines over large areas so they are no longer visible.
+     *
+     * Increasing this setting will make the filter pay less attention to samples further away from the center sample, reducing many artifacts but at the same time increasing noise.
+     *
+     * Useful value range is [0..1].
+     */
+    get bilateralSoften() {
+        return this._thinSSAORenderingPipeline.bilateralSoften;
+    }
+    set bilateralSoften(n) {
+        this._thinSSAORenderingPipeline.bilateralSoften = n;
+    }
+    /**
+     * How forgiving the bilateral denoiser should be when rejecting samples. Default value is 0.
+     *
+     * A higher value results in the bilateral filter being more forgiving and thus doing a better job at denoising slanted and curved surfaces, but can lead to shadows spreading out around corners or between objects that are close to each other depth wise.
+     *
+     * Useful value range is normally [0..1], but higher values are allowed.
+     */
+    get bilateralTolerance() {
+        return this._thinSSAORenderingPipeline.bilateralTolerance;
+    }
+    set bilateralTolerance(n) {
+        this._thinSSAORenderingPipeline.bilateralTolerance = n;
     }
     /**
      *  Support test.
@@ -113,6 +190,15 @@ export class SSAO2RenderingPipeline extends PostProcessRenderPipeline {
         }
         return engine._features.supportSSAO2;
     }
+    /**
+     * Indicates that the combine stage should use the current camera viewport to render the SSAO result on only a portion of the output texture (default: true).
+     */
+    get useViewportInCombineStage() {
+        return this._thinSSAORenderingPipeline.useViewportInCombineStage;
+    }
+    set useViewportInCombineStage(b) {
+        this._thinSSAORenderingPipeline.useViewportInCombineStage = b;
+    }
     /**
      * Gets active scene
      */
@@ -156,68 +242,13 @@ export class SSAO2RenderingPipeline extends PostProcessRenderPipeline {
          * The PostProcess id in the pipeline that combines the SSAO-Blur output with the original scene color (SSAOOriginalSceneColorEffect)
          */
         this.SSAOCombineRenderEffect = "SSAOCombineRenderEffect";
-        /**
-         * The output strength of the SSAO post-process. Default value is 1.0.
-         */
-        this.totalStrength = 1.0;
-        /**
-         * Maximum depth value to still render AO. A smooth falloff makes the dimming more natural, so there will be no abrupt shading change.
-         */
-        this.maxZ = 100.0;
-        /**
-         * In order to save performances, SSAO radius is clamped on close geometry. This ratio changes by how much.
-         */
-        this.minZAspect = 0.2;
-        this._epsilon = 0.02;
-        this._samples = 8;
         this._textureSamples = 1;
         this._forcedGeometryBuffer = null;
         /**
          * Force rendering the geometry through geometry buffer.
          */
         this._forceGeometryBuffer = false;
-        /**
-         * The radius around the analyzed pixel used by the SSAO post-process. Default value is 2.0
-         */
-        this.radius = 2.0;
-        /**
-         * The base color of the SSAO post-process
-         * The final result is "base + ssao" between [0, 1]
-         */
-        this.base = 0;
-        this._bypassBlur = false;
-        this._expensiveBlur = true;
-        /**
-         * The number of samples the bilateral filter uses in both dimensions when denoising the SSAO calculations. Default value is 16.
-         *
-         * A higher value should result in smoother shadows but will use more processing time in the shaders.
-         *
-         * A high value can cause the shadows to get to blurry or create visible artifacts (bands) near sharp details in the geometry. The artifacts can sometimes be mitigated by increasing the bilateralSoften setting.
-         */
-        this.bilateralSamples = 16;
-        /**
-         * Controls the shape of the denoising kernel used by the bilateral filter. Default value is 0.
-         *
-         * By default the bilateral filter acts like a box-filter, treating all samples on the same depth with equal weights. This is effective to maximize the denoising effect given a limited set of samples. However, it also often results in visible ghosting around sharp shadow regions and can spread out lines over large areas so they are no longer visible.
-         *
-         * Increasing this setting will make the filter pay less attention to samples further away from the center sample, reducing many artifacts but at the same time increasing noise.
-         *
-         * Useful value range is [0..1].
-         */
-        this.bilateralSoften = 0;
-        /**
-         * How forgiving the bilateral denoiser should be when rejecting samples. Default value is 0.
-         *
-         * A higher value results in the bilateral filter being more forgiving and thus doing a better job at denoising slanted and curved surfaces, but can lead to shadows spreading out around corners or between objects that are close to each other depth wise.
-         *
-         * Useful value range is normally [0..1], but higher values are allowed.
-         */
-        this.bilateralTolerance = 0;
-        /**
-         * Indicates that the combine stage should use the current camera viewport to render the SSAO result on only a portion of the output texture (default: true).
-         */
-        this.useViewportInCombineStage = true;
-        this._bits = new Uint32Array(1);
+        this._thinSSAORenderingPipeline = new ThinSSAO2RenderingPipeline(name, scene);
         this._scene = scene;
         this._ratio = ratio;
         this._textureType = textureType;
@@ -249,7 +280,6 @@ export class SSAO2RenderingPipeline extends PostProcessRenderPipeline {
                 Logger.Error("SSAO2RenderingPipeline does not support generateNormalsInWorldSpace=true for the prepass renderer!");
             }
         }
-        this._createRandomTexture();
         this._originalColorPostProcess = new PassPostProcess("SSAOOriginalSceneColor", 1.0, null, Texture.BILINEAR_SAMPLINGMODE, scene.getEngine(), undefined, this._textureType);
         this._originalColorPostProcess.samples = this.textureSamples;
         this._createSSAOPostProcess(1.0, textureType);
@@ -298,12 +328,12 @@ export class SSAO2RenderingPipeline extends PostProcessRenderPipeline {
             this._blurVPostProcess.dispose(camera);
             this._ssaoCombinePostProcess.dispose(camera);
         }
-        this._randomTexture.dispose();
         if (disableGeometryBufferRenderer && !this._forcedGeometryBuffer) {
             this._scene.disableGeometryBufferRenderer();
         }
         this._scene.postProcessRenderPipelineManager.detachCamerasFromRenderPipeline(this._name, this._scene.cameras);
         this._scene.postProcessRenderPipelineManager.removePipeline(this._name);
+        this._thinSSAORenderingPipeline.dispose();
         super.dispose();
     }
     // Private Methods
@@ -311,45 +341,24 @@ export class SSAO2RenderingPipeline extends PostProcessRenderPipeline {
     _rebuild() {
         super._rebuild();
     }
-    _getSamplersForBlur(disabled) {
-        return disabled ? ["textureSampler"] : ["textureSampler", "depthSampler"];
-    }
-    _getDefinesForBlur(bilateral, disabled) {
-        let define = "#define BLUR\n";
-        if (disabled) {
-            define += "#define BLUR_BYPASS\n";
-        }
-        if (!bilateral) {
-            define += "#define BLUR_LEGACY\n";
-        }
-        return { h: define + "#define BLUR_H\n", v: define };
-    }
     _createBlurPostProcess(ssaoRatio, blurRatio, textureType) {
-        const defines = this._getDefinesForBlur(this.expensiveBlur, this.bypassBlur);
-        const samplers = this._getSamplersForBlur(this.bypassBlur);
-        this._blurHPostProcess = this._createBlurFilter("BlurH", samplers, ssaoRatio, defines.h, textureType, true);
-        this._blurVPostProcess = this._createBlurFilter("BlurV", samplers, blurRatio, defines.v, textureType, false);
-    }
-    _createBlurFilter(name, samplers, ratio, defines, textureType, horizontal) {
-        const blurFilter = new PostProcess(name, "ssao2", ["outSize", "samples", "soften", "tolerance"], samplers, ratio, null, Texture.BILINEAR_SAMPLINGMODE, this._scene.getEngine(), false, defines, textureType, undefined, undefined, undefined, undefined, this._scene.getEngine().isWebGPU ? 1 /* ShaderLanguage.WGSL */ : 0 /* ShaderLanguage.GLSL */, (useWebGPU, list) => {
-            if (useWebGPU) {
-                list.push(import("../../../ShadersWGSL/ssao2.fragment.js"));
-            }
-            else {
-                list.push(import("../../../Shaders/ssao2.fragment.js"));
-            }
+        this._blurHPostProcess = this._createBlurFilter("BlurH", ssaoRatio, textureType, true);
+        this._blurVPostProcess = this._createBlurFilter("BlurV", blurRatio, textureType, false);
+    }
+    _createBlurFilter(name, ratio, textureType, horizontal) {
+        const blurFilter = new PostProcess(name, ThinSSAO2BlurPostProcess.FragmentUrl, {
+            size: ratio,
+            samplingMode: 2,
+            engine: this._scene.getEngine(),
+            textureType: this._textureType,
+            effectWrapper: horizontal ? this._thinSSAORenderingPipeline._ssaoBlurXPostProcess : this._thinSSAORenderingPipeline._ssaoBlurYPostProcess,
         });
         blurFilter.onApply = (effect) => {
-            if (!this._scene.activeCamera) {
-                return;
-            }
             const ratio = this._ratio.blurRatio || this._ratio;
             const ssaoCombineSize = horizontal ? this._originalColorPostProcess.width * ratio : this._originalColorPostProcess.height * ratio;
             const originalColorSize = horizontal ? this._originalColorPostProcess.width : this._originalColorPostProcess.height;
-            effect.setFloat("outSize", ssaoCombineSize > 0 ? ssaoCombineSize : originalColorSize);
-            effect.setInt("samples", this.bilateralSamples);
-            effect.setFloat("soften", this.bilateralSoften);
-            effect.setFloat("tolerance", this.bilateralTolerance);
+            this._thinSSAORenderingPipeline._ssaoBlurXPostProcess.textureSize = ssaoCombineSize > 0 ? ssaoCombineSize : originalColorSize;
+            this._thinSSAORenderingPipeline._ssaoBlurYPostProcess.textureSize = ssaoCombineSize > 0 ? ssaoCombineSize : originalColorSize;
             if (this._geometryBufferRenderer) {
                 effect.setTexture("depthSampler", this._geometryBufferRenderer.getGBuffer().textures[0]);
             }
@@ -361,111 +370,33 @@ export class SSAO2RenderingPipeline extends PostProcessRenderPipeline {
         blurFilter.autoClear = false;
         return blurFilter;
     }
-    //Van der Corput radical inverse
-    _radicalInverse_VdC(i) {
-        this._bits[0] = i;
-        this._bits[0] = ((this._bits[0] << 16) | (this._bits[0] >> 16)) >>> 0;
-        this._bits[0] = ((this._bits[0] & 0x55555555) << 1) | (((this._bits[0] & 0xaaaaaaaa) >>> 1) >>> 0);
-        this._bits[0] = ((this._bits[0] & 0x33333333) << 2) | (((this._bits[0] & 0xcccccccc) >>> 2) >>> 0);
-        this._bits[0] = ((this._bits[0] & 0x0f0f0f0f) << 4) | (((this._bits[0] & 0xf0f0f0f0) >>> 4) >>> 0);
-        this._bits[0] = ((this._bits[0] & 0x00ff00ff) << 8) | (((this._bits[0] & 0xff00ff00) >>> 8) >>> 0);
-        return this._bits[0] * 2.3283064365386963e-10; // / 0x100000000 or / 4294967296
-    }
-    _hammersley(i, n) {
-        return [i / n, this._radicalInverse_VdC(i)];
-    }
-    _hemisphereSample_uniform(u, v) {
-        const phi = v * 2.0 * Math.PI;
-        // rejecting samples that are close to tangent plane to avoid z-fighting artifacts
-        const cosTheta = 1.0 - u * 0.85;
-        const sinTheta = Math.sqrt(1.0 - cosTheta * cosTheta);
-        return new Vector3(Math.cos(phi) * sinTheta, Math.sin(phi) * sinTheta, cosTheta);
-    }
-    _generateHemisphere() {
-        const numSamples = this.samples;
-        const result = [];
-        let vector;
-        let i = 0;
-        while (i < numSamples) {
-            if (numSamples < 16) {
-                vector = this._hemisphereSample_uniform(Math.random(), Math.random());
-            }
-            else {
-                const rand = this._hammersley(i, numSamples);
-                vector = this._hemisphereSample_uniform(rand[0], rand[1]);
+    _getTextureSize() {
+        const engine = this._scene.getEngine();
+        const prePassRenderer = this._prePassRenderer;
+        let textureSize = { width: engine.getRenderWidth(), height: engine.getRenderHeight() };
+        if (prePassRenderer && this._scene.activeCamera?._getFirstPostProcess() === this._ssaoPostProcess) {
+            const renderTarget = prePassRenderer.getRenderTarget();
+            if (renderTarget && renderTarget.textures) {
+                textureSize = renderTarget.textures[prePassRenderer.getIndex(4)].getSize();
             }
-            result.push(vector.x, vector.y, vector.z);
-            i++;
         }
-        return result;
-    }
-    _getDefinesForSSAO() {
-        let defines = `#define SSAO\n#define SAMPLES ${this.samples}\n#define EPSILON ${this.epsilon.toFixed(4)}`;
-        if (this._scene.activeCamera?.mode === Camera.ORTHOGRAPHIC_CAMERA) {
-            defines += `\n#define ORTHOGRAPHIC_CAMERA`;
+        else if (this._ssaoPostProcess.inputTexture) {
+            textureSize.width = this._ssaoPostProcess.inputTexture.width;
+            textureSize.height = this._ssaoPostProcess.inputTexture.height;
         }
-        return defines;
+        return textureSize;
     }
     _createSSAOPostProcess(ratio, textureType) {
-        this._sampleSphere = this._generateHemisphere();
-        const defines = this._getDefinesForSSAO();
-        const samplers = ["randomSampler", "depthSampler", "normalSampler"];
-        this._ssaoPostProcess = new PostProcess("ssao2", "ssao2", [
-            "sampleSphere",
-            "samplesFactor",
-            "randTextureTiles",
-            "totalStrength",
-            "radius",
-            "base",
-            "range",
-            "projection",
-            "near",
-            "texelSize",
-            "xViewport",
-            "yViewport",
-            "viewport",
-            "maxZ",
-            "minZAspect",
-            "depthProjection",
-        ], samplers, ratio, null, Texture.BILINEAR_SAMPLINGMODE, this._scene.getEngine(), false, defines, textureType, undefined, undefined, undefined, undefined, this._scene.getEngine().isWebGPU ? 1 /* ShaderLanguage.WGSL */ : 0 /* ShaderLanguage.GLSL */, (useWebGPU, list) => {
-            if (useWebGPU) {
-                list.push(import("../../../ShadersWGSL/ssao2.fragment.js"));
-            }
-            else {
-                list.push(import("../../../Shaders/ssao2.fragment.js"));
-            }
+        this._ssaoPostProcess = new PostProcess("ssao", ThinSSAO2PostProcess.FragmentUrl, {
+            size: ratio,
+            samplingMode: 2,
+            engine: this._scene.getEngine(),
+            textureType,
+            effectWrapper: this._thinSSAORenderingPipeline._ssaoPostProcess,
         });
         this._ssaoPostProcess.autoClear = false;
         this._ssaoPostProcess.onApply = (effect) => {
-            if (!this._scene.activeCamera) {
-                return;
-            }
-            effect.setArray3("sampleSphere", this._sampleSphere);
-            effect.setFloat("randTextureTiles", 32.0);
-            effect.setFloat("samplesFactor", 1 / this.samples);
-            effect.setFloat("totalStrength", this.totalStrength);
-            effect.setFloat2("texelSize", 1 / this._ssaoPostProcess.width, 1 / this._ssaoPostProcess.height);
-            effect.setFloat("radius", this.radius);
-            effect.setFloat("maxZ", this.maxZ);
-            effect.setFloat("minZAspect", this.minZAspect);
-            effect.setFloat("base", this.base);
-            effect.setFloat("near", this._scene.activeCamera.minZ);
-            if (this._scene.activeCamera.mode === Camera.PERSPECTIVE_CAMERA) {
-                effect.setMatrix3x3("depthProjection", SSAO2RenderingPipeline.PERSPECTIVE_DEPTH_PROJECTION);
-                effect.setFloat("xViewport", Math.tan(this._scene.activeCamera.fov / 2) * this._scene.getEngine().getAspectRatio(this._scene.activeCamera, true));
-                effect.setFloat("yViewport", Math.tan(this._scene.activeCamera.fov / 2));
-            }
-            else {
-                const halfWidth = this._scene.getEngine().getRenderWidth() / 2.0;
-                const halfHeight = this._scene.getEngine().getRenderHeight() / 2.0;
-                const orthoLeft = this._scene.activeCamera.orthoLeft ?? -halfWidth;
-                const orthoRight = this._scene.activeCamera.orthoRight ?? halfWidth;
-                const orthoBottom = this._scene.activeCamera.orthoBottom ?? -halfHeight;
-                const orthoTop = this._scene.activeCamera.orthoTop ?? halfHeight;
-                effect.setMatrix3x3("depthProjection", SSAO2RenderingPipeline.ORTHO_DEPTH_PROJECTION);
-                effect.setFloat4("viewport", orthoLeft, orthoRight, orthoBottom, orthoTop);
-            }
-            effect.setMatrix("projection", this._scene.getProjectionMatrix());
+            this._thinSSAORenderingPipeline._ssaoPostProcess.camera = this._scene.activeCamera;
             if (this._geometryBufferRenderer) {
                 effect.setTexture("depthSampler", this._geometryBufferRenderer.getGBuffer().textures[0]);
                 effect.setTexture("normalSampler", this._geometryBufferRenderer.getGBuffer().textures[1]);
@@ -474,7 +405,9 @@ export class SSAO2RenderingPipeline extends PostProcessRenderPipeline {
                 effect.setTexture("depthSampler", this._prePassRenderer.getRenderTarget().textures[this._prePassRenderer.getIndex(5)]);
                 effect.setTexture("normalSampler", this._prePassRenderer.getRenderTarget().textures[this._prePassRenderer.getIndex(6)]);
             }
-            effect.setTexture("randomSampler", this._randomTexture);
+            const textureSize = this._getTextureSize();
+            this._thinSSAORenderingPipeline._ssaoPostProcess.textureWidth = textureSize.width;
+            this._thinSSAORenderingPipeline._ssaoPostProcess.textureHeight = textureSize.height;
         };
         this._ssaoPostProcess.samples = this.textureSamples;
         if (!this._forceGeometryBuffer) {
@@ -482,44 +415,20 @@ export class SSAO2RenderingPipeline extends PostProcessRenderPipeline {
         }
     }
     _createSSAOCombinePostProcess(ratio, textureType) {
-        this._ssaoCombinePostProcess = new PostProcess("ssaoCombine", "ssaoCombine", [], ["originalColor", "viewport"], ratio, null, Texture.BILINEAR_SAMPLINGMODE, this._scene.getEngine(), false, undefined, textureType, undefined, undefined, undefined, undefined, this._scene.getEngine().isWebGPU ? 1 /* ShaderLanguage.WGSL */ : 0 /* ShaderLanguage.GLSL */, (useWebGPU, list) => {
-            if (useWebGPU) {
-                list.push(import("../../../ShadersWGSL/ssaoCombine.fragment.js"));
-            }
-            else {
-                list.push(import("../../../Shaders/ssaoCombine.fragment.js"));
-            }
+        this._ssaoCombinePostProcess = new PostProcess("ssaoCombine", ThinSSAO2CombinePostProcess.FragmentUrl, {
+            size: ratio,
+            samplingMode: 2,
+            engine: this._scene.getEngine(),
+            textureType,
+            effectWrapper: this._thinSSAORenderingPipeline._ssaoCombinePostProcess,
         });
         this._ssaoCombinePostProcess.onApply = (effect) => {
-            const viewport = this._scene.activeCamera.viewport;
-            if (this.useViewportInCombineStage) {
-                effect.setVector4("viewport", TmpVectors.Vector4[0].copyFromFloats(viewport.x, viewport.y, viewport.width, viewport.height));
-            }
-            else {
-                effect.setVector4("viewport", TmpVectors.Vector4[0].copyFromFloats(0, 0, 1, 1));
-            }
+            this._thinSSAORenderingPipeline._ssaoCombinePostProcess.camera = this._scene.activeCamera;
             effect.setTextureFromPostProcessOutput("originalColor", this._originalColorPostProcess);
         };
         this._ssaoCombinePostProcess.autoClear = false;
         this._ssaoCombinePostProcess.samples = this.textureSamples;
     }
-    _createRandomTexture() {
-        const size = 128;
-        const data = new Uint8Array(size * size * 4);
-        const randVector = Vector2.Zero();
-        for (let index = 0; index < data.length;) {
-            randVector.set(RandomRange(0, 1), RandomRange(0, 1)).normalize().scaleInPlace(255);
-            data[index++] = Math.floor(randVector.x);
-            data[index++] = Math.floor(randVector.y);
-            data[index++] = 0;
-            data[index++] = 255;
-        }
-        const texture = RawTexture.CreateRGBATexture(data, size, size, this._scene, false, false, 2);
-        texture.name = "SSAORandomTexture";
-        texture.wrapU = Texture.WRAP_ADDRESSMODE;
-        texture.wrapV = Texture.WRAP_ADDRESSMODE;
-        this._randomTexture = texture;
-    }
     /**
      * Serialize the rendering pipeline (Used when exporting)
      * @returns the serialized object
@@ -540,23 +449,21 @@ export class SSAO2RenderingPipeline extends PostProcessRenderPipeline {
         return SerializationHelper.Parse(() => new SSAO2RenderingPipeline(source._name, scene, source._ratio, undefined, source._forceGeometryBuffer, source._textureType), source, scene, rootUrl);
     }
 }
-SSAO2RenderingPipeline.ORTHO_DEPTH_PROJECTION = [1, 0, 0, 0, 1, 0, 0, 0, 1];
-SSAO2RenderingPipeline.PERSPECTIVE_DEPTH_PROJECTION = [0, 0, 0, 0, 0, 0, 1, 1, 1];
 __decorate([
     serialize()
-], SSAO2RenderingPipeline.prototype, "totalStrength", void 0);
+], SSAO2RenderingPipeline.prototype, "totalStrength", null);
 __decorate([
     serialize()
-], SSAO2RenderingPipeline.prototype, "maxZ", void 0);
+], SSAO2RenderingPipeline.prototype, "maxZ", null);
 __decorate([
     serialize()
-], SSAO2RenderingPipeline.prototype, "minZAspect", void 0);
+], SSAO2RenderingPipeline.prototype, "minZAspect", null);
 __decorate([
     serialize("epsilon")
-], SSAO2RenderingPipeline.prototype, "_epsilon", void 0);
+], SSAO2RenderingPipeline.prototype, "epsilon", null);
 __decorate([
     serialize("samples")
-], SSAO2RenderingPipeline.prototype, "_samples", void 0);
+], SSAO2RenderingPipeline.prototype, "samples", null);
 __decorate([
     serialize("textureSamples")
 ], SSAO2RenderingPipeline.prototype, "_textureSamples", void 0);
@@ -571,24 +478,24 @@ __decorate([
 ], SSAO2RenderingPipeline.prototype, "_textureType", void 0);
 __decorate([
     serialize()
-], SSAO2RenderingPipeline.prototype, "radius", void 0);
+], SSAO2RenderingPipeline.prototype, "radius", null);
 __decorate([
     serialize()
-], SSAO2RenderingPipeline.prototype, "base", void 0);
+], SSAO2RenderingPipeline.prototype, "base", null);
 __decorate([
     serialize("bypassBlur")
-], SSAO2RenderingPipeline.prototype, "_bypassBlur", void 0);
+], SSAO2RenderingPipeline.prototype, "bypassBlur", null);
 __decorate([
     serialize("expensiveBlur")
-], SSAO2RenderingPipeline.prototype, "_expensiveBlur", void 0);
+], SSAO2RenderingPipeline.prototype, "expensiveBlur", null);
 __decorate([
     serialize()
-], SSAO2RenderingPipeline.prototype, "bilateralSamples", void 0);
+], SSAO2RenderingPipeline.prototype, "bilateralSamples", null);
 __decorate([
     serialize()
-], SSAO2RenderingPipeline.prototype, "bilateralSoften", void 0);
+], SSAO2RenderingPipeline.prototype, "bilateralSoften", null);
 __decorate([
     serialize()
-], SSAO2RenderingPipeline.prototype, "bilateralTolerance", void 0);
+], SSAO2RenderingPipeline.prototype, "bilateralTolerance", null);
 RegisterClass("BABYLON.SSAO2RenderingPipeline", SSAO2RenderingPipeline);
 //# sourceMappingURL=ssao2RenderingPipeline.js.map