@babylonjs/core 5.50.1 → 5.52.0

package/PostProcesses/RenderPipeline/Pipelines/ssrRenderingPipeline.js

@@ -1,6 +1,5 @@
 import { __decorate } from "../../../tslib.es6.js";
 /* eslint-disable @typescript-eslint/naming-convention */
-import { Logger } from "../../../Misc/logger.js";
 import { serialize, SerializationHelper } from "../../../Misc/decorators.js";
 import { Vector3, Matrix, Quaternion, TmpVectors } from "../../../Maths/math.vector.js";
 import { PostProcess } from "../../postProcess.js";
@@ -44,9 +43,24 @@ export class SSRRenderingPipeline extends PostProcessRenderPipeline {
     get samples() {
         return this._samples;
     }
+    /**
+     * Gets or sets the downsample factor used to reduce the size of the texture used to compute the SSR contribution (default: 0).
+     * Use 0 to render the SSR contribution at full resolution, 1 to render at half resolution, 2 to render at 1/3 resolution, etc.
+     * Note that it is used only when blurring is enabled (blurDispersionStrength \> 0), because in that mode the SSR contribution is generated in a separate texture.
+     */
+    get ssrDownsample() {
+        return this._ssrDownsample;
+    }
+    set ssrDownsample(downsample) {
+        if (downsample === this._ssrDownsample) {
+            return;
+        }
+        this._ssrDownsample = downsample;
+        this._buildPipeline();
+    }
     /**
      * Gets or sets the blur dispersion strength. Set this value to 0 to disable blurring (default: 0.05)
-     * The reflections are blurred based on the distance between the pixel shaded and the reflected pixel: the higher the distance the more blurry the reflection is.
+     * The reflections are blurred based on the roughness of the surface and the distance between the pixel shaded and the reflected pixel: the higher the distance the more blurry the reflection is.
      * blurDispersionStrength allows to increase or decrease this effect.
      */
     get blurDispersionStrength() {
@@ -62,9 +76,26 @@ export class SSRRenderingPipeline extends PostProcessRenderPipeline {
             this._buildPipeline();
         }
     }
+    _useBlur() {
+        return this._blurDispersionStrength > 0;
+    }
+    /**
+     * Gets or sets the downsample factor used to reduce the size of the textures used to blur the reflection effect (default: 0).
+     * Use 0 to blur at full resolution, 1 to render at half resolution, 2 to render at 1/3 resolution, etc.
+     */
+    get blurDownsample() {
+        return this._blurDownsample;
+    }
+    set blurDownsample(downsample) {
+        if (downsample === this._blurDownsample) {
+            return;
+        }
+        this._blurDownsample = downsample;
+        this._buildPipeline();
+    }
     /**
-     * Gets or sets whether or not smoothing reflections is enabled.
-     * Enabling smoothing will require more GPU power and can generate a drop in FPS.
+     * Gets or sets whether or not smoothing reflections is enabled (default: false)
+     * Enabling smoothing will require more GPU power.
      * Note that this setting has no effect if step = 1: it's only used if step \> 1.
      */
     get enableSmoothReflections() {
@@ -124,6 +155,19 @@ export class SSRRenderingPipeline extends PostProcessRenderPipeline {
         this._attenuateIntersectionDistance = attenuate;
         this._updateEffectDefines();
     }
+    /**
+     * Gets or sets a boolean indicating if the reflections should be attenuated according to the number of iterations performed to find the intersection (default: true).
+     */
+    get attenuateIntersectionIterations() {
+        return this._attenuateIntersectionIterations;
+    }
+    set attenuateIntersectionIterations(attenuate) {
+        if (this._attenuateIntersectionIterations === attenuate) {
+            return;
+        }
+        this._attenuateIntersectionIterations = attenuate;
+        this._updateEffectDefines();
+    }
     /**
      * Gets or sets a boolean indicating if the reflections should be attenuated when the reflection ray is facing the camera (the view direction) (default: false).
      */
@@ -188,20 +232,35 @@ export class SSRRenderingPipeline extends PostProcessRenderPipeline {
         return this._depthRenderer;
     }
     /**
-     * Gets or sets the size factor used to create the backface depth texture, used only if enableAutomaticThicknessComputation = true (default: 1).
-     * This factor is used as a divisor of the full screen size (so, 2 means that the backface depth texture will be created at half the screen size, meaning better performances).
-     * Note that you will get rendering artefacts when using a value different from 1: it's a tradeoff between image quality and performances.
+     * Gets or sets the downsample factor (default: 0) used to create the backface depth texture - used only if enableAutomaticThicknessComputation = true.
+     * Use 0 to render the depth at full resolution, 1 to render at half resolution, 2 to render at 1/4 resolution, etc.
+     * Note that you will get rendering artefacts when using a value different from 0: it's a tradeoff between image quality and performances.
      */
-    get backfaceDepthTextureSizeFactor() {
-        return this._backfaceDepthTextureSizeFactor;
+    get backfaceDepthTextureDownsample() {
+        return this._backfaceDepthTextureDownsample;
     }
-    set backfaceDepthTextureSizeFactor(factor) {
-        if (this._backfaceDepthTextureSizeFactor === factor) {
+    set backfaceDepthTextureDownsample(factor) {
+        if (this._backfaceDepthTextureDownsample === factor) {
             return;
         }
-        this._backfaceDepthTextureSizeFactor = factor;
+        this._backfaceDepthTextureDownsample = factor;
         this._resizeDepthRenderer();
     }
+    /**
+     * Gets or sets a boolean (default: true) indicating if the depth of transparent meshes should be written to the backface depth texture (when automatic thickness computation is enabled).
+     */
+    get backfaceForceDepthWriteTransparentMeshes() {
+        return this._backfaceForceDepthWriteTransparentMeshes;
+    }
+    set backfaceForceDepthWriteTransparentMeshes(force) {
+        if (this._backfaceForceDepthWriteTransparentMeshes === force) {
+            return;
+        }
+        this._backfaceForceDepthWriteTransparentMeshes = force;
+        if (this._depthRenderer) {
+            this._depthRenderer.forceDepthWriteTransparentMeshes = force;
+        }
+    }
     /**
      * Gets or sets a boolean indicating if the effect is enabled (default: true).
      */
@@ -230,6 +289,34 @@ export class SSRRenderingPipeline extends PostProcessRenderPipeline {
             }
         }
     }
+    /**
+     * Gets or sets a boolean defining if the input color texture is in gamma space (default: true)
+     * The SSR effect works in linear space, so if the input texture is in gamma space, we must convert the texture to linear space before applying the effect
+     */
+    get inputTextureColorIsInGammaSpace() {
+        return this._inputTextureColorIsInGammaSpace;
+    }
+    set inputTextureColorIsInGammaSpace(gammaSpace) {
+        if (this._inputTextureColorIsInGammaSpace === gammaSpace) {
+            return;
+        }
+        this._inputTextureColorIsInGammaSpace = gammaSpace;
+        this._buildPipeline();
+    }
+    /**
+     * Gets or sets a boolean defining if the output color texture generated by the SSR pipeline should be in gamma space (default: true)
+     * If you have a post-process that comes after the SSR and that post-process needs the input to be in a linear space, you must disable generateOutputInGammaSpace
+     */
+    get generateOutputInGammaSpace() {
+        return this._generateOutputInGammaSpace;
+    }
+    set generateOutputInGammaSpace(gammaSpace) {
+        if (this._generateOutputInGammaSpace === gammaSpace) {
+            return;
+        }
+        this._generateOutputInGammaSpace = gammaSpace;
+        this._buildPipeline();
+    }
     /**
      * Gets or sets a boolean indicating if the effect should be rendered in debug mode (default: false).
      * In this mode, colors have this meaning:
@@ -250,6 +337,13 @@ export class SSRRenderingPipeline extends PostProcessRenderPipeline {
         this._debug = value;
         this._buildPipeline();
     }
+    /**
+     * Gets the scene the effect belongs to.
+     * @returns the scene the effect belongs to.
+     */
+    getScene() {
+        return this._scene;
+    }
     get _geometryBufferRenderer() {
         if (!this._forceGeometryBuffer) {
             return null;
@@ -268,6 +362,13 @@ export class SSRRenderingPipeline extends PostProcessRenderPipeline {
     get scene() {
         return this._scene;
     }
+    /**
+     * Returns true if SSR is supported by the running hardware
+     */
+    get isSupported() {
+        const caps = this._scene.getEngine().getCaps();
+        return caps.drawBuffersExtension && caps.texelFetch;
+    }
     /**
      * Constructor of the SSR rendering pipeline
      * @param name The rendering pipeline name
@@ -316,7 +417,8 @@ export class SSRRenderingPipeline extends PostProcessRenderPipeline {
          */
         this.reflectionSpecularFalloffExponent = 1;
         /**
-         * Maximum number of steps during the ray marching process after which we consider an intersection could not be found (default: 1000)
+         * Maximum number of steps during the ray marching process after which we consider an intersection could not be found (default: 1000).
+         * Should be an integer value.
          */
         this.maxSteps = 1000.0;
         /**
@@ -330,22 +432,28 @@ export class SSRRenderingPipeline extends PostProcessRenderPipeline {
          * 1 should normally be a good value, depending on the scene you may need to use a higher value (2 or 3)
          */
         this.selfCollisionNumSkip = 1;
-        this._blurDispersionStrength = 1 / 20;
         /**
-         * Apply different weighting when blurring.
-         * Must be a value between 2 and 5
+         * Gets or sets the minimum value for one of the reflectivity component of the material to consider it for SSR (default: 0.04).
+         * If all r/g/b components of the reflectivity is below or equal this value, the pixel will not be considered reflective and SSR won't be applied.
          */
-        this.blurQuality = 2;
+        this.reflectivityThreshold = 0.04;
+        this._ssrDownsample = 0;
+        this._blurDispersionStrength = 0.03;
+        this._blurDownsample = 0;
         this._enableSmoothReflections = false;
         this._environmentTextureIsProbe = false;
         this._attenuateScreenBorders = true;
         this._attenuateIntersectionDistance = true;
+        this._attenuateIntersectionIterations = true;
         this._attenuateFacingCamera = false;
         this._attenuateBackfaceReflection = false;
         this._clipToFrustum = true;
         this._enableAutomaticThicknessComputation = false;
-        this._backfaceDepthTextureSizeFactor = 1;
+        this._backfaceDepthTextureDownsample = 0;
+        this._backfaceForceDepthWriteTransparentMeshes = true;
         this._isEnabled = true;
+        this._inputTextureColorIsInGammaSpace = true;
+        this._generateOutputInGammaSpace = true;
         this._debug = false;
         this._forceGeometryBuffer = false;
         this._isDirty = false;
@@ -356,22 +464,24 @@ export class SSRRenderingPipeline extends PostProcessRenderPipeline {
         this._scene = scene;
         this._textureType = textureType;
         this._forceGeometryBuffer = forceGeometryBuffer;
-        if (!this.isSupported) {
-            Logger.Error("The current engine does not support SSR.");
-            return;
-        }
-        scene.postProcessRenderPipelineManager.addPipeline(this);
-        if (this._forceGeometryBuffer) {
-            const geometryBufferRenderer = scene.enableGeometryBufferRenderer();
-            if (geometryBufferRenderer) {
-                geometryBufferRenderer.enableReflectivity = true;
+        if (this.isSupported) {
+            scene.postProcessRenderPipelineManager.addPipeline(this);
+            if (this._forceGeometryBuffer) {
+                const geometryBufferRenderer = scene.enableGeometryBufferRenderer();
+                if (geometryBufferRenderer) {
+                    geometryBufferRenderer.enableReflectivity = true;
+                    geometryBufferRenderer.useSpecificClearForDepthTexture = true;
+                }
             }
+            else {
+                const prePassRenderer = scene.enablePrePassRenderer();
+                if (prePassRenderer) {
+                    prePassRenderer.useSpecificClearForDepthTexture = true;
+                    prePassRenderer.markAsDirty();
+                }
+            }
+            this._buildPipeline();
         }
-        else {
-            const prePassRenderer = scene.enablePrePassRenderer();
-            prePassRenderer === null || prePassRenderer === void 0 ? void 0 : prePassRenderer.markAsDirty();
-        }
-        this._buildPipeline();
     }
     /**
      * Get the class name
@@ -411,20 +521,20 @@ export class SSRRenderingPipeline extends PostProcessRenderPipeline {
         super.dispose();
     }
     _getTextureSize() {
+        var _a, _b;
         const engine = this._scene.getEngine();
-        const geometryBufferRenderer = this._geometryBufferRenderer;
         const prePassRenderer = this._prePassRenderer;
         let textureSize = { width: engine.getRenderWidth(), height: engine.getRenderHeight() };
-        if (geometryBufferRenderer) {
-            textureSize = geometryBufferRenderer.getGBuffer().textures[0].getSize();
-        }
-        else if (prePassRenderer) {
-            const depthIndex = prePassRenderer.getIndex(5);
+        if (prePassRenderer && ((_a = this._scene.activeCamera) === null || _a === void 0 ? void 0 : _a._getFirstPostProcess()) === this._ssrPostProcess) {
             const renderTarget = prePassRenderer.getRenderTarget();
             if (renderTarget && renderTarget.textures) {
-                textureSize = renderTarget.textures[depthIndex].getSize();
+                textureSize = renderTarget.textures[prePassRenderer.getIndex(4)].getSize();
             }
         }
+        else if ((_b = this._ssrPostProcess) === null || _b === void 0 ? void 0 : _b.inputTexture) {
+            textureSize.width = this._ssrPostProcess.inputTexture.width;
+            textureSize.height = this._ssrPostProcess.inputTexture.height;
+        }
         return textureSize;
     }
     _updateEffectDefines() {
@@ -444,6 +554,9 @@ export class SSRRenderingPipeline extends PostProcessRenderPipeline {
             if (this._environmentTexture.boundingBoxSize) {
                 defines.push("#define SSR_USE_LOCAL_REFLECTIONMAP_CUBIC");
             }
+            if (this._environmentTexture.gammaSpace) {
+                defines.push("#define SSR_ENVIRONMENT_CUBE_IS_GAMMASPACE");
+            }
         }
         if (this._environmentTextureIsProbe) {
             defines.push("#define SSR_INVERTCUBICMAP");
@@ -457,6 +570,9 @@ export class SSRRenderingPipeline extends PostProcessRenderPipeline {
         if (this._attenuateIntersectionDistance) {
             defines.push("#define SSR_ATTENUATE_INTERSECTION_DISTANCE");
         }
+        if (this._attenuateIntersectionIterations) {
+            defines.push("#define SSR_ATTENUATE_INTERSECTION_NUMITERATIONS");
+        }
         if (this._attenuateFacingCamera) {
             defines.push("#define SSR_ATTENUATE_FACING_CAMERA");
         }
@@ -466,16 +582,25 @@ export class SSRRenderingPipeline extends PostProcessRenderPipeline {
         if (this._clipToFrustum) {
             defines.push("#define SSRAYTRACE_CLIP_TO_FRUSTUM");
         }
-        if (this._blurDispersionStrength > 0) {
+        if (this._useBlur()) {
             defines.push("#define SSR_USE_BLUR");
         }
         if (this._debug) {
             defines.push("#define SSRAYTRACE_DEBUG");
         }
+        if (this._inputTextureColorIsInGammaSpace) {
+            defines.push("#define SSR_INPUT_IS_GAMMA_SPACE");
+        }
+        if (this._generateOutputInGammaSpace) {
+            defines.push("#define SSR_OUTPUT_IS_GAMMA_SPACE");
+        }
         (_a = this._ssrPostProcess) === null || _a === void 0 ? void 0 : _a.updateEffect(defines.join("\n"));
     }
     _buildPipeline() {
         var _a;
+        if (!this.isSupported) {
+            return;
+        }
         if (!this._isEnabled) {
             this._isDirty = true;
             return;
@@ -495,9 +620,10 @@ export class SSRRenderingPipeline extends PostProcessRenderPipeline {
             if (camera) {
                 this._depthRendererCamera = camera;
                 this._depthRenderer = new DepthRenderer(this._scene, undefined, undefined, undefined, 1, true, "SSRBackDepth");
-                this._depthRenderer.clearColor.r = 1e8; // put a big value because we use the storeCameraSpaceZ mode
+                this._depthRenderer.clearColor.r = 1e8; // "infinity": put a big value because we use the storeCameraSpaceZ mode
                 this._depthRenderer.reverseCulling = true; // we generate depth for the back faces
                 this._depthRenderer.getDepthMap().noPrePassRenderer = true; // we don't want the prepass renderer to attach to our depth buffer!
+                this._depthRenderer.forceDepthWriteTransparentMeshes = this._backfaceForceDepthWriteTransparentMeshes;
                 this._resizeDepthRenderer();
                 camera.customRenderTargets.push(this._depthRenderer.getDepthMap());
             }
@@ -506,7 +632,7 @@ export class SSRRenderingPipeline extends PostProcessRenderPipeline {
         this.addEffect(new PostProcessRenderEffect(engine, this.SSRRenderEffect, () => {
             return this._ssrPostProcess;
         }, true));
-        if (this._blurDispersionStrength > 0) {
+        if (this._useBlur()) {
             this._createBlurAndCombinerPostProcesses();
             this.addEffect(new PostProcessRenderEffect(engine, this.SSRBlurRenderEffect, () => {
                 return [this._blurPostProcessX, this._blurPostProcessY];
@@ -525,8 +651,8 @@ export class SSRRenderingPipeline extends PostProcessRenderPipeline {
         }
         const textureSize = this._getTextureSize();
         const depthRendererSize = this._depthRenderer.getDepthMap().getSize();
-        const width = Math.floor(textureSize.width / this._backfaceDepthTextureSizeFactor);
-        const height = Math.floor(textureSize.height / this._backfaceDepthTextureSizeFactor);
+        const width = Math.floor(textureSize.width / (this._backfaceDepthTextureDownsample + 1));
+        const height = Math.floor(textureSize.height / (this._backfaceDepthTextureDownsample + 1));
         if (depthRendererSize.width !== width || depthRendererSize.height !== height) {
             this._depthRenderer.getDepthMap().resize({ width, height });
         }
@@ -578,6 +704,7 @@ export class SSRRenderingPipeline extends PostProcessRenderPipeline {
             "vReflectionPosition",
             "vReflectionSize",
             "backSizeFactor",
+            "reflectivityThreshold",
         ], ["textureSampler", "normalSampler", "reflectivitySampler", "depthSampler", "envCubeSampler", "backDepthSampler"], 1.0, null, this._textureType, this._scene.getEngine(), false, "", this._textureType);
         this._updateEffectDefines();
         this._ssrPostProcess.onApply = (effect) => {
@@ -603,7 +730,7 @@ export class SSRRenderingPipeline extends PostProcessRenderPipeline {
             }
             if (this._enableAutomaticThicknessComputation && this._depthRenderer) {
                 effect.setTexture("backDepthSampler", this._depthRenderer.getDepthMap());
-                effect.setFloat("backSizeFactor", this._backfaceDepthTextureSizeFactor);
+                effect.setFloat("backSizeFactor", this._backfaceDepthTextureDownsample + 1);
             }
             const camera = this._scene.activeCamera;
             if (!camera) {
@@ -626,6 +753,7 @@ export class SSRRenderingPipeline extends PostProcessRenderPipeline {
             effect.setFloat("nearPlaneZ", camera.minZ);
             effect.setFloat("maxDistance", this.maxDistance);
             effect.setFloat("selfCollisionNumSkip", this.selfCollisionNumSkip);
+            effect.setFloat("reflectivityThreshold", this.reflectivityThreshold);
             const textureSize = this._getTextureSize();
             Matrix.ScalingToRef(textureSize.width, textureSize.height, 1, TmpVectors.Matrix[2]);
             projectionMatrix.multiplyToRef(this._scene.getEngine().isWebGPU ? trsWebGPU : trs, TmpVectors.Matrix[3]);
@@ -646,59 +774,47 @@ export class SSRRenderingPipeline extends PostProcessRenderPipeline {
     }
     _createBlurAndCombinerPostProcesses() {
         const engine = this._scene.getEngine();
-        this._blurPostProcessX = new PostProcess("SSRblurX", "screenSpaceReflection2Blur", ["blurQuality", "texelOffsetScale"], ["textureSampler"], 1, null, 2, engine, false, "", this._textureType);
+        this._blurPostProcessX = new PostProcess("SSRblurX", "screenSpaceReflection2Blur", ["texelOffsetScale"], ["textureSampler"], this._useBlur() ? 1 / (this._ssrDownsample + 1) : 1, null, 2, engine, false, "", this._textureType);
         this._blurPostProcessX.autoClear = false;
         this._blurPostProcessX.onApplyObservable.add((effect) => {
             var _a, _b;
-            let width = this._scene.getEngine().getRenderWidth();
-            if (this._prePassRenderer) {
-                const colorIndex = this._prePassRenderer.getIndex(4);
-                const renderTarget = this._prePassRenderer.getRenderTarget();
-                if (renderTarget && renderTarget.textures) {
-                    width = renderTarget.textures[colorIndex].getSize().width;
-                }
-            }
-            else {
-                width = (_b = (_a = this._ssrPostProcess) === null || _a === void 0 ? void 0 : _a.inputTexture.width) !== null && _b !== void 0 ? _b : width;
-            }
-            effect.setFloat("blurQuality", this.blurQuality);
+            const width = (_b = (_a = this._blurPostProcessX) === null || _a === void 0 ? void 0 : _a.inputTexture.width) !== null && _b !== void 0 ? _b : this._scene.getEngine().getRenderWidth();
             effect.setFloat2("texelOffsetScale", this._blurDispersionStrength / width, 0);
         });
-        this._blurPostProcessY = new PostProcess("SSRblurY", "screenSpaceReflection2Blur", ["blurQuality", "texelOffsetScale"], ["textureSampler"], 1, null, 2, engine, false, "", this._textureType);
+        this._blurPostProcessY = new PostProcess("SSRblurY", "screenSpaceReflection2Blur", ["texelOffsetScale"], ["textureSampler"], this._useBlur() ? 1 / (this._blurDownsample + 1) : 1, null, 2, engine, false, "", this._textureType);
         this._blurPostProcessY.autoClear = false;
         this._blurPostProcessY.onApplyObservable.add((effect) => {
             var _a, _b;
-            let height = this._scene.getEngine().getRenderHeight();
-            if (this._prePassRenderer) {
-                const colorIndex = this._prePassRenderer.getIndex(4);
-                const renderTarget = this._prePassRenderer.getRenderTarget();
-                if (renderTarget && renderTarget.textures) {
-                    height = renderTarget.textures[colorIndex].getSize().height;
-                }
-            }
-            else {
-                height = (_b = (_a = this._ssrPostProcess) === null || _a === void 0 ? void 0 : _a.inputTexture.height) !== null && _b !== void 0 ? _b : height;
-            }
-            effect.setFloat("blurQuality", this.blurQuality);
+            const height = (_b = (_a = this._blurPostProcessY) === null || _a === void 0 ? void 0 : _a.inputTexture.height) !== null && _b !== void 0 ? _b : this._scene.getEngine().getRenderHeight();
             effect.setFloat2("texelOffsetScale", 0, this._blurDispersionStrength / height);
         });
-        this._blurCombinerPostProcess = new PostProcess("SSRblurCombiner", "screenSpaceReflection2BlurCombiner", ["strength", "reflectionSpecularFalloffExponent"], ["textureSampler", "mainSampler", "reflectivitySampler"], 1, null, 1, engine, false, "", this._textureType);
+        let defines = "";
+        if (this._debug) {
+            defines += "#define SSRAYTRACE_DEBUG\n";
+        }
+        if (this._inputTextureColorIsInGammaSpace) {
+            defines += "#define SSR_INPUT_IS_GAMMA_SPACE\n";
+        }
+        if (this._generateOutputInGammaSpace) {
+            defines += "#define SSR_OUTPUT_IS_GAMMA_SPACE\n";
+        }
+        this._blurCombinerPostProcess = new PostProcess("SSRblurCombiner", "screenSpaceReflection2BlurCombiner", ["strength", "reflectionSpecularFalloffExponent", "reflectivityThreshold"], ["textureSampler", "mainSampler", "reflectivitySampler"], this._useBlur() ? 1 / (this._blurDownsample + 1) : 1, null, 1, engine, false, defines, this._textureType);
         this._blurCombinerPostProcess.autoClear = false;
         this._blurCombinerPostProcess.onApplyObservable.add((effect) => {
+            var _a;
             const geometryBufferRenderer = this._geometryBufferRenderer;
             const prePassRenderer = this._prePassRenderer;
             if (!prePassRenderer && !geometryBufferRenderer) {
                 return;
             }
-            if (prePassRenderer) {
-                const colorIndex = prePassRenderer.getIndex(4);
+            if (prePassRenderer && ((_a = this._scene.activeCamera) === null || _a === void 0 ? void 0 : _a._getFirstPostProcess()) === this._ssrPostProcess) {
                 const renderTarget = prePassRenderer.getRenderTarget();
                 if (renderTarget && renderTarget.textures) {
-                    effect.setTexture("mainSampler", renderTarget.textures[colorIndex]);
+                    effect.setTexture("mainSampler", renderTarget.textures[prePassRenderer.getIndex(4)]);
                 }
             }
             else {
-                effect._bindTexture("mainSampler", this._ssrPostProcess.inputTexture.texture);
+                effect.setTextureFromPostProcess("mainSampler", this._ssrPostProcess);
             }
             if (geometryBufferRenderer) {
                 const roughnessIndex = geometryBufferRenderer.getTextureIndex(GeometryBufferRenderer.REFLECTIVITY_TEXTURE_TYPE);
@@ -710,6 +826,7 @@ export class SSRRenderingPipeline extends PostProcessRenderPipeline {
             }
             effect.setFloat("strength", this.strength);
             effect.setFloat("reflectionSpecularFalloffExponent", this.reflectionSpecularFalloffExponent);
+            effect.setFloat("reflectivityThreshold", this.reflectivityThreshold);
         });
     }
     /**
@@ -759,12 +876,21 @@ __decorate([
 __decorate([
     serialize()
 ], SSRRenderingPipeline.prototype, "selfCollisionNumSkip", void 0);
+__decorate([
+    serialize()
+], SSRRenderingPipeline.prototype, "reflectivityThreshold", void 0);
+__decorate([
+    serialize("_ssrDownsample")
+], SSRRenderingPipeline.prototype, "_ssrDownsample", void 0);
+__decorate([
+    serialize()
+], SSRRenderingPipeline.prototype, "ssrDownsample", null);
 __decorate([
     serialize("blurDispersionStrength")
 ], SSRRenderingPipeline.prototype, "_blurDispersionStrength", void 0);
 __decorate([
-    serialize()
-], SSRRenderingPipeline.prototype, "blurQuality", void 0);
+    serialize("blurDownsample")
+], SSRRenderingPipeline.prototype, "_blurDownsample", void 0);
 __decorate([
     serialize("enableSmoothReflections")
 ], SSRRenderingPipeline.prototype, "_enableSmoothReflections", void 0);
@@ -780,6 +906,9 @@ __decorate([
 __decorate([
     serialize("attenuateIntersectionDistance")
 ], SSRRenderingPipeline.prototype, "_attenuateIntersectionDistance", void 0);
+__decorate([
+    serialize("attenuateIntersectionIterations")
+], SSRRenderingPipeline.prototype, "_attenuateIntersectionIterations", void 0);
 __decorate([
     serialize("attenuateFacingCamera")
 ], SSRRenderingPipeline.prototype, "_attenuateFacingCamera", void 0);
@@ -793,11 +922,20 @@ __decorate([
     serialize("enableAutomaticThicknessComputation")
 ], SSRRenderingPipeline.prototype, "_enableAutomaticThicknessComputation", void 0);
 __decorate([
-    serialize("backfaceDepthTextureSizeFactor")
-], SSRRenderingPipeline.prototype, "_backfaceDepthTextureSizeFactor", void 0);
+    serialize("backfaceDepthTextureDownsample")
+], SSRRenderingPipeline.prototype, "_backfaceDepthTextureDownsample", void 0);
+__decorate([
+    serialize("backfaceForceDepthWriteTransparentMeshes")
+], SSRRenderingPipeline.prototype, "_backfaceForceDepthWriteTransparentMeshes", void 0);
 __decorate([
     serialize("isEnabled")
 ], SSRRenderingPipeline.prototype, "_isEnabled", void 0);
+__decorate([
+    serialize("inputTextureColorIsInGammaSpace")
+], SSRRenderingPipeline.prototype, "_inputTextureColorIsInGammaSpace", void 0);
+__decorate([
+    serialize("generateOutputInGammaSpace")
+], SSRRenderingPipeline.prototype, "_generateOutputInGammaSpace", void 0);
 __decorate([
     serialize("debug")
 ], SSRRenderingPipeline.prototype, "_debug", void 0);