@babylonjs/core 5.47.1 → 5.48.0

package/PostProcesses/RenderPipeline/Pipelines/ssrRenderingPipeline.js

@@ -0,0 +1,805 @@
+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";
+import { PostProcessRenderPipeline } from "../postProcessRenderPipeline.js";
+import { PostProcessRenderEffect } from "../postProcessRenderEffect.js";
+import { RegisterClass } from "../../../Misc/typeStore.js";
+import { ScreenSpaceReflections2Configuration } from "../../../Rendering/screenSpaceReflections2Configuration.js";
+import { GeometryBufferRenderer } from "../../../Rendering/geometryBufferRenderer.js";
+
+import { DepthRenderer } from "../../../Rendering/depthRenderer.js";
+import "../postProcessRenderPipelineManagerSceneComponent.js";
+import "../../../Shaders/screenSpaceReflection2.fragment.js";
+import "../../../Shaders/screenSpaceReflection2Blur.fragment.js";
+import "../../../Shaders/screenSpaceReflection2BlurCombiner.fragment.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
+ *
+ * References:
+ *   Screen Space Ray Tracing:
+ *     - http://casual-effects.blogspot.com/2014/08/screen-space-ray-tracing.html
+ *     - https://sourceforge.net/p/g3d/code/HEAD/tree/G3D10/data-files/shader/screenSpaceRayTrace.glsl
+ *     - https://github.com/kode80/kode80SSR
+ *   SSR:
+ *     - general tips: https://sakibsaikia.github.io/graphics/2016/12/26/Screen-Space-Reflection-in-Killing-Floor-2.html
+ *     - computation of blur radius from roughness and distance: https://github.com/godotengine/godot/blob/master/servers/rendering/renderer_rd/shaders/effects/screen_space_reflection.glsl
+ *     - blur and usage of back depth buffer: https://github.com/kode80/kode80SSR
+ */
+export class SSRRenderingPipeline extends PostProcessRenderPipeline {
+    /**
+     * MSAA sample count, setting this to 4 will provide 4x anti aliasing. (default: 1)
+     */
+    set samples(sampleCount) {
+        if (this._samples === sampleCount) {
+            return;
+        }
+        this._samples = sampleCount;
+        this._buildPipeline();
+    }
+    get samples() {
+        return this._samples;
+    }
+    /**
+     * 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.
+     * blurDispersionStrength allows to increase or decrease this effect.
+     */
+    get blurDispersionStrength() {
+        return this._blurDispersionStrength;
+    }
+    set blurDispersionStrength(strength) {
+        if (strength === this._blurDispersionStrength) {
+            return;
+        }
+        const rebuild = (strength === 0 && this._blurDispersionStrength !== 0) || (strength !== 0 && this._blurDispersionStrength === 0);
+        this._blurDispersionStrength = strength;
+        if (rebuild) {
+            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.
+     * Note that this setting has no effect if step = 1: it's only used if step \> 1.
+     */
+    get enableSmoothReflections() {
+        return this._enableSmoothReflections;
+    }
+    set enableSmoothReflections(enabled) {
+        if (enabled === this._enableSmoothReflections) {
+            return;
+        }
+        this._enableSmoothReflections = enabled;
+        this._updateEffectDefines();
+    }
+    /**
+     * 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;
+    }
+    set environmentTexture(texture) {
+        this._environmentTexture = texture;
+        this._updateEffectDefines();
+    }
+    /**
+     * 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;
+    }
+    set environmentTextureIsProbe(isProbe) {
+        this._environmentTextureIsProbe = isProbe;
+        this._updateEffectDefines();
+    }
+    /**
+     * Gets or sets a boolean indicating if the reflections should be attenuated at the screen borders (default: true).
+     */
+    get attenuateScreenBorders() {
+        return this._attenuateScreenBorders;
+    }
+    set attenuateScreenBorders(attenuate) {
+        if (this._attenuateScreenBorders === attenuate) {
+            return;
+        }
+        this._attenuateScreenBorders = attenuate;
+        this._updateEffectDefines();
+    }
+    /**
+     * 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;
+    }
+    set attenuateIntersectionDistance(attenuate) {
+        if (this._attenuateIntersectionDistance === attenuate) {
+            return;
+        }
+        this._attenuateIntersectionDistance = 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).
+     */
+    get attenuateFacingCamera() {
+        return this._attenuateFacingCamera;
+    }
+    set attenuateFacingCamera(attenuate) {
+        if (this._attenuateFacingCamera === attenuate) {
+            return;
+        }
+        this._attenuateFacingCamera = attenuate;
+        this._updateEffectDefines();
+    }
+    /**
+     * Gets or sets a boolean indicating if the backface reflections should be attenuated (default: false).
+     */
+    get attenuateBackfaceReflection() {
+        return this._attenuateBackfaceReflection;
+    }
+    set attenuateBackfaceReflection(attenuate) {
+        if (this._attenuateBackfaceReflection === attenuate) {
+            return;
+        }
+        this._attenuateBackfaceReflection = attenuate;
+        this._updateEffectDefines();
+    }
+    /**
+     * 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;
+    }
+    set clipToFrustum(clip) {
+        if (this._clipToFrustum === clip) {
+            return;
+        }
+        this._clipToFrustum = clip;
+        this._updateEffectDefines();
+    }
+    /**
+     * Gets or sets a boolean defining if geometry thickness should be computed automatically (default: false).
+     * When enabled, a depth renderer is created which will render the back faces of the scene to a depth texture (meaning additional work for the GPU).
+     * In that mode, the "thickness" property is still used as an offset to compute the ray intersection, but you can typically use a much lower
+     * value than when enableAutomaticThicknessComputation is false (it's even possible to use a value of 0 when using low values for "step")
+     * Note that for performance reasons, this option will only apply to the first camera to which the the rendering pipeline is attached!
+     */
+    get enableAutomaticThicknessComputation() {
+        return this._enableAutomaticThicknessComputation;
+    }
+    set enableAutomaticThicknessComputation(automatic) {
+        if (this._enableAutomaticThicknessComputation === automatic) {
+            return;
+        }
+        this._enableAutomaticThicknessComputation = automatic;
+        this._buildPipeline();
+    }
+    /**
+     * Gets the depth renderer used to render the back faces of the scene to a depth texture.
+     */
+    get backfaceDepthRenderer() {
+        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.
+     */
+    get backfaceDepthTextureSizeFactor() {
+        return this._backfaceDepthTextureSizeFactor;
+    }
+    set backfaceDepthTextureSizeFactor(factor) {
+        if (this._backfaceDepthTextureSizeFactor === factor) {
+            return;
+        }
+        this._backfaceDepthTextureSizeFactor = factor;
+        this._resizeDepthRenderer();
+    }
+    /**
+     * Gets or sets a boolean indicating if the effect is enabled (default: true).
+     */
+    get isEnabled() {
+        return this._isEnabled;
+    }
+    set isEnabled(value) {
+        if (this._isEnabled === value) {
+            return;
+        }
+        this._isEnabled = value;
+        if (!value) {
+            if (this._cameras !== null) {
+                this._scene.postProcessRenderPipelineManager.detachCamerasFromRenderPipeline(this._name, this._cameras);
+                this._cameras = this._camerasToBeAttached.slice();
+            }
+        }
+        else if (value) {
+            if (!this._isDirty) {
+                if (this._cameras !== null) {
+                    this._scene.postProcessRenderPipelineManager.attachCamerasToRenderPipeline(this._name, this._cameras);
+                }
+            }
+            else {
+                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:
+     *   - blue: the ray hit the max distance (we reached maxDistance)
+     *   - red: the ray ran out of steps (we reached maxSteps)
+     *   - yellow: the ray went off screen
+     *   - green: the ray hit a surface. The brightness of the green color is proportional to the distance between the ray origin and the intersection point: A brighter green means more computation than a darker green.
+     * In the first 3 cases, the final color is calculated by mixing the skybox color with the pixel color (if environmentTexture is defined), otherwise the pixel color is not modified
+     * 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;
+    }
+    set debug(value) {
+        if (this._debug === value) {
+            return;
+        }
+        this._debug = value;
+        this._buildPipeline();
+    }
+    get _geometryBufferRenderer() {
+        if (!this._forceGeometryBuffer) {
+            return null;
+        }
+        return this._scene.geometryBufferRenderer;
+    }
+    get _prePassRenderer() {
+        if (this._forceGeometryBuffer) {
+            return null;
+        }
+        return this._scene.prePassRenderer;
+    }
+    /**
+     * Gets active scene
+     */
+    get scene() {
+        return this._scene;
+    }
+    /**
+     * Constructor of the SSR rendering pipeline
+     * @param name The rendering pipeline name
+     * @param scene The scene linked to this pipeline
+     * @param cameras The array of cameras that the rendering pipeline will be attached to (default: scene.cameras)
+     * @param forceGeometryBuffer Set to true if you want to use the legacy geometry buffer renderer (default: false)
+     * @param textureType The texture type used by the different post processes created by SSR (default: 0)
+     */
+    constructor(name, scene, cameras, forceGeometryBuffer = false, textureType = 0) {
+        super(scene.getEngine(), name);
+        /**
+         * The SSR PostProcess effect id in the pipeline
+         */
+        this.SSRRenderEffect = "SSRRenderEffect";
+        /**
+         * The blur PostProcess effect id in the pipeline
+         */
+        this.SSRBlurRenderEffect = "SSRBlurRenderEffect";
+        /**
+         * The PostProcess effect id in the pipeline that combines the SSR-Blur output with the original scene color
+         */
+        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)
+         */
+        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._blurDispersionStrength = 1 / 20;
+        /**
+         * Apply different weighting when blurring.
+         * Must be a value between 2 and 5
+         */
+        this.blurQuality = 2;
+        this._enableSmoothReflections = false;
+        this._environmentTextureIsProbe = false;
+        this._attenuateScreenBorders = true;
+        this._attenuateIntersectionDistance = true;
+        this._attenuateFacingCamera = false;
+        this._attenuateBackfaceReflection = false;
+        this._clipToFrustum = true;
+        this._enableAutomaticThicknessComputation = false;
+        this._backfaceDepthTextureSizeFactor = 1;
+        this._isEnabled = true;
+        this._debug = false;
+        this._forceGeometryBuffer = false;
+        this._isDirty = false;
+        this._camerasToBeAttached = [];
+        this._cameras = cameras || scene.cameras;
+        this._cameras = this._cameras.slice();
+        this._camerasToBeAttached = this._cameras.slice();
+        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;
+            }
+        }
+        else {
+            const prePassRenderer = scene.enablePrePassRenderer();
+            prePassRenderer === null || prePassRenderer === void 0 ? void 0 : prePassRenderer.markAsDirty();
+        }
+        this._buildPipeline();
+    }
+    /**
+     * Get the class name
+     * @returns "SSRRenderingPipeline"
+     */
+    getClassName() {
+        return "SSRRenderingPipeline";
+    }
+    /**
+     * Adds a camera to the pipeline
+     * @param camera the camera to be added
+     */
+    addCamera(camera) {
+        this._camerasToBeAttached.push(camera);
+        this._buildPipeline();
+    }
+    /**
+     * Removes a camera from the pipeline
+     * @param camera the camera to remove
+     */
+    removeCamera(camera) {
+        const index = this._camerasToBeAttached.indexOf(camera);
+        this._camerasToBeAttached.splice(index, 1);
+        this._buildPipeline();
+    }
+    /**
+     * Removes the internal pipeline assets and detaches the pipeline from the scene cameras
+     * @param disableGeometryBufferRenderer
+     */
+    dispose(disableGeometryBufferRenderer = false) {
+        this._disposeDepthRenderer();
+        this._disposePostProcesses();
+        if (disableGeometryBufferRenderer) {
+            this._scene.disableGeometryBufferRenderer();
+        }
+        this._scene.postProcessRenderPipelineManager.detachCamerasFromRenderPipeline(this._name, this._cameras);
+        super.dispose();
+    }
+    _getTextureSize() {
+        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);
+            const renderTarget = prePassRenderer.getRenderTarget();
+            if (renderTarget && renderTarget.textures) {
+                textureSize = renderTarget.textures[depthIndex].getSize();
+            }
+        }
+        return textureSize;
+    }
+    _updateEffectDefines() {
+        var _a;
+        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._environmentTexture) {
+            defines.push("#define SSR_USE_ENVIRONMENT_CUBE");
+            if (this._environmentTexture.boundingBoxSize) {
+                defines.push("#define SSR_USE_LOCAL_REFLECTIONMAP_CUBIC");
+            }
+        }
+        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._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._blurDispersionStrength > 0) {
+            defines.push("#define SSR_USE_BLUR");
+        }
+        if (this._debug) {
+            defines.push("#define SSRAYTRACE_DEBUG");
+        }
+        (_a = this._ssrPostProcess) === null || _a === void 0 ? void 0 : _a.updateEffect(defines.join("\n"));
+    }
+    _buildPipeline() {
+        var _a;
+        if (!this._isEnabled) {
+            this._isDirty = true;
+            return;
+        }
+        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();
+        }
+        this._reset();
+        if (this._enableAutomaticThicknessComputation) {
+            const camera = (_a = this._cameras) === null || _a === void 0 ? void 0 : _a[0];
+            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.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._resizeDepthRenderer();
+                camera.customRenderTargets.push(this._depthRenderer.getDepthMap());
+            }
+        }
+        this._createSSRPostProcess();
+        this.addEffect(new PostProcessRenderEffect(engine, this.SSRRenderEffect, () => {
+            return this._ssrPostProcess;
+        }, true));
+        if (this._blurDispersionStrength > 0) {
+            this._createBlurAndCombinerPostProcesses();
+            this.addEffect(new PostProcessRenderEffect(engine, this.SSRBlurRenderEffect, () => {
+                return [this._blurPostProcessX, this._blurPostProcessY];
+            }, true));
+            this.addEffect(new PostProcessRenderEffect(engine, this.SSRCombineRenderEffect, () => {
+                return this._blurCombinerPostProcess;
+            }, true));
+        }
+        if (this._cameras !== null) {
+            this._scene.postProcessRenderPipelineManager.attachCamerasToRenderPipeline(this._name, this._cameras);
+        }
+    }
+    _resizeDepthRenderer() {
+        if (!this._depthRenderer) {
+            return;
+        }
+        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);
+        if (depthRendererSize.width !== width || depthRendererSize.height !== height) {
+            this._depthRenderer.getDepthMap().resize({ width, height });
+        }
+    }
+    _disposeDepthRenderer() {
+        var _a;
+        if (this._depthRenderer) {
+            if (this._depthRendererCamera) {
+                const idx = (_a = this._depthRendererCamera.customRenderTargets.indexOf(this._depthRenderer.getDepthMap())) !== null && _a !== void 0 ? _a : -1;
+                if (idx !== -1) {
+                    this._depthRendererCamera.customRenderTargets.splice(idx, 1);
+                }
+            }
+            this._depthRendererCamera = null;
+            this._depthRenderer.getDepthMap().dispose();
+        }
+        this._depthRenderer = null;
+    }
+    _disposePostProcesses() {
+        var _a, _b, _c, _d;
+        for (let i = 0; i < this._cameras.length; i++) {
+            const camera = this._cameras[i];
+            (_a = this._ssrPostProcess) === null || _a === void 0 ? void 0 : _a.dispose(camera);
+            (_b = this._blurPostProcessX) === null || _b === void 0 ? void 0 : _b.dispose(camera);
+            (_c = this._blurPostProcessY) === null || _c === void 0 ? void 0 : _c.dispose(camera);
+            (_d = this._blurCombinerPostProcess) === null || _d === void 0 ? void 0 : _d.dispose(camera);
+        }
+        this._ssrPostProcess = null;
+        this._blurPostProcessX = null;
+        this._blurPostProcessY = null;
+        this._blurCombinerPostProcess = null;
+    }
+    _createSSRPostProcess() {
+        this._ssrPostProcess = new PostProcess("ssr", "screenSpaceReflection2", [
+            "projection",
+            "invProjectionMatrix",
+            "view",
+            "invView",
+            "thickness",
+            "reflectionSpecularFalloffExponent",
+            "strength",
+            "stepSize",
+            "maxSteps",
+            "roughnessFactor",
+            "projectionPixel",
+            "nearPlaneZ",
+            "maxDistance",
+            "selfCollisionNumSkip",
+            "vReflectionPosition",
+            "vReflectionSize",
+            "backSizeFactor",
+        ], ["textureSampler", "normalSampler", "reflectivitySampler", "depthSampler", "envCubeSampler", "backDepthSampler"], 1.0, null, this._textureType, this._scene.getEngine(), false, "", this._textureType);
+        this._updateEffectDefines();
+        this._ssrPostProcess.onApply = (effect) => {
+            this._resizeDepthRenderer();
+            const geometryBufferRenderer = this._geometryBufferRenderer;
+            const prePassRenderer = this._prePassRenderer;
+            if (!prePassRenderer && !geometryBufferRenderer) {
+                return;
+            }
+            if (geometryBufferRenderer) {
+                const roughnessIndex = geometryBufferRenderer.getTextureIndex(GeometryBufferRenderer.REFLECTIVITY_TEXTURE_TYPE);
+                effect.setTexture("normalSampler", geometryBufferRenderer.getGBuffer().textures[1]);
+                effect.setTexture("reflectivitySampler", geometryBufferRenderer.getGBuffer().textures[roughnessIndex]);
+                effect.setTexture("depthSampler", geometryBufferRenderer.getGBuffer().textures[0]);
+            }
+            else if (prePassRenderer) {
+                const depthIndex = prePassRenderer.getIndex(5);
+                const roughnessIndex = prePassRenderer.getIndex(3);
+                const normalIndex = prePassRenderer.getIndex(6);
+                effect.setTexture("normalSampler", prePassRenderer.getRenderTarget().textures[normalIndex]);
+                effect.setTexture("depthSampler", prePassRenderer.getRenderTarget().textures[depthIndex]);
+                effect.setTexture("reflectivitySampler", prePassRenderer.getRenderTarget().textures[roughnessIndex]);
+            }
+            if (this._enableAutomaticThicknessComputation && this._depthRenderer) {
+                effect.setTexture("backDepthSampler", this._depthRenderer.getDepthMap());
+                effect.setFloat("backSizeFactor", this._backfaceDepthTextureSizeFactor);
+            }
+            const camera = this._scene.activeCamera;
+            if (!camera) {
+                return;
+            }
+            const viewMatrix = camera.getViewMatrix(true);
+            const projectionMatrix = camera.getProjectionMatrix(true);
+            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("maxDistance", this.maxDistance);
+            effect.setFloat("selfCollisionNumSkip", this.selfCollisionNumSkip);
+            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._ssrPostProcess.samples = this.samples;
+        if (!this._forceGeometryBuffer) {
+            this._ssrPostProcess._prePassEffectConfiguration = new ScreenSpaceReflections2Configuration();
+        }
+    }
+    _createBlurAndCombinerPostProcesses() {
+        const engine = this._scene.getEngine();
+        this._blurPostProcessX = new PostProcess("SSRblurX", "screenSpaceReflection2Blur", ["blurQuality", "texelOffsetScale"], ["textureSampler"], 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);
+            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.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);
+            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);
+        this._blurCombinerPostProcess.autoClear = false;
+        this._blurCombinerPostProcess.onApplyObservable.add((effect) => {
+            const geometryBufferRenderer = this._geometryBufferRenderer;
+            const prePassRenderer = this._prePassRenderer;
+            if (!prePassRenderer && !geometryBufferRenderer) {
+                return;
+            }
+            if (prePassRenderer) {
+                const colorIndex = prePassRenderer.getIndex(4);
+                const renderTarget = prePassRenderer.getRenderTarget();
+                if (renderTarget && renderTarget.textures) {
+                    effect.setTexture("mainSampler", renderTarget.textures[colorIndex]);
+                }
+            }
+            else {
+                effect._bindTexture("mainSampler", this._ssrPostProcess.inputTexture.texture);
+            }
+            if (geometryBufferRenderer) {
+                const roughnessIndex = geometryBufferRenderer.getTextureIndex(GeometryBufferRenderer.REFLECTIVITY_TEXTURE_TYPE);
+                effect.setTexture("reflectivitySampler", geometryBufferRenderer.getGBuffer().textures[roughnessIndex]);
+            }
+            else if (prePassRenderer) {
+                const roughnessIndex = prePassRenderer.getIndex(3);
+                effect.setTexture("reflectivitySampler", prePassRenderer.getRenderTarget().textures[roughnessIndex]);
+            }
+            effect.setFloat("strength", this.strength);
+            effect.setFloat("reflectionSpecularFalloffExponent", this.reflectionSpecularFalloffExponent);
+        });
+    }
+    /**
+     * Serializes the rendering pipeline (Used when exporting)
+     * @returns the serialized object
+     */
+    serialize() {
+        const serializationObject = SerializationHelper.Serialize(this);
+        serializationObject.customType = "SSRRenderingPipeline";
+        return serializationObject;
+    }
+    /**
+     * Parse the serialized pipeline
+     * @param source Source pipeline.
+     * @param scene The scene to load the pipeline to.
+     * @param rootUrl The URL of the serialized pipeline.
+     * @returns An instantiated pipeline from the serialized object.
+     */
+    static Parse(source, scene, rootUrl) {
+        return SerializationHelper.Parse(() => new SSRRenderingPipeline(source._name, scene, source._ratio), source, scene, rootUrl);
+    }
+}
+__decorate([
+    serialize()
+], SSRRenderingPipeline.prototype, "samples", null);
+__decorate([
+    serialize()
+], SSRRenderingPipeline.prototype, "maxDistance", void 0);
+__decorate([
+    serialize()
+], SSRRenderingPipeline.prototype, "step", void 0);
+__decorate([
+    serialize()
+], SSRRenderingPipeline.prototype, "thickness", void 0);
+__decorate([
+    serialize()
+], SSRRenderingPipeline.prototype, "strength", void 0);
+__decorate([
+    serialize()
+], SSRRenderingPipeline.prototype, "reflectionSpecularFalloffExponent", void 0);
+__decorate([
+    serialize()
+], SSRRenderingPipeline.prototype, "maxSteps", void 0);
+__decorate([
+    serialize()
+], SSRRenderingPipeline.prototype, "roughnessFactor", void 0);
+__decorate([
+    serialize()
+], SSRRenderingPipeline.prototype, "selfCollisionNumSkip", void 0);
+__decorate([
+    serialize("blurDispersionStrength")
+], SSRRenderingPipeline.prototype, "_blurDispersionStrength", void 0);
+__decorate([
+    serialize()
+], SSRRenderingPipeline.prototype, "blurQuality", void 0);
+__decorate([
+    serialize("enableSmoothReflections")
+], SSRRenderingPipeline.prototype, "_enableSmoothReflections", void 0);
+__decorate([
+    serialize("environmentTexture")
+], SSRRenderingPipeline.prototype, "_environmentTexture", void 0);
+__decorate([
+    serialize("environmentTextureIsProbe")
+], SSRRenderingPipeline.prototype, "_environmentTextureIsProbe", void 0);
+__decorate([
+    serialize("attenuateScreenBorders")
+], SSRRenderingPipeline.prototype, "_attenuateScreenBorders", void 0);
+__decorate([
+    serialize("attenuateIntersectionDistance")
+], SSRRenderingPipeline.prototype, "_attenuateIntersectionDistance", void 0);
+__decorate([
+    serialize("attenuateFacingCamera")
+], SSRRenderingPipeline.prototype, "_attenuateFacingCamera", void 0);
+__decorate([
+    serialize("attenuateBackfaceReflection")
+], SSRRenderingPipeline.prototype, "_attenuateBackfaceReflection", void 0);
+__decorate([
+    serialize("clipToFrustum")
+], SSRRenderingPipeline.prototype, "_clipToFrustum", void 0);
+__decorate([
+    serialize("enableAutomaticThicknessComputation")
+], SSRRenderingPipeline.prototype, "_enableAutomaticThicknessComputation", void 0);
+__decorate([
+    serialize("backfaceDepthTextureSizeFactor")
+], SSRRenderingPipeline.prototype, "_backfaceDepthTextureSizeFactor", void 0);
+__decorate([
+    serialize("isEnabled")
+], SSRRenderingPipeline.prototype, "_isEnabled", void 0);
+__decorate([
+    serialize("debug")
+], SSRRenderingPipeline.prototype, "_debug", void 0);
+RegisterClass("BABYLON.SSRRenderingPipeline", SSRRenderingPipeline);
+//# sourceMappingURL=ssrRenderingPipeline.js.map