@babylonjs/core 7.52.1 → 7.52.3

package/PostProcesses/RenderPipeline/Pipelines/thinSSRRenderingPipeline.js

@@ -0,0 +1,373 @@
+import { Vector2 } from "../../../Maths/math.vector.js";
+import { ThinSSRPostProcess } from "../../thinSSRPostProcess.js";
+import { ThinSSRBlurPostProcess } from "../../thinSSRBlurPostProcess.js";
+import { ThinSSRBlurCombinerPostProcess } from "../../thinSSRBlurCombinerPostProcess.js";
+/**
+ * The SSR rendering pipeline is used to generate a reflection based on a flat mirror model.
+ */
+export class ThinSSRRenderingPipeline {
+    /**
+     * Gets or sets a boolean indicating if the SSR rendering pipeline is supported
+     */
+    get isSSRSupported() {
+        return this._ssrPostProcess.isSSRSupported;
+    }
+    set isSSRSupported(supported) {
+        this._ssrPostProcess.isSSRSupported = supported;
+    }
+    /**
+     * 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._ssrPostProcess.maxDistance;
+    }
+    set maxDistance(distance) {
+        this._ssrPostProcess.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._ssrPostProcess.step;
+    }
+    set step(step) {
+        this._ssrPostProcess.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._ssrPostProcess.thickness;
+    }
+    set thickness(thickness) {
+        this._ssrPostProcess.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._ssrPostProcess.strength;
+    }
+    set strength(strength) {
+        this._ssrPostProcess.strength = strength;
+        this._ssrBlurCombinerPostProcess.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._ssrPostProcess.reflectionSpecularFalloffExponent;
+    }
+    set reflectionSpecularFalloffExponent(exponent) {
+        this._ssrPostProcess.reflectionSpecularFalloffExponent = exponent;
+        this._ssrBlurCombinerPostProcess.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._ssrPostProcess.maxSteps;
+    }
+    set maxSteps(steps) {
+        this._ssrPostProcess.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._ssrPostProcess.roughnessFactor;
+    }
+    set roughnessFactor(factor) {
+        this._ssrPostProcess.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._ssrPostProcess.selfCollisionNumSkip;
+    }
+    set selfCollisionNumSkip(skip) {
+        this._ssrPostProcess.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._ssrPostProcess.reflectivityThreshold;
+    }
+    set reflectivityThreshold(threshold) {
+        const currentThreshold = this._ssrPostProcess.reflectivityThreshold;
+        if (threshold === currentThreshold) {
+            return;
+        }
+        this._ssrPostProcess.reflectivityThreshold = threshold;
+        this._ssrBlurCombinerPostProcess.reflectivityThreshold = threshold;
+    }
+    /**
+     * 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._ssrBlurXPostProcess.blurStrength;
+    }
+    set blurDispersionStrength(strength) {
+        if (strength === this._ssrBlurXPostProcess.blurStrength) {
+            return;
+        }
+        this._ssrPostProcess.useBlur = strength > 0;
+        this._ssrBlurXPostProcess.blurStrength = strength;
+        this._ssrBlurYPostProcess.blurStrength = strength;
+    }
+    /**
+     * 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() {
+        return this._ssrPostProcess.enableSmoothReflections;
+    }
+    set enableSmoothReflections(enabled) {
+        this._ssrPostProcess.enableSmoothReflections = enabled;
+    }
+    /**
+     * 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._ssrPostProcess.environmentTexture;
+    }
+    set environmentTexture(texture) {
+        this._ssrPostProcess.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._ssrPostProcess.environmentTextureIsProbe;
+    }
+    set environmentTextureIsProbe(isProbe) {
+        this._ssrPostProcess.environmentTextureIsProbe = isProbe;
+    }
+    /**
+     * Gets or sets a boolean indicating if the reflections should be attenuated at the screen borders (default: true).
+     */
+    get attenuateScreenBorders() {
+        return this._ssrPostProcess.attenuateScreenBorders;
+    }
+    set attenuateScreenBorders(attenuate) {
+        this._ssrPostProcess.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._ssrPostProcess.attenuateIntersectionDistance;
+    }
+    set attenuateIntersectionDistance(attenuate) {
+        this._ssrPostProcess.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._ssrPostProcess.attenuateIntersectionIterations;
+    }
+    set attenuateIntersectionIterations(attenuate) {
+        this._ssrPostProcess.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._ssrPostProcess.attenuateFacingCamera;
+    }
+    set attenuateFacingCamera(attenuate) {
+        this._ssrPostProcess.attenuateFacingCamera = attenuate;
+    }
+    /**
+     * Gets or sets a boolean indicating if the backface reflections should be attenuated (default: false).
+     */
+    get attenuateBackfaceReflection() {
+        return this._ssrPostProcess.attenuateBackfaceReflection;
+    }
+    set attenuateBackfaceReflection(attenuate) {
+        this._ssrPostProcess.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._ssrPostProcess.clipToFrustum;
+    }
+    set clipToFrustum(clip) {
+        this._ssrPostProcess.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._ssrPostProcess.useFresnel;
+    }
+    set useFresnel(fresnel) {
+        this._ssrPostProcess.useFresnel = fresnel;
+        this._ssrBlurCombinerPostProcess.useFresnel = fresnel;
+    }
+    /**
+     * 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 rendering pipeline is attached!
+     */
+    get enableAutomaticThicknessComputation() {
+        return this._ssrPostProcess.enableAutomaticThicknessComputation;
+    }
+    set enableAutomaticThicknessComputation(automatic) {
+        if (this._ssrPostProcess.enableAutomaticThicknessComputation === automatic) {
+            return;
+        }
+        this._ssrPostProcess.enableAutomaticThicknessComputation = automatic;
+    }
+    /**
+     * Gets or sets a boolean defining if the input color texture is in gamma space (default: true)
+     * The SSR effect works in linear space, so if the input texture is in gamma space, we must convert the texture to linear space before applying the effect
+     */
+    get inputTextureColorIsInGammaSpace() {
+        return this._ssrPostProcess.inputTextureColorIsInGammaSpace;
+    }
+    set inputTextureColorIsInGammaSpace(gammaSpace) {
+        if (this._ssrPostProcess.inputTextureColorIsInGammaSpace === gammaSpace) {
+            return;
+        }
+        this._ssrPostProcess.inputTextureColorIsInGammaSpace = gammaSpace;
+        this._ssrBlurCombinerPostProcess.inputTextureColorIsInGammaSpace = gammaSpace;
+    }
+    /**
+     * Gets or sets a boolean defining if the output color texture generated by the SSR pipeline should be in gamma space (default: true)
+     * If you have a post-process that comes after the SSR and that post-process needs the input to be in a linear space, you must disable generateOutputInGammaSpace
+     */
+    get generateOutputInGammaSpace() {
+        return this._ssrPostProcess.generateOutputInGammaSpace;
+    }
+    set generateOutputInGammaSpace(gammaSpace) {
+        if (this._ssrPostProcess.generateOutputInGammaSpace === gammaSpace) {
+            return;
+        }
+        this._ssrPostProcess.generateOutputInGammaSpace = gammaSpace;
+        this._ssrBlurCombinerPostProcess.generateOutputInGammaSpace = gammaSpace;
+    }
+    /**
+     * 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._ssrPostProcess.debug;
+    }
+    set debug(value) {
+        if (this._ssrPostProcess.debug === value) {
+            return;
+        }
+        this._ssrPostProcess.debug = value;
+        this._ssrBlurCombinerPostProcess.debug = value;
+    }
+    /**
+     * Gets or sets the camera to use to render the reflection
+     */
+    get camera() {
+        return this._ssrPostProcess.camera;
+    }
+    set camera(camera) {
+        this._ssrPostProcess.camera = camera;
+        this._ssrBlurCombinerPostProcess.camera = camera;
+    }
+    /**
+     * Gets or sets a boolean indicating if the depth buffer stores screen space depth instead of camera view space depth.
+     */
+    get useScreenspaceDepth() {
+        return this._ssrPostProcess.useScreenspaceDepth;
+    }
+    set useScreenspaceDepth(use) {
+        this._ssrPostProcess.useScreenspaceDepth = use;
+        this._ssrBlurCombinerPostProcess.useScreenspaceDepth = use;
+    }
+    /**
+     * Gets or sets a boolean indicating if the normals are in world space (false by default, meaning normals are in camera view space).
+     */
+    get normalsAreInWorldSpace() {
+        return this._ssrPostProcess.normalsAreInWorldSpace;
+    }
+    set normalsAreInWorldSpace(normalsAreInWorldSpace) {
+        this._ssrPostProcess.normalsAreInWorldSpace = normalsAreInWorldSpace;
+        this._ssrBlurCombinerPostProcess.normalsAreInWorldSpace = normalsAreInWorldSpace;
+    }
+    /**
+     * Gets or sets a boolean indicating if the normals are encoded as unsigned, that is normalUnsigned = normal*0.5+0.5 (false by default).
+     */
+    get normalsAreUnsigned() {
+        return this._ssrPostProcess.normalsAreUnsigned;
+    }
+    set normalsAreUnsigned(normalsAreUnsigned) {
+        this._ssrPostProcess.normalsAreUnsigned = normalsAreUnsigned;
+        this._ssrBlurCombinerPostProcess.normalsAreUnsigned = normalsAreUnsigned;
+    }
+    /**
+     * Checks if all the post processes in the pipeline are ready.
+     * @returns true if all the post processes in the pipeline are ready
+     */
+    isReady() {
+        return this._ssrPostProcess.isReady() && this._ssrBlurXPostProcess.isReady() && this._ssrBlurYPostProcess.isReady() && this._ssrBlurCombinerPostProcess.isReady();
+    }
+    /**
+     * Constructor of the SSR rendering pipeline
+     * @param name The rendering pipeline name
+     * @param scene The scene linked to this pipeline
+     */
+    constructor(name, scene) {
+        /**
+         * 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.
+         */
+        this.ssrDownsample = 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.
+         */
+        this.blurDownsample = 0;
+        this.name = name;
+        this._scene = scene;
+        this._ssrPostProcess = new ThinSSRPostProcess(this.name, this._scene);
+        this._ssrBlurXPostProcess = new ThinSSRBlurPostProcess(this.name + " BlurX", this._scene.getEngine(), new Vector2(1, 0));
+        this._ssrBlurYPostProcess = new ThinSSRBlurPostProcess(this.name + " BlurY", this._scene.getEngine(), new Vector2(0, 1));
+        this._ssrBlurCombinerPostProcess = new ThinSSRBlurCombinerPostProcess(this.name + " BlurCombiner", this._scene.getEngine());
+        this._ssrPostProcess.useBlur = this._ssrBlurXPostProcess.blurStrength > 0;
+    }
+    /**
+     * Disposes of the pipeline
+     */
+    dispose() {
+        this._ssrPostProcess?.dispose();
+        this._ssrBlurXPostProcess?.dispose();
+        this._ssrBlurYPostProcess?.dispose();
+        this._ssrBlurCombinerPostProcess?.dispose();
+    }
+}
+//# sourceMappingURL=thinSSRRenderingPipeline.js.map

package/PostProcesses/RenderPipeline/Pipelines/thinSSRRenderingPipeline.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"thinSSRRenderingPipeline.js","sourceRoot":"","sources":["../../../../../../dev/core/src/PostProcesses/RenderPipeline/Pipelines/thinSSRRenderingPipeline.ts"],"names":[],"mappings":"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","sourcesContent":["// eslint-disable-next-line import/no-internal-modules\r\nimport type { Nullable, CubeTexture, Scene, Camera } from \"core/index\";\r\nimport { Vector2 } from \"core/Maths/math.vector\";\r\nimport { ThinSSRPostProcess } from \"core/PostProcesses/thinSSRPostProcess\";\r\nimport { ThinSSRBlurPostProcess } from \"core/PostProcesses/thinSSRBlurPostProcess\";\r\nimport { ThinSSRBlurCombinerPostProcess } from \"core/PostProcesses/thinSSRBlurCombinerPostProcess\";\r\n\r\n/**\r\n * The SSR rendering pipeline is used to generate a reflection based on a flat mirror model.\r\n */\r\nexport class ThinSSRRenderingPipeline {\r\n    /** @internal */\r\n    public readonly _ssrPostProcess: ThinSSRPostProcess;\r\n    /** @internal */\r\n    public readonly _ssrBlurXPostProcess: ThinSSRBlurPostProcess;\r\n    /** @internal */\r\n    public readonly _ssrBlurYPostProcess: ThinSSRBlurPostProcess;\r\n    /** @internal */\r\n    public readonly _ssrBlurCombinerPostProcess: ThinSSRBlurCombinerPostProcess;\r\n\r\n    /**\r\n     * Gets or sets the name of the rendering pipeline\r\n     */\r\n    public name: string;\r\n\r\n    /**\r\n     * Gets or sets a boolean indicating if the SSR rendering pipeline is supported\r\n     */\r\n    public get isSSRSupported(): boolean {\r\n        return this._ssrPostProcess.isSSRSupported;\r\n    }\r\n\r\n    public set isSSRSupported(supported: boolean) {\r\n        this._ssrPostProcess.isSSRSupported = supported;\r\n    }\r\n\r\n    /**\r\n     * Gets or sets the maxDistance used to define how far we look for reflection during the ray-marching on the reflected ray (default: 1000).\r\n     * Note that this value is a view (camera) space distance (not pixels!).\r\n     */\r\n    public get maxDistance() {\r\n        return this._ssrPostProcess.maxDistance;\r\n    }\r\n\r\n    public set maxDistance(distance: number) {\r\n        this._ssrPostProcess.maxDistance = distance;\r\n    }\r\n\r\n    /**\r\n     * 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).\r\n     * Use higher values to improve performances (but at the expense of quality).\r\n     */\r\n    public get step() {\r\n        return this._ssrPostProcess.step;\r\n    }\r\n\r\n    public set step(step: number) {\r\n        this._ssrPostProcess.step = step;\r\n    }\r\n\r\n    /**\r\n     * Gets or sets the thickness value used as tolerance when computing the intersection between the reflected ray and the scene (default: 0.5).\r\n     * If setting \"enableAutomaticThicknessComputation\" to true, you can use lower values for \"thickness\" (even 0), as the geometry thickness\r\n     * is automatically computed thank to the regular depth buffer + the backface depth buffer\r\n     */\r\n    public get thickness() {\r\n        return this._ssrPostProcess.thickness;\r\n    }\r\n\r\n    public set thickness(thickness: number) {\r\n        this._ssrPostProcess.thickness = thickness;\r\n    }\r\n\r\n    /**\r\n     * Gets or sets the current reflection strength. 1.0 is an ideal value but can be increased/decreased for particular results (default: 1).\r\n     */\r\n    public get strength() {\r\n        return this._ssrPostProcess.strength;\r\n    }\r\n\r\n    public set strength(strength: number) {\r\n        this._ssrPostProcess.strength = strength;\r\n        this._ssrBlurCombinerPostProcess.strength = strength;\r\n    }\r\n\r\n    /**\r\n     * Gets or sets the falloff exponent used to compute the reflection strength. Higher values lead to fainter reflections (default: 1).\r\n     */\r\n    public get reflectionSpecularFalloffExponent() {\r\n        return this._ssrPostProcess.reflectionSpecularFalloffExponent;\r\n    }\r\n\r\n    public set reflectionSpecularFalloffExponent(exponent: number) {\r\n        this._ssrPostProcess.reflectionSpecularFalloffExponent = exponent;\r\n        this._ssrBlurCombinerPostProcess.reflectionSpecularFalloffExponent = exponent;\r\n    }\r\n\r\n    /**\r\n     * Maximum number of steps during the ray marching process after which we consider an intersection could not be found (default: 1000).\r\n     * Should be an integer value.\r\n     */\r\n    public get maxSteps() {\r\n        return this._ssrPostProcess.maxSteps;\r\n    }\r\n\r\n    public set maxSteps(steps: number) {\r\n        this._ssrPostProcess.maxSteps = steps;\r\n    }\r\n\r\n    /**\r\n     * Gets or sets the factor applied when computing roughness. Default value is 0.2.\r\n     * When blurring based on roughness is enabled (meaning blurDispersionStrength \\> 0), roughnessFactor is used as a global roughness factor applied on all objects.\r\n     * If you want to disable this global roughness set it to 0.\r\n     */\r\n    public get roughnessFactor() {\r\n        return this._ssrPostProcess.roughnessFactor;\r\n    }\r\n\r\n    public set roughnessFactor(factor: number) {\r\n        this._ssrPostProcess.roughnessFactor = factor;\r\n    }\r\n\r\n    /**\r\n     * Number of steps to skip at start when marching the ray to avoid self collisions (default: 1)\r\n     * 1 should normally be a good value, depending on the scene you may need to use a higher value (2 or 3)\r\n     */\r\n    public get selfCollisionNumSkip() {\r\n        return this._ssrPostProcess.selfCollisionNumSkip;\r\n    }\r\n\r\n    public set selfCollisionNumSkip(skip: number) {\r\n        this._ssrPostProcess.selfCollisionNumSkip = skip;\r\n    }\r\n\r\n    /**\r\n     * Gets or sets the minimum value for one of the reflectivity component of the material to consider it for SSR (default: 0.04).\r\n     * 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.\r\n     */\r\n    public get reflectivityThreshold() {\r\n        return this._ssrPostProcess.reflectivityThreshold;\r\n    }\r\n\r\n    public set reflectivityThreshold(threshold: number) {\r\n        const currentThreshold = this._ssrPostProcess.reflectivityThreshold;\r\n\r\n        if (threshold === currentThreshold) {\r\n            return;\r\n        }\r\n\r\n        this._ssrPostProcess.reflectivityThreshold = threshold;\r\n        this._ssrBlurCombinerPostProcess.reflectivityThreshold = threshold;\r\n    }\r\n\r\n    /**\r\n     * Gets or sets the downsample factor used to reduce the size of the texture used to compute the SSR contribution (default: 0).\r\n     * Use 0 to render the SSR contribution at full resolution, 1 to render at half resolution, 2 to render at 1/3 resolution, etc.\r\n     * 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.\r\n     */\r\n    public ssrDownsample = 0;\r\n\r\n    /**\r\n     * Gets or sets the blur dispersion strength. Set this value to 0 to disable blurring (default: 0.03)\r\n     * 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.\r\n     * blurDispersionStrength allows to increase or decrease this effect.\r\n     */\r\n    public get blurDispersionStrength() {\r\n        return this._ssrBlurXPostProcess.blurStrength;\r\n    }\r\n\r\n    public set blurDispersionStrength(strength: number) {\r\n        if (strength === this._ssrBlurXPostProcess.blurStrength) {\r\n            return;\r\n        }\r\n\r\n        this._ssrPostProcess.useBlur = strength > 0;\r\n\r\n        this._ssrBlurXPostProcess.blurStrength = strength;\r\n        this._ssrBlurYPostProcess.blurStrength = strength;\r\n    }\r\n\r\n    /**\r\n     * Gets or sets the downsample factor used to reduce the size of the textures used to blur the reflection effect (default: 0).\r\n     * Use 0 to blur at full resolution, 1 to render at half resolution, 2 to render at 1/3 resolution, etc.\r\n     */\r\n    public blurDownsample = 0;\r\n\r\n    /**\r\n     * Gets or sets whether or not smoothing reflections is enabled (default: false)\r\n     * Enabling smoothing will require more GPU power.\r\n     * Note that this setting has no effect if step = 1: it's only used if step \\> 1.\r\n     */\r\n    public get enableSmoothReflections(): boolean {\r\n        return this._ssrPostProcess.enableSmoothReflections;\r\n    }\r\n\r\n    public set enableSmoothReflections(enabled: boolean) {\r\n        this._ssrPostProcess.enableSmoothReflections = enabled;\r\n    }\r\n\r\n    /**\r\n     * 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.\r\n     */\r\n    public get environmentTexture() {\r\n        return this._ssrPostProcess.environmentTexture;\r\n    }\r\n\r\n    public set environmentTexture(texture: Nullable<CubeTexture>) {\r\n        this._ssrPostProcess.environmentTexture = texture;\r\n    }\r\n\r\n    /**\r\n     * Gets or sets the boolean defining if the environment texture is a standard cubemap (false) or a probe (true). Default value is false.\r\n     * Note: a probe cube texture is treated differently than an ordinary cube texture because the Y axis is reversed.\r\n     */\r\n    public get environmentTextureIsProbe(): boolean {\r\n        return this._ssrPostProcess.environmentTextureIsProbe;\r\n    }\r\n\r\n    public set environmentTextureIsProbe(isProbe: boolean) {\r\n        this._ssrPostProcess.environmentTextureIsProbe = isProbe;\r\n    }\r\n\r\n    /**\r\n     * Gets or sets a boolean indicating if the reflections should be attenuated at the screen borders (default: true).\r\n     */\r\n    public get attenuateScreenBorders() {\r\n        return this._ssrPostProcess.attenuateScreenBorders;\r\n    }\r\n\r\n    public set attenuateScreenBorders(attenuate: boolean) {\r\n        this._ssrPostProcess.attenuateScreenBorders = attenuate;\r\n    }\r\n\r\n    /**\r\n     * Gets or sets a boolean indicating if the reflections should be attenuated according to the distance of the intersection (default: true).\r\n     */\r\n    public get attenuateIntersectionDistance() {\r\n        return this._ssrPostProcess.attenuateIntersectionDistance;\r\n    }\r\n\r\n    public set attenuateIntersectionDistance(attenuate: boolean) {\r\n        this._ssrPostProcess.attenuateIntersectionDistance = attenuate;\r\n    }\r\n\r\n    /**\r\n     * 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).\r\n     */\r\n    public get attenuateIntersectionIterations() {\r\n        return this._ssrPostProcess.attenuateIntersectionIterations;\r\n    }\r\n\r\n    public set attenuateIntersectionIterations(attenuate: boolean) {\r\n        this._ssrPostProcess.attenuateIntersectionIterations = attenuate;\r\n    }\r\n\r\n    /**\r\n     * 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).\r\n     */\r\n    public get attenuateFacingCamera() {\r\n        return this._ssrPostProcess.attenuateFacingCamera;\r\n    }\r\n\r\n    public set attenuateFacingCamera(attenuate: boolean) {\r\n        this._ssrPostProcess.attenuateFacingCamera = attenuate;\r\n    }\r\n\r\n    /**\r\n     * Gets or sets a boolean indicating if the backface reflections should be attenuated (default: false).\r\n     */\r\n    public get attenuateBackfaceReflection() {\r\n        return this._ssrPostProcess.attenuateBackfaceReflection;\r\n    }\r\n\r\n    public set attenuateBackfaceReflection(attenuate: boolean) {\r\n        this._ssrPostProcess.attenuateBackfaceReflection = attenuate;\r\n    }\r\n\r\n    /**\r\n     * Gets or sets a boolean indicating if the ray should be clipped to the frustum (default: true).\r\n     * 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\r\n     */\r\n    public get clipToFrustum() {\r\n        return this._ssrPostProcess.clipToFrustum;\r\n    }\r\n\r\n    public set clipToFrustum(clip: boolean) {\r\n        this._ssrPostProcess.clipToFrustum = clip;\r\n    }\r\n\r\n    /**\r\n     * 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).\r\n     * 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).\r\n     */\r\n    public get useFresnel() {\r\n        return this._ssrPostProcess.useFresnel;\r\n    }\r\n\r\n    public set useFresnel(fresnel: boolean) {\r\n        this._ssrPostProcess.useFresnel = fresnel;\r\n        this._ssrBlurCombinerPostProcess.useFresnel = fresnel;\r\n    }\r\n\r\n    /**\r\n     * Gets or sets a boolean defining if geometry thickness should be computed automatically (default: false).\r\n     * 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).\r\n     * 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\r\n     * value than when enableAutomaticThicknessComputation is false (it's even possible to use a value of 0 when using low values for \"step\")\r\n     * Note that for performance reasons, this option will only apply to the first camera to which the rendering pipeline is attached!\r\n     */\r\n    public get enableAutomaticThicknessComputation(): boolean {\r\n        return this._ssrPostProcess.enableAutomaticThicknessComputation;\r\n    }\r\n\r\n    public set enableAutomaticThicknessComputation(automatic: boolean) {\r\n        if (this._ssrPostProcess.enableAutomaticThicknessComputation === automatic) {\r\n            return;\r\n        }\r\n\r\n        this._ssrPostProcess.enableAutomaticThicknessComputation = automatic;\r\n    }\r\n\r\n    /**\r\n     * Gets or sets a boolean defining if the input color texture is in gamma space (default: true)\r\n     * 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\r\n     */\r\n    public get inputTextureColorIsInGammaSpace(): boolean {\r\n        return this._ssrPostProcess.inputTextureColorIsInGammaSpace;\r\n    }\r\n\r\n    public set inputTextureColorIsInGammaSpace(gammaSpace: boolean) {\r\n        if (this._ssrPostProcess.inputTextureColorIsInGammaSpace === gammaSpace) {\r\n            return;\r\n        }\r\n\r\n        this._ssrPostProcess.inputTextureColorIsInGammaSpace = gammaSpace;\r\n        this._ssrBlurCombinerPostProcess.inputTextureColorIsInGammaSpace = gammaSpace;\r\n    }\r\n\r\n    /**\r\n     * Gets or sets a boolean defining if the output color texture generated by the SSR pipeline should be in gamma space (default: true)\r\n     * 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\r\n     */\r\n    public get generateOutputInGammaSpace(): boolean {\r\n        return this._ssrPostProcess.generateOutputInGammaSpace;\r\n    }\r\n\r\n    public set generateOutputInGammaSpace(gammaSpace: boolean) {\r\n        if (this._ssrPostProcess.generateOutputInGammaSpace === gammaSpace) {\r\n            return;\r\n        }\r\n\r\n        this._ssrPostProcess.generateOutputInGammaSpace = gammaSpace;\r\n        this._ssrBlurCombinerPostProcess.generateOutputInGammaSpace = gammaSpace;\r\n    }\r\n\r\n    /**\r\n     * Gets or sets a boolean indicating if the effect should be rendered in debug mode (default: false).\r\n     * In this mode, colors have this meaning:\r\n     *   - blue: the ray hit the max distance (we reached maxDistance)\r\n     *   - red: the ray ran out of steps (we reached maxSteps)\r\n     *   - yellow: the ray went off screen\r\n     *   - 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.\r\n     * 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\r\n     * 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.\r\n     */\r\n    public get debug(): boolean {\r\n        return this._ssrPostProcess.debug;\r\n    }\r\n\r\n    public set debug(value: boolean) {\r\n        if (this._ssrPostProcess.debug === value) {\r\n            return;\r\n        }\r\n\r\n        this._ssrPostProcess.debug = value;\r\n        this._ssrBlurCombinerPostProcess.debug = value;\r\n    }\r\n\r\n    /**\r\n     * Gets or sets the camera to use to render the reflection\r\n     */\r\n    public get camera() {\r\n        return this._ssrPostProcess.camera;\r\n    }\r\n\r\n    public set camera(camera: Nullable<Camera>) {\r\n        this._ssrPostProcess.camera = camera;\r\n        this._ssrBlurCombinerPostProcess.camera = camera;\r\n    }\r\n\r\n    /**\r\n     * Gets or sets a boolean indicating if the depth buffer stores screen space depth instead of camera view space depth.\r\n     */\r\n    public get useScreenspaceDepth() {\r\n        return this._ssrPostProcess.useScreenspaceDepth;\r\n    }\r\n\r\n    public set useScreenspaceDepth(use: boolean) {\r\n        this._ssrPostProcess.useScreenspaceDepth = use;\r\n        this._ssrBlurCombinerPostProcess.useScreenspaceDepth = use;\r\n    }\r\n\r\n    /**\r\n     * Gets or sets a boolean indicating if the normals are in world space (false by default, meaning normals are in camera view space).\r\n     */\r\n    public get normalsAreInWorldSpace() {\r\n        return this._ssrPostProcess.normalsAreInWorldSpace;\r\n    }\r\n\r\n    public set normalsAreInWorldSpace(normalsAreInWorldSpace: boolean) {\r\n        this._ssrPostProcess.normalsAreInWorldSpace = normalsAreInWorldSpace;\r\n        this._ssrBlurCombinerPostProcess.normalsAreInWorldSpace = normalsAreInWorldSpace;\r\n    }\r\n\r\n    /**\r\n     * Gets or sets a boolean indicating if the normals are encoded as unsigned, that is normalUnsigned = normal*0.5+0.5 (false by default).\r\n     */\r\n    public get normalsAreUnsigned() {\r\n        return this._ssrPostProcess.normalsAreUnsigned;\r\n    }\r\n\r\n    public set normalsAreUnsigned(normalsAreUnsigned: boolean) {\r\n        this._ssrPostProcess.normalsAreUnsigned = normalsAreUnsigned;\r\n        this._ssrBlurCombinerPostProcess.normalsAreUnsigned = normalsAreUnsigned;\r\n    }\r\n\r\n    /**\r\n     * Checks if all the post processes in the pipeline are ready.\r\n     * @returns true if all the post processes in the pipeline are ready\r\n     */\r\n    public isReady(): boolean {\r\n        return this._ssrPostProcess.isReady() && this._ssrBlurXPostProcess.isReady() && this._ssrBlurYPostProcess.isReady() && this._ssrBlurCombinerPostProcess.isReady();\r\n    }\r\n\r\n    private _scene: Scene;\r\n\r\n    /**\r\n     * Constructor of the SSR rendering pipeline\r\n     * @param name The rendering pipeline name\r\n     * @param scene The scene linked to this pipeline\r\n     */\r\n    constructor(name: string, scene: Scene) {\r\n        this.name = name;\r\n        this._scene = scene;\r\n\r\n        this._ssrPostProcess = new ThinSSRPostProcess(this.name, this._scene);\r\n        this._ssrBlurXPostProcess = new ThinSSRBlurPostProcess(this.name + \" BlurX\", this._scene.getEngine(), new Vector2(1, 0));\r\n        this._ssrBlurYPostProcess = new ThinSSRBlurPostProcess(this.name + \" BlurY\", this._scene.getEngine(), new Vector2(0, 1));\r\n        this._ssrBlurCombinerPostProcess = new ThinSSRBlurCombinerPostProcess(this.name + \" BlurCombiner\", this._scene.getEngine());\r\n\r\n        this._ssrPostProcess.useBlur = this._ssrBlurXPostProcess.blurStrength > 0;\r\n    }\r\n\r\n    /**\r\n     * Disposes of the pipeline\r\n     */\r\n    public dispose(): void {\r\n        this._ssrPostProcess?.dispose();\r\n        this._ssrBlurXPostProcess?.dispose();\r\n        this._ssrBlurYPostProcess?.dispose();\r\n        this._ssrBlurCombinerPostProcess?.dispose();\r\n    }\r\n}\r\n"]}

package/PostProcesses/thinDepthOfFieldEffect.d.ts

@@ -22,13 +22,13 @@ export declare enum ThinDepthOfFieldEffectBlurLevel {
 }
 export declare class ThinDepthOfFieldEffect {
     /** @internal */
-    _circleOfConfusion: ThinCircleOfConfusionPostProcess;
+    readonly _circleOfConfusion: ThinCircleOfConfusionPostProcess;
     /** @internal */
-    _depthOfFieldBlurX: Array<[ThinBlurPostProcess, number]>;
+    readonly _depthOfFieldBlurX: Array<[ThinBlurPostProcess, number]>;
     /** @internal */
-    _depthOfFieldBlurY: Array<[ThinBlurPostProcess, number]>;
+    readonly _depthOfFieldBlurY: Array<[ThinBlurPostProcess, number]>;
     /** @internal */
-    _dofMerge: ThinDepthOfFieldMergePostProcess;
+    readonly _dofMerge: ThinDepthOfFieldMergePostProcess;
     /**
      * The focal the length of the camera used in the effect in scene units/1000 (eg. millimeter)
      */

package/PostProcesses/thinDepthOfFieldEffect.js.map

@@ -1 +1 @@
-{"version":3,"file":"thinDepthOfFieldEffect.js","sourceRoot":"","sources":["../../../../dev/core/src/PostProcesses/thinDepthOfFieldEffect.ts"],"names":[],"mappings":"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","sourcesContent":["import type { Nullable } from \"core/types\";\r\nimport type { AbstractEngine } from \"core/Engines/abstractEngine\";\r\nimport { ThinBlurPostProcess } from \"./thinBlurPostProcess\";\r\nimport { ThinCircleOfConfusionPostProcess } from \"./thinCircleOfConfusionPostProcess\";\r\nimport { ThinDepthOfFieldMergePostProcess } from \"./thinDepthOfFieldMergePostProcess\";\r\nimport { Vector2 } from \"core/Maths/math.vector\";\r\n\r\n/**\r\n * Specifies the level of blur that should be applied when using the depth of field effect\r\n */\r\nexport const enum ThinDepthOfFieldEffectBlurLevel {\r\n    /**\r\n     * Subtle blur\r\n     */\r\n    Low,\r\n    /**\r\n     * Medium blur\r\n     */\r\n    Medium,\r\n    /**\r\n     * Large blur\r\n     */\r\n    High,\r\n}\r\n\r\nexport class ThinDepthOfFieldEffect {\r\n    /** @internal */\r\n    public _circleOfConfusion: ThinCircleOfConfusionPostProcess;\r\n    /** @internal */\r\n    public _depthOfFieldBlurX: Array<[ThinBlurPostProcess, number]> = [];\r\n    /** @internal */\r\n    public _depthOfFieldBlurY: Array<[ThinBlurPostProcess, number]> = [];\r\n    /** @internal */\r\n    public _dofMerge: ThinDepthOfFieldMergePostProcess;\r\n\r\n    /**\r\n     * The focal the length of the camera used in the effect in scene units/1000 (eg. millimeter)\r\n     */\r\n    public set focalLength(value: number) {\r\n        this._circleOfConfusion.focalLength = value;\r\n    }\r\n    public get focalLength() {\r\n        return this._circleOfConfusion.focalLength;\r\n    }\r\n    /**\r\n     * F-Stop of the effect's camera. The diameter of the resulting aperture can be computed by lensSize/fStop. (default: 1.4)\r\n     */\r\n    public set fStop(value: number) {\r\n        this._circleOfConfusion.fStop = value;\r\n    }\r\n    public get fStop() {\r\n        return this._circleOfConfusion.fStop;\r\n    }\r\n    /**\r\n     * Distance away from the camera to focus on in scene units/1000 (eg. millimeter). (default: 2000)\r\n     */\r\n    public set focusDistance(value: number) {\r\n        this._circleOfConfusion.focusDistance = value;\r\n    }\r\n    public get focusDistance() {\r\n        return this._circleOfConfusion.focusDistance;\r\n    }\r\n    /**\r\n     * Max lens size in scene units/1000 (eg. millimeter). Standard cameras are 50mm. (default: 50) The diameter of the resulting aperture can be computed by lensSize/fStop.\r\n     */\r\n    public set lensSize(value: number) {\r\n        this._circleOfConfusion.lensSize = value;\r\n    }\r\n    public get lensSize() {\r\n        return this._circleOfConfusion.lensSize;\r\n    }\r\n\r\n    /**\r\n     * The quality of the effect.\r\n     */\r\n    public readonly blurLevel: ThinDepthOfFieldEffectBlurLevel;\r\n\r\n    /**\r\n     * Creates a new instance of @see ThinDepthOfFieldEffect\r\n     * @param name The name of the depth of field render effect\r\n     * @param engine The engine which the render effect will be applied. (default: current engine)\r\n     * @param blurLevel The quality of the effect. (default: DepthOfFieldEffectBlurLevel.Low)\r\n     * @param depthNotNormalized If the (view) depth used in circle of confusion post-process is normalized (0.0 to 1.0 from near to far) or not (0 to camera max distance) (default: false)\r\n     * @param blockCompilation If shaders should not be compiled when the effect is created (default: false)\r\n     */\r\n    constructor(\r\n        name: string,\r\n        engine: Nullable<AbstractEngine>,\r\n        blurLevel: ThinDepthOfFieldEffectBlurLevel = ThinDepthOfFieldEffectBlurLevel.Low,\r\n        depthNotNormalized = false,\r\n        blockCompilation = false\r\n    ) {\r\n        this._circleOfConfusion = new ThinCircleOfConfusionPostProcess(name, engine, { depthNotNormalized, blockCompilation });\r\n        this.blurLevel = blurLevel;\r\n\r\n        let blurCount = 1;\r\n        let kernelSize = 15;\r\n        switch (blurLevel) {\r\n            case ThinDepthOfFieldEffectBlurLevel.High: {\r\n                blurCount = 3;\r\n                kernelSize = 51;\r\n                break;\r\n            }\r\n            case ThinDepthOfFieldEffectBlurLevel.Medium: {\r\n                blurCount = 2;\r\n                kernelSize = 31;\r\n                break;\r\n            }\r\n            default: {\r\n                kernelSize = 15;\r\n                blurCount = 1;\r\n                break;\r\n            }\r\n        }\r\n\r\n        const adjustedKernelSize = kernelSize / Math.pow(2, blurCount - 1);\r\n        let ratio = 1.0;\r\n        for (let i = 0; i < blurCount; i++) {\r\n            this._depthOfFieldBlurY.push([new ThinBlurPostProcess(name, engine, new Vector2(0, 1), adjustedKernelSize, { blockCompilation }), ratio]);\r\n            ratio = 0.75 / Math.pow(2, i);\r\n            this._depthOfFieldBlurX.push([new ThinBlurPostProcess(name, engine, new Vector2(1, 0), adjustedKernelSize, { blockCompilation }), ratio]);\r\n        }\r\n\r\n        this._dofMerge = new ThinDepthOfFieldMergePostProcess(name, engine, { blockCompilation });\r\n    }\r\n\r\n    /**\r\n     * Checks if the effect is ready to be used\r\n     * @returns if the effect is ready\r\n     */\r\n    public isReady() {\r\n        let isReady = this._circleOfConfusion.isReady() && this._dofMerge.isReady();\r\n        for (let i = 0; i < this._depthOfFieldBlurX.length; i++) {\r\n            isReady = isReady && this._depthOfFieldBlurX[i][0].isReady() && this._depthOfFieldBlurY[i][0].isReady();\r\n        }\r\n        return isReady;\r\n    }\r\n}\r\n"]}
+{"version":3,"file":"thinDepthOfFieldEffect.js","sourceRoot":"","sources":["../../../../dev/core/src/PostProcesses/thinDepthOfFieldEffect.ts"],"names":[],"mappings":"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","sourcesContent":["import type { Nullable } from \"core/types\";\r\nimport type { AbstractEngine } from \"core/Engines/abstractEngine\";\r\nimport { ThinBlurPostProcess } from \"./thinBlurPostProcess\";\r\nimport { ThinCircleOfConfusionPostProcess } from \"./thinCircleOfConfusionPostProcess\";\r\nimport { ThinDepthOfFieldMergePostProcess } from \"./thinDepthOfFieldMergePostProcess\";\r\nimport { Vector2 } from \"core/Maths/math.vector\";\r\n\r\n/**\r\n * Specifies the level of blur that should be applied when using the depth of field effect\r\n */\r\nexport const enum ThinDepthOfFieldEffectBlurLevel {\r\n    /**\r\n     * Subtle blur\r\n     */\r\n    Low,\r\n    /**\r\n     * Medium blur\r\n     */\r\n    Medium,\r\n    /**\r\n     * Large blur\r\n     */\r\n    High,\r\n}\r\n\r\nexport class ThinDepthOfFieldEffect {\r\n    /** @internal */\r\n    public readonly _circleOfConfusion: ThinCircleOfConfusionPostProcess;\r\n    /** @internal */\r\n    public readonly _depthOfFieldBlurX: Array<[ThinBlurPostProcess, number]> = [];\r\n    /** @internal */\r\n    public readonly _depthOfFieldBlurY: Array<[ThinBlurPostProcess, number]> = [];\r\n    /** @internal */\r\n    public readonly _dofMerge: ThinDepthOfFieldMergePostProcess;\r\n\r\n    /**\r\n     * The focal the length of the camera used in the effect in scene units/1000 (eg. millimeter)\r\n     */\r\n    public set focalLength(value: number) {\r\n        this._circleOfConfusion.focalLength = value;\r\n    }\r\n    public get focalLength() {\r\n        return this._circleOfConfusion.focalLength;\r\n    }\r\n    /**\r\n     * F-Stop of the effect's camera. The diameter of the resulting aperture can be computed by lensSize/fStop. (default: 1.4)\r\n     */\r\n    public set fStop(value: number) {\r\n        this._circleOfConfusion.fStop = value;\r\n    }\r\n    public get fStop() {\r\n        return this._circleOfConfusion.fStop;\r\n    }\r\n    /**\r\n     * Distance away from the camera to focus on in scene units/1000 (eg. millimeter). (default: 2000)\r\n     */\r\n    public set focusDistance(value: number) {\r\n        this._circleOfConfusion.focusDistance = value;\r\n    }\r\n    public get focusDistance() {\r\n        return this._circleOfConfusion.focusDistance;\r\n    }\r\n    /**\r\n     * Max lens size in scene units/1000 (eg. millimeter). Standard cameras are 50mm. (default: 50) The diameter of the resulting aperture can be computed by lensSize/fStop.\r\n     */\r\n    public set lensSize(value: number) {\r\n        this._circleOfConfusion.lensSize = value;\r\n    }\r\n    public get lensSize() {\r\n        return this._circleOfConfusion.lensSize;\r\n    }\r\n\r\n    /**\r\n     * The quality of the effect.\r\n     */\r\n    public readonly blurLevel: ThinDepthOfFieldEffectBlurLevel;\r\n\r\n    /**\r\n     * Creates a new instance of @see ThinDepthOfFieldEffect\r\n     * @param name The name of the depth of field render effect\r\n     * @param engine The engine which the render effect will be applied. (default: current engine)\r\n     * @param blurLevel The quality of the effect. (default: DepthOfFieldEffectBlurLevel.Low)\r\n     * @param depthNotNormalized If the (view) depth used in circle of confusion post-process is normalized (0.0 to 1.0 from near to far) or not (0 to camera max distance) (default: false)\r\n     * @param blockCompilation If shaders should not be compiled when the effect is created (default: false)\r\n     */\r\n    constructor(\r\n        name: string,\r\n        engine: Nullable<AbstractEngine>,\r\n        blurLevel: ThinDepthOfFieldEffectBlurLevel = ThinDepthOfFieldEffectBlurLevel.Low,\r\n        depthNotNormalized = false,\r\n        blockCompilation = false\r\n    ) {\r\n        this._circleOfConfusion = new ThinCircleOfConfusionPostProcess(name, engine, { depthNotNormalized, blockCompilation });\r\n        this.blurLevel = blurLevel;\r\n\r\n        let blurCount = 1;\r\n        let kernelSize = 15;\r\n        switch (blurLevel) {\r\n            case ThinDepthOfFieldEffectBlurLevel.High: {\r\n                blurCount = 3;\r\n                kernelSize = 51;\r\n                break;\r\n            }\r\n            case ThinDepthOfFieldEffectBlurLevel.Medium: {\r\n                blurCount = 2;\r\n                kernelSize = 31;\r\n                break;\r\n            }\r\n            default: {\r\n                kernelSize = 15;\r\n                blurCount = 1;\r\n                break;\r\n            }\r\n        }\r\n\r\n        const adjustedKernelSize = kernelSize / Math.pow(2, blurCount - 1);\r\n        let ratio = 1.0;\r\n        for (let i = 0; i < blurCount; i++) {\r\n            this._depthOfFieldBlurY.push([new ThinBlurPostProcess(name, engine, new Vector2(0, 1), adjustedKernelSize, { blockCompilation }), ratio]);\r\n            ratio = 0.75 / Math.pow(2, i);\r\n            this._depthOfFieldBlurX.push([new ThinBlurPostProcess(name, engine, new Vector2(1, 0), adjustedKernelSize, { blockCompilation }), ratio]);\r\n        }\r\n\r\n        this._dofMerge = new ThinDepthOfFieldMergePostProcess(name, engine, { blockCompilation });\r\n    }\r\n\r\n    /**\r\n     * Checks if the effect is ready to be used\r\n     * @returns if the effect is ready\r\n     */\r\n    public isReady() {\r\n        let isReady = this._circleOfConfusion.isReady() && this._dofMerge.isReady();\r\n        for (let i = 0; i < this._depthOfFieldBlurX.length; i++) {\r\n            isReady = isReady && this._depthOfFieldBlurX[i][0].isReady() && this._depthOfFieldBlurY[i][0].isReady();\r\n        }\r\n        return isReady;\r\n    }\r\n}\r\n"]}

package/PostProcesses/thinSSRBlurCombinerPostProcess.d.ts

@@ -0,0 +1,41 @@
+import type { Nullable, AbstractEngine, EffectWrapperCreationOptions, Camera } from "../index.js";
+import { EffectWrapper } from "../Materials/effectRenderer";
+/**
+ * @internal
+ */
+export declare class ThinSSRBlurCombinerPostProcess extends EffectWrapper {
+    static readonly FragmentUrl = "screenSpaceReflection2BlurCombiner";
+    static readonly Uniforms: string[];
+    static readonly Samplers: string[];
+    protected _gatherImports(useWebGPU: boolean, list: Promise<any>[]): void;
+    constructor(name: string, engine?: Nullable<AbstractEngine>, options?: EffectWrapperCreationOptions);
+    strength: number;
+    reflectionSpecularFalloffExponent: number;
+    camera: Nullable<Camera>;
+    private _useFresnel;
+    get useFresnel(): boolean;
+    set useFresnel(fresnel: boolean);
+    private _useScreenspaceDepth;
+    get useScreenspaceDepth(): boolean;
+    set useScreenspaceDepth(value: boolean);
+    private _inputTextureColorIsInGammaSpace;
+    get inputTextureColorIsInGammaSpace(): boolean;
+    set inputTextureColorIsInGammaSpace(gammaSpace: boolean);
+    private _generateOutputInGammaSpace;
+    get generateOutputInGammaSpace(): boolean;
+    set generateOutputInGammaSpace(gammaSpace: boolean);
+    private _debug;
+    get debug(): boolean;
+    set debug(value: boolean);
+    private _reflectivityThreshold;
+    get reflectivityThreshold(): number;
+    set reflectivityThreshold(threshold: number);
+    private _normalsAreInWorldSpace;
+    get normalsAreInWorldSpace(): boolean;
+    set normalsAreInWorldSpace(value: boolean);
+    private _normalsAreUnsigned;
+    get normalsAreUnsigned(): boolean;
+    set normalsAreUnsigned(value: boolean);
+    bind(): void;
+    private _updateEffectDefines;
+}