@babylonjs/core 7.52.2 → 7.53.0

package/PostProcesses/RenderPipeline/Pipelines/ssrRenderingPipeline.js

@@ -2,7 +2,6 @@ import { __decorate } from "../../../tslib.es6.js";
 /* eslint-disable @typescript-eslint/naming-convention */
 import { serialize } from "../../../Misc/decorators.js";
 import { SerializationHelper } from "../../../Misc/decorators.serialization.js";
-import { Vector3, Matrix, Quaternion, TmpVectors } from "../../../Maths/math.vector.js";
 import { PostProcess } from "../../postProcess.js";
 import { PostProcessRenderPipeline } from "../postProcessRenderPipeline.js";
 import { PostProcessRenderEffect } from "../postProcessRenderEffect.js";
@@ -11,9 +10,11 @@ import { ScreenSpaceReflections2Configuration } from "../../../Rendering/screenS
 import { GeometryBufferRenderer } from "../../../Rendering/geometryBufferRenderer.js";
 
 import { DepthRenderer } from "../../../Rendering/depthRenderer.js";
+import { ThinSSRRenderingPipeline } from "./thinSSRRenderingPipeline.js";
+import { ThinSSRPostProcess } from "../../thinSSRPostProcess.js";
+import { ThinSSRBlurPostProcess } from "../../thinSSRBlurPostProcess.js";
+import { ThinSSRBlurCombinerPostProcess } from "../../thinSSRBlurCombinerPostProcess.js";
 import "../postProcessRenderPipelineManagerSceneComponent.js";
-const trs = Matrix.Compose(new Vector3(0.5, 0.5, 0.5), Quaternion.Identity(), new Vector3(0.5, 0.5, 0.5));
-const trsWebGPU = Matrix.Compose(new Vector3(0.5, 0.5, 1), Quaternion.Identity(), new Vector3(0.5, 0.5, 0));
 /**
  * Render pipeline to produce Screen Space Reflections (SSR) effect
  *
@@ -36,29 +37,109 @@ export class SSRRenderingPipeline extends PostProcessRenderPipeline {
             return;
         }
         this._samples = sampleCount;
-        this._buildPipeline();
+        if (this._ssrPostProcess) {
+            this._ssrPostProcess.samples = this.samples;
+        }
     }
     get samples() {
         return this._samples;
     }
+    /**
+     * Gets or sets the maxDistance used to define how far we look for reflection during the ray-marching on the reflected ray (default: 1000).
+     * Note that this value is a view (camera) space distance (not pixels!).
+     */
+    get maxDistance() {
+        return this._thinSSRRenderingPipeline.maxDistance;
+    }
+    set maxDistance(distance) {
+        this._thinSSRRenderingPipeline.maxDistance = distance;
+    }
+    /**
+     * Gets or sets the step size used to iterate until the effect finds the color of the reflection's pixel. Should be an integer \>= 1 as it is the number of pixels we advance at each step (default: 1).
+     * Use higher values to improve performances (but at the expense of quality).
+     */
+    get step() {
+        return this._thinSSRRenderingPipeline.step;
+    }
+    set step(step) {
+        this._thinSSRRenderingPipeline.step = step;
+    }
+    /**
+     * Gets or sets the thickness value used as tolerance when computing the intersection between the reflected ray and the scene (default: 0.5).
+     * If setting "enableAutomaticThicknessComputation" to true, you can use lower values for "thickness" (even 0), as the geometry thickness
+     * is automatically computed thank to the regular depth buffer + the backface depth buffer
+     */
+    get thickness() {
+        return this._thinSSRRenderingPipeline.thickness;
+    }
+    set thickness(thickness) {
+        this._thinSSRRenderingPipeline.thickness = thickness;
+    }
+    /**
+     * Gets or sets the current reflection strength. 1.0 is an ideal value but can be increased/decreased for particular results (default: 1).
+     */
+    get strength() {
+        return this._thinSSRRenderingPipeline.strength;
+    }
+    set strength(strength) {
+        this._thinSSRRenderingPipeline.strength = strength;
+    }
+    /**
+     * Gets or sets the falloff exponent used to compute the reflection strength. Higher values lead to fainter reflections (default: 1).
+     */
+    get reflectionSpecularFalloffExponent() {
+        return this._thinSSRRenderingPipeline.reflectionSpecularFalloffExponent;
+    }
+    set reflectionSpecularFalloffExponent(exponent) {
+        this._thinSSRRenderingPipeline.reflectionSpecularFalloffExponent = exponent;
+    }
+    /**
+     * 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.
+     */
+    get maxSteps() {
+        return this._thinSSRRenderingPipeline.maxSteps;
+    }
+    set maxSteps(steps) {
+        this._thinSSRRenderingPipeline.maxSteps = steps;
+    }
+    /**
+     * Gets or sets the factor applied when computing roughness. Default value is 0.2.
+     * When blurring based on roughness is enabled (meaning blurDispersionStrength \> 0), roughnessFactor is used as a global roughness factor applied on all objects.
+     * If you want to disable this global roughness set it to 0.
+     */
+    get roughnessFactor() {
+        return this._thinSSRRenderingPipeline.roughnessFactor;
+    }
+    set roughnessFactor(factor) {
+        this._thinSSRRenderingPipeline.roughnessFactor = factor;
+    }
+    /**
+     * Number of steps to skip at start when marching the ray to avoid self collisions (default: 1)
+     * 1 should normally be a good value, depending on the scene you may need to use a higher value (2 or 3)
+     */
+    get selfCollisionNumSkip() {
+        return this._thinSSRRenderingPipeline.selfCollisionNumSkip;
+    }
+    set selfCollisionNumSkip(skip) {
+        this._thinSSRRenderingPipeline.selfCollisionNumSkip = skip;
+    }
     /**
      * 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.
      */
     get reflectivityThreshold() {
-        return this._reflectivityThreshold;
+        return this._thinSSRRenderingPipeline.reflectivityThreshold;
     }
     set reflectivityThreshold(threshold) {
-        if (threshold === this._reflectivityThreshold) {
+        const currentThreshold = this.reflectivityThreshold;
+        if (threshold === currentThreshold) {
             return;
         }
-        if ((threshold === 0 && this._reflectivityThreshold !== 0) || (threshold !== 0 && this._reflectivityThreshold === 0)) {
-            this._reflectivityThreshold = threshold;
+        this._thinSSRRenderingPipeline.reflectivityThreshold = threshold;
+        if ((threshold === 0 && currentThreshold !== 0) || (threshold !== 0 && currentThreshold === 0)) {
             this._buildPipeline();
         }
-        else {
-            this._reflectivityThreshold = threshold;
-        }
     }
     /**
      * Gets or sets the downsample factor used to reduce the size of the texture used to compute the SSR contribution (default: 0).
@@ -66,48 +147,42 @@ export class SSRRenderingPipeline extends PostProcessRenderPipeline {
      * 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;
+        return this._thinSSRRenderingPipeline.ssrDownsample;
     }
     set ssrDownsample(downsample) {
-        if (downsample === this._ssrDownsample) {
-            return;
-        }
-        this._ssrDownsample = downsample;
+        this._thinSSRRenderingPipeline.ssrDownsample = downsample;
         this._buildPipeline();
     }
     /**
-     * Gets or sets the blur dispersion strength. Set this value to 0 to disable blurring (default: 0.05)
+     * Gets or sets the blur dispersion strength. Set this value to 0 to disable blurring (default: 0.03)
      * 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() {
-        return this._blurDispersionStrength;
+        return this._thinSSRRenderingPipeline.blurDispersionStrength;
     }
     set blurDispersionStrength(strength) {
-        if (strength === this._blurDispersionStrength) {
+        const currentStrength = this.blurDispersionStrength;
+        if (strength === currentStrength) {
             return;
         }
-        const rebuild = (strength === 0 && this._blurDispersionStrength !== 0) || (strength !== 0 && this._blurDispersionStrength === 0);
-        this._blurDispersionStrength = strength;
-        if (rebuild) {
+        this._thinSSRRenderingPipeline.blurDispersionStrength = strength;
+        if ((strength === 0 && currentStrength !== 0) || (strength !== 0 && currentStrength === 0)) {
             this._buildPipeline();
         }
     }
     _useBlur() {
-        return this._blurDispersionStrength > 0;
+        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;
+        return this._thinSSRRenderingPipeline.blurDownsample;
     }
     set blurDownsample(downsample) {
-        if (downsample === this._blurDownsample) {
-            return;
-        }
-        this._blurDownsample = downsample;
+        this._thinSSRRenderingPipeline.blurDownsample = downsample;
         this._buildPipeline();
     }
     /**
@@ -116,127 +191,97 @@ export class SSRRenderingPipeline extends PostProcessRenderPipeline {
      * Note that this setting has no effect if step = 1: it's only used if step \> 1.
      */
     get enableSmoothReflections() {
-        return this._enableSmoothReflections;
+        return this._thinSSRRenderingPipeline.enableSmoothReflections;
     }
     set enableSmoothReflections(enabled) {
-        if (enabled === this._enableSmoothReflections) {
-            return;
-        }
-        this._enableSmoothReflections = enabled;
-        this._updateEffectDefines();
+        this._thinSSRRenderingPipeline.enableSmoothReflections = enabled;
+    }
+    get _useScreenspaceDepth() {
+        return this._thinSSRRenderingPipeline.useScreenspaceDepth;
     }
     /**
      * Gets or sets the environment cube texture used to define the reflection when the reflected rays of SSR leave the view space or when the maxDistance/maxSteps is reached.
      */
     get environmentTexture() {
-        return this._environmentTexture;
+        return this._thinSSRRenderingPipeline.environmentTexture;
     }
     set environmentTexture(texture) {
-        this._environmentTexture = texture;
-        this._updateEffectDefines();
+        this._thinSSRRenderingPipeline.environmentTexture = texture;
     }
     /**
      * Gets or sets the boolean defining if the environment texture is a standard cubemap (false) or a probe (true). Default value is false.
      * Note: a probe cube texture is treated differently than an ordinary cube texture because the Y axis is reversed.
      */
     get environmentTextureIsProbe() {
-        return this._environmentTextureIsProbe;
+        return this._thinSSRRenderingPipeline.environmentTextureIsProbe;
     }
     set environmentTextureIsProbe(isProbe) {
-        this._environmentTextureIsProbe = isProbe;
-        this._updateEffectDefines();
+        this._thinSSRRenderingPipeline.environmentTextureIsProbe = isProbe;
     }
     /**
      * Gets or sets a boolean indicating if the reflections should be attenuated at the screen borders (default: true).
      */
     get attenuateScreenBorders() {
-        return this._attenuateScreenBorders;
+        return this._thinSSRRenderingPipeline.attenuateScreenBorders;
     }
     set attenuateScreenBorders(attenuate) {
-        if (this._attenuateScreenBorders === attenuate) {
-            return;
-        }
-        this._attenuateScreenBorders = attenuate;
-        this._updateEffectDefines();
+        this._thinSSRRenderingPipeline.attenuateScreenBorders = attenuate;
     }
     /**
      * Gets or sets a boolean indicating if the reflections should be attenuated according to the distance of the intersection (default: true).
      */
     get attenuateIntersectionDistance() {
-        return this._attenuateIntersectionDistance;
+        return this._thinSSRRenderingPipeline.attenuateIntersectionDistance;
     }
     set attenuateIntersectionDistance(attenuate) {
-        if (this._attenuateIntersectionDistance === attenuate) {
-            return;
-        }
-        this._attenuateIntersectionDistance = attenuate;
-        this._updateEffectDefines();
+        this._thinSSRRenderingPipeline.attenuateIntersectionDistance = attenuate;
     }
     /**
      * 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;
+        return this._thinSSRRenderingPipeline.attenuateIntersectionIterations;
     }
     set attenuateIntersectionIterations(attenuate) {
-        if (this._attenuateIntersectionIterations === attenuate) {
-            return;
-        }
-        this._attenuateIntersectionIterations = attenuate;
-        this._updateEffectDefines();
+        this._thinSSRRenderingPipeline.attenuateIntersectionIterations = attenuate;
     }
     /**
      * 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).
      */
     get attenuateFacingCamera() {
-        return this._attenuateFacingCamera;
+        return this._thinSSRRenderingPipeline.attenuateFacingCamera;
     }
     set attenuateFacingCamera(attenuate) {
-        if (this._attenuateFacingCamera === attenuate) {
-            return;
-        }
-        this._attenuateFacingCamera = attenuate;
-        this._updateEffectDefines();
+        this._thinSSRRenderingPipeline.attenuateFacingCamera = attenuate;
     }
     /**
      * Gets or sets a boolean indicating if the backface reflections should be attenuated (default: false).
      */
     get attenuateBackfaceReflection() {
-        return this._attenuateBackfaceReflection;
+        return this._thinSSRRenderingPipeline.attenuateBackfaceReflection;
     }
     set attenuateBackfaceReflection(attenuate) {
-        if (this._attenuateBackfaceReflection === attenuate) {
-            return;
-        }
-        this._attenuateBackfaceReflection = attenuate;
-        this._updateEffectDefines();
+        this._thinSSRRenderingPipeline.attenuateBackfaceReflection = attenuate;
     }
     /**
      * Gets or sets a boolean indicating if the ray should be clipped to the frustum (default: true).
      * You can try to set this parameter to false to save some performances: it may produce some artefacts in some cases, but generally they won't really be visible
      */
     get clipToFrustum() {
-        return this._clipToFrustum;
+        return this._thinSSRRenderingPipeline.clipToFrustum;
     }
     set clipToFrustum(clip) {
-        if (this._clipToFrustum === clip) {
-            return;
-        }
-        this._clipToFrustum = clip;
-        this._updateEffectDefines();
+        this._thinSSRRenderingPipeline.clipToFrustum = clip;
     }
     /**
      * Gets or sets a boolean indicating whether the blending between the current color pixel and the reflection color should be done with a Fresnel coefficient (default: false).
      * It is more physically accurate to use the Fresnel coefficient (otherwise it uses the reflectivity of the material for blending), but it is also more expensive when you use blur (when blurDispersionStrength \> 0).
      */
     get useFresnel() {
-        return this._useFresnel;
+        return this._thinSSRRenderingPipeline.useFresnel;
     }
     set useFresnel(fresnel) {
-        if (this._useFresnel === fresnel) {
-            return;
-        }
-        this._useFresnel = fresnel;
+        this._thinSSRRenderingPipeline.useFresnel = fresnel;
         this._buildPipeline();
     }
     /**
@@ -247,13 +292,10 @@ export class SSRRenderingPipeline extends PostProcessRenderPipeline {
      * Note that for performance reasons, this option will only apply to the first camera to which the rendering pipeline is attached!
      */
     get enableAutomaticThicknessComputation() {
-        return this._enableAutomaticThicknessComputation;
+        return this._thinSSRRenderingPipeline.enableAutomaticThicknessComputation;
     }
     set enableAutomaticThicknessComputation(automatic) {
-        if (this._enableAutomaticThicknessComputation === automatic) {
-            return;
-        }
-        this._enableAutomaticThicknessComputation = automatic;
+        this._thinSSRRenderingPipeline.enableAutomaticThicknessComputation = automatic;
         this._buildPipeline();
     }
     /**
@@ -325,13 +367,10 @@ export class SSRRenderingPipeline extends PostProcessRenderPipeline {
      * 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;
+        return this._thinSSRRenderingPipeline.inputTextureColorIsInGammaSpace;
     }
     set inputTextureColorIsInGammaSpace(gammaSpace) {
-        if (this._inputTextureColorIsInGammaSpace === gammaSpace) {
-            return;
-        }
-        this._inputTextureColorIsInGammaSpace = gammaSpace;
+        this._thinSSRRenderingPipeline.inputTextureColorIsInGammaSpace = gammaSpace;
         this._buildPipeline();
     }
     /**
@@ -339,13 +378,10 @@ export class SSRRenderingPipeline extends PostProcessRenderPipeline {
      * 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;
+        return this._thinSSRRenderingPipeline.generateOutputInGammaSpace;
     }
     set generateOutputInGammaSpace(gammaSpace) {
-        if (this._generateOutputInGammaSpace === gammaSpace) {
-            return;
-        }
-        this._generateOutputInGammaSpace = gammaSpace;
+        this._thinSSRRenderingPipeline.generateOutputInGammaSpace = gammaSpace;
         this._buildPipeline();
     }
     /**
@@ -359,13 +395,10 @@ export class SSRRenderingPipeline extends PostProcessRenderPipeline {
      * You should try to get as few blue/red/yellow pixels as possible, as this means that the ray has gone further than if it had hit a surface.
      */
     get debug() {
-        return this._debug;
+        return this._thinSSRRenderingPipeline.debug;
     }
     set debug(value) {
-        if (this._debug === value) {
-            return;
-        }
-        this._debug = value;
+        this._thinSSRRenderingPipeline.debug = value;
         this._buildPipeline();
     }
     /**
@@ -424,78 +457,23 @@ export class SSRRenderingPipeline extends PostProcessRenderPipeline {
          */
         this.SSRCombineRenderEffect = "SSRCombineRenderEffect";
         this._samples = 1;
-        /**
-         * Gets or sets the maxDistance used to define how far we look for reflection during the ray-marching on the reflected ray (default: 1000).
-         * Note that this value is a view (camera) space distance (not pixels!).
-         */
-        this.maxDistance = 1000.0;
-        /**
-         * Gets or sets the step size used to iterate until the effect finds the color of the reflection's pixel. Should be an integer \>= 1 as it is the number of pixels we advance at each step (default: 1).
-         * Use higher values to improve performances (but at the expense of quality).
-         */
-        this.step = 1.0;
-        /**
-         * Gets or sets the thickness value used as tolerance when computing the intersection between the reflected ray and the scene (default: 0.5).
-         * If setting "enableAutomaticThicknessComputation" to true, you can use lower values for "thickness" (even 0), as the geometry thickness
-         * is automatically computed thank to the regular depth buffer + the backface depth buffer
-         */
-        this.thickness = 0.5;
-        /**
-         * Gets or sets the current reflection strength. 1.0 is an ideal value but can be increased/decreased for particular results (default: 1).
-         */
-        this.strength = 1;
-        /**
-         * Gets or sets the falloff exponent used to compute the reflection strength. Higher values lead to fainter reflections (default: 1).
-         */
-        this.reflectionSpecularFalloffExponent = 1;
-        /**
-         * 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;
-        /**
-         * Gets or sets the factor applied when computing roughness. Default value is 0.2.
-         * When blurring based on roughness is enabled (meaning blurDispersionStrength \> 0), roughnessFactor is used as a global roughness factor applied on all objects.
-         * If you want to disable this global roughness set it to 0.
-         */
-        this.roughnessFactor = 0.2;
-        /**
-         * Number of steps to skip at start when marching the ray to avoid self collisions (default: 1)
-         * 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._reflectivityThreshold = 0.04;
-        this._ssrDownsample = 0;
-        this._blurDispersionStrength = 0.03;
-        this._blurDownsample = 0;
-        this._enableSmoothReflections = false;
-        this._useScreenspaceDepth = false;
-        this._environmentTextureIsProbe = false;
-        this._attenuateScreenBorders = true;
-        this._attenuateIntersectionDistance = true;
-        this._attenuateIntersectionIterations = true;
-        this._attenuateFacingCamera = false;
-        this._attenuateBackfaceReflection = false;
-        this._clipToFrustum = true;
-        this._useFresnel = false;
-        this._enableAutomaticThicknessComputation = false;
         this._backfaceDepthTextureDownsample = 0;
         this._backfaceForceDepthWriteTransparentMeshes = true;
         this._isEnabled = true;
-        this._inputTextureColorIsInGammaSpace = true;
-        this._generateOutputInGammaSpace = true;
-        this._debug = false;
         this._forceGeometryBuffer = false;
         this._isDirty = false;
         this._camerasToBeAttached = [];
+        this._thinSSRRenderingPipeline = new ThinSSRRenderingPipeline(name, scene);
+        this._thinSSRRenderingPipeline.isSSRSupported = false;
+        this._thinSSRRenderingPipeline.useScreenspaceDepth = useScreenspaceDepth;
         this._cameras = cameras || scene.cameras;
         this._cameras = this._cameras.slice();
         this._camerasToBeAttached = this._cameras.slice();
         this._scene = scene;
         this._textureType = textureType;
         this._forceGeometryBuffer = forceGeometryBuffer;
-        this._useScreenspaceDepth = useScreenspaceDepth;
         if (this.isSupported) {
+            this._createSSRPostProcess();
             scene.postProcessRenderPipelineManager.addPipeline(this);
             if (this._forceGeometryBuffer) {
                 const geometryBufferRenderer = scene.enableGeometryBufferRenderer();
@@ -513,6 +491,7 @@ export class SSRRenderingPipeline extends PostProcessRenderPipeline {
                     prePassRenderer.markAsDirty();
                 }
             }
+            this._thinSSRRenderingPipeline.isSSRSupported = !!this._geometryBufferRenderer || !!this._prePassRenderer;
             this._buildPipeline();
         }
     }
@@ -546,11 +525,13 @@ export class SSRRenderingPipeline extends PostProcessRenderPipeline {
      */
     dispose(disableGeometryBufferRenderer = false) {
         this._disposeDepthRenderer();
-        this._disposePostProcesses();
+        this._disposeSSRPostProcess();
+        this._disposeBlurPostProcesses();
         if (disableGeometryBufferRenderer) {
             this._scene.disableGeometryBufferRenderer();
         }
         this._scene.postProcessRenderPipelineManager.detachCamerasFromRenderPipeline(this._name, this._cameras);
+        this._thinSSRRenderingPipeline.dispose();
         super.dispose();
     }
     _getTextureSize() {
@@ -569,83 +550,6 @@ export class SSRRenderingPipeline extends PostProcessRenderPipeline {
         }
         return textureSize;
     }
-    _updateEffectDefines() {
-        const defines = [];
-        if (this._geometryBufferRenderer || this._prePassRenderer) {
-            defines.push("#define SSR_SUPPORTED");
-        }
-        if (this._enableSmoothReflections) {
-            defines.push("#define SSRAYTRACE_ENABLE_REFINEMENT");
-        }
-        if (this._scene.useRightHandedSystem) {
-            defines.push("#define SSRAYTRACE_RIGHT_HANDED_SCENE");
-        }
-        if (this._useScreenspaceDepth) {
-            defines.push("#define SSRAYTRACE_SCREENSPACE_DEPTH");
-        }
-        if (this._environmentTexture) {
-            defines.push("#define SSR_USE_ENVIRONMENT_CUBE");
-            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");
-        }
-        if (this._enableAutomaticThicknessComputation) {
-            defines.push("#define SSRAYTRACE_USE_BACK_DEPTHBUFFER");
-        }
-        if (this._attenuateScreenBorders) {
-            defines.push("#define SSR_ATTENUATE_SCREEN_BORDERS");
-        }
-        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");
-        }
-        if (this._attenuateBackfaceReflection) {
-            defines.push("#define SSR_ATTENUATE_BACKFACE_REFLECTION");
-        }
-        if (this._clipToFrustum) {
-            defines.push("#define SSRAYTRACE_CLIP_TO_FRUSTUM");
-        }
-        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");
-        }
-        if (this._useFresnel) {
-            defines.push("#define SSR_BLEND_WITH_FRESNEL");
-        }
-        if (this._reflectivityThreshold === 0) {
-            defines.push("#define SSR_DISABLE_REFLECTIVITY_TEST");
-        }
-        if (this._geometryBufferRenderer?.generateNormalsInWorldSpace ?? this._prePassRenderer?.generateNormalsInWorldSpace) {
-            defines.push("#define SSR_NORMAL_IS_IN_WORLDSPACE");
-        }
-        if (this._geometryBufferRenderer?.normalsAreUnsigned) {
-            defines.push("#define SSR_DECODE_NORMAL");
-        }
-        const camera = this._cameras?.[0];
-        if (camera && camera.mode === 1) {
-            defines.push("#define ORTHOGRAPHIC_CAMERA");
-        }
-        this._ssrPostProcess?.updateEffect(defines.join("\n"));
-    }
     _buildPipeline() {
         if (!this.isSupported) {
             return;
@@ -657,14 +561,17 @@ export class SSRRenderingPipeline extends PostProcessRenderPipeline {
         this._isDirty = false;
         const engine = this._scene.getEngine();
         this._disposeDepthRenderer();
-        this._disposePostProcesses();
         if (this._cameras !== null) {
             this._scene.postProcessRenderPipelineManager.detachCamerasFromRenderPipeline(this._name, this._cameras);
             // get back cameras to be used to reattach pipeline
             this._cameras = this._camerasToBeAttached.slice();
+            if (this._cameras.length > 0) {
+                this._thinSSRRenderingPipeline.camera = this._cameras[0];
+            }
         }
         this._reset();
-        if (this._enableAutomaticThicknessComputation) {
+        this._thinSSRRenderingPipeline.normalsAreInWorldSpace = !!(this._geometryBufferRenderer?.generateNormalsInWorldSpace ?? this._prePassRenderer?.generateNormalsInWorldSpace);
+        if (this.enableAutomaticThicknessComputation) {
             const camera = this._cameras?.[0];
             if (camera) {
                 this._depthRendererCamera = camera;
@@ -673,15 +580,15 @@ export class SSRRenderingPipeline extends PostProcessRenderPipeline {
                     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.forceDepthWriteTransparentMeshes = this._backfaceForceDepthWriteTransparentMeshes;
+                this._depthRenderer.forceDepthWriteTransparentMeshes = this.backfaceForceDepthWriteTransparentMeshes;
                 this._resizeDepthRenderer();
                 camera.customRenderTargets.push(this._depthRenderer.getDepthMap());
             }
         }
-        this._createSSRPostProcess();
         this.addEffect(new PostProcessRenderEffect(engine, this.SSRRenderEffect, () => {
             return this._ssrPostProcess;
         }, true));
+        this._disposeBlurPostProcesses();
         if (this._useBlur()) {
             this._createBlurAndCombinerPostProcesses();
             this.addEffect(new PostProcessRenderEffect(engine, this.SSRBlurRenderEffect, () => {
@@ -701,8 +608,8 @@ export class SSRRenderingPipeline extends PostProcessRenderPipeline {
         }
         const textureSize = this._getTextureSize();
         const depthRendererSize = this._depthRenderer.getDepthMap().getSize();
-        const width = Math.floor(textureSize.width / (this._backfaceDepthTextureDownsample + 1));
-        const height = Math.floor(textureSize.height / (this._backfaceDepthTextureDownsample + 1));
+        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 });
         }
@@ -720,49 +627,34 @@ export class SSRRenderingPipeline extends PostProcessRenderPipeline {
         }
         this._depthRenderer = null;
     }
-    _disposePostProcesses() {
+    _disposeBlurPostProcesses() {
         for (let i = 0; i < this._cameras.length; i++) {
             const camera = this._cameras[i];
-            this._ssrPostProcess?.dispose(camera);
             this._blurPostProcessX?.dispose(camera);
             this._blurPostProcessY?.dispose(camera);
             this._blurCombinerPostProcess?.dispose(camera);
         }
-        this._ssrPostProcess = null;
         this._blurPostProcessX = null;
         this._blurPostProcessY = null;
         this._blurCombinerPostProcess = null;
     }
+    _disposeSSRPostProcess() {
+        for (let i = 0; i < this._cameras.length; i++) {
+            const camera = this._cameras[i];
+            this._ssrPostProcess?.dispose(camera);
+        }
+        this._ssrPostProcess = null;
+    }
     _createSSRPostProcess() {
-        this._ssrPostProcess = new PostProcess("ssr", "screenSpaceReflection2", [
-            "projection",
-            "invProjectionMatrix",
-            "view",
-            "invView",
-            "thickness",
-            "reflectionSpecularFalloffExponent",
-            "strength",
-            "stepSize",
-            "maxSteps",
-            "roughnessFactor",
-            "projectionPixel",
-            "nearPlaneZ",
-            "farPlaneZ",
-            "maxDistance",
-            "selfCollisionNumSkip",
-            "vReflectionPosition",
-            "vReflectionSize",
-            "backSizeFactor",
-            "reflectivityThreshold",
-        ], ["textureSampler", "normalSampler", "reflectivitySampler", "depthSampler", "envCubeSampler", "backDepthSampler"], 1.0, null, this._textureType, this._scene.getEngine(), false, "", this._textureType, undefined, undefined, undefined, undefined, this._scene.getEngine().isWebGPU ? 1 /* ShaderLanguage.WGSL */ : 0 /* ShaderLanguage.GLSL */, (useWebGPU, list) => {
-            if (useWebGPU) {
-                list.push(import("../../../ShadersWGSL/screenSpaceReflection2.fragment.js"));
-            }
-            else {
-                list.push(import("../../../Shaders/screenSpaceReflection2.fragment.js"));
-            }
+        this._ssrPostProcess = new PostProcess("ssr", ThinSSRPostProcess.FragmentUrl, {
+            uniformNames: ThinSSRPostProcess.Uniforms,
+            samplerNames: ThinSSRPostProcess.Samplers,
+            size: 1.0,
+            samplingMode: 2,
+            engine: this._scene.getEngine(),
+            textureType: this._textureType,
+            effectWrapper: this._thinSSRRenderingPipeline._ssrPostProcess,
         });
-        this._updateEffectDefines();
         this._ssrPostProcess.onApply = (effect) => {
             this._resizeDepthRenderer();
             const geometryBufferRenderer = this._geometryBufferRenderer;
@@ -792,45 +684,13 @@ export class SSRRenderingPipeline extends PostProcessRenderPipeline {
                 effect.setTexture("depthSampler", prePassRenderer.getRenderTarget().textures[depthIndex]);
                 effect.setTexture("reflectivitySampler", prePassRenderer.getRenderTarget().textures[roughnessIndex]);
             }
-            if (this._enableAutomaticThicknessComputation && this._depthRenderer) {
+            if (this.enableAutomaticThicknessComputation && this._depthRenderer) {
                 effect.setTexture("backDepthSampler", this._depthRenderer.getDepthMap());
-                effect.setFloat("backSizeFactor", this._backfaceDepthTextureDownsample + 1);
+                effect.setFloat("backSizeFactor", this.backfaceDepthTextureDownsample + 1);
             }
-            const camera = this._scene.activeCamera;
-            if (!camera) {
-                return;
-            }
-            const viewMatrix = camera.getViewMatrix();
-            const projectionMatrix = camera.getProjectionMatrix();
-            projectionMatrix.invertToRef(TmpVectors.Matrix[0]);
-            viewMatrix.invertToRef(TmpVectors.Matrix[1]);
-            effect.setMatrix("projection", projectionMatrix);
-            effect.setMatrix("view", viewMatrix);
-            effect.setMatrix("invView", TmpVectors.Matrix[1]);
-            effect.setMatrix("invProjectionMatrix", TmpVectors.Matrix[0]);
-            effect.setFloat("thickness", this.thickness);
-            effect.setFloat("reflectionSpecularFalloffExponent", this.reflectionSpecularFalloffExponent);
-            effect.setFloat("strength", this.strength);
-            effect.setFloat("stepSize", this.step);
-            effect.setFloat("maxSteps", this.maxSteps);
-            effect.setFloat("roughnessFactor", this.roughnessFactor);
-            effect.setFloat("nearPlaneZ", camera.minZ);
-            effect.setFloat("farPlaneZ", camera.maxZ);
-            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]);
-            TmpVectors.Matrix[3].multiplyToRef(TmpVectors.Matrix[2], TmpVectors.Matrix[4]);
-            effect.setMatrix("projectionPixel", TmpVectors.Matrix[4]);
-            if (this._environmentTexture) {
-                effect.setTexture("envCubeSampler", this._environmentTexture);
-                if (this._environmentTexture.boundingBoxSize) {
-                    effect.setVector3("vReflectionPosition", this._environmentTexture.boundingBoxPosition);
-                    effect.setVector3("vReflectionSize", this._environmentTexture.boundingBoxSize);
-                }
-            }
+            this._thinSSRRenderingPipeline._ssrPostProcess.textureWidth = textureSize.width;
+            this._thinSSRRenderingPipeline._ssrPostProcess.textureHeight = textureSize.height;
         };
         this._ssrPostProcess.samples = this.samples;
         if (!this._forceGeometryBuffer) {
@@ -839,62 +699,42 @@ export class SSRRenderingPipeline extends PostProcessRenderPipeline {
     }
     _createBlurAndCombinerPostProcesses() {
         const engine = this._scene.getEngine();
-        this._blurPostProcessX = new PostProcess("SSRblurX", "screenSpaceReflection2Blur", ["texelOffsetScale"], ["textureSampler"], this._useBlur() ? 1 / (this._ssrDownsample + 1) : 1, null, 2, engine, false, "", this._textureType, undefined, undefined, undefined, undefined, this._scene.getEngine().isWebGPU ? 1 /* ShaderLanguage.WGSL */ : 0 /* ShaderLanguage.GLSL */, (useWebGPU, list) => {
-            if (useWebGPU) {
-                list.push(import("../../../ShadersWGSL/screenSpaceReflection2Blur.fragment.js"));
-            }
-            else {
-                list.push(import("../../../Shaders/screenSpaceReflection2Blur.fragment.js"));
-            }
+        this._blurPostProcessX = new PostProcess("SSRblurX", ThinSSRBlurPostProcess.FragmentUrl, {
+            uniformNames: ThinSSRBlurPostProcess.Uniforms,
+            samplerNames: ThinSSRBlurPostProcess.Samplers,
+            size: 1 / (this.ssrDownsample + 1),
+            samplingMode: 2,
+            engine,
+            textureType: this._textureType,
+            effectWrapper: this._thinSSRRenderingPipeline._ssrBlurXPostProcess,
         });
         this._blurPostProcessX.autoClear = false;
-        this._blurPostProcessX.onApplyObservable.add((effect) => {
-            const width = this._blurPostProcessX?.inputTexture.width ?? this._scene.getEngine().getRenderWidth();
-            effect.setFloat2("texelOffsetScale", this._blurDispersionStrength / width, 0);
+        this._blurPostProcessX.onApplyObservable.add(() => {
+            this._thinSSRRenderingPipeline._ssrBlurXPostProcess.textureWidth = this._blurPostProcessX?.inputTexture.width ?? this._scene.getEngine().getRenderWidth();
+            this._thinSSRRenderingPipeline._ssrBlurXPostProcess.textureHeight = 1; // not used
         });
-        this._blurPostProcessY = new PostProcess("SSRblurY", "screenSpaceReflection2Blur", ["texelOffsetScale"], ["textureSampler"], this._useBlur() ? 1 / (this._blurDownsample + 1) : 1, null, 2, engine, false, "", this._textureType, undefined, undefined, undefined, undefined, this._scene.getEngine().isWebGPU ? 1 /* ShaderLanguage.WGSL */ : 0 /* ShaderLanguage.GLSL */, (useWebGPU, list) => {
-            if (useWebGPU) {
-                list.push(import("../../../ShadersWGSL/screenSpaceReflection2Blur.fragment.js"));
-            }
-            else {
-                list.push(import("../../../Shaders/screenSpaceReflection2Blur.fragment.js"));
-            }
+        this._blurPostProcessY = new PostProcess("SSRblurY", ThinSSRBlurPostProcess.FragmentUrl, {
+            uniformNames: ThinSSRBlurPostProcess.Uniforms,
+            samplerNames: ThinSSRBlurPostProcess.Samplers,
+            size: 1 / (this.blurDownsample + 1),
+            samplingMode: 2,
+            engine,
+            textureType: this._textureType,
+            effectWrapper: this._thinSSRRenderingPipeline._ssrBlurYPostProcess,
         });
         this._blurPostProcessY.autoClear = false;
-        this._blurPostProcessY.onApplyObservable.add((effect) => {
-            const height = this._blurPostProcessY?.inputTexture.height ?? this._scene.getEngine().getRenderHeight();
-            effect.setFloat2("texelOffsetScale", 0, this._blurDispersionStrength / height);
+        this._blurPostProcessY.onApplyObservable.add(() => {
+            this._thinSSRRenderingPipeline._ssrBlurYPostProcess.textureWidth = 1; // not used
+            this._thinSSRRenderingPipeline._ssrBlurYPostProcess.textureHeight = this._blurPostProcessY?.inputTexture.height ?? this._scene.getEngine().getRenderHeight();
         });
-        const uniformNames = ["strength", "reflectionSpecularFalloffExponent", "reflectivityThreshold"];
-        const samplerNames = ["textureSampler", "mainSampler", "reflectivitySampler"];
-        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";
-        }
-        if (this.useFresnel) {
-            defines += "#define SSR_BLEND_WITH_FRESNEL\n";
-            uniformNames.push("projection", "invProjectionMatrix", "nearPlaneZ", "farPlaneZ");
-            samplerNames.push("depthSampler", "normalSampler");
-        }
-        if (this._useScreenspaceDepth) {
-            defines += "#define SSRAYTRACE_SCREENSPACE_DEPTH";
-        }
-        if (this._reflectivityThreshold === 0) {
-            defines += "#define SSR_DISABLE_REFLECTIVITY_TEST";
-        }
-        this._blurCombinerPostProcess = new PostProcess("SSRblurCombiner", "screenSpaceReflection2BlurCombiner", uniformNames, samplerNames, this._useBlur() ? 1 / (this._blurDownsample + 1) : 1, null, 1, engine, false, defines, this._textureType, undefined, undefined, undefined, undefined, this._scene.getEngine().isWebGPU ? 1 /* ShaderLanguage.WGSL */ : 0 /* ShaderLanguage.GLSL */, (useWebGPU, list) => {
-            if (useWebGPU) {
-                list.push(import("../../../ShadersWGSL/screenSpaceReflection2BlurCombiner.fragment.js"));
-            }
-            else {
-                list.push(import("../../../Shaders/screenSpaceReflection2BlurCombiner.fragment.js"));
-            }
+        this._blurCombinerPostProcess = new PostProcess("SSRblurCombiner", ThinSSRBlurCombinerPostProcess.FragmentUrl, {
+            uniformNames: ThinSSRBlurCombinerPostProcess.Uniforms,
+            samplerNames: ThinSSRBlurCombinerPostProcess.Samplers,
+            size: 1 / (this.blurDownsample + 1),
+            samplingMode: 1,
+            engine,
+            textureType: this._textureType,
+            effectWrapper: this._thinSSRRenderingPipeline._ssrBlurCombinerPostProcess,
         });
         this._blurCombinerPostProcess.autoClear = false;
         this._blurCombinerPostProcess.onApplyObservable.add((effect) => {
@@ -916,11 +756,6 @@ export class SSRRenderingPipeline extends PostProcessRenderPipeline {
                 const roughnessIndex = geometryBufferRenderer.getTextureIndex(GeometryBufferRenderer.REFLECTIVITY_TEXTURE_TYPE);
                 effect.setTexture("reflectivitySampler", geometryBufferRenderer.getGBuffer().textures[roughnessIndex]);
                 if (this.useFresnel) {
-                    const camera = this._scene.activeCamera;
-                    if (camera && this._useScreenspaceDepth) {
-                        effect.setFloat("nearPlaneZ", camera.minZ);
-                        effect.setFloat("farPlaneZ", camera.maxZ);
-                    }
                     effect.setTexture("normalSampler", geometryBufferRenderer.getGBuffer().textures[1]);
                     if (this._useScreenspaceDepth) {
                         const depthIndex = geometryBufferRenderer.getTextureIndex(GeometryBufferRenderer.SCREENSPACE_DEPTH_TEXTURE_TYPE);
@@ -935,29 +770,12 @@ export class SSRRenderingPipeline extends PostProcessRenderPipeline {
                 const roughnessIndex = prePassRenderer.getIndex(3);
                 effect.setTexture("reflectivitySampler", prePassRenderer.getRenderTarget().textures[roughnessIndex]);
                 if (this.useFresnel) {
-                    const camera = this._scene.activeCamera;
-                    if (camera && this._useScreenspaceDepth) {
-                        effect.setFloat("nearPlaneZ", camera.minZ);
-                        effect.setFloat("farPlaneZ", camera.maxZ);
-                    }
                     const depthIndex = prePassRenderer.getIndex(this._useScreenspaceDepth ? 10 : 5);
                     const normalIndex = prePassRenderer.getIndex(6);
                     effect.setTexture("normalSampler", prePassRenderer.getRenderTarget().textures[normalIndex]);
                     effect.setTexture("depthSampler", prePassRenderer.getRenderTarget().textures[depthIndex]);
                 }
             }
-            effect.setFloat("strength", this.strength);
-            effect.setFloat("reflectionSpecularFalloffExponent", this.reflectionSpecularFalloffExponent);
-            effect.setFloat("reflectivityThreshold", this._reflectivityThreshold);
-            if (this.useFresnel) {
-                const camera = this._scene.activeCamera;
-                if (camera) {
-                    const projectionMatrix = camera.getProjectionMatrix();
-                    projectionMatrix.invertToRef(TmpVectors.Matrix[0]);
-                    effect.setMatrix("projection", projectionMatrix);
-                    effect.setMatrix("invProjectionMatrix", TmpVectors.Matrix[0]);
-                }
-            }
         });
     }
     /**
@@ -985,76 +803,73 @@ __decorate([
 ], SSRRenderingPipeline.prototype, "samples", null);
 __decorate([
     serialize()
-], SSRRenderingPipeline.prototype, "maxDistance", void 0);
+], SSRRenderingPipeline.prototype, "maxDistance", null);
 __decorate([
     serialize()
-], SSRRenderingPipeline.prototype, "step", void 0);
+], SSRRenderingPipeline.prototype, "step", null);
 __decorate([
     serialize()
-], SSRRenderingPipeline.prototype, "thickness", void 0);
+], SSRRenderingPipeline.prototype, "thickness", null);
 __decorate([
     serialize()
-], SSRRenderingPipeline.prototype, "strength", void 0);
+], SSRRenderingPipeline.prototype, "strength", null);
 __decorate([
     serialize()
-], SSRRenderingPipeline.prototype, "reflectionSpecularFalloffExponent", void 0);
+], SSRRenderingPipeline.prototype, "reflectionSpecularFalloffExponent", null);
 __decorate([
     serialize()
-], SSRRenderingPipeline.prototype, "maxSteps", void 0);
+], SSRRenderingPipeline.prototype, "maxSteps", null);
 __decorate([
     serialize()
-], SSRRenderingPipeline.prototype, "roughnessFactor", void 0);
+], SSRRenderingPipeline.prototype, "roughnessFactor", null);
 __decorate([
     serialize()
-], SSRRenderingPipeline.prototype, "selfCollisionNumSkip", void 0);
+], SSRRenderingPipeline.prototype, "selfCollisionNumSkip", null);
 __decorate([
     serialize()
-], SSRRenderingPipeline.prototype, "_reflectivityThreshold", void 0);
-__decorate([
-    serialize("_ssrDownsample")
-], SSRRenderingPipeline.prototype, "_ssrDownsample", void 0);
+], SSRRenderingPipeline.prototype, "reflectivityThreshold", null);
 __decorate([
     serialize()
 ], SSRRenderingPipeline.prototype, "ssrDownsample", null);
 __decorate([
     serialize("blurDispersionStrength")
-], SSRRenderingPipeline.prototype, "_blurDispersionStrength", void 0);
+], SSRRenderingPipeline.prototype, "blurDispersionStrength", null);
 __decorate([
     serialize("blurDownsample")
-], SSRRenderingPipeline.prototype, "_blurDownsample", void 0);
+], SSRRenderingPipeline.prototype, "blurDownsample", null);
 __decorate([
     serialize("enableSmoothReflections")
-], SSRRenderingPipeline.prototype, "_enableSmoothReflections", void 0);
+], SSRRenderingPipeline.prototype, "enableSmoothReflections", null);
 __decorate([
     serialize("environmentTexture")
-], SSRRenderingPipeline.prototype, "_environmentTexture", void 0);
+], SSRRenderingPipeline.prototype, "environmentTexture", null);
 __decorate([
     serialize("environmentTextureIsProbe")
-], SSRRenderingPipeline.prototype, "_environmentTextureIsProbe", void 0);
+], SSRRenderingPipeline.prototype, "environmentTextureIsProbe", null);
 __decorate([
     serialize("attenuateScreenBorders")
-], SSRRenderingPipeline.prototype, "_attenuateScreenBorders", void 0);
+], SSRRenderingPipeline.prototype, "attenuateScreenBorders", null);
 __decorate([
     serialize("attenuateIntersectionDistance")
-], SSRRenderingPipeline.prototype, "_attenuateIntersectionDistance", void 0);
+], SSRRenderingPipeline.prototype, "attenuateIntersectionDistance", null);
 __decorate([
     serialize("attenuateIntersectionIterations")
-], SSRRenderingPipeline.prototype, "_attenuateIntersectionIterations", void 0);
+], SSRRenderingPipeline.prototype, "attenuateIntersectionIterations", null);
 __decorate([
     serialize("attenuateFacingCamera")
-], SSRRenderingPipeline.prototype, "_attenuateFacingCamera", void 0);
+], SSRRenderingPipeline.prototype, "attenuateFacingCamera", null);
 __decorate([
     serialize("attenuateBackfaceReflection")
-], SSRRenderingPipeline.prototype, "_attenuateBackfaceReflection", void 0);
+], SSRRenderingPipeline.prototype, "attenuateBackfaceReflection", null);
 __decorate([
     serialize("clipToFrustum")
-], SSRRenderingPipeline.prototype, "_clipToFrustum", void 0);
+], SSRRenderingPipeline.prototype, "clipToFrustum", null);
 __decorate([
     serialize("useFresnel")
-], SSRRenderingPipeline.prototype, "_useFresnel", void 0);
+], SSRRenderingPipeline.prototype, "useFresnel", null);
 __decorate([
     serialize("enableAutomaticThicknessComputation")
-], SSRRenderingPipeline.prototype, "_enableAutomaticThicknessComputation", void 0);
+], SSRRenderingPipeline.prototype, "enableAutomaticThicknessComputation", null);
 __decorate([
     serialize("backfaceDepthTextureDownsample")
 ], SSRRenderingPipeline.prototype, "_backfaceDepthTextureDownsample", void 0);
@@ -1066,12 +881,12 @@ __decorate([
 ], SSRRenderingPipeline.prototype, "_isEnabled", void 0);
 __decorate([
     serialize("inputTextureColorIsInGammaSpace")
-], SSRRenderingPipeline.prototype, "_inputTextureColorIsInGammaSpace", void 0);
+], SSRRenderingPipeline.prototype, "inputTextureColorIsInGammaSpace", null);
 __decorate([
     serialize("generateOutputInGammaSpace")
-], SSRRenderingPipeline.prototype, "_generateOutputInGammaSpace", void 0);
+], SSRRenderingPipeline.prototype, "generateOutputInGammaSpace", null);
 __decorate([
     serialize("debug")
-], SSRRenderingPipeline.prototype, "_debug", void 0);
+], SSRRenderingPipeline.prototype, "debug", null);
 RegisterClass("BABYLON.SSRRenderingPipeline", SSRRenderingPipeline);
 //# sourceMappingURL=ssrRenderingPipeline.js.map