@babylonjs/core 5.50.1 → 5.52.0

package/PostProcesses/RenderPipeline/Pipelines/ssrRenderingPipeline.d.ts

@@ -65,7 +65,8 @@ export declare class SSRRenderingPipeline extends PostProcessRenderPipeline {
      */
     reflectionSpecularFalloffExponent: number;
     /**
-     * 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.
      */
     maxSteps: number;
     /**
@@ -79,23 +80,39 @@ export declare 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)
      */
     selfCollisionNumSkip: number;
+    /**
+     * 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.
+     */
+    reflectivityThreshold: number;
+    private _ssrDownsample;
+    /**
+     * 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(): number;
+    set ssrDownsample(downsample: number);
     private _blurDispersionStrength;
     /**
      * 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(): number;
     set blurDispersionStrength(strength: number);
+    private _useBlur;
+    private _blurDownsample;
     /**
-     * Apply different weighting when blurring.
-     * Must be a value between 2 and 5
+     * 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.
      */
-    blurQuality: number;
+    get blurDownsample(): number;
+    set blurDownsample(downsample: number);
     private _enableSmoothReflections;
     /**
-     * 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(): boolean;
@@ -125,6 +142,12 @@ export declare class SSRRenderingPipeline extends PostProcessRenderPipeline {
      */
     get attenuateIntersectionDistance(): boolean;
     set attenuateIntersectionDistance(attenuate: boolean);
+    private _attenuateIntersectionIterations;
+    /**
+     * 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(): boolean;
+    set attenuateIntersectionIterations(attenuate: boolean);
     private _attenuateFacingCamera;
     /**
      * 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).
@@ -158,20 +181,40 @@ export declare class SSRRenderingPipeline extends PostProcessRenderPipeline {
      * Gets the depth renderer used to render the back faces of the scene to a depth texture.
      */
     get backfaceDepthRenderer(): Nullable<DepthRenderer>;
-    private _backfaceDepthTextureSizeFactor;
+    private _backfaceDepthTextureDownsample;
+    /**
+     * 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 backfaceDepthTextureDownsample(): number;
+    set backfaceDepthTextureDownsample(factor: number);
+    private _backfaceForceDepthWriteTransparentMeshes;
     /**
-     * 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 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 backfaceDepthTextureSizeFactor(): number;
-    set backfaceDepthTextureSizeFactor(factor: number);
+    get backfaceForceDepthWriteTransparentMeshes(): boolean;
+    set backfaceForceDepthWriteTransparentMeshes(force: boolean);
     private _isEnabled;
     /**
      * Gets or sets a boolean indicating if the effect is enabled (default: true).
      */
     get isEnabled(): boolean;
     set isEnabled(value: boolean);
+    private _inputTextureColorIsInGammaSpace;
+    /**
+     * 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(): boolean;
+    set inputTextureColorIsInGammaSpace(gammaSpace: boolean);
+    private _generateOutputInGammaSpace;
+    /**
+     * 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(): boolean;
+    set generateOutputInGammaSpace(gammaSpace: boolean);
     private _debug;
     /**
      * Gets or sets a boolean indicating if the effect should be rendered in debug mode (default: false).
@@ -185,6 +228,11 @@ export declare class SSRRenderingPipeline extends PostProcessRenderPipeline {
      */
     get debug(): boolean;
     set debug(value: boolean);
+    /**
+     * Gets the scene the effect belongs to.
+     * @returns the scene the effect belongs to.
+     */
+    getScene(): Scene;
     private _forceGeometryBuffer;
     private get _geometryBufferRenderer();
     private get _prePassRenderer();
@@ -202,6 +250,10 @@ export declare class SSRRenderingPipeline extends PostProcessRenderPipeline {
      * Gets active scene
      */
     get scene(): Scene;
+    /**
+     * Returns true if SSR is supported by the running hardware
+     */
+    get isSupported(): boolean;
     /**
      * Constructor of the SSR rendering pipeline
      * @param name The rendering pipeline name