@babylonjs/core 7.32.0 → 7.32.1

package/PostProcesses/depthOfFieldBlurPostProcess.d.ts

@@ -12,10 +12,6 @@ import type { AbstractEngine } from "../Engines/abstractEngine.js";
  * See section 2.6.2 http://fileadmin.cs.lth.se/cs/education/edan35/lectures/12dof.pdf
  */
 export declare class DepthOfFieldBlurPostProcess extends BlurPostProcess {
-    /**
-     * The direction the blur should be applied
-     */
-    direction: Vector2;
     /**
      * Gets a string identifying the name of the class
      * @returns "DepthOfFieldBlurPostProcess" string
@@ -24,7 +20,7 @@ export declare class DepthOfFieldBlurPostProcess extends BlurPostProcess {
     /**
      * Creates a new instance DepthOfFieldBlurPostProcess
      * @param name The name of the effect.
-     * @param scene The scene the effect belongs to.
+     * @param _scene The scene the effect belongs to (not used, you can pass null)
      * @param direction The direction the blur should be applied.
      * @param kernel The size of the kernel used to blur.
      * @param options The required width/height ratio to downsize to before computing the render pass.
@@ -38,5 +34,5 @@ export declare class DepthOfFieldBlurPostProcess extends BlurPostProcess {
      * @param blockCompilation If compilation of the shader should not be done in the constructor. The updateEffect method can be used to compile the shader at a later time. (default: false)
      * @param textureFormat Format of textures used when performing the post process. (default: TEXTUREFORMAT_RGBA)
      */
-    constructor(name: string, scene: Scene, direction: Vector2, kernel: number, options: number | PostProcessOptions, camera: Nullable<Camera>, circleOfConfusion: PostProcess, imageToBlur?: Nullable<PostProcess>, samplingMode?: number, engine?: AbstractEngine, reusable?: boolean, textureType?: number, blockCompilation?: boolean, textureFormat?: number);
+    constructor(name: string, _scene: Nullable<Scene>, direction: Vector2, kernel: number, options: number | PostProcessOptions, camera: Nullable<Camera>, circleOfConfusion: PostProcess, imageToBlur?: Nullable<PostProcess>, samplingMode?: number, engine?: AbstractEngine, reusable?: boolean, textureType?: number, blockCompilation?: boolean, textureFormat?: number);
 }

package/PostProcesses/depthOfFieldBlurPostProcess.js

@@ -1,9 +1,7 @@
-import { __decorate } from "../tslib.es6.js";
 import { Texture } from "../Materials/Textures/texture.js";
 import { BlurPostProcess } from "./blurPostProcess.js";
 
 import { RegisterClass } from "../Misc/typeStore.js";
-import { serialize } from "../Misc/decorators.js";
 /**
  * The DepthOfFieldBlurPostProcess applied a blur in a give direction.
  * This blur differs from the standard BlurPostProcess as it attempts to avoid blurring pixels
@@ -21,7 +19,7 @@ export class DepthOfFieldBlurPostProcess extends BlurPostProcess {
     /**
      * Creates a new instance DepthOfFieldBlurPostProcess
      * @param name The name of the effect.
-     * @param scene The scene the effect belongs to.
+     * @param _scene The scene the effect belongs to (not used, you can pass null)
      * @param direction The direction the blur should be applied.
      * @param kernel The size of the kernel used to blur.
      * @param options The required width/height ratio to downsize to before computing the render pass.
@@ -35,11 +33,19 @@ export class DepthOfFieldBlurPostProcess extends BlurPostProcess {
      * @param blockCompilation If compilation of the shader should not be done in the constructor. The updateEffect method can be used to compile the shader at a later time. (default: false)
      * @param textureFormat Format of textures used when performing the post process. (default: TEXTUREFORMAT_RGBA)
      */
-    constructor(name, scene, direction, kernel, options, camera, circleOfConfusion, imageToBlur = null, samplingMode = Texture.BILINEAR_SAMPLINGMODE, engine, reusable, textureType = 0, blockCompilation = false, textureFormat = 5) {
-        super(name, direction, kernel, options, camera, 
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        (samplingMode = 2), engine, reusable, textureType, `#define DOF 1\n`, blockCompilation, textureFormat);
-        this.direction = direction;
+    constructor(name, _scene, direction, kernel, options, camera, circleOfConfusion, imageToBlur = null, samplingMode = Texture.BILINEAR_SAMPLINGMODE, engine, reusable, textureType = 0, blockCompilation = false, textureFormat = 5) {
+        super(name, direction, kernel, {
+            camera,
+            engine,
+            reusable,
+            textureType,
+            defines: `#define DOF 1\n`,
+            blockCompilation,
+            textureFormat,
+            ...options,
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+            samplingMode: (samplingMode = 2),
+        });
         this.externalTextureSamplerBinding = !!imageToBlur;
         this.onApplyObservable.add((effect) => {
             if (imageToBlur != null) {
@@ -49,8 +55,5 @@ export class DepthOfFieldBlurPostProcess extends BlurPostProcess {
         });
     }
 }
-__decorate([
-    serialize()
-], DepthOfFieldBlurPostProcess.prototype, "direction", void 0);
 RegisterClass("BABYLON.DepthOfFieldBlurPostProcess", DepthOfFieldBlurPostProcess);
 //# sourceMappingURL=depthOfFieldBlurPostProcess.js.map

package/PostProcesses/depthOfFieldBlurPostProcess.js.map

@@ -1 +1 @@
-{"version":3,"file":"depthOfFieldBlurPostProcess.js","sourceRoot":"","sources":["../../../../dev/core/src/PostProcesses/depthOfFieldBlurPostProcess.ts"],"names":[],"mappings":";AAIA,OAAO,EAAE,OAAO,EAAE,MAAM,+BAA+B,CAAC;AAExD,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAEpD,OAAO,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AACjD,OAAO,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAClD,OAAO,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAG/C;;;;;GAKG;AACH,MAAM,OAAO,2BAA4B,SAAQ,eAAe;IAO5D;;;OAGG;IACa,YAAY;QACxB,OAAO,6BAA6B,CAAC;IACzC,CAAC;IAED;;;;;;;;;;;;;;;;OAgBG;IACH,YACI,IAAY,EACZ,KAAY,EACZ,SAAkB,EAClB,MAAc,EACd,OAAoC,EACpC,MAAwB,EACxB,iBAA8B,EAC9B,cAAqC,IAAI,EACzC,YAAY,GAAG,OAAO,CAAC,qBAAqB,EAC5C,MAAuB,EACvB,QAAkB,EAClB,WAAW,GAAG,SAAS,CAAC,wBAAwB,EAChD,gBAAgB,GAAG,KAAK,EACxB,aAAa,GAAG,SAAS,CAAC,kBAAkB;QAE5C,KAAK,CACD,IAAI,EACJ,SAAS,EACT,MAAM,EACN,OAAO,EACP,MAAM;QACN,6DAA6D;QAC7D,CAAC,YAAY,GAAG,SAAS,CAAC,6BAA6B,CAAC,EACxD,MAAM,EACN,QAAQ,EACR,WAAW,EACX,iBAAiB,EACjB,gBAAgB,EAChB,aAAa,CAChB,CAAC;QAEF,IAAI,CAAC,SAAS,GAAG,SAAS,CAAC;QAC3B,IAAI,CAAC,6BAA6B,GAAG,CAAC,CAAC,WAAW,CAAC;QAEnD,IAAI,CAAC,iBAAiB,CAAC,GAAG,CAAC,CAAC,MAAc,EAAE,EAAE;YAC1C,IAAI,WAAW,IAAI,IAAI,EAAE;gBACrB,MAAM,CAAC,yBAAyB,CAAC,gBAAgB,EAAE,WAAW,CAAC,CAAC;aACnE;YACD,MAAM,CAAC,+BAA+B,CAAC,0BAA0B,EAAE,iBAAiB,CAAC,CAAC;QAC1F,CAAC,CAAC,CAAC;IACP,CAAC;CACJ;AArEmB;IADf,SAAS,EAAE;8DACuB;AAuEvC,aAAa,CAAC,qCAAqC,EAAE,2BAA2B,CAAC,CAAC","sourcesContent":["import type { Nullable } from \"../types\";\r\nimport type { Vector2 } from \"../Maths/math.vector\";\r\nimport type { Camera } from \"../Cameras/camera\";\r\nimport type { Effect } from \"../Materials/effect\";\r\nimport { Texture } from \"../Materials/Textures/texture\";\r\nimport type { PostProcess, PostProcessOptions } from \"./postProcess\";\r\nimport { BlurPostProcess } from \"./blurPostProcess\";\r\nimport type { Scene } from \"../scene\";\r\nimport { Constants } from \"../Engines/constants\";\r\nimport { RegisterClass } from \"../Misc/typeStore\";\r\nimport { serialize } from \"../Misc/decorators\";\r\nimport type { AbstractEngine } from \"core/Engines/abstractEngine\";\r\n\r\n/**\r\n * The DepthOfFieldBlurPostProcess applied a blur in a give direction.\r\n * This blur differs from the standard BlurPostProcess as it attempts to avoid blurring pixels\r\n * based on samples that have a large difference in distance than the center pixel.\r\n * See section 2.6.2 http://fileadmin.cs.lth.se/cs/education/edan35/lectures/12dof.pdf\r\n */\r\nexport class DepthOfFieldBlurPostProcess extends BlurPostProcess {\r\n    /**\r\n     * The direction the blur should be applied\r\n     */\r\n    @serialize()\r\n    public override direction: Vector2;\r\n\r\n    /**\r\n     * Gets a string identifying the name of the class\r\n     * @returns \"DepthOfFieldBlurPostProcess\" string\r\n     */\r\n    public override getClassName(): string {\r\n        return \"DepthOfFieldBlurPostProcess\";\r\n    }\r\n\r\n    /**\r\n     * Creates a new instance DepthOfFieldBlurPostProcess\r\n     * @param name The name of the effect.\r\n     * @param scene The scene the effect belongs to.\r\n     * @param direction The direction the blur should be applied.\r\n     * @param kernel The size of the kernel used to blur.\r\n     * @param options The required width/height ratio to downsize to before computing the render pass.\r\n     * @param camera The camera to apply the render pass to.\r\n     * @param circleOfConfusion The circle of confusion + depth map to be used to avoid blurring across edges\r\n     * @param imageToBlur The image to apply the blur to (default: Current rendered frame)\r\n     * @param samplingMode The sampling mode to be used when computing the pass. (default: 0)\r\n     * @param engine The engine which the post process will be applied. (default: current engine)\r\n     * @param reusable If the post process can be reused on the same frame. (default: false)\r\n     * @param textureType Type of textures used when performing the post process. (default: 0)\r\n     * @param blockCompilation If compilation of the shader should not be done in the constructor. The updateEffect method can be used to compile the shader at a later time. (default: false)\r\n     * @param textureFormat Format of textures used when performing the post process. (default: TEXTUREFORMAT_RGBA)\r\n     */\r\n    constructor(\r\n        name: string,\r\n        scene: Scene,\r\n        direction: Vector2,\r\n        kernel: number,\r\n        options: number | PostProcessOptions,\r\n        camera: Nullable<Camera>,\r\n        circleOfConfusion: PostProcess,\r\n        imageToBlur: Nullable<PostProcess> = null,\r\n        samplingMode = Texture.BILINEAR_SAMPLINGMODE,\r\n        engine?: AbstractEngine,\r\n        reusable?: boolean,\r\n        textureType = Constants.TEXTURETYPE_UNSIGNED_INT,\r\n        blockCompilation = false,\r\n        textureFormat = Constants.TEXTUREFORMAT_RGBA\r\n    ) {\r\n        super(\r\n            name,\r\n            direction,\r\n            kernel,\r\n            options,\r\n            camera,\r\n            // eslint-disable-next-line @typescript-eslint/no-unused-vars\r\n            (samplingMode = Constants.TEXTURE_BILINEAR_SAMPLINGMODE),\r\n            engine,\r\n            reusable,\r\n            textureType,\r\n            `#define DOF 1\\n`,\r\n            blockCompilation,\r\n            textureFormat\r\n        );\r\n\r\n        this.direction = direction;\r\n        this.externalTextureSamplerBinding = !!imageToBlur;\r\n\r\n        this.onApplyObservable.add((effect: Effect) => {\r\n            if (imageToBlur != null) {\r\n                effect.setTextureFromPostProcess(\"textureSampler\", imageToBlur);\r\n            }\r\n            effect.setTextureFromPostProcessOutput(\"circleOfConfusionSampler\", circleOfConfusion);\r\n        });\r\n    }\r\n}\r\n\r\nRegisterClass(\"BABYLON.DepthOfFieldBlurPostProcess\", DepthOfFieldBlurPostProcess);\r\n"]}
+{"version":3,"file":"depthOfFieldBlurPostProcess.js","sourceRoot":"","sources":["../../../../dev/core/src/PostProcesses/depthOfFieldBlurPostProcess.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,OAAO,EAAE,MAAM,+BAA+B,CAAC;AAExD,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAEpD,OAAO,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AACjD,OAAO,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAGlD;;;;;GAKG;AACH,MAAM,OAAO,2BAA4B,SAAQ,eAAe;IAC5D;;;OAGG;IACa,YAAY;QACxB,OAAO,6BAA6B,CAAC;IACzC,CAAC;IAED;;;;;;;;;;;;;;;;OAgBG;IACH,YACI,IAAY,EACZ,MAAuB,EACvB,SAAkB,EAClB,MAAc,EACd,OAAoC,EACpC,MAAwB,EACxB,iBAA8B,EAC9B,cAAqC,IAAI,EACzC,YAAY,GAAG,OAAO,CAAC,qBAAqB,EAC5C,MAAuB,EACvB,QAAkB,EAClB,WAAW,GAAG,SAAS,CAAC,wBAAwB,EAChD,gBAAgB,GAAG,KAAK,EACxB,aAAa,GAAG,SAAS,CAAC,kBAAkB;QAE5C,KAAK,CAAC,IAAI,EAAE,SAAS,EAAE,MAAM,EAAE;YAC3B,MAAM;YACN,MAAM;YACN,QAAQ;YACR,WAAW;YACX,OAAO,EAAE,iBAAiB;YAC1B,gBAAgB;YAChB,aAAa;YACb,GAAI,OAA8B;YAClC,6DAA6D;YAC7D,YAAY,EAAE,CAAC,YAAY,GAAG,SAAS,CAAC,6BAA6B,CAAC;SACzE,CAAC,CAAC;QAEH,IAAI,CAAC,6BAA6B,GAAG,CAAC,CAAC,WAAW,CAAC;QAEnD,IAAI,CAAC,iBAAiB,CAAC,GAAG,CAAC,CAAC,MAAc,EAAE,EAAE;YAC1C,IAAI,WAAW,IAAI,IAAI,EAAE;gBACrB,MAAM,CAAC,yBAAyB,CAAC,gBAAgB,EAAE,WAAW,CAAC,CAAC;aACnE;YACD,MAAM,CAAC,+BAA+B,CAAC,0BAA0B,EAAE,iBAAiB,CAAC,CAAC;QAC1F,CAAC,CAAC,CAAC;IACP,CAAC;CACJ;AAED,aAAa,CAAC,qCAAqC,EAAE,2BAA2B,CAAC,CAAC","sourcesContent":["import type { Nullable } from \"../types\";\r\nimport type { Vector2 } from \"../Maths/math.vector\";\r\nimport type { Camera } from \"../Cameras/camera\";\r\nimport type { Effect } from \"../Materials/effect\";\r\nimport { Texture } from \"../Materials/Textures/texture\";\r\nimport type { PostProcess, PostProcessOptions } from \"./postProcess\";\r\nimport { BlurPostProcess } from \"./blurPostProcess\";\r\nimport type { Scene } from \"../scene\";\r\nimport { Constants } from \"../Engines/constants\";\r\nimport { RegisterClass } from \"../Misc/typeStore\";\r\nimport type { AbstractEngine } from \"core/Engines/abstractEngine\";\r\n\r\n/**\r\n * The DepthOfFieldBlurPostProcess applied a blur in a give direction.\r\n * This blur differs from the standard BlurPostProcess as it attempts to avoid blurring pixels\r\n * based on samples that have a large difference in distance than the center pixel.\r\n * See section 2.6.2 http://fileadmin.cs.lth.se/cs/education/edan35/lectures/12dof.pdf\r\n */\r\nexport class DepthOfFieldBlurPostProcess extends BlurPostProcess {\r\n    /**\r\n     * Gets a string identifying the name of the class\r\n     * @returns \"DepthOfFieldBlurPostProcess\" string\r\n     */\r\n    public override getClassName(): string {\r\n        return \"DepthOfFieldBlurPostProcess\";\r\n    }\r\n\r\n    /**\r\n     * Creates a new instance DepthOfFieldBlurPostProcess\r\n     * @param name The name of the effect.\r\n     * @param _scene The scene the effect belongs to (not used, you can pass null)\r\n     * @param direction The direction the blur should be applied.\r\n     * @param kernel The size of the kernel used to blur.\r\n     * @param options The required width/height ratio to downsize to before computing the render pass.\r\n     * @param camera The camera to apply the render pass to.\r\n     * @param circleOfConfusion The circle of confusion + depth map to be used to avoid blurring across edges\r\n     * @param imageToBlur The image to apply the blur to (default: Current rendered frame)\r\n     * @param samplingMode The sampling mode to be used when computing the pass. (default: 0)\r\n     * @param engine The engine which the post process will be applied. (default: current engine)\r\n     * @param reusable If the post process can be reused on the same frame. (default: false)\r\n     * @param textureType Type of textures used when performing the post process. (default: 0)\r\n     * @param blockCompilation If compilation of the shader should not be done in the constructor. The updateEffect method can be used to compile the shader at a later time. (default: false)\r\n     * @param textureFormat Format of textures used when performing the post process. (default: TEXTUREFORMAT_RGBA)\r\n     */\r\n    constructor(\r\n        name: string,\r\n        _scene: Nullable<Scene>,\r\n        direction: Vector2,\r\n        kernel: number,\r\n        options: number | PostProcessOptions,\r\n        camera: Nullable<Camera>,\r\n        circleOfConfusion: PostProcess,\r\n        imageToBlur: Nullable<PostProcess> = null,\r\n        samplingMode = Texture.BILINEAR_SAMPLINGMODE,\r\n        engine?: AbstractEngine,\r\n        reusable?: boolean,\r\n        textureType = Constants.TEXTURETYPE_UNSIGNED_INT,\r\n        blockCompilation = false,\r\n        textureFormat = Constants.TEXTUREFORMAT_RGBA\r\n    ) {\r\n        super(name, direction, kernel, {\r\n            camera,\r\n            engine,\r\n            reusable,\r\n            textureType,\r\n            defines: `#define DOF 1\\n`,\r\n            blockCompilation,\r\n            textureFormat,\r\n            ...(options as PostProcessOptions),\r\n            // eslint-disable-next-line @typescript-eslint/no-unused-vars\r\n            samplingMode: (samplingMode = Constants.TEXTURE_BILINEAR_SAMPLINGMODE),\r\n        });\r\n\r\n        this.externalTextureSamplerBinding = !!imageToBlur;\r\n\r\n        this.onApplyObservable.add((effect: Effect) => {\r\n            if (imageToBlur != null) {\r\n                effect.setTextureFromPostProcess(\"textureSampler\", imageToBlur);\r\n            }\r\n            effect.setTextureFromPostProcessOutput(\"circleOfConfusionSampler\", circleOfConfusion);\r\n        });\r\n    }\r\n}\r\n\r\nRegisterClass(\"BABYLON.DepthOfFieldBlurPostProcess\", DepthOfFieldBlurPostProcess);\r\n"]}

package/PostProcesses/depthOfFieldEffect.d.ts

@@ -5,6 +5,7 @@ import type { PostProcess } from "./postProcess";
 import { PostProcessRenderEffect } from "../PostProcesses/RenderPipeline/postProcessRenderEffect";
 import { DepthOfFieldBlurPostProcess } from "./depthOfFieldBlurPostProcess";
 import type { Scene } from "../scene";
+import type { AbstractEngine } from "../Engines/abstractEngine.js";
 /**
  * Specifies the level of max blur that should be applied when using the depth of field effect
  */
@@ -57,15 +58,17 @@ export declare class DepthOfFieldEffect extends PostProcessRenderEffect {
      */
     set lensSize(value: number);
     get lensSize(): number;
+    private _thinDepthOfFieldEffect;
     /**
      * Creates a new instance DepthOfFieldEffect
-     * @param scene The scene the effect belongs to.
+     * @param sceneOrEngine The scene or engine the effect belongs to.
      * @param depthTexture The depth texture of the scene to compute the circle of confusion.This must be set in order for this to function but may be set after initialization if needed.
      * @param blurLevel
      * @param pipelineTextureType The type of texture to be used when performing the post processing.
      * @param blockCompilation If compilation of the shader should not be done in the constructor. The updateEffect method can be used to compile the shader at a later time. (default: false)
+     * @param depthNotNormalized If the depth from the depth texture is already normalized or if the normalization should be done at runtime in the shader (default: false)
      */
-    constructor(scene: Scene, depthTexture: Nullable<RenderTargetTexture>, blurLevel?: DepthOfFieldEffectBlurLevel, pipelineTextureType?: number, blockCompilation?: boolean);
+    constructor(sceneOrEngine: Scene | AbstractEngine, depthTexture: Nullable<RenderTargetTexture>, blurLevel?: DepthOfFieldEffectBlurLevel, pipelineTextureType?: number, blockCompilation?: boolean, depthNotNormalized?: boolean);
     /**
      * Get the current class name of the current effect
      * @returns "DepthOfFieldEffect"

package/PostProcesses/depthOfFieldEffect.js

@@ -1,10 +1,10 @@
-import { Vector2 } from "../Maths/math.vector.js";
 import { Texture } from "../Materials/Textures/texture.js";
 import { PostProcessRenderEffect } from "../PostProcesses/RenderPipeline/postProcessRenderEffect.js";
 import { CircleOfConfusionPostProcess } from "./circleOfConfusionPostProcess.js";
 import { DepthOfFieldBlurPostProcess } from "./depthOfFieldBlurPostProcess.js";
 import { DepthOfFieldMergePostProcess } from "./depthOfFieldMergePostProcess.js";
 
+import { ThinDepthOfFieldEffect } from "./thinDepthOfFieldEffect.js";
 /**
  * Specifies the level of max blur that should be applied when using the depth of field effect
  */
@@ -31,91 +31,97 @@ export class DepthOfFieldEffect extends PostProcessRenderEffect {
      * The focal the length of the camera used in the effect in scene units/1000 (eg. millimeter)
      */
     set focalLength(value) {
-        this._circleOfConfusion.focalLength = value;
+        this._thinDepthOfFieldEffect.focalLength = value;
     }
     get focalLength() {
-        return this._circleOfConfusion.focalLength;
+        return this._thinDepthOfFieldEffect.focalLength;
     }
     /**
      * F-Stop of the effect's camera. The diameter of the resulting aperture can be computed by lensSize/fStop. (default: 1.4)
      */
     set fStop(value) {
-        this._circleOfConfusion.fStop = value;
+        this._thinDepthOfFieldEffect.fStop = value;
     }
     get fStop() {
-        return this._circleOfConfusion.fStop;
+        return this._thinDepthOfFieldEffect.fStop;
     }
     /**
      * Distance away from the camera to focus on in scene units/1000 (eg. millimeter). (default: 2000)
      */
     set focusDistance(value) {
-        this._circleOfConfusion.focusDistance = value;
+        this._thinDepthOfFieldEffect.focusDistance = value;
     }
     get focusDistance() {
-        return this._circleOfConfusion.focusDistance;
+        return this._thinDepthOfFieldEffect.focusDistance;
     }
     /**
      * 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.
      */
     set lensSize(value) {
-        this._circleOfConfusion.lensSize = value;
+        this._thinDepthOfFieldEffect.lensSize = value;
     }
     get lensSize() {
-        return this._circleOfConfusion.lensSize;
+        return this._thinDepthOfFieldEffect.lensSize;
     }
     /**
      * Creates a new instance DepthOfFieldEffect
-     * @param scene The scene the effect belongs to.
+     * @param sceneOrEngine The scene or engine the effect belongs to.
      * @param depthTexture The depth texture of the scene to compute the circle of confusion.This must be set in order for this to function but may be set after initialization if needed.
      * @param blurLevel
      * @param pipelineTextureType The type of texture to be used when performing the post processing.
      * @param blockCompilation If compilation of the shader should not be done in the constructor. The updateEffect method can be used to compile the shader at a later time. (default: false)
+     * @param depthNotNormalized If the depth from the depth texture is already normalized or if the normalization should be done at runtime in the shader (default: false)
      */
-    constructor(scene, depthTexture, blurLevel = 0 /* DepthOfFieldEffectBlurLevel.Low */, pipelineTextureType = 0, blockCompilation = false) {
-        super(scene.getEngine(), "depth of field", () => {
+    constructor(sceneOrEngine, depthTexture, blurLevel = 0 /* DepthOfFieldEffectBlurLevel.Low */, pipelineTextureType = 0, blockCompilation = false, depthNotNormalized = false) {
+        const engine = sceneOrEngine._renderForCamera ? sceneOrEngine.getEngine() : sceneOrEngine;
+        super(engine, "depth of field", () => {
             return this._effects;
         }, true);
         /**
          * @internal Internal post processes in depth of field effect
          */
         this._effects = [];
+        this._thinDepthOfFieldEffect = new ThinDepthOfFieldEffect("Depth of Field", engine, blurLevel, false, blockCompilation);
         // Use R-only formats if supported to store the circle of confusion values.
         // This should be more space and bandwidth efficient than using RGBA.
-        const engine = scene.getEngine();
         const circleOfConfusionTextureFormat = engine.isWebGPU || engine.version > 1 ? 6 : 5;
         // Circle of confusion value for each pixel is used to determine how much to blur that pixel
-        this._circleOfConfusion = new CircleOfConfusionPostProcess("circleOfConfusion", depthTexture, 1, null, Texture.BILINEAR_SAMPLINGMODE, engine, false, pipelineTextureType, blockCompilation);
+        this._circleOfConfusion = new CircleOfConfusionPostProcess("circleOfConfusion", depthTexture, {
+            size: 1,
+            samplingMode: Texture.BILINEAR_SAMPLINGMODE,
+            engine,
+            textureType: pipelineTextureType,
+            blockCompilation,
+            depthNotNormalized,
+            effectWrapper: this._thinDepthOfFieldEffect._circleOfConfusion,
+        }, null);
         // Create a pyramid of blurred images (eg. fullSize 1/4 blur, half size 1/2 blur, quarter size 3/4 blur, eith size 4/4 blur)
         // Blur the image but do not blur on sharp far to near distance changes to avoid bleeding artifacts
         // See section 2.6.2 http://fileadmin.cs.lth.se/cs/education/edan35/lectures/12dof.pdf
         this._depthOfFieldBlurY = [];
         this._depthOfFieldBlurX = [];
-        let blurCount = 1;
-        let kernelSize = 15;
-        switch (blurLevel) {
-            case 2 /* DepthOfFieldEffectBlurLevel.High */: {
-                blurCount = 3;
-                kernelSize = 51;
-                break;
-            }
-            case 1 /* DepthOfFieldEffectBlurLevel.Medium */: {
-                blurCount = 2;
-                kernelSize = 31;
-                break;
-            }
-            default: {
-                kernelSize = 15;
-                blurCount = 1;
-                break;
-            }
-        }
-        const adjustedKernelSize = kernelSize / Math.pow(2, blurCount - 1);
-        let ratio = 1.0;
+        const blurCount = this._thinDepthOfFieldEffect._depthOfFieldBlurX.length;
         for (let i = 0; i < blurCount; i++) {
-            const blurY = new DepthOfFieldBlurPostProcess("vertical blur", scene, new Vector2(0, 1.0), adjustedKernelSize, ratio, null, this._circleOfConfusion, i == 0 ? this._circleOfConfusion : null, Texture.BILINEAR_SAMPLINGMODE, engine, false, pipelineTextureType, blockCompilation, i == 0 ? circleOfConfusionTextureFormat : 5);
+            const [thinBlurY, ratioY] = this._thinDepthOfFieldEffect._depthOfFieldBlurY[i];
+            const blurY = new DepthOfFieldBlurPostProcess("vertical blur", null, thinBlurY.direction, thinBlurY.kernel, {
+                size: ratioY,
+                samplingMode: Texture.BILINEAR_SAMPLINGMODE,
+                engine,
+                textureType: pipelineTextureType,
+                blockCompilation,
+                textureFormat: i == 0 ? circleOfConfusionTextureFormat : 5,
+                effectWrapper: thinBlurY,
+            }, null, this._circleOfConfusion, i == 0 ? this._circleOfConfusion : null);
             blurY.autoClear = false;
-            ratio = 0.75 / Math.pow(2, i);
-            const blurX = new DepthOfFieldBlurPostProcess("horizontal blur", scene, new Vector2(1.0, 0), adjustedKernelSize, ratio, null, this._circleOfConfusion, null, Texture.BILINEAR_SAMPLINGMODE, engine, false, pipelineTextureType, blockCompilation);
+            const [thinBlurX, ratioX] = this._thinDepthOfFieldEffect._depthOfFieldBlurX[i];
+            const blurX = new DepthOfFieldBlurPostProcess("horizontal blur", null, thinBlurX.direction, thinBlurX.kernel, {
+                size: ratioX,
+                samplingMode: Texture.BILINEAR_SAMPLINGMODE,
+                engine,
+                textureType: pipelineTextureType,
+                blockCompilation,
+                effectWrapper: thinBlurX,
+            }, null, this._circleOfConfusion, null);
             blurX.autoClear = false;
             this._depthOfFieldBlurY.push(blurY);
             this._depthOfFieldBlurX.push(blurX);
@@ -127,7 +133,14 @@ export class DepthOfFieldEffect extends PostProcessRenderEffect {
             this._effects.push(this._depthOfFieldBlurX[i]);
         }
         // Merge blurred images with original image based on circleOfConfusion
-        this._dofMerge = new DepthOfFieldMergePostProcess("dofMerge", this._circleOfConfusion, this._circleOfConfusion, this._depthOfFieldBlurX, ratio, null, Texture.BILINEAR_SAMPLINGMODE, engine, false, pipelineTextureType, blockCompilation);
+        this._dofMerge = new DepthOfFieldMergePostProcess("dofMerge", this._circleOfConfusion, this._circleOfConfusion, this._depthOfFieldBlurX, {
+            size: this._thinDepthOfFieldEffect._depthOfFieldBlurX[blurCount - 1][1],
+            samplingMode: Texture.BILINEAR_SAMPLINGMODE,
+            engine,
+            textureType: pipelineTextureType,
+            blockCompilation,
+            effectWrapper: this._thinDepthOfFieldEffect._dofMerge,
+        }, null);
         this._dofMerge.autoClear = false;
         this._effects.push(this._dofMerge);
     }
@@ -167,12 +180,7 @@ export class DepthOfFieldEffect extends PostProcessRenderEffect {
      * @internal
      */
     _isReady() {
-        for (let effectIndex = 0; effectIndex < this._effects.length; effectIndex++) {
-            if (!this._effects[effectIndex].isReady()) {
-                return false;
-            }
-        }
-        return true;
+        return this._thinDepthOfFieldEffect.isReady();
     }
 }
 //# sourceMappingURL=depthOfFieldEffect.js.map

package/PostProcesses/depthOfFieldEffect.js.map

@@ -1 +1 @@
-{"version":3,"file":"depthOfFieldEffect.js","sourceRoot":"","sources":["../../../../dev/core/src/PostProcesses/depthOfFieldEffect.ts"],"names":[],"mappings":"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","sourcesContent":["import type { Nullable } from \"../types\";\r\nimport { Vector2 } from \"../Maths/math.vector\";\r\nimport type { Camera } from \"../Cameras/camera\";\r\nimport { Texture } from \"../Materials/Textures/texture\";\r\nimport type { RenderTargetTexture } from \"../Materials/Textures/renderTargetTexture\";\r\nimport type { PostProcess } from \"./postProcess\";\r\nimport { PostProcessRenderEffect } from \"../PostProcesses/RenderPipeline/postProcessRenderEffect\";\r\nimport { CircleOfConfusionPostProcess } from \"./circleOfConfusionPostProcess\";\r\nimport { DepthOfFieldBlurPostProcess } from \"./depthOfFieldBlurPostProcess\";\r\nimport { DepthOfFieldMergePostProcess } from \"./depthOfFieldMergePostProcess\";\r\nimport type { Scene } from \"../scene\";\r\nimport { Constants } from \"../Engines/constants\";\r\n\r\n/**\r\n * Specifies the level of max blur that should be applied when using the depth of field effect\r\n */\r\nexport const enum DepthOfFieldEffectBlurLevel {\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\n * The depth of field effect applies a blur to objects that are closer or further from where the camera is focusing.\r\n */\r\nexport class DepthOfFieldEffect extends PostProcessRenderEffect {\r\n    private _circleOfConfusion: CircleOfConfusionPostProcess;\r\n    /**\r\n     * @internal Internal, blurs from high to low\r\n     */\r\n    public _depthOfFieldBlurX: Array<DepthOfFieldBlurPostProcess>;\r\n    private _depthOfFieldBlurY: Array<DepthOfFieldBlurPostProcess>;\r\n    private _dofMerge: Nullable<DepthOfFieldMergePostProcess>;\r\n\r\n    /**\r\n     * @internal Internal post processes in depth of field effect\r\n     */\r\n    public _effects: Array<PostProcess> = [];\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     * Creates a new instance DepthOfFieldEffect\r\n     * @param scene The scene the effect belongs to.\r\n     * @param depthTexture The depth texture of the scene to compute the circle of confusion.This must be set in order for this to function but may be set after initialization if needed.\r\n     * @param blurLevel\r\n     * @param pipelineTextureType The type of texture to be used when performing the post processing.\r\n     * @param blockCompilation If compilation of the shader should not be done in the constructor. The updateEffect method can be used to compile the shader at a later time. (default: false)\r\n     */\r\n    constructor(\r\n        scene: Scene,\r\n        depthTexture: Nullable<RenderTargetTexture>,\r\n        blurLevel: DepthOfFieldEffectBlurLevel = DepthOfFieldEffectBlurLevel.Low,\r\n        pipelineTextureType = 0,\r\n        blockCompilation = false\r\n    ) {\r\n        super(\r\n            scene.getEngine(),\r\n            \"depth of field\",\r\n            () => {\r\n                return this._effects;\r\n            },\r\n            true\r\n        );\r\n\r\n        // Use R-only formats if supported to store the circle of confusion values.\r\n        // This should be more space and bandwidth efficient than using RGBA.\r\n        const engine = scene.getEngine();\r\n        const circleOfConfusionTextureFormat = engine.isWebGPU || engine.version > 1 ? Constants.TEXTUREFORMAT_RED : Constants.TEXTUREFORMAT_RGBA;\r\n\r\n        // Circle of confusion value for each pixel is used to determine how much to blur that pixel\r\n        this._circleOfConfusion = new CircleOfConfusionPostProcess(\r\n            \"circleOfConfusion\",\r\n            depthTexture,\r\n            1,\r\n            null,\r\n            Texture.BILINEAR_SAMPLINGMODE,\r\n            engine,\r\n            false,\r\n            pipelineTextureType,\r\n            blockCompilation\r\n        );\r\n\r\n        // Create a pyramid of blurred images (eg. fullSize 1/4 blur, half size 1/2 blur, quarter size 3/4 blur, eith size 4/4 blur)\r\n        // Blur the image but do not blur on sharp far to near distance changes to avoid bleeding artifacts\r\n        // See section 2.6.2 http://fileadmin.cs.lth.se/cs/education/edan35/lectures/12dof.pdf\r\n        this._depthOfFieldBlurY = [];\r\n        this._depthOfFieldBlurX = [];\r\n        let blurCount = 1;\r\n        let kernelSize = 15;\r\n        switch (blurLevel) {\r\n            case DepthOfFieldEffectBlurLevel.High: {\r\n                blurCount = 3;\r\n                kernelSize = 51;\r\n                break;\r\n            }\r\n            case DepthOfFieldEffectBlurLevel.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        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            const blurY = new DepthOfFieldBlurPostProcess(\r\n                \"vertical blur\",\r\n                scene,\r\n                new Vector2(0, 1.0),\r\n                adjustedKernelSize,\r\n                ratio,\r\n                null,\r\n                this._circleOfConfusion,\r\n                i == 0 ? this._circleOfConfusion : null,\r\n                Texture.BILINEAR_SAMPLINGMODE,\r\n                engine,\r\n                false,\r\n                pipelineTextureType,\r\n                blockCompilation,\r\n                i == 0 ? circleOfConfusionTextureFormat : Constants.TEXTUREFORMAT_RGBA\r\n            );\r\n            blurY.autoClear = false;\r\n            ratio = 0.75 / Math.pow(2, i);\r\n            const blurX = new DepthOfFieldBlurPostProcess(\r\n                \"horizontal blur\",\r\n                scene,\r\n                new Vector2(1.0, 0),\r\n                adjustedKernelSize,\r\n                ratio,\r\n                null,\r\n                this._circleOfConfusion,\r\n                null,\r\n                Texture.BILINEAR_SAMPLINGMODE,\r\n                engine,\r\n                false,\r\n                pipelineTextureType,\r\n                blockCompilation\r\n            );\r\n            blurX.autoClear = false;\r\n            this._depthOfFieldBlurY.push(blurY);\r\n            this._depthOfFieldBlurX.push(blurX);\r\n        }\r\n\r\n        // Set all post processes on the effect.\r\n        this._effects = [this._circleOfConfusion];\r\n        for (let i = 0; i < this._depthOfFieldBlurX.length; i++) {\r\n            this._effects.push(this._depthOfFieldBlurY[i]);\r\n            this._effects.push(this._depthOfFieldBlurX[i]);\r\n        }\r\n\r\n        // Merge blurred images with original image based on circleOfConfusion\r\n        this._dofMerge = new DepthOfFieldMergePostProcess(\r\n            \"dofMerge\",\r\n            this._circleOfConfusion,\r\n            this._circleOfConfusion,\r\n            this._depthOfFieldBlurX,\r\n            ratio,\r\n            null,\r\n            Texture.BILINEAR_SAMPLINGMODE,\r\n            engine,\r\n            false,\r\n            pipelineTextureType,\r\n            blockCompilation\r\n        );\r\n        this._dofMerge.autoClear = false;\r\n        this._effects.push(this._dofMerge);\r\n    }\r\n\r\n    /**\r\n     * Get the current class name of the current effect\r\n     * @returns \"DepthOfFieldEffect\"\r\n     */\r\n    public getClassName(): string {\r\n        return \"DepthOfFieldEffect\";\r\n    }\r\n\r\n    /**\r\n     * Depth texture to be used to compute the circle of confusion. This must be set here or in the constructor in order for the post process to function.\r\n     */\r\n    public set depthTexture(value: RenderTargetTexture) {\r\n        this._circleOfConfusion.depthTexture = value;\r\n    }\r\n\r\n    /**\r\n     * Disposes each of the internal effects for a given camera.\r\n     * @param camera The camera to dispose the effect on.\r\n     */\r\n    public disposeEffects(camera: Camera) {\r\n        for (let effectIndex = 0; effectIndex < this._effects.length; effectIndex++) {\r\n            this._effects[effectIndex].dispose(camera);\r\n        }\r\n    }\r\n\r\n    /**\r\n     * @internal Internal\r\n     */\r\n    public _updateEffects() {\r\n        for (let effectIndex = 0; effectIndex < this._effects.length; effectIndex++) {\r\n            this._effects[effectIndex].updateEffect();\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Internal\r\n     * @returns if all the contained post processes are ready.\r\n     * @internal\r\n     */\r\n    public _isReady() {\r\n        for (let effectIndex = 0; effectIndex < this._effects.length; effectIndex++) {\r\n            if (!this._effects[effectIndex].isReady()) {\r\n                return false;\r\n            }\r\n        }\r\n        return true;\r\n    }\r\n}\r\n"]}
+{"version":3,"file":"depthOfFieldEffect.js","sourceRoot":"","sources":["../../../../dev/core/src/PostProcesses/depthOfFieldEffect.ts"],"names":[],"mappings":"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","sourcesContent":["import type { Nullable } from \"../types\";\r\nimport type { Camera } from \"../Cameras/camera\";\r\nimport { Texture } from \"../Materials/Textures/texture\";\r\nimport type { RenderTargetTexture } from \"../Materials/Textures/renderTargetTexture\";\r\nimport type { PostProcess } from \"./postProcess\";\r\nimport { PostProcessRenderEffect } from \"../PostProcesses/RenderPipeline/postProcessRenderEffect\";\r\nimport { CircleOfConfusionPostProcess } from \"./circleOfConfusionPostProcess\";\r\nimport { DepthOfFieldBlurPostProcess } from \"./depthOfFieldBlurPostProcess\";\r\nimport { DepthOfFieldMergePostProcess } from \"./depthOfFieldMergePostProcess\";\r\nimport type { Scene } from \"../scene\";\r\nimport { Constants } from \"../Engines/constants\";\r\nimport type { AbstractEngine } from \"core/Engines/abstractEngine\";\r\nimport type { ThinDepthOfFieldEffectBlurLevel } from \"./thinDepthOfFieldEffect\";\r\nimport { ThinDepthOfFieldEffect } from \"./thinDepthOfFieldEffect\";\r\n\r\n/**\r\n * Specifies the level of max blur that should be applied when using the depth of field effect\r\n */\r\nexport const enum DepthOfFieldEffectBlurLevel {\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\n/**\r\n * The depth of field effect applies a blur to objects that are closer or further from where the camera is focusing.\r\n */\r\nexport class DepthOfFieldEffect extends PostProcessRenderEffect {\r\n    private _circleOfConfusion: CircleOfConfusionPostProcess;\r\n    /**\r\n     * @internal Internal, blurs from high to low\r\n     */\r\n    public _depthOfFieldBlurX: Array<DepthOfFieldBlurPostProcess>;\r\n    private _depthOfFieldBlurY: Array<DepthOfFieldBlurPostProcess>;\r\n    private _dofMerge: Nullable<DepthOfFieldMergePostProcess>;\r\n\r\n    /**\r\n     * @internal Internal post processes in depth of field effect\r\n     */\r\n    public _effects: Array<PostProcess> = [];\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._thinDepthOfFieldEffect.focalLength = value;\r\n    }\r\n    public get focalLength() {\r\n        return this._thinDepthOfFieldEffect.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._thinDepthOfFieldEffect.fStop = value;\r\n    }\r\n    public get fStop() {\r\n        return this._thinDepthOfFieldEffect.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._thinDepthOfFieldEffect.focusDistance = value;\r\n    }\r\n    public get focusDistance() {\r\n        return this._thinDepthOfFieldEffect.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._thinDepthOfFieldEffect.lensSize = value;\r\n    }\r\n    public get lensSize() {\r\n        return this._thinDepthOfFieldEffect.lensSize;\r\n    }\r\n\r\n    private _thinDepthOfFieldEffect: ThinDepthOfFieldEffect;\r\n\r\n    /**\r\n     * Creates a new instance DepthOfFieldEffect\r\n     * @param sceneOrEngine The scene or engine the effect belongs to.\r\n     * @param depthTexture The depth texture of the scene to compute the circle of confusion.This must be set in order for this to function but may be set after initialization if needed.\r\n     * @param blurLevel\r\n     * @param pipelineTextureType The type of texture to be used when performing the post processing.\r\n     * @param blockCompilation If compilation of the shader should not be done in the constructor. The updateEffect method can be used to compile the shader at a later time. (default: false)\r\n     * @param depthNotNormalized If the depth from the depth texture is already normalized or if the normalization should be done at runtime in the shader (default: false)\r\n     */\r\n    constructor(\r\n        sceneOrEngine: Scene | AbstractEngine,\r\n        depthTexture: Nullable<RenderTargetTexture>,\r\n        blurLevel: DepthOfFieldEffectBlurLevel = DepthOfFieldEffectBlurLevel.Low,\r\n        pipelineTextureType = 0,\r\n        blockCompilation = false,\r\n        depthNotNormalized = false\r\n    ) {\r\n        const engine = (sceneOrEngine as Scene)._renderForCamera ? (sceneOrEngine as Scene).getEngine() : (sceneOrEngine as AbstractEngine);\r\n        super(\r\n            engine,\r\n            \"depth of field\",\r\n            () => {\r\n                return this._effects;\r\n            },\r\n            true\r\n        );\r\n\r\n        this._thinDepthOfFieldEffect = new ThinDepthOfFieldEffect(\"Depth of Field\", engine, blurLevel as unknown as ThinDepthOfFieldEffectBlurLevel, false, blockCompilation);\r\n\r\n        // Use R-only formats if supported to store the circle of confusion values.\r\n        // This should be more space and bandwidth efficient than using RGBA.\r\n        const circleOfConfusionTextureFormat = engine.isWebGPU || engine.version > 1 ? Constants.TEXTUREFORMAT_RED : Constants.TEXTUREFORMAT_RGBA;\r\n\r\n        // Circle of confusion value for each pixel is used to determine how much to blur that pixel\r\n        this._circleOfConfusion = new CircleOfConfusionPostProcess(\r\n            \"circleOfConfusion\",\r\n            depthTexture,\r\n            {\r\n                size: 1,\r\n                samplingMode: Texture.BILINEAR_SAMPLINGMODE,\r\n                engine,\r\n                textureType: pipelineTextureType,\r\n                blockCompilation,\r\n                depthNotNormalized,\r\n                effectWrapper: this._thinDepthOfFieldEffect._circleOfConfusion,\r\n            },\r\n            null\r\n        );\r\n\r\n        // Create a pyramid of blurred images (eg. fullSize 1/4 blur, half size 1/2 blur, quarter size 3/4 blur, eith size 4/4 blur)\r\n        // Blur the image but do not blur on sharp far to near distance changes to avoid bleeding artifacts\r\n        // See section 2.6.2 http://fileadmin.cs.lth.se/cs/education/edan35/lectures/12dof.pdf\r\n        this._depthOfFieldBlurY = [];\r\n        this._depthOfFieldBlurX = [];\r\n\r\n        const blurCount = this._thinDepthOfFieldEffect._depthOfFieldBlurX.length;\r\n\r\n        for (let i = 0; i < blurCount; i++) {\r\n            const [thinBlurY, ratioY] = this._thinDepthOfFieldEffect._depthOfFieldBlurY[i];\r\n            const blurY = new DepthOfFieldBlurPostProcess(\r\n                \"vertical blur\",\r\n                null,\r\n                thinBlurY.direction,\r\n                thinBlurY.kernel,\r\n                {\r\n                    size: ratioY,\r\n                    samplingMode: Texture.BILINEAR_SAMPLINGMODE,\r\n                    engine,\r\n                    textureType: pipelineTextureType,\r\n                    blockCompilation,\r\n                    textureFormat: i == 0 ? circleOfConfusionTextureFormat : Constants.TEXTUREFORMAT_RGBA,\r\n                    effectWrapper: thinBlurY,\r\n                },\r\n                null,\r\n                this._circleOfConfusion,\r\n                i == 0 ? this._circleOfConfusion : null\r\n            );\r\n            blurY.autoClear = false;\r\n\r\n            const [thinBlurX, ratioX] = this._thinDepthOfFieldEffect._depthOfFieldBlurX[i];\r\n            const blurX = new DepthOfFieldBlurPostProcess(\r\n                \"horizontal blur\",\r\n                null,\r\n                thinBlurX.direction,\r\n                thinBlurX.kernel,\r\n                {\r\n                    size: ratioX,\r\n                    samplingMode: Texture.BILINEAR_SAMPLINGMODE,\r\n                    engine,\r\n                    textureType: pipelineTextureType,\r\n                    blockCompilation,\r\n                    effectWrapper: thinBlurX,\r\n                },\r\n                null,\r\n                this._circleOfConfusion,\r\n                null\r\n            );\r\n            blurX.autoClear = false;\r\n            this._depthOfFieldBlurY.push(blurY);\r\n            this._depthOfFieldBlurX.push(blurX);\r\n        }\r\n\r\n        // Set all post processes on the effect.\r\n        this._effects = [this._circleOfConfusion];\r\n        for (let i = 0; i < this._depthOfFieldBlurX.length; i++) {\r\n            this._effects.push(this._depthOfFieldBlurY[i]);\r\n            this._effects.push(this._depthOfFieldBlurX[i]);\r\n        }\r\n\r\n        // Merge blurred images with original image based on circleOfConfusion\r\n        this._dofMerge = new DepthOfFieldMergePostProcess(\r\n            \"dofMerge\",\r\n            this._circleOfConfusion,\r\n            this._circleOfConfusion,\r\n            this._depthOfFieldBlurX,\r\n            {\r\n                size: this._thinDepthOfFieldEffect._depthOfFieldBlurX[blurCount - 1][1],\r\n                samplingMode: Texture.BILINEAR_SAMPLINGMODE,\r\n                engine,\r\n                textureType: pipelineTextureType,\r\n                blockCompilation,\r\n                effectWrapper: this._thinDepthOfFieldEffect._dofMerge,\r\n            },\r\n            null\r\n        );\r\n        this._dofMerge.autoClear = false;\r\n        this._effects.push(this._dofMerge);\r\n    }\r\n\r\n    /**\r\n     * Get the current class name of the current effect\r\n     * @returns \"DepthOfFieldEffect\"\r\n     */\r\n    public getClassName(): string {\r\n        return \"DepthOfFieldEffect\";\r\n    }\r\n\r\n    /**\r\n     * Depth texture to be used to compute the circle of confusion. This must be set here or in the constructor in order for the post process to function.\r\n     */\r\n    public set depthTexture(value: RenderTargetTexture) {\r\n        this._circleOfConfusion.depthTexture = value;\r\n    }\r\n\r\n    /**\r\n     * Disposes each of the internal effects for a given camera.\r\n     * @param camera The camera to dispose the effect on.\r\n     */\r\n    public disposeEffects(camera: Camera) {\r\n        for (let effectIndex = 0; effectIndex < this._effects.length; effectIndex++) {\r\n            this._effects[effectIndex].dispose(camera);\r\n        }\r\n    }\r\n\r\n    /**\r\n     * @internal Internal\r\n     */\r\n    public _updateEffects() {\r\n        for (let effectIndex = 0; effectIndex < this._effects.length; effectIndex++) {\r\n            this._effects[effectIndex].updateEffect();\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Internal\r\n     * @returns if all the contained post processes are ready.\r\n     * @internal\r\n     */\r\n    public _isReady() {\r\n        return this._thinDepthOfFieldEffect.isReady();\r\n    }\r\n}\r\n"]}

package/PostProcesses/depthOfFieldMergePostProcess.d.ts

@@ -29,7 +29,6 @@ export declare class DepthOfFieldMergePostProcess extends PostProcess {
      * @param blockCompilation If compilation of the shader should not be done in the constructor. The updateEffect method can be used to compile the shader at a later time. (default: false)
      */
     constructor(name: string, originalFromInput: PostProcess, circleOfConfusion: PostProcess, _blurSteps: Array<PostProcess>, options: number | PostProcessOptions, camera: Nullable<Camera>, samplingMode?: number, engine?: AbstractEngine, reusable?: boolean, textureType?: number, blockCompilation?: boolean);
-    protected _gatherImports(useWebGPU: boolean, list: Promise<any>[]): void;
     /**
      * Updates the effect with the current post process compile time values and recompiles the shader.
      * @param defines Define statements that should be added at the beginning of the shader. (default: null)

package/PostProcesses/depthOfFieldMergePostProcess.js

@@ -1,5 +1,6 @@
 import { PostProcess } from "./postProcess.js";
 
+import { ThinDepthOfFieldMergePostProcess } from "./thinDepthOfFieldMergePostProcess.js";
 /**
  * The DepthOfFieldMergePostProcess merges blurred images with the original based on the values of the circle of confusion.
  */
@@ -26,7 +27,22 @@ export class DepthOfFieldMergePostProcess extends PostProcess {
      * @param blockCompilation If compilation of the shader should not be done in the constructor. The updateEffect method can be used to compile the shader at a later time. (default: false)
      */
     constructor(name, originalFromInput, circleOfConfusion, _blurSteps, options, camera, samplingMode, engine, reusable, textureType = 0, blockCompilation = false) {
-        super(name, "depthOfFieldMerge", [], ["circleOfConfusionSampler", "blurStep0", "blurStep1", "blurStep2"], options, camera, samplingMode, engine, reusable, null, textureType, undefined, null, true);
+        const blockCompilationFinal = typeof options === "number" ? blockCompilation : !!options.blockCompilation;
+        const localOptions = {
+            samplers: ThinDepthOfFieldMergePostProcess.Samplers,
+            size: typeof options === "number" ? options : undefined,
+            camera,
+            samplingMode,
+            engine,
+            reusable,
+            textureType,
+            ...options,
+            blockCompilation: true,
+        };
+        super(name, ThinDepthOfFieldMergePostProcess.FragmentUrl, {
+            effectWrapper: typeof options === "number" || !options.effectWrapper ? new ThinDepthOfFieldMergePostProcess(name, engine, localOptions) : undefined,
+            ...localOptions,
+        });
         this._blurSteps = _blurSteps;
         this.externalTextureSamplerBinding = true;
         this.onApplyObservable.add((effect) => {
@@ -36,20 +52,10 @@ export class DepthOfFieldMergePostProcess extends PostProcess {
                 effect.setTextureFromPostProcessOutput("blurStep" + (_blurSteps.length - index - 1), step);
             });
         });
-        if (!blockCompilation) {
+        if (!blockCompilationFinal) {
             this.updateEffect();
         }
     }
-    _gatherImports(useWebGPU, list) {
-        if (useWebGPU) {
-            this._webGPUReady = true;
-            list.push(import("../ShadersWGSL/depthOfFieldMerge.fragment.js"));
-        }
-        else {
-            list.push(import("../Shaders/depthOfFieldMerge.fragment.js"));
-        }
-        super._gatherImports(useWebGPU, list);
-    }
     /**
      * Updates the effect with the current post process compile time values and recompiles the shader.
      * @param defines Define statements that should be added at the beginning of the shader. (default: null)

package/PostProcesses/depthOfFieldMergePostProcess.js.map

@@ -1 +1 @@
-{"version":3,"file":"depthOfFieldMergePostProcess.js","sourceRoot":"","sources":["../../../../dev/core/src/PostProcesses/depthOfFieldMergePostProcess.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AAIjD;;GAEG;AACH,MAAM,OAAO,4BAA6B,SAAQ,WAAW;IACzD;;;OAGG;IACa,YAAY;QACxB,OAAO,8BAA8B,CAAC;IAC1C,CAAC;IAED;;;;;;;;;;;;;OAaG;IACH,YACI,IAAY,EACZ,iBAA8B,EAC9B,iBAA8B,EACtB,UAA8B,EACtC,OAAoC,EACpC,MAAwB,EACxB,YAAqB,EACrB,MAAuB,EACvB,QAAkB,EAClB,WAAW,GAAG,SAAS,CAAC,wBAAwB,EAChD,gBAAgB,GAAG,KAAK;QAExB,KAAK,CACD,IAAI,EACJ,mBAAmB,EACnB,EAAE,EACF,CAAC,0BAA0B,EAAE,WAAW,EAAE,WAAW,EAAE,WAAW,CAAC,EACnE,OAAO,EACP,MAAM,EACN,YAAY,EACZ,MAAM,EACN,QAAQ,EACR,IAAI,EACJ,WAAW,EACX,SAAS,EACT,IAAI,EACJ,IAAI,CACP,CAAC;QAxBM,eAAU,GAAV,UAAU,CAAoB;QAyBtC,IAAI,CAAC,6BAA6B,GAAG,IAAI,CAAC;QAC1C,IAAI,CAAC,iBAAiB,CAAC,GAAG,CAAC,CAAC,MAAc,EAAE,EAAE;YAC1C,MAAM,CAAC,yBAAyB,CAAC,gBAAgB,EAAE,iBAAiB,CAAC,CAAC;YACtE,MAAM,CAAC,+BAA+B,CAAC,0BAA0B,EAAE,iBAAiB,CAAC,CAAC;YACtF,UAAU,CAAC,OAAO,CAAC,CAAC,IAAI,EAAE,KAAK,EAAE,EAAE;gBAC/B,MAAM,CAAC,+BAA+B,CAAC,UAAU,GAAG,CAAC,UAAU,CAAC,MAAM,GAAG,KAAK,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC;YAC/F,CAAC,CAAC,CAAC;QACP,CAAC,CAAC,CAAC;QAEH,IAAI,CAAC,gBAAgB,EAAE;YACnB,IAAI,CAAC,YAAY,EAAE,CAAC;SACvB;IACL,CAAC;IAEkB,cAAc,CAAC,SAAkB,EAAE,IAAoB;QACtE,IAAI,SAAS,EAAE;YACX,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC;YACzB,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,2CAA2C,CAAC,CAAC,CAAC;SAClE;aAAM;YACH,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,uCAAuC,CAAC,CAAC,CAAC;SAC9D;QAED,KAAK,CAAC,cAAc,CAAC,SAAS,EAAE,IAAI,CAAC,CAAC;IAC1C,CAAC;IAED;;;;;;;;OAQG;IACa,YAAY,CACxB,UAA4B,IAAI,EAChC,WAA+B,IAAI,EACnC,WAA+B,IAAI,EACnC,eAAqB,EACrB,UAAqC,EACrC,OAAkD;QAElD,IAAI,CAAC,OAAO,EAAE;YACV,OAAO,GAAG,EAAE,CAAC;YACb,OAAO,IAAI,qBAAqB,GAAG,CAAC,IAAI,CAAC,UAAU,CAAC,MAAM,GAAG,CAAC,CAAC,GAAG,IAAI,CAAC;SAC1E;QACD,KAAK,CAAC,YAAY,CAAC,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,eAAe,EAAE,UAAU,EAAE,OAAO,CAAC,CAAC;IAC1F,CAAC;CACJ","sourcesContent":["import type { Nullable } from \"../types\";\r\nimport type { Camera } from \"../Cameras/camera\";\r\nimport type { Effect } from \"../Materials/effect\";\r\nimport type { PostProcessOptions } from \"./postProcess\";\r\nimport { PostProcess } from \"./postProcess\";\r\nimport { Constants } from \"../Engines/constants\";\r\n\r\nimport type { AbstractEngine } from \"core/Engines/abstractEngine\";\r\n\r\n/**\r\n * The DepthOfFieldMergePostProcess merges blurred images with the original based on the values of the circle of confusion.\r\n */\r\nexport class DepthOfFieldMergePostProcess extends PostProcess {\r\n    /**\r\n     * Gets a string identifying the name of the class\r\n     * @returns \"DepthOfFieldMergePostProcess\" string\r\n     */\r\n    public override getClassName(): string {\r\n        return \"DepthOfFieldMergePostProcess\";\r\n    }\r\n\r\n    /**\r\n     * Creates a new instance of DepthOfFieldMergePostProcess\r\n     * @param name The name of the effect.\r\n     * @param originalFromInput Post process which's input will be used for the merge.\r\n     * @param circleOfConfusion Circle of confusion post process which's output will be used to blur each pixel.\r\n     * @param _blurSteps Blur post processes from low to high which will be mixed with the original image.\r\n     * @param options The required width/height ratio to downsize to before computing the render pass.\r\n     * @param camera The camera to apply the render pass to.\r\n     * @param samplingMode The sampling mode to be used when computing the pass. (default: 0)\r\n     * @param engine The engine which the post process will be applied. (default: current engine)\r\n     * @param reusable If the post process can be reused on the same frame. (default: false)\r\n     * @param textureType Type of textures used when performing the post process. (default: 0)\r\n     * @param blockCompilation If compilation of the shader should not be done in the constructor. The updateEffect method can be used to compile the shader at a later time. (default: false)\r\n     */\r\n    constructor(\r\n        name: string,\r\n        originalFromInput: PostProcess,\r\n        circleOfConfusion: PostProcess,\r\n        private _blurSteps: Array<PostProcess>,\r\n        options: number | PostProcessOptions,\r\n        camera: Nullable<Camera>,\r\n        samplingMode?: number,\r\n        engine?: AbstractEngine,\r\n        reusable?: boolean,\r\n        textureType = Constants.TEXTURETYPE_UNSIGNED_INT,\r\n        blockCompilation = false\r\n    ) {\r\n        super(\r\n            name,\r\n            \"depthOfFieldMerge\",\r\n            [],\r\n            [\"circleOfConfusionSampler\", \"blurStep0\", \"blurStep1\", \"blurStep2\"],\r\n            options,\r\n            camera,\r\n            samplingMode,\r\n            engine,\r\n            reusable,\r\n            null,\r\n            textureType,\r\n            undefined,\r\n            null,\r\n            true\r\n        );\r\n        this.externalTextureSamplerBinding = true;\r\n        this.onApplyObservable.add((effect: Effect) => {\r\n            effect.setTextureFromPostProcess(\"textureSampler\", originalFromInput);\r\n            effect.setTextureFromPostProcessOutput(\"circleOfConfusionSampler\", circleOfConfusion);\r\n            _blurSteps.forEach((step, index) => {\r\n                effect.setTextureFromPostProcessOutput(\"blurStep\" + (_blurSteps.length - index - 1), step);\r\n            });\r\n        });\r\n\r\n        if (!blockCompilation) {\r\n            this.updateEffect();\r\n        }\r\n    }\r\n\r\n    protected override _gatherImports(useWebGPU: boolean, list: Promise<any>[]) {\r\n        if (useWebGPU) {\r\n            this._webGPUReady = true;\r\n            list.push(import(\"../ShadersWGSL/depthOfFieldMerge.fragment\"));\r\n        } else {\r\n            list.push(import(\"../Shaders/depthOfFieldMerge.fragment\"));\r\n        }\r\n\r\n        super._gatherImports(useWebGPU, list);\r\n    }\r\n\r\n    /**\r\n     * Updates the effect with the current post process compile time values and recompiles the shader.\r\n     * @param defines Define statements that should be added at the beginning of the shader. (default: null)\r\n     * @param uniforms Set of uniform variables that will be passed to the shader. (default: null)\r\n     * @param samplers Set of Texture2D variables that will be passed to the shader. (default: null)\r\n     * @param indexParameters The index parameters to be used for babylons include syntax \"#include<kernelBlurVaryingDeclaration>[0..varyingCount]\". (default: undefined) See usage in babylon.blurPostProcess.ts and kernelBlur.vertex.fx\r\n     * @param onCompiled Called when the shader has been compiled.\r\n     * @param onError Called if there is an error when compiling a shader.\r\n     */\r\n    public override updateEffect(\r\n        defines: Nullable<string> = null,\r\n        uniforms: Nullable<string[]> = null,\r\n        samplers: Nullable<string[]> = null,\r\n        indexParameters?: any,\r\n        onCompiled?: (effect: Effect) => void,\r\n        onError?: (effect: Effect, errors: string) => void\r\n    ) {\r\n        if (!defines) {\r\n            defines = \"\";\r\n            defines += \"#define BLUR_LEVEL \" + (this._blurSteps.length - 1) + \"\\n\";\r\n        }\r\n        super.updateEffect(defines, uniforms, samplers, indexParameters, onCompiled, onError);\r\n    }\r\n}\r\n"]}
+{"version":3,"file":"depthOfFieldMergePostProcess.js","sourceRoot":"","sources":["../../../../dev/core/src/PostProcesses/depthOfFieldMergePostProcess.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AAGjD,OAAO,EAAE,gCAAgC,EAAE,MAAM,oCAAoC,CAAC;AAEtF;;GAEG;AACH,MAAM,OAAO,4BAA6B,SAAQ,WAAW;IACzD;;;OAGG;IACa,YAAY;QACxB,OAAO,8BAA8B,CAAC;IAC1C,CAAC;IAED;;;;;;;;;;;;;OAaG;IACH,YACI,IAAY,EACZ,iBAA8B,EAC9B,iBAA8B,EACtB,UAA8B,EACtC,OAAoC,EACpC,MAAwB,EACxB,YAAqB,EACrB,MAAuB,EACvB,QAAkB,EAClB,WAAW,GAAG,SAAS,CAAC,wBAAwB,EAChD,gBAAgB,GAAG,KAAK;QAExB,MAAM,qBAAqB,GAAG,OAAO,OAAO,KAAK,QAAQ,CAAC,CAAC,CAAC,gBAAgB,CAAC,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,gBAAgB,CAAC;QAC1G,MAAM,YAAY,GAAG;YACjB,QAAQ,EAAE,gCAAgC,CAAC,QAAQ;YACnD,IAAI,EAAE,OAAO,OAAO,KAAK,QAAQ,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,SAAS;YACvD,MAAM;YACN,YAAY;YACZ,MAAM;YACN,QAAQ;YACR,WAAW;YACX,GAAI,OAA8B;YAClC,gBAAgB,EAAE,IAAI;SACzB,CAAC;QAEF,KAAK,CAAC,IAAI,EAAE,gCAAgC,CAAC,WAAW,EAAE;YACtD,aAAa,EAAE,OAAO,OAAO,KAAK,QAAQ,IAAI,CAAC,OAAO,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,gCAAgC,CAAC,IAAI,EAAE,MAAM,EAAE,YAAY,CAAC,CAAC,CAAC,CAAC,SAAS;YACnJ,GAAG,YAAY;SAClB,CAAC,CAAC;QAzBK,eAAU,GAAV,UAAU,CAAoB;QA2BtC,IAAI,CAAC,6BAA6B,GAAG,IAAI,CAAC;QAC1C,IAAI,CAAC,iBAAiB,CAAC,GAAG,CAAC,CAAC,MAAc,EAAE,EAAE;YAC1C,MAAM,CAAC,yBAAyB,CAAC,gBAAgB,EAAE,iBAAiB,CAAC,CAAC;YACtE,MAAM,CAAC,+BAA+B,CAAC,0BAA0B,EAAE,iBAAiB,CAAC,CAAC;YACtF,UAAU,CAAC,OAAO,CAAC,CAAC,IAAI,EAAE,KAAK,EAAE,EAAE;gBAC/B,MAAM,CAAC,+BAA+B,CAAC,UAAU,GAAG,CAAC,UAAU,CAAC,MAAM,GAAG,KAAK,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC;YAC/F,CAAC,CAAC,CAAC;QACP,CAAC,CAAC,CAAC;QAEH,IAAI,CAAC,qBAAqB,EAAE;YACxB,IAAI,CAAC,YAAY,EAAE,CAAC;SACvB;IACL,CAAC;IAED;;;;;;;;OAQG;IACa,YAAY,CACxB,UAA4B,IAAI,EAChC,WAA+B,IAAI,EACnC,WAA+B,IAAI,EACnC,eAAqB,EACrB,UAAqC,EACrC,OAAkD;QAElD,IAAI,CAAC,OAAO,EAAE;YACV,OAAO,GAAG,EAAE,CAAC;YACb,OAAO,IAAI,qBAAqB,GAAG,CAAC,IAAI,CAAC,UAAU,CAAC,MAAM,GAAG,CAAC,CAAC,GAAG,IAAI,CAAC;SAC1E;QACD,KAAK,CAAC,YAAY,CAAC,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,eAAe,EAAE,UAAU,EAAE,OAAO,CAAC,CAAC;IAC1F,CAAC;CACJ","sourcesContent":["import type { Nullable } from \"../types\";\r\nimport type { Camera } from \"../Cameras/camera\";\r\nimport type { Effect } from \"../Materials/effect\";\r\nimport type { PostProcessOptions } from \"./postProcess\";\r\nimport { PostProcess } from \"./postProcess\";\r\nimport { Constants } from \"../Engines/constants\";\r\n\r\nimport type { AbstractEngine } from \"core/Engines/abstractEngine\";\r\nimport { ThinDepthOfFieldMergePostProcess } from \"./thinDepthOfFieldMergePostProcess\";\r\n\r\n/**\r\n * The DepthOfFieldMergePostProcess merges blurred images with the original based on the values of the circle of confusion.\r\n */\r\nexport class DepthOfFieldMergePostProcess extends PostProcess {\r\n    /**\r\n     * Gets a string identifying the name of the class\r\n     * @returns \"DepthOfFieldMergePostProcess\" string\r\n     */\r\n    public override getClassName(): string {\r\n        return \"DepthOfFieldMergePostProcess\";\r\n    }\r\n\r\n    /**\r\n     * Creates a new instance of DepthOfFieldMergePostProcess\r\n     * @param name The name of the effect.\r\n     * @param originalFromInput Post process which's input will be used for the merge.\r\n     * @param circleOfConfusion Circle of confusion post process which's output will be used to blur each pixel.\r\n     * @param _blurSteps Blur post processes from low to high which will be mixed with the original image.\r\n     * @param options The required width/height ratio to downsize to before computing the render pass.\r\n     * @param camera The camera to apply the render pass to.\r\n     * @param samplingMode The sampling mode to be used when computing the pass. (default: 0)\r\n     * @param engine The engine which the post process will be applied. (default: current engine)\r\n     * @param reusable If the post process can be reused on the same frame. (default: false)\r\n     * @param textureType Type of textures used when performing the post process. (default: 0)\r\n     * @param blockCompilation If compilation of the shader should not be done in the constructor. The updateEffect method can be used to compile the shader at a later time. (default: false)\r\n     */\r\n    constructor(\r\n        name: string,\r\n        originalFromInput: PostProcess,\r\n        circleOfConfusion: PostProcess,\r\n        private _blurSteps: Array<PostProcess>,\r\n        options: number | PostProcessOptions,\r\n        camera: Nullable<Camera>,\r\n        samplingMode?: number,\r\n        engine?: AbstractEngine,\r\n        reusable?: boolean,\r\n        textureType = Constants.TEXTURETYPE_UNSIGNED_INT,\r\n        blockCompilation = false\r\n    ) {\r\n        const blockCompilationFinal = typeof options === \"number\" ? blockCompilation : !!options.blockCompilation;\r\n        const localOptions = {\r\n            samplers: ThinDepthOfFieldMergePostProcess.Samplers,\r\n            size: typeof options === \"number\" ? options : undefined,\r\n            camera,\r\n            samplingMode,\r\n            engine,\r\n            reusable,\r\n            textureType,\r\n            ...(options as PostProcessOptions),\r\n            blockCompilation: true,\r\n        };\r\n\r\n        super(name, ThinDepthOfFieldMergePostProcess.FragmentUrl, {\r\n            effectWrapper: typeof options === \"number\" || !options.effectWrapper ? new ThinDepthOfFieldMergePostProcess(name, engine, localOptions) : undefined,\r\n            ...localOptions,\r\n        });\r\n\r\n        this.externalTextureSamplerBinding = true;\r\n        this.onApplyObservable.add((effect: Effect) => {\r\n            effect.setTextureFromPostProcess(\"textureSampler\", originalFromInput);\r\n            effect.setTextureFromPostProcessOutput(\"circleOfConfusionSampler\", circleOfConfusion);\r\n            _blurSteps.forEach((step, index) => {\r\n                effect.setTextureFromPostProcessOutput(\"blurStep\" + (_blurSteps.length - index - 1), step);\r\n            });\r\n        });\r\n\r\n        if (!blockCompilationFinal) {\r\n            this.updateEffect();\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Updates the effect with the current post process compile time values and recompiles the shader.\r\n     * @param defines Define statements that should be added at the beginning of the shader. (default: null)\r\n     * @param uniforms Set of uniform variables that will be passed to the shader. (default: null)\r\n     * @param samplers Set of Texture2D variables that will be passed to the shader. (default: null)\r\n     * @param indexParameters The index parameters to be used for babylons include syntax \"#include<kernelBlurVaryingDeclaration>[0..varyingCount]\". (default: undefined) See usage in babylon.blurPostProcess.ts and kernelBlur.vertex.fx\r\n     * @param onCompiled Called when the shader has been compiled.\r\n     * @param onError Called if there is an error when compiling a shader.\r\n     */\r\n    public override updateEffect(\r\n        defines: Nullable<string> = null,\r\n        uniforms: Nullable<string[]> = null,\r\n        samplers: Nullable<string[]> = null,\r\n        indexParameters?: any,\r\n        onCompiled?: (effect: Effect) => void,\r\n        onError?: (effect: Effect, errors: string) => void\r\n    ) {\r\n        if (!defines) {\r\n            defines = \"\";\r\n            defines += \"#define BLUR_LEVEL \" + (this._blurSteps.length - 1) + \"\\n\";\r\n        }\r\n        super.updateEffect(defines, uniforms, samplers, indexParameters, onCompiled, onError);\r\n    }\r\n}\r\n"]}

package/PostProcesses/extractHighlightsPostProcess.d.ts

@@ -3,6 +3,7 @@ import type { Camera } from "../Cameras/camera";
 import type { PostProcessOptions } from "./postProcess";
 import { PostProcess } from "./postProcess";
 import type { AbstractEngine } from "../Engines/abstractEngine";
+import { ThinExtractHighlightsPostProcess } from "./thinExtractHighlightsPostProcess";
 /**
  * The extract highlights post process sets all pixels to black except pixels above the specified luminance threshold. Used as the first step for a bloom effect.
  */
@@ -10,9 +11,12 @@ export declare class ExtractHighlightsPostProcess extends PostProcess {
     /**
      * The luminance threshold, pixels below this value will be set to black.
      */
-    threshold: number;
+    get threshold(): number;
+    set threshold(value: number);
     /** @internal */
-    _exposure: number;
+    get _exposure(): number;
+    /** @internal */
+    set _exposure(value: number);
     /**
      * Post process which has the input texture to be used when performing highlight extraction
      * @internal
@@ -23,6 +27,6 @@ export declare class ExtractHighlightsPostProcess extends PostProcess {
      * @returns "ExtractHighlightsPostProcess" string
      */
     getClassName(): string;
-    constructor(name: string, options: number | PostProcessOptions, camera: Nullable<Camera>, samplingMode?: number, engine?: AbstractEngine, reusable?: boolean, textureType?: number, blockCompilation?: boolean);
-    protected _gatherImports(useWebGPU: boolean, list: Promise<any>[]): void;
+    protected _effectWrapper: ThinExtractHighlightsPostProcess;
+    constructor(name: string, options: number | PostProcessOptions, camera?: Nullable<Camera>, samplingMode?: number, engine?: AbstractEngine, reusable?: boolean, textureType?: number, blockCompilation?: boolean);
 }

package/PostProcesses/extractHighlightsPostProcess.js

@@ -1,13 +1,30 @@
 import { __decorate } from "../tslib.es6.js";
 import { PostProcess } from "./postProcess.js";
-import { ToGammaSpace } from "../Maths/math.constants.js";
 
 import { serialize } from "../Misc/decorators.js";
 import { RegisterClass } from "../Misc/typeStore.js";
+import { ThinExtractHighlightsPostProcess } from "./thinExtractHighlightsPostProcess.js";
 /**
  * The extract highlights post process sets all pixels to black except pixels above the specified luminance threshold. Used as the first step for a bloom effect.
  */
 export class ExtractHighlightsPostProcess extends PostProcess {
+    /**
+     * The luminance threshold, pixels below this value will be set to black.
+     */
+    get threshold() {
+        return this._effectWrapper.threshold;
+    }
+    set threshold(value) {
+        this._effectWrapper.threshold = value;
+    }
+    /** @internal */
+    get _exposure() {
+        return this._effectWrapper._exposure;
+    }
+    /** @internal */
+    set _exposure(value) {
+        this._effectWrapper._exposure = value;
+    }
     /**
      * Gets a string identifying the name of the class
      * @returns "ExtractHighlightsPostProcess" string
@@ -15,14 +32,22 @@ export class ExtractHighlightsPostProcess extends PostProcess {
     getClassName() {
         return "ExtractHighlightsPostProcess";
     }
-    constructor(name, options, camera, samplingMode, engine, reusable, textureType = 0, blockCompilation = false) {
-        super(name, "extractHighlights", ["threshold", "exposure"], null, options, camera, samplingMode, engine, reusable, null, textureType, undefined, null, blockCompilation);
-        /**
-         * The luminance threshold, pixels below this value will be set to black.
-         */
-        this.threshold = 0.9;
-        /** @internal */
-        this._exposure = 1;
+    constructor(name, options, camera = null, samplingMode, engine, reusable, textureType = 0, blockCompilation = false) {
+        const localOptions = {
+            uniforms: ThinExtractHighlightsPostProcess.Uniforms,
+            size: typeof options === "number" ? options : undefined,
+            camera,
+            samplingMode,
+            engine,
+            reusable,
+            textureType,
+            blockCompilation,
+            ...options,
+        };
+        super(name, ThinExtractHighlightsPostProcess.FragmentUrl, {
+            effectWrapper: typeof options === "number" || !options.effectWrapper ? new ThinExtractHighlightsPostProcess(name, engine, localOptions) : undefined,
+            ...localOptions,
+        });
         /**
          * Post process which has the input texture to be used when performing highlight extraction
          * @internal
@@ -33,23 +58,11 @@ export class ExtractHighlightsPostProcess extends PostProcess {
             if (this._inputPostProcess) {
                 effect.setTextureFromPostProcess("textureSampler", this._inputPostProcess);
             }
-            effect.setFloat("threshold", Math.pow(this.threshold, ToGammaSpace));
-            effect.setFloat("exposure", this._exposure);
         });
     }
-    _gatherImports(useWebGPU, list) {
-        if (useWebGPU) {
-            this._webGPUReady = true;
-            list.push(import("../ShadersWGSL/extractHighlights.fragment.js"));
-        }
-        else {
-            list.push(import("../Shaders/extractHighlights.fragment.js"));
-        }
-        super._gatherImports(useWebGPU, list);
-    }
 }
 __decorate([
     serialize()
-], ExtractHighlightsPostProcess.prototype, "threshold", void 0);
+], ExtractHighlightsPostProcess.prototype, "threshold", null);
 RegisterClass("BABYLON.ExtractHighlightsPostProcess", ExtractHighlightsPostProcess);
 //# sourceMappingURL=extractHighlightsPostProcess.js.map