@babylonjs/core 7.32.0 → 7.32.1

package/PostProcesses/thinBloomMergePostProcess.js

@@ -0,0 +1,38 @@
+import { EffectWrapper } from "../Materials/effectRenderer.js";
+import { Engine } from "../Engines/engine.js";
+/**
+ * @internal
+ */
+export class ThinBloomMergePostProcess extends EffectWrapper {
+    _gatherImports(useWebGPU, list) {
+        if (useWebGPU) {
+            this._webGPUReady = true;
+            list.push(import("../ShadersWGSL/bloomMerge.fragment.js"));
+        }
+        else {
+            list.push(import("../Shaders/bloomMerge.fragment.js"));
+        }
+    }
+    constructor(name, engine = null, options) {
+        super({
+            ...options,
+            name,
+            engine: engine || Engine.LastCreatedEngine,
+            useShaderStore: true,
+            useAsPostProcess: true,
+            fragmentShader: ThinBloomMergePostProcess.FragmentUrl,
+            uniforms: ThinBloomMergePostProcess.Uniforms,
+            samplers: ThinBloomMergePostProcess.Samplers,
+        });
+        /** Weight of the bloom to be added to the original input. */
+        this.weight = 1;
+    }
+    bind() {
+        super.bind();
+        this._drawWrapper.effect.setFloat("bloomWeight", this.weight);
+    }
+}
+ThinBloomMergePostProcess.FragmentUrl = "bloomMerge";
+ThinBloomMergePostProcess.Uniforms = ["bloomWeight"];
+ThinBloomMergePostProcess.Samplers = ["bloomBlur"];
+//# sourceMappingURL=thinBloomMergePostProcess.js.map

package/PostProcesses/thinBloomMergePostProcess.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"thinBloomMergePostProcess.js","sourceRoot":"","sources":["../../../../dev/core/src/PostProcesses/thinBloomMergePostProcess.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAC;AAC5D,OAAO,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAE3C;;GAEG;AACH,MAAM,OAAO,yBAA0B,SAAQ,aAAa;IAOrC,cAAc,CAAC,SAAkB,EAAE,IAAoB;QACtE,IAAI,SAAS,EAAE;YACX,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC;YACzB,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,oCAAoC,CAAC,CAAC,CAAC;SAC3D;aAAM;YACH,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,gCAAgC,CAAC,CAAC,CAAC;SACvD;IACL,CAAC;IAED,YAAY,IAAY,EAAE,SAAmC,IAAI,EAAE,OAAsC;QACrG,KAAK,CAAC;YACF,GAAG,OAAO;YACV,IAAI;YACJ,MAAM,EAAE,MAAM,IAAI,MAAM,CAAC,iBAAkB;YAC3C,cAAc,EAAE,IAAI;YACpB,gBAAgB,EAAE,IAAI;YACtB,cAAc,EAAE,yBAAyB,CAAC,WAAW;YACrD,QAAQ,EAAE,yBAAyB,CAAC,QAAQ;YAC5C,QAAQ,EAAE,yBAAyB,CAAC,QAAQ;SAC/C,CAAC,CAAC;QAGP,6DAA6D;QACtD,WAAM,GAAG,CAAC,CAAC;IAHlB,CAAC;IAKe,IAAI;QAChB,KAAK,CAAC,IAAI,EAAE,CAAC;QACb,IAAI,CAAC,YAAY,CAAC,MAAO,CAAC,QAAQ,CAAC,aAAa,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC;IACnE,CAAC;;AAlCsB,qCAAW,GAAG,YAAY,AAAf,CAAgB;AAE3B,kCAAQ,GAAG,CAAC,aAAa,CAAC,AAAlB,CAAmB;AAE3B,kCAAQ,GAAG,CAAC,WAAW,CAAC,AAAhB,CAAiB","sourcesContent":["// eslint-disable-next-line import/no-internal-modules\r\nimport type { Nullable, AbstractEngine, EffectWrapperCreationOptions } from \"core/index\";\r\nimport { EffectWrapper } from \"../Materials/effectRenderer\";\r\nimport { Engine } from \"../Engines/engine\";\r\n\r\n/**\r\n * @internal\r\n */\r\nexport class ThinBloomMergePostProcess extends EffectWrapper {\r\n    public static readonly FragmentUrl = \"bloomMerge\";\r\n\r\n    public static readonly Uniforms = [\"bloomWeight\"];\r\n\r\n    public static readonly Samplers = [\"bloomBlur\"];\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/bloomMerge.fragment\"));\r\n        } else {\r\n            list.push(import(\"../Shaders/bloomMerge.fragment\"));\r\n        }\r\n    }\r\n\r\n    constructor(name: string, engine: Nullable<AbstractEngine> = null, options?: EffectWrapperCreationOptions) {\r\n        super({\r\n            ...options,\r\n            name,\r\n            engine: engine || Engine.LastCreatedEngine!,\r\n            useShaderStore: true,\r\n            useAsPostProcess: true,\r\n            fragmentShader: ThinBloomMergePostProcess.FragmentUrl,\r\n            uniforms: ThinBloomMergePostProcess.Uniforms,\r\n            samplers: ThinBloomMergePostProcess.Samplers,\r\n        });\r\n    }\r\n\r\n    /** Weight of the bloom to be added to the original input. */\r\n    public weight = 1;\r\n\r\n    public override bind() {\r\n        super.bind();\r\n        this._drawWrapper.effect!.setFloat(\"bloomWeight\", this.weight);\r\n    }\r\n}\r\n"]}

package/PostProcesses/thinBlurPostProcess.d.ts

@@ -0,0 +1,89 @@
+import type { Nullable, AbstractEngine, EffectWrapperCreationOptions, Vector2, Effect } from "../index.js";
+import { EffectWrapper } from "../Materials/effectRenderer";
+/**
+ * Post process used to apply a blur effect
+ */
+export declare class ThinBlurPostProcess extends EffectWrapper {
+    /**
+     * The vertex shader url
+     */
+    static readonly VertexUrl = "kernelBlur";
+    /**
+     * The fragment shader url
+     */
+    static readonly FragmentUrl = "kernelBlur";
+    /**
+     * The list of uniforms used by the effect
+     */
+    static readonly Uniforms: string[];
+    /**
+     * The list of samplers used by the effect
+     */
+    static readonly Samplers: string[];
+    protected _gatherImports(useWebGPU: boolean, list: Promise<any>[]): void;
+    protected _kernel: number;
+    protected _idealKernel: number;
+    protected _packedFloat: boolean;
+    private _staticDefines;
+    /**
+     * Constructs a new blur post process
+     * @param name Name of the effect
+     * @param engine Engine to use to render the effect. If not provided, the last created engine will be used
+     * @param direction Direction in which to apply the blur
+     * @param kernel Kernel size of the blur
+     * @param options Options to configure the effect
+     */
+    constructor(name: string, engine?: Nullable<AbstractEngine>, direction?: Vector2, kernel?: number, options?: EffectWrapperCreationOptions);
+    /**
+     * Width of the texture to apply the blur on
+     */
+    textureWidth: number;
+    /**
+     * Height of the texture to apply the blur on
+     */
+    textureHeight: number;
+    /** The direction in which to blur the image. */
+    direction: Vector2;
+    /**
+     * Sets the length in pixels of the blur sample region
+     */
+    set kernel(v: number);
+    /**
+     * Gets the length in pixels of the blur sample region
+     */
+    get kernel(): number;
+    /**
+     * Sets whether or not the blur needs to unpack/repack floats
+     */
+    set packedFloat(v: boolean);
+    /**
+     * Gets whether or not the blur is unpacking/repacking floats
+     */
+    get packedFloat(): boolean;
+    bind(): void;
+    /** @internal */
+    _updateParameters(onCompiled?: (effect: Effect) => void, onError?: (effect: Effect, errors: string) => void): void;
+    /**
+     * Best kernels are odd numbers that when divided by 2, their integer part is even, so 5, 9 or 13.
+     * Other odd kernels optimize correctly but require proportionally more samples, even kernels are
+     * possible but will produce minor visual artifacts. Since each new kernel requires a new shader we
+     * want to minimize kernel changes, having gaps between physical kernels is helpful in that regard.
+     * The gaps between physical kernels are compensated for in the weighting of the samples
+     * @param idealKernel Ideal blur kernel.
+     * @returns Nearest best kernel.
+     */
+    protected _nearestBestKernel(idealKernel: number): number;
+    /**
+     * Calculates the value of a Gaussian distribution with sigma 3 at a given point.
+     * @param x The point on the Gaussian distribution to sample.
+     * @returns the value of the Gaussian function at x.
+     */
+    protected _gaussianWeight(x: number): number;
+    /**
+     * Generates a string that can be used as a floating point number in GLSL.
+     * @param x Value to print.
+     * @param decimalFigures Number of decimal places to print the number to (excluding trailing 0s).
+     * @returns GLSL float string.
+     */
+    protected _glslFloat(x: number, decimalFigures?: number): string;
+}

package/PostProcesses/thinBlurPostProcess.js

@@ -0,0 +1,242 @@
+import { EffectWrapper } from "../Materials/effectRenderer.js";
+import { Engine } from "../Engines/engine.js";
+/**
+ * Post process used to apply a blur effect
+ */
+export class ThinBlurPostProcess extends EffectWrapper {
+    _gatherImports(useWebGPU, list) {
+        if (useWebGPU) {
+            this._webGPUReady = true;
+            list.push(Promise.all([import("../ShadersWGSL/kernelBlur.fragment.js"), import("../ShadersWGSL/kernelBlur.vertex.js")]));
+        }
+        else {
+            list.push(Promise.all([import("../Shaders/kernelBlur.fragment.js"), import("../Shaders/kernelBlur.vertex.js")]));
+        }
+    }
+    /**
+     * Constructs a new blur post process
+     * @param name Name of the effect
+     * @param engine Engine to use to render the effect. If not provided, the last created engine will be used
+     * @param direction Direction in which to apply the blur
+     * @param kernel Kernel size of the blur
+     * @param options Options to configure the effect
+     */
+    constructor(name, engine = null, direction, kernel, options) {
+        const blockCompilationFinal = !!options?.blockCompilation;
+        super({
+            ...options,
+            name,
+            engine: engine || Engine.LastCreatedEngine,
+            useShaderStore: true,
+            useAsPostProcess: true,
+            fragmentShader: ThinBlurPostProcess.FragmentUrl,
+            uniforms: ThinBlurPostProcess.Uniforms,
+            samplers: ThinBlurPostProcess.Samplers,
+            vertexUrl: ThinBlurPostProcess.VertexUrl,
+            blockCompilation: true,
+        });
+        this._packedFloat = false;
+        this._staticDefines = "";
+        /**
+         * Width of the texture to apply the blur on
+         */
+        this.textureWidth = 0;
+        /**
+         * Height of the texture to apply the blur on
+         */
+        this.textureHeight = 0;
+        this.options.blockCompilation = blockCompilationFinal;
+        if (direction !== undefined) {
+            this.direction = direction;
+        }
+        if (kernel !== undefined) {
+            this.kernel = kernel;
+        }
+    }
+    /**
+     * Sets the length in pixels of the blur sample region
+     */
+    set kernel(v) {
+        if (this._idealKernel === v) {
+            return;
+        }
+        v = Math.max(v, 1);
+        this._idealKernel = v;
+        this._kernel = this._nearestBestKernel(v);
+        if (!this.options.blockCompilation) {
+            this._updateParameters();
+        }
+    }
+    /**
+     * Gets the length in pixels of the blur sample region
+     */
+    get kernel() {
+        return this._idealKernel;
+    }
+    /**
+     * Sets whether or not the blur needs to unpack/repack floats
+     */
+    set packedFloat(v) {
+        if (this._packedFloat === v) {
+            return;
+        }
+        this._packedFloat = v;
+        if (!this.options.blockCompilation) {
+            this._updateParameters();
+        }
+    }
+    /**
+     * Gets whether or not the blur is unpacking/repacking floats
+     */
+    get packedFloat() {
+        return this._packedFloat;
+    }
+    bind() {
+        super.bind();
+        this._drawWrapper.effect.setFloat2("delta", (1 / this.textureWidth) * this.direction.x, (1 / this.textureHeight) * this.direction.y);
+    }
+    /** @internal */
+    _updateParameters(onCompiled, onError) {
+        // Generate sampling offsets and weights
+        const N = this._kernel;
+        const centerIndex = (N - 1) / 2;
+        // Generate Gaussian sampling weights over kernel
+        let offsets = [];
+        let weights = [];
+        let totalWeight = 0;
+        for (let i = 0; i < N; i++) {
+            const u = i / (N - 1);
+            const w = this._gaussianWeight(u * 2.0 - 1);
+            offsets[i] = i - centerIndex;
+            weights[i] = w;
+            totalWeight += w;
+        }
+        // Normalize weights
+        for (let i = 0; i < weights.length; i++) {
+            weights[i] /= totalWeight;
+        }
+        // Optimize: combine samples to take advantage of hardware linear sampling
+        // Walk from left to center, combining pairs (symmetrically)
+        const linearSamplingWeights = [];
+        const linearSamplingOffsets = [];
+        const linearSamplingMap = [];
+        for (let i = 0; i <= centerIndex; i += 2) {
+            const j = Math.min(i + 1, Math.floor(centerIndex));
+            const singleCenterSample = i === j;
+            if (singleCenterSample) {
+                linearSamplingMap.push({ o: offsets[i], w: weights[i] });
+            }
+            else {
+                const sharedCell = j === centerIndex;
+                const weightLinear = weights[i] + weights[j] * (sharedCell ? 0.5 : 1);
+                const offsetLinear = offsets[i] + 1 / (1 + weights[i] / weights[j]);
+                if (offsetLinear === 0) {
+                    linearSamplingMap.push({ o: offsets[i], w: weights[i] });
+                    linearSamplingMap.push({ o: offsets[i + 1], w: weights[i + 1] });
+                }
+                else {
+                    linearSamplingMap.push({ o: offsetLinear, w: weightLinear });
+                    linearSamplingMap.push({ o: -offsetLinear, w: weightLinear });
+                }
+            }
+        }
+        for (let i = 0; i < linearSamplingMap.length; i++) {
+            linearSamplingOffsets[i] = linearSamplingMap[i].o;
+            linearSamplingWeights[i] = linearSamplingMap[i].w;
+        }
+        // Replace with optimized
+        offsets = linearSamplingOffsets;
+        weights = linearSamplingWeights;
+        // Generate shaders
+        const maxVaryingRows = this.options.engine.getCaps().maxVaryingVectors - (this.options.shaderLanguage === 1 /* ShaderLanguage.WGSL */ ? 1 : 0); // Because of the additional builtins
+        const freeVaryingVec2 = Math.max(maxVaryingRows, 0) - 1; // Because of sampleCenter
+        let varyingCount = Math.min(offsets.length, freeVaryingVec2);
+        let defines = "";
+        defines += this._staticDefines;
+        // The DOF fragment should ignore the center pixel when looping as it is handled manually in the fragment shader.
+        if (this._staticDefines.indexOf("DOF") != -1) {
+            defines += `#define CENTER_WEIGHT ${this._glslFloat(weights[varyingCount - 1])}\n`;
+            varyingCount--;
+        }
+        for (let i = 0; i < varyingCount; i++) {
+            defines += `#define KERNEL_OFFSET${i} ${this._glslFloat(offsets[i])}\n`;
+            defines += `#define KERNEL_WEIGHT${i} ${this._glslFloat(weights[i])}\n`;
+        }
+        let depCount = 0;
+        for (let i = freeVaryingVec2; i < offsets.length; i++) {
+            defines += `#define KERNEL_DEP_OFFSET${depCount} ${this._glslFloat(offsets[i])}\n`;
+            defines += `#define KERNEL_DEP_WEIGHT${depCount} ${this._glslFloat(weights[i])}\n`;
+            depCount++;
+        }
+        if (this.packedFloat) {
+            defines += `#define PACKEDFLOAT 1`;
+        }
+        this.options.blockCompilation = false;
+        this.updateEffect(defines, null, null, {
+            varyingCount: varyingCount,
+            depCount: depCount,
+        }, onCompiled, onError);
+    }
+    /**
+     * Best kernels are odd numbers that when divided by 2, their integer part is even, so 5, 9 or 13.
+     * Other odd kernels optimize correctly but require proportionally more samples, even kernels are
+     * possible but will produce minor visual artifacts. Since each new kernel requires a new shader we
+     * want to minimize kernel changes, having gaps between physical kernels is helpful in that regard.
+     * The gaps between physical kernels are compensated for in the weighting of the samples
+     * @param idealKernel Ideal blur kernel.
+     * @returns Nearest best kernel.
+     */
+    _nearestBestKernel(idealKernel) {
+        const v = Math.round(idealKernel);
+        for (const k of [v, v - 1, v + 1, v - 2, v + 2]) {
+            if (k % 2 !== 0 && Math.floor(k / 2) % 2 === 0 && k > 0) {
+                return Math.max(k, 3);
+            }
+        }
+        return Math.max(v, 3);
+    }
+    /**
+     * Calculates the value of a Gaussian distribution with sigma 3 at a given point.
+     * @param x The point on the Gaussian distribution to sample.
+     * @returns the value of the Gaussian function at x.
+     */
+    _gaussianWeight(x) {
+        //reference: Engines/ImageProcessingBlur.cpp #dcc760
+        // We are evaluating the Gaussian (normal) distribution over a kernel parameter space of [-1,1],
+        // so we truncate at three standard deviations by setting stddev (sigma) to 1/3.
+        // The choice of 3-sigma truncation is common but arbitrary, and means that the signal is
+        // truncated at around 1.3% of peak strength.
+        //the distribution is scaled to account for the difference between the actual kernel size and the requested kernel size
+        const sigma = 1 / 3;
+        const denominator = Math.sqrt(2.0 * Math.PI) * sigma;
+        const exponent = -((x * x) / (2.0 * sigma * sigma));
+        const weight = (1.0 / denominator) * Math.exp(exponent);
+        return weight;
+    }
+    /**
+     * Generates a string that can be used as a floating point number in GLSL.
+     * @param x Value to print.
+     * @param decimalFigures Number of decimal places to print the number to (excluding trailing 0s).
+     * @returns GLSL float string.
+     */
+    _glslFloat(x, decimalFigures = 8) {
+        return x.toFixed(decimalFigures).replace(/0+$/, "");
+    }
+}
+/**
+ * The vertex shader url
+ */
+ThinBlurPostProcess.VertexUrl = "kernelBlur";
+/**
+ * The fragment shader url
+ */
+ThinBlurPostProcess.FragmentUrl = "kernelBlur";
+/**
+ * The list of uniforms used by the effect
+ */
+ThinBlurPostProcess.Uniforms = ["delta", "direction"];
+/**
+ * The list of samplers used by the effect
+ */
+ThinBlurPostProcess.Samplers = ["circleOfConfusionSampler"];
+//# sourceMappingURL=thinBlurPostProcess.js.map

package/PostProcesses/thinBlurPostProcess.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"thinBlurPostProcess.js","sourceRoot":"","sources":["../../../../dev/core/src/PostProcesses/thinBlurPostProcess.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAC;AAE5D,OAAO,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAE3C;;GAEG;AACH,MAAM,OAAO,mBAAoB,SAAQ,aAAa;IAqB/B,cAAc,CAAC,SAAkB,EAAE,IAAoB;QACtE,IAAI,SAAS,EAAE;YACX,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC;YACzB,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,MAAM,CAAC,oCAAoC,CAAC,EAAE,MAAM,CAAC,kCAAkC,CAAC,CAAC,CAAC,CAAC,CAAC;SACtH;aAAM;YACH,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,MAAM,CAAC,gCAAgC,CAAC,EAAE,MAAM,CAAC,8BAA8B,CAAC,CAAC,CAAC,CAAC,CAAC;SAC9G;IACL,CAAC;IAOD;;;;;;;OAOG;IACH,YAAY,IAAY,EAAE,SAAmC,IAAI,EAAE,SAAmB,EAAE,MAAe,EAAE,OAAsC;QAC3I,MAAM,qBAAqB,GAAG,CAAC,CAAC,OAAO,EAAE,gBAAgB,CAAC;QAC1D,KAAK,CAAC;YACF,GAAG,OAAO;YACV,IAAI;YACJ,MAAM,EAAE,MAAM,IAAI,MAAM,CAAC,iBAAkB;YAC3C,cAAc,EAAE,IAAI;YACpB,gBAAgB,EAAE,IAAI;YACtB,cAAc,EAAE,mBAAmB,CAAC,WAAW;YAC/C,QAAQ,EAAE,mBAAmB,CAAC,QAAQ;YACtC,QAAQ,EAAE,mBAAmB,CAAC,QAAQ;YACtC,SAAS,EAAE,mBAAmB,CAAC,SAAS;YACxC,gBAAgB,EAAE,IAAI;SACzB,CAAC,CAAC;QAxBG,iBAAY,GAAY,KAAK,CAAC;QAChC,mBAAc,GAAW,EAAE,CAAC;QAmCpC;;WAEG;QACI,iBAAY,GAAW,CAAC,CAAC;QAEhC;;WAEG;QACI,kBAAa,GAAW,CAAC,CAAC;QAlB7B,IAAI,CAAC,OAAO,CAAC,gBAAgB,GAAG,qBAAqB,CAAC;QAEtD,IAAI,SAAS,KAAK,SAAS,EAAE;YACzB,IAAI,CAAC,SAAS,GAAG,SAAS,CAAC;SAC9B;QACD,IAAI,MAAM,KAAK,SAAS,EAAE;YACtB,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;SACxB;IACL,CAAC;IAeD;;OAEG;IACH,IAAW,MAAM,CAAC,CAAS;QACvB,IAAI,IAAI,CAAC,YAAY,KAAK,CAAC,EAAE;YACzB,OAAO;SACV;QAED,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;QACnB,IAAI,CAAC,YAAY,GAAG,CAAC,CAAC;QACtB,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC,kBAAkB,CAAC,CAAC,CAAC,CAAC;QAC1C,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,gBAAgB,EAAE;YAChC,IAAI,CAAC,iBAAiB,EAAE,CAAC;SAC5B;IACL,CAAC;IAED;;OAEG;IACH,IAAW,MAAM;QACb,OAAO,IAAI,CAAC,YAAY,CAAC;IAC7B,CAAC;IAED;;OAEG;IACH,IAAW,WAAW,CAAC,CAAU;QAC7B,IAAI,IAAI,CAAC,YAAY,KAAK,CAAC,EAAE;YACzB,OAAO;SACV;QACD,IAAI,CAAC,YAAY,GAAG,CAAC,CAAC;QACtB,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,gBAAgB,EAAE;YAChC,IAAI,CAAC,iBAAiB,EAAE,CAAC;SAC5B;IACL,CAAC;IAED;;OAEG;IACH,IAAW,WAAW;QAClB,OAAO,IAAI,CAAC,YAAY,CAAC;IAC7B,CAAC;IAEe,IAAI;QAChB,KAAK,CAAC,IAAI,EAAE,CAAC;QACb,IAAI,CAAC,YAAY,CAAC,MAAO,CAAC,SAAS,CAAC,OAAO,EAAE,CAAC,CAAC,GAAG,IAAI,CAAC,YAAY,CAAC,GAAG,IAAI,CAAC,SAAS,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,IAAI,CAAC,aAAa,CAAC,GAAG,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC;IAC1I,CAAC;IAED,gBAAgB;IACT,iBAAiB,CAAC,UAAqC,EAAE,OAAkD;QAC9G,wCAAwC;QACxC,MAAM,CAAC,GAAG,IAAI,CAAC,OAAO,CAAC;QACvB,MAAM,WAAW,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC;QAEhC,iDAAiD;QACjD,IAAI,OAAO,GAAG,EAAE,CAAC;QACjB,IAAI,OAAO,GAAG,EAAE,CAAC;QACjB,IAAI,WAAW,GAAG,CAAC,CAAC;QACpB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE,EAAE;YACxB,MAAM,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;YACtB,MAAM,CAAC,GAAG,IAAI,CAAC,eAAe,CAAC,CAAC,GAAG,GAAG,GAAG,CAAC,CAAC,CAAC;YAC5C,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,GAAG,WAAW,CAAC;YAC7B,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;YACf,WAAW,IAAI,CAAC,CAAC;SACpB;QAED,oBAAoB;QACpB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;YACrC,OAAO,CAAC,CAAC,CAAC,IAAI,WAAW,CAAC;SAC7B;QAED,0EAA0E;QAC1E,4DAA4D;QAC5D,MAAM,qBAAqB,GAAG,EAAE,CAAC;QACjC,MAAM,qBAAqB,GAAG,EAAE,CAAC;QAEjC,MAAM,iBAAiB,GAAG,EAAE,CAAC;QAE7B,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,IAAI,WAAW,EAAE,CAAC,IAAI,CAAC,EAAE;YACtC,MAAM,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,EAAE,IAAI,CAAC,KAAK,CAAC,WAAW,CAAC,CAAC,CAAC;YAEnD,MAAM,kBAAkB,GAAG,CAAC,KAAK,CAAC,CAAC;YAEnC,IAAI,kBAAkB,EAAE;gBACpB,iBAAiB,CAAC,IAAI,CAAC,EAAE,CAAC,EAAE,OAAO,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,OAAO,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;aAC5D;iBAAM;gBACH,MAAM,UAAU,GAAG,CAAC,KAAK,WAAW,CAAC;gBAErC,MAAM,YAAY,GAAG,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;gBACtE,MAAM,YAAY,GAAG,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC;gBAEpE,IAAI,YAAY,KAAK,CAAC,EAAE;oBACpB,iBAAiB,CAAC,IAAI,CAAC,EAAE,CAAC,EAAE,OAAO,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,OAAO,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;oBACzD,iBAAiB,CAAC,IAAI,CAAC,EAAE,CAAC,EAAE,OAAO,CAAC,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,EAAE,OAAO,CAAC,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC;iBACpE;qBAAM;oBACH,iBAAiB,CAAC,IAAI,CAAC,EAAE,CAAC,EAAE,YAAY,EAAE,CAAC,EAAE,YAAY,EAAE,CAAC,CAAC;oBAC7D,iBAAiB,CAAC,IAAI,CAAC,EAAE,CAAC,EAAE,CAAC,YAAY,EAAE,CAAC,EAAE,YAAY,EAAE,CAAC,CAAC;iBACjE;aACJ;SACJ;QAED,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,iBAAiB,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;YAC/C,qBAAqB,CAAC,CAAC,CAAC,GAAG,iBAAiB,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;YAClD,qBAAqB,CAAC,CAAC,CAAC,GAAG,iBAAiB,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;SACrD;QAED,yBAAyB;QACzB,OAAO,GAAG,qBAAqB,CAAC;QAChC,OAAO,GAAG,qBAAqB,CAAC;QAEhC,mBAAmB;QACnB,MAAM,cAAc,GAAG,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,OAAO,EAAE,CAAC,iBAAiB,GAAG,CAAC,IAAI,CAAC,OAAO,CAAC,cAAc,gCAAwB,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,qCAAqC;QAC7K,MAAM,eAAe,GAAG,IAAI,CAAC,GAAG,CAAC,cAAc,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,0BAA0B;QAEnF,IAAI,YAAY,GAAG,IAAI,CAAC,GAAG,CAAC,OAAO,CAAC,MAAM,EAAE,eAAe,CAAC,CAAC;QAE7D,IAAI,OAAO,GAAG,EAAE,CAAC;QACjB,OAAO,IAAI,IAAI,CAAC,cAAc,CAAC;QAE/B,iHAAiH;QACjH,IAAI,IAAI,CAAC,cAAc,CAAC,OAAO,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,EAAE;YAC1C,OAAO,IAAI,yBAAyB,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC,YAAY,GAAG,CAAC,CAAC,CAAC,IAAI,CAAC;YACnF,YAAY,EAAE,CAAC;SAClB;QAED,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,YAAY,EAAE,CAAC,EAAE,EAAE;YACnC,OAAO,IAAI,wBAAwB,CAAC,IAAI,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;YACxE,OAAO,IAAI,wBAAwB,CAAC,IAAI,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;SAC3E;QAED,IAAI,QAAQ,GAAG,CAAC,CAAC;QACjB,KAAK,IAAI,CAAC,GAAG,eAAe,EAAE,CAAC,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;YACnD,OAAO,IAAI,4BAA4B,QAAQ,IAAI,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;YACnF,OAAO,IAAI,4BAA4B,QAAQ,IAAI,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;YACnF,QAAQ,EAAE,CAAC;SACd;QAED,IAAI,IAAI,CAAC,WAAW,EAAE;YAClB,OAAO,IAAI,uBAAuB,CAAC;SACtC;QAED,IAAI,CAAC,OAAO,CAAC,gBAAgB,GAAG,KAAK,CAAC;QAEtC,IAAI,CAAC,YAAY,CACb,OAAO,EACP,IAAI,EACJ,IAAI,EACJ;YACI,YAAY,EAAE,YAAY;YAC1B,QAAQ,EAAE,QAAQ;SACrB,EACD,UAAU,EACV,OAAO,CACV,CAAC;IACN,CAAC;IAED;;;;;;;;OAQG;IACO,kBAAkB,CAAC,WAAmB;QAC5C,MAAM,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,WAAW,CAAC,CAAC;QAClC,KAAK,MAAM,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC,EAAE;YAC7C,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,IAAI,IAAI,CAAC,KAAK,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE;gBACrD,OAAO,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;aACzB;SACJ;QACD,OAAO,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;IAC1B,CAAC;IAED;;;;OAIG;IACO,eAAe,CAAC,CAAS;QAC/B,oDAAoD;QACpD,gGAAgG;QAChG,gFAAgF;QAChF,yFAAyF;QACzF,6CAA6C;QAE7C,uHAAuH;QACvH,MAAM,KAAK,GAAG,CAAC,GAAG,CAAC,CAAC;QACpB,MAAM,WAAW,GAAG,IAAI,CAAC,IAAI,CAAC,GAAG,GAAG,IAAI,CAAC,EAAE,CAAC,GAAG,KAAK,CAAC;QACrD,MAAM,QAAQ,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,GAAG,GAAG,KAAK,GAAG,KAAK,CAAC,CAAC,CAAC;QACpD,MAAM,MAAM,GAAG,CAAC,GAAG,GAAG,WAAW,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;QACxD,OAAO,MAAM,CAAC;IAClB,CAAC;IAED;;;;;OAKG;IACO,UAAU,CAAC,CAAS,EAAE,cAAc,GAAG,CAAC;QAC9C,OAAO,CAAC,CAAC,OAAO,CAAC,cAAc,CAAC,CAAC,OAAO,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;IACxD,CAAC;;AA3RD;;GAEG;AACoB,6BAAS,GAAG,YAAY,AAAf,CAAgB;AAEhD;;GAEG;AACoB,+BAAW,GAAG,YAAY,AAAf,CAAgB;AAElD;;GAEG;AACoB,4BAAQ,GAAG,CAAC,OAAO,EAAE,WAAW,CAAC,AAAzB,CAA0B;AAEzD;;GAEG;AACoB,4BAAQ,GAAG,CAAC,0BAA0B,CAAC,AAA/B,CAAgC","sourcesContent":["// eslint-disable-next-line import/no-internal-modules\r\nimport type { Nullable, AbstractEngine, EffectWrapperCreationOptions, Vector2, Effect } from \"core/index\";\r\nimport { EffectWrapper } from \"../Materials/effectRenderer\";\r\nimport { ShaderLanguage } from \"../Materials/shaderLanguage\";\r\nimport { Engine } from \"../Engines/engine\";\r\n\r\n/**\r\n * Post process used to apply a blur effect\r\n */\r\nexport class ThinBlurPostProcess extends EffectWrapper {\r\n    /**\r\n     * The vertex shader url\r\n     */\r\n    public static readonly VertexUrl = \"kernelBlur\";\r\n\r\n    /**\r\n     * The fragment shader url\r\n     */\r\n    public static readonly FragmentUrl = \"kernelBlur\";\r\n\r\n    /**\r\n     * The list of uniforms used by the effect\r\n     */\r\n    public static readonly Uniforms = [\"delta\", \"direction\"];\r\n\r\n    /**\r\n     * The list of samplers used by the effect\r\n     */\r\n    public static readonly Samplers = [\"circleOfConfusionSampler\"];\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(Promise.all([import(\"../ShadersWGSL/kernelBlur.fragment\"), import(\"../ShadersWGSL/kernelBlur.vertex\")]));\r\n        } else {\r\n            list.push(Promise.all([import(\"../Shaders/kernelBlur.fragment\"), import(\"../Shaders/kernelBlur.vertex\")]));\r\n        }\r\n    }\r\n\r\n    protected _kernel: number;\r\n    protected _idealKernel: number;\r\n    protected _packedFloat: boolean = false;\r\n    private _staticDefines: string = \"\";\r\n\r\n    /**\r\n     * Constructs a new blur post process\r\n     * @param name Name of the effect\r\n     * @param engine Engine to use to render the effect. If not provided, the last created engine will be used\r\n     * @param direction Direction in which to apply the blur\r\n     * @param kernel Kernel size of the blur\r\n     * @param options Options to configure the effect\r\n     */\r\n    constructor(name: string, engine: Nullable<AbstractEngine> = null, direction?: Vector2, kernel?: number, options?: EffectWrapperCreationOptions) {\r\n        const blockCompilationFinal = !!options?.blockCompilation;\r\n        super({\r\n            ...options,\r\n            name,\r\n            engine: engine || Engine.LastCreatedEngine!,\r\n            useShaderStore: true,\r\n            useAsPostProcess: true,\r\n            fragmentShader: ThinBlurPostProcess.FragmentUrl,\r\n            uniforms: ThinBlurPostProcess.Uniforms,\r\n            samplers: ThinBlurPostProcess.Samplers,\r\n            vertexUrl: ThinBlurPostProcess.VertexUrl,\r\n            blockCompilation: true,\r\n        });\r\n\r\n        this.options.blockCompilation = blockCompilationFinal;\r\n\r\n        if (direction !== undefined) {\r\n            this.direction = direction;\r\n        }\r\n        if (kernel !== undefined) {\r\n            this.kernel = kernel;\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Width of the texture to apply the blur on\r\n     */\r\n    public textureWidth: number = 0;\r\n\r\n    /**\r\n     * Height of the texture to apply the blur on\r\n     */\r\n    public textureHeight: number = 0;\r\n\r\n    /** The direction in which to blur the image. */\r\n    public direction: Vector2;\r\n\r\n    /**\r\n     * Sets the length in pixels of the blur sample region\r\n     */\r\n    public set kernel(v: number) {\r\n        if (this._idealKernel === v) {\r\n            return;\r\n        }\r\n\r\n        v = Math.max(v, 1);\r\n        this._idealKernel = v;\r\n        this._kernel = this._nearestBestKernel(v);\r\n        if (!this.options.blockCompilation) {\r\n            this._updateParameters();\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Gets the length in pixels of the blur sample region\r\n     */\r\n    public get kernel(): number {\r\n        return this._idealKernel;\r\n    }\r\n\r\n    /**\r\n     * Sets whether or not the blur needs to unpack/repack floats\r\n     */\r\n    public set packedFloat(v: boolean) {\r\n        if (this._packedFloat === v) {\r\n            return;\r\n        }\r\n        this._packedFloat = v;\r\n        if (!this.options.blockCompilation) {\r\n            this._updateParameters();\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Gets whether or not the blur is unpacking/repacking floats\r\n     */\r\n    public get packedFloat(): boolean {\r\n        return this._packedFloat;\r\n    }\r\n\r\n    public override bind() {\r\n        super.bind();\r\n        this._drawWrapper.effect!.setFloat2(\"delta\", (1 / this.textureWidth) * this.direction.x, (1 / this.textureHeight) * this.direction.y);\r\n    }\r\n\r\n    /** @internal */\r\n    public _updateParameters(onCompiled?: (effect: Effect) => void, onError?: (effect: Effect, errors: string) => void): void {\r\n        // Generate sampling offsets and weights\r\n        const N = this._kernel;\r\n        const centerIndex = (N - 1) / 2;\r\n\r\n        // Generate Gaussian sampling weights over kernel\r\n        let offsets = [];\r\n        let weights = [];\r\n        let totalWeight = 0;\r\n        for (let i = 0; i < N; i++) {\r\n            const u = i / (N - 1);\r\n            const w = this._gaussianWeight(u * 2.0 - 1);\r\n            offsets[i] = i - centerIndex;\r\n            weights[i] = w;\r\n            totalWeight += w;\r\n        }\r\n\r\n        // Normalize weights\r\n        for (let i = 0; i < weights.length; i++) {\r\n            weights[i] /= totalWeight;\r\n        }\r\n\r\n        // Optimize: combine samples to take advantage of hardware linear sampling\r\n        // Walk from left to center, combining pairs (symmetrically)\r\n        const linearSamplingWeights = [];\r\n        const linearSamplingOffsets = [];\r\n\r\n        const linearSamplingMap = [];\r\n\r\n        for (let i = 0; i <= centerIndex; i += 2) {\r\n            const j = Math.min(i + 1, Math.floor(centerIndex));\r\n\r\n            const singleCenterSample = i === j;\r\n\r\n            if (singleCenterSample) {\r\n                linearSamplingMap.push({ o: offsets[i], w: weights[i] });\r\n            } else {\r\n                const sharedCell = j === centerIndex;\r\n\r\n                const weightLinear = weights[i] + weights[j] * (sharedCell ? 0.5 : 1);\r\n                const offsetLinear = offsets[i] + 1 / (1 + weights[i] / weights[j]);\r\n\r\n                if (offsetLinear === 0) {\r\n                    linearSamplingMap.push({ o: offsets[i], w: weights[i] });\r\n                    linearSamplingMap.push({ o: offsets[i + 1], w: weights[i + 1] });\r\n                } else {\r\n                    linearSamplingMap.push({ o: offsetLinear, w: weightLinear });\r\n                    linearSamplingMap.push({ o: -offsetLinear, w: weightLinear });\r\n                }\r\n            }\r\n        }\r\n\r\n        for (let i = 0; i < linearSamplingMap.length; i++) {\r\n            linearSamplingOffsets[i] = linearSamplingMap[i].o;\r\n            linearSamplingWeights[i] = linearSamplingMap[i].w;\r\n        }\r\n\r\n        // Replace with optimized\r\n        offsets = linearSamplingOffsets;\r\n        weights = linearSamplingWeights;\r\n\r\n        // Generate shaders\r\n        const maxVaryingRows = this.options.engine.getCaps().maxVaryingVectors - (this.options.shaderLanguage === ShaderLanguage.WGSL ? 1 : 0); // Because of the additional builtins\r\n        const freeVaryingVec2 = Math.max(maxVaryingRows, 0) - 1; // Because of sampleCenter\r\n\r\n        let varyingCount = Math.min(offsets.length, freeVaryingVec2);\r\n\r\n        let defines = \"\";\r\n        defines += this._staticDefines;\r\n\r\n        // The DOF fragment should ignore the center pixel when looping as it is handled manually in the fragment shader.\r\n        if (this._staticDefines.indexOf(\"DOF\") != -1) {\r\n            defines += `#define CENTER_WEIGHT ${this._glslFloat(weights[varyingCount - 1])}\\n`;\r\n            varyingCount--;\r\n        }\r\n\r\n        for (let i = 0; i < varyingCount; i++) {\r\n            defines += `#define KERNEL_OFFSET${i} ${this._glslFloat(offsets[i])}\\n`;\r\n            defines += `#define KERNEL_WEIGHT${i} ${this._glslFloat(weights[i])}\\n`;\r\n        }\r\n\r\n        let depCount = 0;\r\n        for (let i = freeVaryingVec2; i < offsets.length; i++) {\r\n            defines += `#define KERNEL_DEP_OFFSET${depCount} ${this._glslFloat(offsets[i])}\\n`;\r\n            defines += `#define KERNEL_DEP_WEIGHT${depCount} ${this._glslFloat(weights[i])}\\n`;\r\n            depCount++;\r\n        }\r\n\r\n        if (this.packedFloat) {\r\n            defines += `#define PACKEDFLOAT 1`;\r\n        }\r\n\r\n        this.options.blockCompilation = false;\r\n\r\n        this.updateEffect(\r\n            defines,\r\n            null,\r\n            null,\r\n            {\r\n                varyingCount: varyingCount,\r\n                depCount: depCount,\r\n            },\r\n            onCompiled,\r\n            onError\r\n        );\r\n    }\r\n\r\n    /**\r\n     * Best kernels are odd numbers that when divided by 2, their integer part is even, so 5, 9 or 13.\r\n     * Other odd kernels optimize correctly but require proportionally more samples, even kernels are\r\n     * possible but will produce minor visual artifacts. Since each new kernel requires a new shader we\r\n     * want to minimize kernel changes, having gaps between physical kernels is helpful in that regard.\r\n     * The gaps between physical kernels are compensated for in the weighting of the samples\r\n     * @param idealKernel Ideal blur kernel.\r\n     * @returns Nearest best kernel.\r\n     */\r\n    protected _nearestBestKernel(idealKernel: number): number {\r\n        const v = Math.round(idealKernel);\r\n        for (const k of [v, v - 1, v + 1, v - 2, v + 2]) {\r\n            if (k % 2 !== 0 && Math.floor(k / 2) % 2 === 0 && k > 0) {\r\n                return Math.max(k, 3);\r\n            }\r\n        }\r\n        return Math.max(v, 3);\r\n    }\r\n\r\n    /**\r\n     * Calculates the value of a Gaussian distribution with sigma 3 at a given point.\r\n     * @param x The point on the Gaussian distribution to sample.\r\n     * @returns the value of the Gaussian function at x.\r\n     */\r\n    protected _gaussianWeight(x: number): number {\r\n        //reference: Engines/ImageProcessingBlur.cpp #dcc760\r\n        // We are evaluating the Gaussian (normal) distribution over a kernel parameter space of [-1,1],\r\n        // so we truncate at three standard deviations by setting stddev (sigma) to 1/3.\r\n        // The choice of 3-sigma truncation is common but arbitrary, and means that the signal is\r\n        // truncated at around 1.3% of peak strength.\r\n\r\n        //the distribution is scaled to account for the difference between the actual kernel size and the requested kernel size\r\n        const sigma = 1 / 3;\r\n        const denominator = Math.sqrt(2.0 * Math.PI) * sigma;\r\n        const exponent = -((x * x) / (2.0 * sigma * sigma));\r\n        const weight = (1.0 / denominator) * Math.exp(exponent);\r\n        return weight;\r\n    }\r\n\r\n    /**\r\n     * Generates a string that can be used as a floating point number in GLSL.\r\n     * @param x Value to print.\r\n     * @param decimalFigures Number of decimal places to print the number to (excluding trailing 0s).\r\n     * @returns GLSL float string.\r\n     */\r\n    protected _glslFloat(x: number, decimalFigures = 8) {\r\n        return x.toFixed(decimalFigures).replace(/0+$/, \"\");\r\n    }\r\n}\r\n"]}

package/PostProcesses/thinCircleOfConfusionPostProcess.d.ts

@@ -0,0 +1,62 @@
+import type { Nullable, AbstractEngine, EffectWrapperCreationOptions } from "../index.js";
+import { EffectWrapper } from "../Materials/effectRenderer";
+import type { Camera } from "../Cameras/camera.js";
+/**
+ * Options used to create a ThinCircleOfConfusionPostProcess.
+ */
+export interface ThinCircleOfConfusionPostProcessOptions extends EffectWrapperCreationOptions {
+    /**
+     * If the (view) depth is normalized (0.0 to 1.0 from near to far) or not (0 to camera max distance)
+     */
+    depthNotNormalized?: boolean;
+}
+/**
+ * Post process used to calculate the circle of confusion (used for depth of field, for example)
+ */
+export declare class ThinCircleOfConfusionPostProcess extends EffectWrapper {
+    /**
+     * The fragment shader url
+     */
+    static readonly FragmentUrl = "circleOfConfusion";
+    /**
+     * The list of uniforms used by the effect
+     */
+    static readonly Uniforms: string[];
+    /**
+     * The list of samplers used by the effect
+     */
+    static readonly Samplers: string[];
+    /**
+     * Defines if the depth is normalized or not
+     */
+    static readonly DefinesDepthNotNormalized = "#define COC_DEPTH_NOT_NORMALIZED";
+    protected _gatherImports(useWebGPU: boolean, list: Promise<any>[]): void;
+    /**
+     * Constructs a new circle of confusion post process
+     * @param name Name of the effect
+     * @param engine Engine to use to render the effect. If not provided, the last created engine will be used
+     * @param options Options to configure the effect
+     */
+    constructor(name: string, engine?: Nullable<AbstractEngine>, options?: ThinCircleOfConfusionPostProcessOptions);
+    /**
+     * The camera to use to calculate the circle of confusion
+     */
+    camera: Camera;
+    /**
+     * 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.
+     */
+    lensSize: number;
+    /**
+     * F-Stop of the effect's camera. The diameter of the resulting aperture can be computed by lensSize/fStop. (default: 1.4)
+     */
+    fStop: number;
+    /**
+     * Distance away from the camera to focus on in scene units/1000 (eg. millimeter). (default: 2000)
+     */
+    focusDistance: number;
+    /**
+     * Focal length of the effect's camera in scene units/1000 (eg. millimeter). (default: 50)
+     */
+    focalLength: number;
+    bind(): void;
+}

package/PostProcesses/thinCircleOfConfusionPostProcess.js

@@ -0,0 +1,81 @@
+import { EffectWrapper } from "../Materials/effectRenderer.js";
+import { Engine } from "../Engines/engine.js";
+/**
+ * Post process used to calculate the circle of confusion (used for depth of field, for example)
+ */
+export class ThinCircleOfConfusionPostProcess extends EffectWrapper {
+    _gatherImports(useWebGPU, list) {
+        if (useWebGPU) {
+            this._webGPUReady = true;
+            list.push(import("../ShadersWGSL/circleOfConfusion.fragment.js"));
+        }
+        else {
+            list.push(import("../Shaders/circleOfConfusion.fragment.js"));
+        }
+    }
+    /**
+     * Constructs a new circle of confusion post process
+     * @param name Name of the effect
+     * @param engine Engine to use to render the effect. If not provided, the last created engine will be used
+     * @param options Options to configure the effect
+     */
+    constructor(name, engine = null, options) {
+        super({
+            ...options,
+            name,
+            engine: engine || Engine.LastCreatedEngine,
+            useShaderStore: true,
+            useAsPostProcess: true,
+            fragmentShader: ThinCircleOfConfusionPostProcess.FragmentUrl,
+            uniforms: ThinCircleOfConfusionPostProcess.Uniforms,
+            samplers: ThinCircleOfConfusionPostProcess.Samplers,
+            defines: options?.depthNotNormalized ? ThinCircleOfConfusionPostProcess.DefinesDepthNotNormalized : undefined,
+        });
+        /**
+         * 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.
+         */
+        this.lensSize = 50;
+        /**
+         * F-Stop of the effect's camera. The diameter of the resulting aperture can be computed by lensSize/fStop. (default: 1.4)
+         */
+        this.fStop = 1.4;
+        /**
+         * Distance away from the camera to focus on in scene units/1000 (eg. millimeter). (default: 2000)
+         */
+        this.focusDistance = 2000;
+        /**
+         * Focal length of the effect's camera in scene units/1000 (eg. millimeter). (default: 50)
+         */
+        this.focalLength = 50;
+    }
+    bind() {
+        super.bind();
+        const options = this.options;
+        const effect = this._drawWrapper.effect;
+        if (!options.depthNotNormalized) {
+            effect.setFloat2("cameraMinMaxZ", this.camera.minZ, this.camera.maxZ - this.camera.minZ);
+        }
+        // Circle of confusion calculation, See https://developer.nvidia.com/gpugems/GPUGems/gpugems_ch23.html
+        const aperture = this.lensSize / this.fStop;
+        const cocPrecalculation = (aperture * this.focalLength) / (this.focusDistance - this.focalLength); // * ((this.focusDistance - pixelDistance)/pixelDistance) [This part is done in shader]
+        effect.setFloat("focusDistance", this.focusDistance);
+        effect.setFloat("cocPrecalculation", cocPrecalculation);
+    }
+}
+/**
+ * The fragment shader url
+ */
+ThinCircleOfConfusionPostProcess.FragmentUrl = "circleOfConfusion";
+/**
+ * The list of uniforms used by the effect
+ */
+ThinCircleOfConfusionPostProcess.Uniforms = ["cameraMinMaxZ", "focusDistance", "cocPrecalculation"];
+/**
+ * The list of samplers used by the effect
+ */
+ThinCircleOfConfusionPostProcess.Samplers = ["depthSampler"];
+/**
+ * Defines if the depth is normalized or not
+ */
+ThinCircleOfConfusionPostProcess.DefinesDepthNotNormalized = "#define COC_DEPTH_NOT_NORMALIZED";
+//# sourceMappingURL=thinCircleOfConfusionPostProcess.js.map

package/PostProcesses/thinCircleOfConfusionPostProcess.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"thinCircleOfConfusionPostProcess.js","sourceRoot":"","sources":["../../../../dev/core/src/PostProcesses/thinCircleOfConfusionPostProcess.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAC;AAE5D,OAAO,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAY3C;;GAEG;AACH,MAAM,OAAO,gCAAiC,SAAQ,aAAa;IAqB5C,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;IACL,CAAC;IAED;;;;;OAKG;IACH,YAAY,IAAY,EAAE,SAAmC,IAAI,EAAE,OAAiD;QAChH,KAAK,CAAC;YACF,GAAG,OAAO;YACV,IAAI;YACJ,MAAM,EAAE,MAAM,IAAI,MAAM,CAAC,iBAAkB;YAC3C,cAAc,EAAE,IAAI;YACpB,gBAAgB,EAAE,IAAI;YACtB,cAAc,EAAE,gCAAgC,CAAC,WAAW;YAC5D,QAAQ,EAAE,gCAAgC,CAAC,QAAQ;YACnD,QAAQ,EAAE,gCAAgC,CAAC,QAAQ;YACnD,OAAO,EAAE,OAAO,EAAE,kBAAkB,CAAC,CAAC,CAAC,gCAAgC,CAAC,yBAAyB,CAAC,CAAC,CAAC,SAAS;SAChH,CAAC,CAAC;QAQP;;WAEG;QACI,aAAQ,GAAG,EAAE,CAAC;QAErB;;WAEG;QACI,UAAK,GAAG,GAAG,CAAC;QAEnB;;WAEG;QACI,kBAAa,GAAG,IAAI,CAAC;QAE5B;;WAEG;QACI,gBAAW,GAAG,EAAE,CAAC;IAzBxB,CAAC;IA2Be,IAAI;QAChB,KAAK,CAAC,IAAI,EAAE,CAAC;QAEb,MAAM,OAAO,GAAG,IAAI,CAAC,OAAkD,CAAC;QAExE,MAAM,MAAM,GAAG,IAAI,CAAC,YAAY,CAAC,MAAO,CAAC;QAEzC,IAAI,CAAC,OAAO,CAAC,kBAAkB,EAAE;YAC7B,MAAM,CAAC,SAAS,CAAC,eAAe,EAAE,IAAI,CAAC,MAAM,CAAC,IAAI,EAAE,IAAI,CAAC,MAAM,CAAC,IAAI,GAAG,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;SAC5F;QAED,sGAAsG;QACtG,MAAM,QAAQ,GAAG,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC,KAAK,CAAC;QAC5C,MAAM,iBAAiB,GAAG,CAAC,QAAQ,GAAG,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,IAAI,CAAC,aAAa,GAAG,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC,uFAAuF;QAE1L,MAAM,CAAC,QAAQ,CAAC,eAAe,EAAE,IAAI,CAAC,aAAa,CAAC,CAAC;QACrD,MAAM,CAAC,QAAQ,CAAC,mBAAmB,EAAE,iBAAiB,CAAC,CAAC;IAC5D,CAAC;;AA3FD;;GAEG;AACoB,4CAAW,GAAG,mBAAmB,AAAtB,CAAuB;AAEzD;;GAEG;AACoB,yCAAQ,GAAG,CAAC,eAAe,EAAE,eAAe,EAAE,mBAAmB,CAAC,AAA1D,CAA2D;AAE1F;;GAEG;AACoB,yCAAQ,GAAG,CAAC,cAAc,CAAC,AAAnB,CAAoB;AAEnD;;GAEG;AACoB,0DAAyB,GAAG,kCAAkC,AAArC,CAAsC","sourcesContent":["// eslint-disable-next-line import/no-internal-modules\r\nimport type { Nullable, AbstractEngine, EffectWrapperCreationOptions } from \"core/index\";\r\nimport { EffectWrapper } from \"../Materials/effectRenderer\";\r\nimport type { Camera } from \"core/Cameras/camera\";\r\nimport { Engine } from \"../Engines/engine\";\r\n\r\n/**\r\n * Options used to create a ThinCircleOfConfusionPostProcess.\r\n */\r\nexport interface ThinCircleOfConfusionPostProcessOptions extends EffectWrapperCreationOptions {\r\n    /**\r\n     * If the (view) depth is normalized (0.0 to 1.0 from near to far) or not (0 to camera max distance)\r\n     */\r\n    depthNotNormalized?: boolean;\r\n}\r\n\r\n/**\r\n * Post process used to calculate the circle of confusion (used for depth of field, for example)\r\n */\r\nexport class ThinCircleOfConfusionPostProcess extends EffectWrapper {\r\n    /**\r\n     * The fragment shader url\r\n     */\r\n    public static readonly FragmentUrl = \"circleOfConfusion\";\r\n\r\n    /**\r\n     * The list of uniforms used by the effect\r\n     */\r\n    public static readonly Uniforms = [\"cameraMinMaxZ\", \"focusDistance\", \"cocPrecalculation\"];\r\n\r\n    /**\r\n     * The list of samplers used by the effect\r\n     */\r\n    public static readonly Samplers = [\"depthSampler\"];\r\n\r\n    /**\r\n     * Defines if the depth is normalized or not\r\n     */\r\n    public static readonly DefinesDepthNotNormalized = \"#define COC_DEPTH_NOT_NORMALIZED\";\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/circleOfConfusion.fragment\"));\r\n        } else {\r\n            list.push(import(\"../Shaders/circleOfConfusion.fragment\"));\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Constructs a new circle of confusion post process\r\n     * @param name Name of the effect\r\n     * @param engine Engine to use to render the effect. If not provided, the last created engine will be used\r\n     * @param options Options to configure the effect\r\n     */\r\n    constructor(name: string, engine: Nullable<AbstractEngine> = null, options?: ThinCircleOfConfusionPostProcessOptions) {\r\n        super({\r\n            ...options,\r\n            name,\r\n            engine: engine || Engine.LastCreatedEngine!,\r\n            useShaderStore: true,\r\n            useAsPostProcess: true,\r\n            fragmentShader: ThinCircleOfConfusionPostProcess.FragmentUrl,\r\n            uniforms: ThinCircleOfConfusionPostProcess.Uniforms,\r\n            samplers: ThinCircleOfConfusionPostProcess.Samplers,\r\n            defines: options?.depthNotNormalized ? ThinCircleOfConfusionPostProcess.DefinesDepthNotNormalized : undefined,\r\n        });\r\n    }\r\n\r\n    /**\r\n     * The camera to use to calculate the circle of confusion\r\n     */\r\n    public camera: Camera;\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 lensSize = 50;\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 fStop = 1.4;\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 focusDistance = 2000;\r\n\r\n    /**\r\n     * Focal length of the effect's camera in scene units/1000 (eg. millimeter). (default: 50)\r\n     */\r\n    public focalLength = 50;\r\n\r\n    public override bind() {\r\n        super.bind();\r\n\r\n        const options = this.options as ThinCircleOfConfusionPostProcessOptions;\r\n\r\n        const effect = this._drawWrapper.effect!;\r\n\r\n        if (!options.depthNotNormalized) {\r\n            effect.setFloat2(\"cameraMinMaxZ\", this.camera.minZ, this.camera.maxZ - this.camera.minZ);\r\n        }\r\n\r\n        // Circle of confusion calculation, See https://developer.nvidia.com/gpugems/GPUGems/gpugems_ch23.html\r\n        const aperture = this.lensSize / this.fStop;\r\n        const cocPrecalculation = (aperture * this.focalLength) / (this.focusDistance - this.focalLength); // * ((this.focusDistance - pixelDistance)/pixelDistance) [This part is done in shader]\r\n\r\n        effect.setFloat(\"focusDistance\", this.focusDistance);\r\n        effect.setFloat(\"cocPrecalculation\", cocPrecalculation);\r\n    }\r\n}\r\n"]}

package/PostProcesses/thinDepthOfFieldBlurPostProcess.d.ts

@@ -0,0 +1,8 @@
+import type { Nullable, AbstractEngine, EffectWrapperCreationOptions, Vector2 } from "../index.js";
+import { ThinBlurPostProcess } from "./thinBlurPostProcess";
+/**
+ * @internal
+ */
+export declare class ThinDepthOfFieldBlurPostProcess extends ThinBlurPostProcess {
+    constructor(name: string, engine: Nullable<AbstractEngine> | undefined, direction: Vector2, kernel: number, options?: EffectWrapperCreationOptions);
+}

package/PostProcesses/thinDepthOfFieldBlurPostProcess.js

@@ -0,0 +1,13 @@
+import { ThinBlurPostProcess } from "./thinBlurPostProcess.js";
+/**
+ * @internal
+ */
+export class ThinDepthOfFieldBlurPostProcess extends ThinBlurPostProcess {
+    constructor(name, engine = null, direction, kernel, options) {
+        super(name, engine, direction, kernel, {
+            ...options,
+            defines: `#define DOF 1\n`,
+        });
+    }
+}
+//# sourceMappingURL=thinDepthOfFieldBlurPostProcess.js.map

package/PostProcesses/thinDepthOfFieldBlurPostProcess.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"thinDepthOfFieldBlurPostProcess.js","sourceRoot":"","sources":["../../../../dev/core/src/PostProcesses/thinDepthOfFieldBlurPostProcess.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AAE5D;;GAEG;AACH,MAAM,OAAO,+BAAgC,SAAQ,mBAAmB;IACpE,YAAY,IAAY,EAAE,SAAmC,IAAI,EAAE,SAAkB,EAAE,MAAc,EAAE,OAAsC;QACzI,KAAK,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE;YACnC,GAAG,OAAO;YACV,OAAO,EAAE,iBAAiB;SAC7B,CAAC,CAAC;IACP,CAAC;CACJ","sourcesContent":["// eslint-disable-next-line import/no-internal-modules\r\nimport type { Nullable, AbstractEngine, EffectWrapperCreationOptions, Vector2 } from \"core/index\";\r\nimport { ThinBlurPostProcess } from \"./thinBlurPostProcess\";\r\n\r\n/**\r\n * @internal\r\n */\r\nexport class ThinDepthOfFieldBlurPostProcess extends ThinBlurPostProcess {\r\n    constructor(name: string, engine: Nullable<AbstractEngine> = null, direction: Vector2, kernel: number, options?: EffectWrapperCreationOptions) {\r\n        super(name, engine, direction, kernel, {\r\n            ...options,\r\n            defines: `#define DOF 1\\n`,\r\n        });\r\n    }\r\n}\r\n"]}