@spiffcommerce/preview 3.6.2-rc.8 → 4.0.0

package/dist/renderingPipeline.esm2.js

@@ -1,11394 +0,0 @@
-import { e as ShaderStore, z as ImageProcessingConfiguration, c as Tools, L as Logger, S as Scene, h as SceneComponentConstants, T as ThinEngine, I as InternalTexture, a as InternalTextureSource, V as VertexBuffer, m as PrecisionDate, C as ColorCurves } from './engine.esm.js';
-import { A as ArrayTools, R as RegisterClass, b as ToGammaSpace, C as Color4, a as Color3, S as Scalar } from './math.color.esm.js';
-import { V as Vector3, Q as Quaternion, M as Matrix, T as TmpVectors, _ as __decorate, s as serialize, S as SerializationHelper, E as EngineStore, b as Vector2, O as Observable, a as _WarnImport, l as serializeAsTexture, e as Vector4 } from './webRequest.esm.js';
-import { P as PostProcess, T as Texture, R as RenderTargetTexture } from './helperFunctions.esm.js';
-import { G as GlowLayer } from './glowLayer.esm.js';
-import { M as MaterialFlags } from './bumpVertex.esm.js';
-import { B as BlurPostProcess } from './blurPostProcess.esm.js';
-import { D as DynamicTexture } from './dynamicTexture.esm2.js';
-import { C as Camera, b as addClipPlaneUniforms, a as MaterialHelper, p as prepareStringDefinesForClipPlanes, M as Material, c as bindClipPlane } from './material.esm2.js';
-import { P as PassPostProcess } from './pbrBRDFFunctions.esm.js';
-import './effectFallbacks.esm.js';
-import { A as Animation } from './animation.esm.js';
-import { S as Size } from './math.size.esm.js';
-import { N as Node } from './node.esm.js';
-import { S as Space } from './math.axis.esm.js';
-import { renderingPipelineDefaults } from './renderConstants.esm.js';
-
-/**
- * Class used to store bone information
- * @see https://doc.babylonjs.com/features/featuresDeepDive/mesh/bonesSkeletons
- */
-class Bone extends Node {
-    /** @internal */
-    get _matrix() {
-        this._compose();
-        return this._localMatrix;
-    }
-    /** @internal */
-    set _matrix(value) {
-        // skip if the matrices are the same
-        if (value.updateFlag === this._localMatrix.updateFlag && !this._needToCompose) {
-            return;
-        }
-        this._needToCompose = false; // in case there was a pending compose
-        this._localMatrix.copyFrom(value);
-        this._markAsDirtyAndDecompose();
-    }
-    /**
-     * Create a new bone
-     * @param name defines the bone name
-     * @param skeleton defines the parent skeleton
-     * @param parentBone defines the parent (can be null if the bone is the root)
-     * @param localMatrix defines the local matrix (default: identity)
-     * @param restMatrix defines the rest matrix (default: localMatrix)
-     * @param bindMatrix defines the bind matrix (default: localMatrix)
-     * @param index defines index of the bone in the hierarchy (default: null)
-     */
-    constructor(
-    /**
-     * defines the bone name
-     */
-    name, skeleton, parentBone = null, localMatrix = null, restMatrix = null, bindMatrix = null, index = null) {
-        var _a;
-        super(name, skeleton.getScene());
-        this.name = name;
-        /**
-         * Gets the list of child bones
-         */
-        this.children = new Array();
-        /** Gets the animations associated with this bone */
-        this.animations = new Array();
-        /**
-         * @internal Internal only
-         * Set this value to map this bone to a different index in the transform matrices
-         * Set this value to -1 to exclude the bone from the transform matrices
-         */
-        this._index = null;
-        this._scalingDeterminant = 1;
-        this._needToDecompose = true;
-        this._needToCompose = false;
-        /** @internal */
-        this._linkedTransformNode = null;
-        /** @internal */
-        this._waitingTransformNodeId = null;
-        this._skeleton = skeleton;
-        this._localMatrix = (_a = localMatrix === null || localMatrix === void 0 ? void 0 : localMatrix.clone()) !== null && _a !== void 0 ? _a : Matrix.Identity();
-        this._restMatrix = restMatrix !== null && restMatrix !== void 0 ? restMatrix : this._localMatrix.clone();
-        this._bindMatrix = bindMatrix !== null && bindMatrix !== void 0 ? bindMatrix : this._localMatrix.clone();
-        this._index = index;
-        this._absoluteMatrix = new Matrix();
-        this._absoluteBindMatrix = new Matrix();
-        this._absoluteInverseBindMatrix = new Matrix();
-        this._finalMatrix = new Matrix();
-        skeleton.bones.push(this);
-        this.setParent(parentBone, false);
-        this._updateAbsoluteBindMatrices();
-    }
-    /**
-     * Gets the current object class name.
-     * @returns the class name
-     */
-    getClassName() {
-        return "Bone";
-    }
-    // Members
-    /**
-     * Gets the parent skeleton
-     * @returns a skeleton
-     */
-    getSkeleton() {
-        return this._skeleton;
-    }
-    get parent() {
-        return this._parentNode;
-    }
-    /**
-     * Gets parent bone
-     * @returns a bone or null if the bone is the root of the bone hierarchy
-     */
-    getParent() {
-        return this.parent;
-    }
-    /**
-     * Returns an array containing the children of the bone
-     * @returns an array containing the children of the bone (can be empty if the bone has no children)
-     */
-    getChildren() {
-        return this.children;
-    }
-    /**
-     * Gets the node index in matrix array generated for rendering
-     * @returns the node index
-     */
-    getIndex() {
-        return this._index === null ? this.getSkeleton().bones.indexOf(this) : this._index;
-    }
-    set parent(newParent) {
-        this.setParent(newParent);
-    }
-    /**
-     * Sets the parent bone
-     * @param parent defines the parent (can be null if the bone is the root)
-     * @param updateAbsoluteBindMatrices defines if the absolute bind and absolute inverse bind matrices must be updated
-     */
-    setParent(parent, updateAbsoluteBindMatrices = true) {
-        if (this.parent === parent) {
-            return;
-        }
-        if (this.parent) {
-            const index = this.parent.children.indexOf(this);
-            if (index !== -1) {
-                this.parent.children.splice(index, 1);
-            }
-        }
-        this._parentNode = parent;
-        if (this.parent) {
-            this.parent.children.push(this);
-        }
-        if (updateAbsoluteBindMatrices) {
-            this._updateAbsoluteBindMatrices();
-        }
-        this.markAsDirty();
-    }
-    /**
-     * Gets the local matrix
-     * @returns the local matrix
-     */
-    getLocalMatrix() {
-        this._compose();
-        return this._localMatrix;
-    }
-    /**
-     * Gets the bind matrix
-     * @returns the bind matrix
-     */
-    getBindMatrix() {
-        return this._bindMatrix;
-    }
-    /**
-     * Gets the bind matrix.
-     * @returns the bind matrix
-     * @deprecated Please use getBindMatrix instead
-     */
-    getBaseMatrix() {
-        return this.getBindMatrix();
-    }
-    /**
-     * Gets the rest matrix
-     * @returns the rest matrix
-     */
-    getRestMatrix() {
-        return this._restMatrix;
-    }
-    /**
-     * Gets the rest matrix
-     * @returns the rest matrix
-     * @deprecated Please use getRestMatrix instead
-     */
-    getRestPose() {
-        return this.getRestMatrix();
-    }
-    /**
-     * Sets the rest matrix
-     * @param matrix the local-space rest matrix to set for this bone
-     */
-    setRestMatrix(matrix) {
-        this._restMatrix.copyFrom(matrix);
-    }
-    /**
-     * Sets the rest matrix
-     * @param matrix the local-space rest to set for this bone
-     * @deprecated Please use setRestMatrix instead
-     */
-    setRestPose(matrix) {
-        this.setRestMatrix(matrix);
-    }
-    /**
-     * Gets the bind matrix
-     * @returns the bind matrix
-     * @deprecated Please use getBindMatrix instead
-     */
-    getBindPose() {
-        return this.getBindMatrix();
-    }
-    /**
-     * Sets the bind matrix
-     * This will trigger a recomputation of the absolute bind and absolute inverse bind matrices for this bone and its children
-     * Note that the local matrix will also be set with the matrix passed in parameter!
-     * @param matrix the local-space bind matrix to set for this bone
-     */
-    setBindMatrix(matrix) {
-        this.updateMatrix(matrix);
-    }
-    /**
-     * Sets the bind matrix
-     * @param matrix the local-space bind to set for this bone
-     * @deprecated Please use setBindMatrix instead
-     */
-    setBindPose(matrix) {
-        this.setBindMatrix(matrix);
-    }
-    /**
-     * Gets the matrix used to store the final world transformation of the bone (ie. the matrix sent to shaders)
-     */
-    getFinalMatrix() {
-        return this._finalMatrix;
-    }
-    /**
-     * Gets the matrix used to store the final world transformation of the bone (ie. the matrix sent to shaders)
-     * @deprecated Please use getFinalMatrix instead
-     */
-    getWorldMatrix() {
-        return this.getFinalMatrix();
-    }
-    /**
-     * Sets the local matrix to the rest matrix
-     */
-    returnToRest() {
-        var _a;
-        if (this._linkedTransformNode) {
-            const localScaling = TmpVectors.Vector3[0];
-            const localRotation = TmpVectors.Quaternion[0];
-            const localPosition = TmpVectors.Vector3[1];
-            this.getRestMatrix().decompose(localScaling, localRotation, localPosition);
-            this._linkedTransformNode.position.copyFrom(localPosition);
-            this._linkedTransformNode.rotationQuaternion = (_a = this._linkedTransformNode.rotationQuaternion) !== null && _a !== void 0 ? _a : Quaternion.Identity();
-            this._linkedTransformNode.rotationQuaternion.copyFrom(localRotation);
-            this._linkedTransformNode.scaling.copyFrom(localScaling);
-        }
-        else {
-            this._matrix = this._restMatrix;
-        }
-    }
-    /**
-     * Gets the inverse of the bind matrix, in world space (relative to the skeleton root)
-     * @returns the inverse bind matrix, in world space
-     */
-    getAbsoluteInverseBindMatrix() {
-        return this._absoluteInverseBindMatrix;
-    }
-    /**
-     * Gets the inverse of the bind matrix, in world space (relative to the skeleton root)
-     * @returns the inverse bind matrix, in world space
-     * @deprecated Please use getAbsoluteInverseBindMatrix instead
-     */
-    getInvertedAbsoluteTransform() {
-        return this.getAbsoluteInverseBindMatrix();
-    }
-    /**
-     * Gets the bone matrix, in world space (relative to the skeleton root)
-     * @returns the bone matrix, in world space
-     */
-    getAbsoluteMatrix() {
-        return this._absoluteMatrix;
-    }
-    /**
-     * Gets the bone matrix, in world space (relative to the skeleton root)
-     * @returns the bone matrix, in world space
-     * @deprecated Please use getAbsoluteMatrix instead
-     */
-    getAbsoluteTransform() {
-        return this._absoluteMatrix;
-    }
-    /**
-     * Links with the given transform node.
-     * The local matrix of this bone is overwritten by the transform of the node every frame.
-     * @param transformNode defines the transform node to link to
-     */
-    linkTransformNode(transformNode) {
-        if (this._linkedTransformNode) {
-            this._skeleton._numBonesWithLinkedTransformNode--;
-        }
-        this._linkedTransformNode = transformNode;
-        if (this._linkedTransformNode) {
-            this._skeleton._numBonesWithLinkedTransformNode++;
-        }
-    }
-    // Properties (matches TransformNode properties)
-    /**
-     * Gets the node used to drive the bone's transformation
-     * @returns a transform node or null
-     */
-    getTransformNode() {
-        return this._linkedTransformNode;
-    }
-    /** Gets or sets current position (in local space) */
-    get position() {
-        this._decompose();
-        return this._localPosition;
-    }
-    set position(newPosition) {
-        this._decompose();
-        this._localPosition.copyFrom(newPosition);
-        this._markAsDirtyAndCompose();
-    }
-    /** Gets or sets current rotation (in local space) */
-    get rotation() {
-        return this.getRotation();
-    }
-    set rotation(newRotation) {
-        this.setRotation(newRotation);
-    }
-    /** Gets or sets current rotation quaternion (in local space) */
-    get rotationQuaternion() {
-        this._decompose();
-        return this._localRotation;
-    }
-    set rotationQuaternion(newRotation) {
-        this.setRotationQuaternion(newRotation);
-    }
-    /** Gets or sets current scaling (in local space) */
-    get scaling() {
-        return this.getScale();
-    }
-    set scaling(newScaling) {
-        this.setScale(newScaling);
-    }
-    /**
-     * Gets the animation properties override
-     */
-    get animationPropertiesOverride() {
-        return this._skeleton.animationPropertiesOverride;
-    }
-    // Methods
-    _decompose() {
-        if (!this._needToDecompose) {
-            return;
-        }
-        this._needToDecompose = false;
-        if (!this._localScaling) {
-            this._localScaling = Vector3.Zero();
-            this._localRotation = Quaternion.Zero();
-            this._localPosition = Vector3.Zero();
-        }
-        this._localMatrix.decompose(this._localScaling, this._localRotation, this._localPosition);
-    }
-    _compose() {
-        if (!this._needToCompose) {
-            return;
-        }
-        if (!this._localScaling) {
-            this._needToCompose = false;
-            return;
-        }
-        this._needToCompose = false;
-        Matrix.ComposeToRef(this._localScaling, this._localRotation, this._localPosition, this._localMatrix);
-    }
-    /**
-     * Update the bind (and optionally the local) matrix
-     * @param bindMatrix defines the new matrix to set to the bind/local matrix, in local space
-     * @param updateAbsoluteBindMatrices defines if the absolute bind and absolute inverse bind matrices must be recomputed (default: true)
-     * @param updateLocalMatrix defines if the local matrix should also be updated with the matrix passed in parameter (default: true)
-     */
-    updateMatrix(bindMatrix, updateAbsoluteBindMatrices = true, updateLocalMatrix = true) {
-        this._bindMatrix.copyFrom(bindMatrix);
-        if (updateAbsoluteBindMatrices) {
-            this._updateAbsoluteBindMatrices();
-        }
-        if (updateLocalMatrix) {
-            this._matrix = bindMatrix;
-        }
-        else {
-            this.markAsDirty();
-        }
-    }
-    /**
-     * @internal
-     */
-    _updateAbsoluteBindMatrices(bindMatrix, updateChildren = true) {
-        if (!bindMatrix) {
-            bindMatrix = this._bindMatrix;
-        }
-        if (this.parent) {
-            bindMatrix.multiplyToRef(this.parent._absoluteBindMatrix, this._absoluteBindMatrix);
-        }
-        else {
-            this._absoluteBindMatrix.copyFrom(bindMatrix);
-        }
-        this._absoluteBindMatrix.invertToRef(this._absoluteInverseBindMatrix);
-        if (updateChildren) {
-            for (let index = 0; index < this.children.length; index++) {
-                this.children[index]._updateAbsoluteBindMatrices();
-            }
-        }
-        this._scalingDeterminant = this._absoluteBindMatrix.determinant() < 0 ? -1 : 1;
-    }
-    /**
-     * Flag the bone as dirty (Forcing it to update everything)
-     * @returns this bone
-     */
-    markAsDirty() {
-        this._currentRenderId++;
-        this._childUpdateId++;
-        this._skeleton._markAsDirty();
-        return this;
-    }
-    /** @internal */
-    _markAsDirtyAndCompose() {
-        this.markAsDirty();
-        this._needToCompose = true;
-    }
-    _markAsDirtyAndDecompose() {
-        this.markAsDirty();
-        this._needToDecompose = true;
-    }
-    _updatePosition(vec, space = Space.LOCAL, tNode, translationMode = true) {
-        const lm = this.getLocalMatrix();
-        if (space == Space.LOCAL) {
-            if (translationMode) {
-                lm.addAtIndex(12, vec.x);
-                lm.addAtIndex(13, vec.y);
-                lm.addAtIndex(14, vec.z);
-            }
-            else {
-                lm.setTranslationFromFloats(vec.x, vec.y, vec.z);
-            }
-        }
-        else {
-            let wm = null;
-            //tNode.getWorldMatrix() needs to be called before skeleton.computeAbsoluteMatrices()
-            if (tNode) {
-                wm = tNode.getWorldMatrix();
-            }
-            this._skeleton.computeAbsoluteMatrices();
-            const tmat = Bone._TmpMats[0];
-            const tvec = Bone._TmpVecs[0];
-            if (this.parent) {
-                if (tNode && wm) {
-                    tmat.copyFrom(this.parent.getAbsoluteMatrix());
-                    tmat.multiplyToRef(wm, tmat);
-                }
-                else {
-                    tmat.copyFrom(this.parent.getAbsoluteMatrix());
-                }
-            }
-            else {
-                Matrix.IdentityToRef(tmat);
-            }
-            if (translationMode) {
-                tmat.setTranslationFromFloats(0, 0, 0);
-            }
-            tmat.invert();
-            Vector3.TransformCoordinatesToRef(vec, tmat, tvec);
-            if (translationMode) {
-                lm.addAtIndex(12, tvec.x);
-                lm.addAtIndex(13, tvec.y);
-                lm.addAtIndex(14, tvec.z);
-            }
-            else {
-                lm.setTranslationFromFloats(tvec.x, tvec.y, tvec.z);
-            }
-        }
-        this._markAsDirtyAndDecompose();
-    }
-    /**
-     * Translate the bone in local or world space
-     * @param vec The amount to translate the bone
-     * @param space The space that the translation is in (default: Space.LOCAL)
-     * @param tNode A TransformNode whose world matrix is to be applied to the calculated absolute matrix. In most cases, you'll want to pass the mesh associated with the skeleton from which this bone comes. Used only when space=Space.WORLD
-     */
-    translate(vec, space = Space.LOCAL, tNode) {
-        this._updatePosition(vec, space, tNode, true);
-    }
-    /**
-     * Set the position of the bone in local or world space
-     * @param position The position to set the bone
-     * @param space The space that the position is in (default: Space.LOCAL)
-     * @param tNode A TransformNode whose world matrix is to be applied to the calculated absolute matrix. In most cases, you'll want to pass the mesh associated with the skeleton from which this bone comes. Used only when space=Space.WORLD
-     */
-    setPosition(position, space = Space.LOCAL, tNode) {
-        this._updatePosition(position, space, tNode, false);
-    }
-    /**
-     * Set the absolute position of the bone (world space)
-     * @param position The position to set the bone
-     * @param tNode A TransformNode whose world matrix is to be applied to the calculated absolute matrix. In most cases, you'll want to pass the mesh associated with the skeleton from which this bone comes. Used only when space=Space.WORLD
-     */
-    setAbsolutePosition(position, tNode) {
-        this.setPosition(position, Space.WORLD, tNode);
-    }
-    /**
-     * Scale the bone on the x, y and z axes (in local space)
-     * @param x The amount to scale the bone on the x axis
-     * @param y The amount to scale the bone on the y axis
-     * @param z The amount to scale the bone on the z axis
-     * @param scaleChildren sets this to true if children of the bone should be scaled as well (false by default)
-     */
-    scale(x, y, z, scaleChildren = false) {
-        const locMat = this.getLocalMatrix();
-        // Apply new scaling on top of current local matrix
-        const scaleMat = Bone._TmpMats[0];
-        Matrix.ScalingToRef(x, y, z, scaleMat);
-        scaleMat.multiplyToRef(locMat, locMat);
-        // Invert scaling matrix and apply the inverse to all children
-        scaleMat.invert();
-        for (const child of this.children) {
-            const cm = child.getLocalMatrix();
-            cm.multiplyToRef(scaleMat, cm);
-            cm.multiplyAtIndex(12, x);
-            cm.multiplyAtIndex(13, y);
-            cm.multiplyAtIndex(14, z);
-            child._markAsDirtyAndDecompose();
-        }
-        this._markAsDirtyAndDecompose();
-        if (scaleChildren) {
-            for (const child of this.children) {
-                child.scale(x, y, z, scaleChildren);
-            }
-        }
-    }
-    /**
-     * Set the bone scaling in local space
-     * @param scale defines the scaling vector
-     */
-    setScale(scale) {
-        this._decompose();
-        this._localScaling.copyFrom(scale);
-        this._markAsDirtyAndCompose();
-    }
-    /**
-     * Gets the current scaling in local space
-     * @returns the current scaling vector
-     */
-    getScale() {
-        this._decompose();
-        return this._localScaling;
-    }
-    /**
-     * Gets the current scaling in local space and stores it in a target vector
-     * @param result defines the target vector
-     */
-    getScaleToRef(result) {
-        this._decompose();
-        result.copyFrom(this._localScaling);
-    }
-    /**
-     * Set the yaw, pitch, and roll of the bone in local or world space
-     * @param yaw The rotation of the bone on the y axis
-     * @param pitch The rotation of the bone on the x axis
-     * @param roll The rotation of the bone on the z axis
-     * @param space The space that the axes of rotation are in
-     * @param tNode A TransformNode whose world matrix is to be applied to the calculated absolute matrix. In most cases, you'll want to pass the mesh associated with the skeleton from which this bone comes. Used only when space=Space.WORLD
-     */
-    setYawPitchRoll(yaw, pitch, roll, space = Space.LOCAL, tNode) {
-        if (space === Space.LOCAL) {
-            const quat = Bone._TmpQuat;
-            Quaternion.RotationYawPitchRollToRef(yaw, pitch, roll, quat);
-            this.setRotationQuaternion(quat, space, tNode);
-            return;
-        }
-        const rotMatInv = Bone._TmpMats[0];
-        if (!this._getAbsoluteInverseMatrixUnscaledToRef(rotMatInv, tNode)) {
-            return;
-        }
-        const rotMat = Bone._TmpMats[1];
-        Matrix.RotationYawPitchRollToRef(yaw, pitch, roll, rotMat);
-        rotMatInv.multiplyToRef(rotMat, rotMat);
-        this._rotateWithMatrix(rotMat, space, tNode);
-    }
-    /**
-     * Add a rotation to the bone on an axis in local or world space
-     * @param axis The axis to rotate the bone on
-     * @param amount The amount to rotate the bone
-     * @param space The space that the axis is in
-     * @param tNode A TransformNode whose world matrix is to be applied to the calculated absolute matrix. In most cases, you'll want to pass the mesh associated with the skeleton from which this bone comes. Used only when space=Space.WORLD
-     */
-    rotate(axis, amount, space = Space.LOCAL, tNode) {
-        const rmat = Bone._TmpMats[0];
-        rmat.setTranslationFromFloats(0, 0, 0);
-        Matrix.RotationAxisToRef(axis, amount, rmat);
-        this._rotateWithMatrix(rmat, space, tNode);
-    }
-    /**
-     * Set the rotation of the bone to a particular axis angle in local or world space
-     * @param axis The axis to rotate the bone on
-     * @param angle The angle that the bone should be rotated to
-     * @param space The space that the axis is in
-     * @param tNode A TransformNode whose world matrix is to be applied to the calculated absolute matrix. In most cases, you'll want to pass the mesh associated with the skeleton from which this bone comes. Used only when space=Space.WORLD
-     */
-    setAxisAngle(axis, angle, space = Space.LOCAL, tNode) {
-        if (space === Space.LOCAL) {
-            const quat = Bone._TmpQuat;
-            Quaternion.RotationAxisToRef(axis, angle, quat);
-            this.setRotationQuaternion(quat, space, tNode);
-            return;
-        }
-        const rotMatInv = Bone._TmpMats[0];
-        if (!this._getAbsoluteInverseMatrixUnscaledToRef(rotMatInv, tNode)) {
-            return;
-        }
-        const rotMat = Bone._TmpMats[1];
-        Matrix.RotationAxisToRef(axis, angle, rotMat);
-        rotMatInv.multiplyToRef(rotMat, rotMat);
-        this._rotateWithMatrix(rotMat, space, tNode);
-    }
-    /**
-     * Set the euler rotation of the bone in local or world space
-     * @param rotation The euler rotation that the bone should be set to
-     * @param space The space that the rotation is in
-     * @param tNode A TransformNode whose world matrix is to be applied to the calculated absolute matrix. In most cases, you'll want to pass the mesh associated with the skeleton from which this bone comes. Used only when space=Space.WORLD
-     */
-    setRotation(rotation, space = Space.LOCAL, tNode) {
-        this.setYawPitchRoll(rotation.y, rotation.x, rotation.z, space, tNode);
-    }
-    /**
-     * Set the quaternion rotation of the bone in local or world space
-     * @param quat The quaternion rotation that the bone should be set to
-     * @param space The space that the rotation is in
-     * @param tNode A TransformNode whose world matrix is to be applied to the calculated absolute matrix. In most cases, you'll want to pass the mesh associated with the skeleton from which this bone comes. Used only when space=Space.WORLD
-     */
-    setRotationQuaternion(quat, space = Space.LOCAL, tNode) {
-        if (space === Space.LOCAL) {
-            this._decompose();
-            this._localRotation.copyFrom(quat);
-            this._markAsDirtyAndCompose();
-            return;
-        }
-        const rotMatInv = Bone._TmpMats[0];
-        if (!this._getAbsoluteInverseMatrixUnscaledToRef(rotMatInv, tNode)) {
-            return;
-        }
-        const rotMat = Bone._TmpMats[1];
-        Matrix.FromQuaternionToRef(quat, rotMat);
-        rotMatInv.multiplyToRef(rotMat, rotMat);
-        this._rotateWithMatrix(rotMat, space, tNode);
-    }
-    /**
-     * Set the rotation matrix of the bone in local or world space
-     * @param rotMat The rotation matrix that the bone should be set to
-     * @param space The space that the rotation is in
-     * @param tNode A TransformNode whose world matrix is to be applied to the calculated absolute matrix. In most cases, you'll want to pass the mesh associated with the skeleton from which this bone comes. Used only when space=Space.WORLD
-     */
-    setRotationMatrix(rotMat, space = Space.LOCAL, tNode) {
-        if (space === Space.LOCAL) {
-            const quat = Bone._TmpQuat;
-            Quaternion.FromRotationMatrixToRef(rotMat, quat);
-            this.setRotationQuaternion(quat, space, tNode);
-            return;
-        }
-        const rotMatInv = Bone._TmpMats[0];
-        if (!this._getAbsoluteInverseMatrixUnscaledToRef(rotMatInv, tNode)) {
-            return;
-        }
-        const rotMat2 = Bone._TmpMats[1];
-        rotMat2.copyFrom(rotMat);
-        rotMatInv.multiplyToRef(rotMat, rotMat2);
-        this._rotateWithMatrix(rotMat2, space, tNode);
-    }
-    _rotateWithMatrix(rmat, space = Space.LOCAL, tNode) {
-        const lmat = this.getLocalMatrix();
-        const lx = lmat.m[12];
-        const ly = lmat.m[13];
-        const lz = lmat.m[14];
-        const parent = this.getParent();
-        const parentScale = Bone._TmpMats[3];
-        const parentScaleInv = Bone._TmpMats[4];
-        if (parent && space == Space.WORLD) {
-            if (tNode) {
-                parentScale.copyFrom(tNode.getWorldMatrix());
-                parent.getAbsoluteMatrix().multiplyToRef(parentScale, parentScale);
-            }
-            else {
-                parentScale.copyFrom(parent.getAbsoluteMatrix());
-            }
-            parentScaleInv.copyFrom(parentScale);
-            parentScaleInv.invert();
-            lmat.multiplyToRef(parentScale, lmat);
-            lmat.multiplyToRef(rmat, lmat);
-            lmat.multiplyToRef(parentScaleInv, lmat);
-        }
-        else {
-            if (space == Space.WORLD && tNode) {
-                parentScale.copyFrom(tNode.getWorldMatrix());
-                parentScaleInv.copyFrom(parentScale);
-                parentScaleInv.invert();
-                lmat.multiplyToRef(parentScale, lmat);
-                lmat.multiplyToRef(rmat, lmat);
-                lmat.multiplyToRef(parentScaleInv, lmat);
-            }
-            else {
-                lmat.multiplyToRef(rmat, lmat);
-            }
-        }
-        lmat.setTranslationFromFloats(lx, ly, lz);
-        this.computeAbsoluteMatrices();
-        this._markAsDirtyAndDecompose();
-    }
-    _getAbsoluteInverseMatrixUnscaledToRef(rotMatInv, tNode) {
-        const scaleMatrix = Bone._TmpMats[2];
-        rotMatInv.copyFrom(this.getAbsoluteMatrix());
-        if (tNode) {
-            rotMatInv.multiplyToRef(tNode.getWorldMatrix(), rotMatInv);
-            Matrix.ScalingToRef(tNode.scaling.x, tNode.scaling.y, tNode.scaling.z, scaleMatrix);
-        }
-        else {
-            Matrix.IdentityToRef(scaleMatrix);
-        }
-        rotMatInv.invert();
-        if (isNaN(rotMatInv.m[0])) {
-            // Matrix failed to invert.
-            // This can happen if scale is zero for example.
-            return false;
-        }
-        scaleMatrix.multiplyAtIndex(0, this._scalingDeterminant);
-        rotMatInv.multiplyToRef(scaleMatrix, rotMatInv);
-        return true;
-    }
-    /**
-     * Get the position of the bone in local or world space
-     * @param space The space that the returned position is in
-     * @param tNode A TransformNode whose world matrix is to be applied to the calculated absolute matrix. In most cases, you'll want to pass the mesh associated with the skeleton from which this bone comes. Used only when space=Space.WORLD
-     * @returns The position of the bone
-     */
-    getPosition(space = Space.LOCAL, tNode = null) {
-        const pos = Vector3.Zero();
-        this.getPositionToRef(space, tNode, pos);
-        return pos;
-    }
-    /**
-     * Copy the position of the bone to a vector3 in local or world space
-     * @param space The space that the returned position is in
-     * @param tNode A TransformNode whose world matrix is to be applied to the calculated absolute matrix. In most cases, you'll want to pass the mesh associated with the skeleton from which this bone comes. Used only when space=Space.WORLD
-     * @param result The vector3 to copy the position to
-     */
-    getPositionToRef(space = Space.LOCAL, tNode, result) {
-        if (space == Space.LOCAL) {
-            const lm = this.getLocalMatrix();
-            result.x = lm.m[12];
-            result.y = lm.m[13];
-            result.z = lm.m[14];
-        }
-        else {
-            let wm = null;
-            //tNode.getWorldMatrix() needs to be called before skeleton.computeAbsoluteMatrices()
-            if (tNode) {
-                wm = tNode.getWorldMatrix();
-            }
-            this._skeleton.computeAbsoluteMatrices();
-            let tmat = Bone._TmpMats[0];
-            if (tNode && wm) {
-                tmat.copyFrom(this.getAbsoluteMatrix());
-                tmat.multiplyToRef(wm, tmat);
-            }
-            else {
-                tmat = this.getAbsoluteMatrix();
-            }
-            result.x = tmat.m[12];
-            result.y = tmat.m[13];
-            result.z = tmat.m[14];
-        }
-    }
-    /**
-     * Get the absolute position of the bone (world space)
-     * @param tNode A TransformNode whose world matrix is to be applied to the calculated absolute matrix. In most cases, you'll want to pass the mesh associated with the skeleton from which this bone comes. Used only when space=Space.WORLD
-     * @returns The absolute position of the bone
-     */
-    getAbsolutePosition(tNode = null) {
-        const pos = Vector3.Zero();
-        this.getPositionToRef(Space.WORLD, tNode, pos);
-        return pos;
-    }
-    /**
-     * Copy the absolute position of the bone (world space) to the result param
-     * @param tNode A TransformNode whose world matrix is to be applied to the calculated absolute matrix. In most cases, you'll want to pass the mesh associated with the skeleton from which this bone comes. Used only when space=Space.WORLD
-     * @param result The vector3 to copy the absolute position to
-     */
-    getAbsolutePositionToRef(tNode, result) {
-        this.getPositionToRef(Space.WORLD, tNode, result);
-    }
-    /**
-     * Compute the absolute matrices of this bone and its children
-     */
-    computeAbsoluteMatrices() {
-        this._compose();
-        if (this.parent) {
-            this._localMatrix.multiplyToRef(this.parent._absoluteMatrix, this._absoluteMatrix);
-        }
-        else {
-            this._absoluteMatrix.copyFrom(this._localMatrix);
-            const poseMatrix = this._skeleton.getPoseMatrix();
-            if (poseMatrix) {
-                this._absoluteMatrix.multiplyToRef(poseMatrix, this._absoluteMatrix);
-            }
-        }
-        const children = this.children;
-        const len = children.length;
-        for (let i = 0; i < len; i++) {
-            children[i].computeAbsoluteMatrices();
-        }
-    }
-    /**
-     * Compute the absolute matrices of this bone and its children
-     * @deprecated Please use computeAbsoluteMatrices instead
-     */
-    computeAbsoluteTransforms() {
-        this.computeAbsoluteMatrices();
-    }
-    /**
-     * Get the world direction from an axis that is in the local space of the bone
-     * @param localAxis The local direction that is used to compute the world direction
-     * @param tNode A TransformNode whose world matrix is to be applied to the calculated absolute matrix. In most cases, you'll want to pass the mesh associated with the skeleton from which this bone comes. Used only when space=Space.WORLD
-     * @returns The world direction
-     */
-    getDirection(localAxis, tNode = null) {
-        const result = Vector3.Zero();
-        this.getDirectionToRef(localAxis, tNode, result);
-        return result;
-    }
-    /**
-     * Copy the world direction to a vector3 from an axis that is in the local space of the bone
-     * @param localAxis The local direction that is used to compute the world direction
-     * @param tNode A TransformNode whose world matrix is to be applied to the calculated absolute matrix. In most cases, you'll want to pass the mesh associated with the skeleton from which this bone comes. Used only when space=Space.WORLD
-     * @param result The vector3 that the world direction will be copied to
-     */
-    getDirectionToRef(localAxis, tNode = null, result) {
-        let wm = null;
-        //tNode.getWorldMatrix() needs to be called before skeleton.computeAbsoluteMatrices()
-        if (tNode) {
-            wm = tNode.getWorldMatrix();
-        }
-        this._skeleton.computeAbsoluteMatrices();
-        const mat = Bone._TmpMats[0];
-        mat.copyFrom(this.getAbsoluteMatrix());
-        if (tNode && wm) {
-            mat.multiplyToRef(wm, mat);
-        }
-        Vector3.TransformNormalToRef(localAxis, mat, result);
-        result.normalize();
-    }
-    /**
-     * Get the euler rotation of the bone in local or world space
-     * @param space The space that the rotation should be in
-     * @param tNode A TransformNode whose world matrix is to be applied to the calculated absolute matrix. In most cases, you'll want to pass the mesh associated with the skeleton from which this bone comes. Used only when space=Space.WORLD
-     * @returns The euler rotation
-     */
-    getRotation(space = Space.LOCAL, tNode = null) {
-        const result = Vector3.Zero();
-        this.getRotationToRef(space, tNode, result);
-        return result;
-    }
-    /**
-     * Copy the euler rotation of the bone to a vector3.  The rotation can be in either local or world space
-     * @param space The space that the rotation should be in
-     * @param tNode A TransformNode whose world matrix is to be applied to the calculated absolute matrix. In most cases, you'll want to pass the mesh associated with the skeleton from which this bone comes. Used only when space=Space.WORLD
-     * @param result The vector3 that the rotation should be copied to
-     */
-    getRotationToRef(space = Space.LOCAL, tNode = null, result) {
-        const quat = Bone._TmpQuat;
-        this.getRotationQuaternionToRef(space, tNode, quat);
-        quat.toEulerAnglesToRef(result);
-    }
-    /**
-     * Get the quaternion rotation of the bone in either local or world space
-     * @param space The space that the rotation should be in
-     * @param tNode A TransformNode whose world matrix is to be applied to the calculated absolute matrix. In most cases, you'll want to pass the mesh associated with the skeleton from which this bone comes. Used only when space=Space.WORLD
-     * @returns The quaternion rotation
-     */
-    getRotationQuaternion(space = Space.LOCAL, tNode = null) {
-        const result = Quaternion.Identity();
-        this.getRotationQuaternionToRef(space, tNode, result);
-        return result;
-    }
-    /**
-     * Copy the quaternion rotation of the bone to a quaternion.  The rotation can be in either local or world space
-     * @param space The space that the rotation should be in
-     * @param tNode A TransformNode whose world matrix is to be applied to the calculated absolute matrix. In most cases, you'll want to pass the mesh associated with the skeleton from which this bone comes. Used only when space=Space.WORLD
-     * @param result The quaternion that the rotation should be copied to
-     */
-    getRotationQuaternionToRef(space = Space.LOCAL, tNode = null, result) {
-        if (space == Space.LOCAL) {
-            this._decompose();
-            result.copyFrom(this._localRotation);
-        }
-        else {
-            const mat = Bone._TmpMats[0];
-            const amat = this.getAbsoluteMatrix();
-            if (tNode) {
-                amat.multiplyToRef(tNode.getWorldMatrix(), mat);
-            }
-            else {
-                mat.copyFrom(amat);
-            }
-            mat.multiplyAtIndex(0, this._scalingDeterminant);
-            mat.multiplyAtIndex(1, this._scalingDeterminant);
-            mat.multiplyAtIndex(2, this._scalingDeterminant);
-            mat.decompose(undefined, result, undefined);
-        }
-    }
-    /**
-     * Get the rotation matrix of the bone in local or world space
-     * @param space The space that the rotation should be in
-     * @param tNode A TransformNode whose world matrix is to be applied to the calculated absolute matrix. In most cases, you'll want to pass the mesh associated with the skeleton from which this bone comes. Used only when space=Space.WORLD
-     * @returns The rotation matrix
-     */
-    getRotationMatrix(space = Space.LOCAL, tNode) {
-        const result = Matrix.Identity();
-        this.getRotationMatrixToRef(space, tNode, result);
-        return result;
-    }
-    /**
-     * Copy the rotation matrix of the bone to a matrix.  The rotation can be in either local or world space
-     * @param space The space that the rotation should be in
-     * @param tNode A TransformNode whose world matrix is to be applied to the calculated absolute matrix. In most cases, you'll want to pass the mesh associated with the skeleton from which this bone comes. Used only when space=Space.WORLD
-     * @param result The quaternion that the rotation should be copied to
-     */
-    getRotationMatrixToRef(space = Space.LOCAL, tNode, result) {
-        if (space == Space.LOCAL) {
-            this.getLocalMatrix().getRotationMatrixToRef(result);
-        }
-        else {
-            const mat = Bone._TmpMats[0];
-            const amat = this.getAbsoluteMatrix();
-            if (tNode) {
-                amat.multiplyToRef(tNode.getWorldMatrix(), mat);
-            }
-            else {
-                mat.copyFrom(amat);
-            }
-            mat.multiplyAtIndex(0, this._scalingDeterminant);
-            mat.multiplyAtIndex(1, this._scalingDeterminant);
-            mat.multiplyAtIndex(2, this._scalingDeterminant);
-            mat.getRotationMatrixToRef(result);
-        }
-    }
-    /**
-     * Get the world position of a point that is in the local space of the bone
-     * @param position The local position
-     * @param tNode A TransformNode whose world matrix is to be applied to the calculated absolute matrix. In most cases, you'll want to pass the mesh associated with the skeleton from which this bone comes. Used only when space=Space.WORLD
-     * @returns The world position
-     */
-    getAbsolutePositionFromLocal(position, tNode = null) {
-        const result = Vector3.Zero();
-        this.getAbsolutePositionFromLocalToRef(position, tNode, result);
-        return result;
-    }
-    /**
-     * Get the world position of a point that is in the local space of the bone and copy it to the result param
-     * @param position The local position
-     * @param tNode A TransformNode whose world matrix is to be applied to the calculated absolute matrix. In most cases, you'll want to pass the mesh associated with the skeleton from which this bone comes. Used only when space=Space.WORLD
-     * @param result The vector3 that the world position should be copied to
-     */
-    getAbsolutePositionFromLocalToRef(position, tNode = null, result) {
-        let wm = null;
-        //tNode.getWorldMatrix() needs to be called before skeleton.computeAbsoluteMatrices()
-        if (tNode) {
-            wm = tNode.getWorldMatrix();
-        }
-        this._skeleton.computeAbsoluteMatrices();
-        const tmat = Bone._TmpMats[0];
-        tmat.copyFrom(this.getAbsoluteMatrix());
-        if (tNode && wm) {
-            tmat.multiplyToRef(wm, tmat);
-        }
-        Vector3.TransformCoordinatesToRef(position, tmat, result);
-    }
-    /**
-     * Get the local position of a point that is in world space
-     * @param position The world position
-     * @param tNode A TransformNode whose world matrix is to be applied to the calculated absolute matrix. In most cases, you'll want to pass the mesh associated with the skeleton from which this bone comes. Used only when space=Space.WORLD
-     * @returns The local position
-     */
-    getLocalPositionFromAbsolute(position, tNode = null) {
-        const result = Vector3.Zero();
-        this.getLocalPositionFromAbsoluteToRef(position, tNode, result);
-        return result;
-    }
-    /**
-     * Get the local position of a point that is in world space and copy it to the result param
-     * @param position The world position
-     * @param tNode A TransformNode whose world matrix is to be applied to the calculated absolute matrix. In most cases, you'll want to pass the mesh associated with the skeleton from which this bone comes. Used only when space=Space.WORLD
-     * @param result The vector3 that the local position should be copied to
-     */
-    getLocalPositionFromAbsoluteToRef(position, tNode = null, result) {
-        let wm = null;
-        //tNode.getWorldMatrix() needs to be called before skeleton.computeAbsoluteMatrices()
-        if (tNode) {
-            wm = tNode.getWorldMatrix();
-        }
-        this._skeleton.computeAbsoluteMatrices();
-        const tmat = Bone._TmpMats[0];
-        tmat.copyFrom(this.getAbsoluteMatrix());
-        if (tNode && wm) {
-            tmat.multiplyToRef(wm, tmat);
-        }
-        tmat.invert();
-        Vector3.TransformCoordinatesToRef(position, tmat, result);
-    }
-    /**
-     * Set the current local matrix as the restMatrix for this bone.
-     */
-    setCurrentPoseAsRest() {
-        this.setRestMatrix(this.getLocalMatrix());
-    }
-}
-Bone._TmpVecs = ArrayTools.BuildArray(2, Vector3.Zero);
-Bone._TmpQuat = Quaternion.Identity();
-Bone._TmpMats = ArrayTools.BuildArray(5, Matrix.Identity);
-
-// Do not edit.
-const name$s = "sharpenPixelShader";
-const shader$s = `varying vec2 vUV;
-void main(void)
-// Sideeffect
-ShaderStore.ShadersStore[name$s] = shader$s;
-
-/**
- * The SharpenPostProcess applies a sharpen kernel to every pixel
- * See http://en.wikipedia.org/wiki/Kernel_(image_processing)
- */
-class SharpenPostProcess extends PostProcess {
-    /**
-     * Gets a string identifying the name of the class
-     * @returns "SharpenPostProcess" string
-     */
-    getClassName() {
-        return "SharpenPostProcess";
-    }
-    /**
-     * Creates a new instance ConvolutionPostProcess
-     * @param name The name of the effect.
-     * @param options The required width/height ratio to downsize to before computing the render pass.
-     * @param camera The camera to apply the render pass to.
-     * @param samplingMode The sampling mode to be used when computing the pass. (default: 0)
-     * @param engine The engine which the post process will be applied. (default: current engine)
-     * @param reusable If the post process can be reused on the same frame. (default: false)
-     * @param textureType Type of textures used when performing the post process. (default: 0)
-     * @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, options, camera, samplingMode, engine, reusable, textureType = 0, blockCompilation = false) {
-        super(name, "sharpen", ["sharpnessAmounts", "screenSize"], null, options, camera, samplingMode, engine, reusable, null, textureType, undefined, null, blockCompilation);
-        /**
-         * How much of the original color should be applied. Setting this to 0 will display edge detection. (default: 1)
-         */
-        this.colorAmount = 1.0;
-        /**
-         * How much sharpness should be applied (default: 0.3)
-         */
-        this.edgeAmount = 0.3;
-        this.onApply = (effect) => {
-            effect.setFloat2("screenSize", this.width, this.height);
-            effect.setFloat2("sharpnessAmounts", this.edgeAmount, this.colorAmount);
-        };
-    }
-    /**
-     * @internal
-     */
-    static _Parse(parsedPostProcess, targetCamera, scene, rootUrl) {
-        return SerializationHelper.Parse(() => {
-            return new SharpenPostProcess(parsedPostProcess.name, parsedPostProcess.options, targetCamera, parsedPostProcess.renderTargetSamplingMode, scene.getEngine(), parsedPostProcess.textureType, parsedPostProcess.reusable);
-        }, parsedPostProcess, scene, rootUrl);
-    }
-}
-__decorate([
-    serialize()
-], SharpenPostProcess.prototype, "colorAmount", void 0);
-__decorate([
-    serialize()
-], SharpenPostProcess.prototype, "edgeAmount", void 0);
-RegisterClass("BABYLON.SharpenPostProcess", SharpenPostProcess);
-
-// Do not edit.
-const name$r = "imageProcessingPixelShader";
-const shader$r = `varying vec2 vUV;
-#include<helperFunctions>
-#include<imageProcessingFunctions>
-#define CUSTOM_FRAGMENT_DEFINITIONS
-void main(void)
-#ifndef FROMLINEARSPACE
-result.rgb=toLinearSpace(result.rgb);
-result=applyImageProcessing(result);
-#ifdef FROMLINEARSPACE
-result=applyImageProcessing(result);
-#endif
-gl_FragColor=result;
-// Sideeffect
-ShaderStore.ShadersStore[name$r] = shader$r;
-
-/**
- * ImageProcessingPostProcess
- * @see https://doc.babylonjs.com/features/featuresDeepDive/postProcesses/usePostProcesses#imageprocessing
- */
-class ImageProcessingPostProcess extends PostProcess {
-    /**
-     * Gets the image processing configuration used either in this material.
-     */
-    get imageProcessingConfiguration() {
-        return this._imageProcessingConfiguration;
-    }
-    /**
-     * Sets the Default image processing configuration used either in the this material.
-     *
-     * If sets to null, the scene one is in use.
-     */
-    set imageProcessingConfiguration(value) {
-        // We are almost sure it is applied by post process as
-        // We are in the post process :-)
-        value.applyByPostProcess = true;
-        this._attachImageProcessingConfiguration(value);
-    }
-    /**
-     * Attaches a new image processing configuration to the PBR Material.
-     * @param configuration
-     * @param doNotBuild
-     */
-    _attachImageProcessingConfiguration(configuration, doNotBuild = false) {
-        if (configuration === this._imageProcessingConfiguration) {
-            return;
-        }
-        // Detaches observer.
-        if (this._imageProcessingConfiguration && this._imageProcessingObserver) {
-            this._imageProcessingConfiguration.onUpdateParameters.remove(this._imageProcessingObserver);
-        }
-        // Pick the scene configuration if needed.
-        if (!configuration) {
-            let scene = null;
-            const engine = this.getEngine();
-            const camera = this.getCamera();
-            if (camera) {
-                scene = camera.getScene();
-            }
-            else if (engine && engine.scenes) {
-                const scenes = engine.scenes;
-                scene = scenes[scenes.length - 1];
-            }
-            else {
-                scene = EngineStore.LastCreatedScene;
-            }
-            if (scene) {
-                this._imageProcessingConfiguration = scene.imageProcessingConfiguration;
-            }
-            else {
-                this._imageProcessingConfiguration = new ImageProcessingConfiguration();
-            }
-        }
-        else {
-            this._imageProcessingConfiguration = configuration;
-        }
-        // Attaches observer.
-        if (this._imageProcessingConfiguration) {
-            this._imageProcessingObserver = this._imageProcessingConfiguration.onUpdateParameters.add(() => {
-                this._updateParameters();
-            });
-        }
-        // Ensure the effect will be rebuilt.
-        if (!doNotBuild) {
-            this._updateParameters();
-        }
-    }
-    /**
-     * If the post process is supported.
-     */
-    get isSupported() {
-        const effect = this.getEffect();
-        return !effect || effect.isSupported;
-    }
-    /**
-     * Gets Color curves setup used in the effect if colorCurvesEnabled is set to true .
-     */
-    get colorCurves() {
-        return this.imageProcessingConfiguration.colorCurves;
-    }
-    /**
-     * Sets Color curves setup used in the effect if colorCurvesEnabled is set to true .
-     */
-    set colorCurves(value) {
-        this.imageProcessingConfiguration.colorCurves = value;
-    }
-    /**
-     * Gets whether the color curves effect is enabled.
-     */
-    get colorCurvesEnabled() {
-        return this.imageProcessingConfiguration.colorCurvesEnabled;
-    }
-    /**
-     * Sets whether the color curves effect is enabled.
-     */
-    set colorCurvesEnabled(value) {
-        this.imageProcessingConfiguration.colorCurvesEnabled = value;
-    }
-    /**
-     * Gets Color grading LUT texture used in the effect if colorGradingEnabled is set to true.
-     */
-    get colorGradingTexture() {
-        return this.imageProcessingConfiguration.colorGradingTexture;
-    }
-    /**
-     * Sets Color grading LUT texture used in the effect if colorGradingEnabled is set to true.
-     */
-    set colorGradingTexture(value) {
-        this.imageProcessingConfiguration.colorGradingTexture = value;
-    }
-    /**
-     * Gets whether the color grading effect is enabled.
-     */
-    get colorGradingEnabled() {
-        return this.imageProcessingConfiguration.colorGradingEnabled;
-    }
-    /**
-     * Gets whether the color grading effect is enabled.
-     */
-    set colorGradingEnabled(value) {
-        this.imageProcessingConfiguration.colorGradingEnabled = value;
-    }
-    /**
-     * Gets exposure used in the effect.
-     */
-    get exposure() {
-        return this.imageProcessingConfiguration.exposure;
-    }
-    /**
-     * Sets exposure used in the effect.
-     */
-    set exposure(value) {
-        this.imageProcessingConfiguration.exposure = value;
-    }
-    /**
-     * Gets whether tonemapping is enabled or not.
-     */
-    get toneMappingEnabled() {
-        return this._imageProcessingConfiguration.toneMappingEnabled;
-    }
-    /**
-     * Sets whether tonemapping is enabled or not
-     */
-    set toneMappingEnabled(value) {
-        this._imageProcessingConfiguration.toneMappingEnabled = value;
-    }
-    /**
-     * Gets the type of tone mapping effect.
-     */
-    get toneMappingType() {
-        return this._imageProcessingConfiguration.toneMappingType;
-    }
-    /**
-     * Sets the type of tone mapping effect.
-     */
-    set toneMappingType(value) {
-        this._imageProcessingConfiguration.toneMappingType = value;
-    }
-    /**
-     * Gets contrast used in the effect.
-     */
-    get contrast() {
-        return this.imageProcessingConfiguration.contrast;
-    }
-    /**
-     * Sets contrast used in the effect.
-     */
-    set contrast(value) {
-        this.imageProcessingConfiguration.contrast = value;
-    }
-    /**
-     * Gets Vignette stretch size.
-     */
-    get vignetteStretch() {
-        return this.imageProcessingConfiguration.vignetteStretch;
-    }
-    /**
-     * Sets Vignette stretch size.
-     */
-    set vignetteStretch(value) {
-        this.imageProcessingConfiguration.vignetteStretch = value;
-    }
-    /**
-     * Gets Vignette center X Offset.
-     * @deprecated use vignetteCenterX instead
-     */
-    get vignetteCentreX() {
-        return this.imageProcessingConfiguration.vignetteCenterX;
-    }
-    /**
-     * Sets Vignette center X Offset.
-     * @deprecated use vignetteCenterX instead
-     */
-    set vignetteCentreX(value) {
-        this.imageProcessingConfiguration.vignetteCenterX = value;
-    }
-    /**
-     * Gets Vignette center Y Offset.
-     * @deprecated use vignetteCenterY instead
-     */
-    get vignetteCentreY() {
-        return this.imageProcessingConfiguration.vignetteCenterY;
-    }
-    /**
-     * Sets Vignette center Y Offset.
-     * @deprecated use vignetteCenterY instead
-     */
-    set vignetteCentreY(value) {
-        this.imageProcessingConfiguration.vignetteCenterY = value;
-    }
-    /**
-     * Vignette center Y Offset.
-     */
-    get vignetteCenterY() {
-        return this.imageProcessingConfiguration.vignetteCenterY;
-    }
-    set vignetteCenterY(value) {
-        this.imageProcessingConfiguration.vignetteCenterY = value;
-    }
-    /**
-     * Vignette center X Offset.
-     */
-    get vignetteCenterX() {
-        return this.imageProcessingConfiguration.vignetteCenterX;
-    }
-    set vignetteCenterX(value) {
-        this.imageProcessingConfiguration.vignetteCenterX = value;
-    }
-    /**
-     * Gets Vignette weight or intensity of the vignette effect.
-     */
-    get vignetteWeight() {
-        return this.imageProcessingConfiguration.vignetteWeight;
-    }
-    /**
-     * Sets Vignette weight or intensity of the vignette effect.
-     */
-    set vignetteWeight(value) {
-        this.imageProcessingConfiguration.vignetteWeight = value;
-    }
-    /**
-     * Gets Color of the vignette applied on the screen through the chosen blend mode (vignetteBlendMode)
-     * if vignetteEnabled is set to true.
-     */
-    get vignetteColor() {
-        return this.imageProcessingConfiguration.vignetteColor;
-    }
-    /**
-     * Sets Color of the vignette applied on the screen through the chosen blend mode (vignetteBlendMode)
-     * if vignetteEnabled is set to true.
-     */
-    set vignetteColor(value) {
-        this.imageProcessingConfiguration.vignetteColor = value;
-    }
-    /**
-     * Gets Camera field of view used by the Vignette effect.
-     */
-    get vignetteCameraFov() {
-        return this.imageProcessingConfiguration.vignetteCameraFov;
-    }
-    /**
-     * Sets Camera field of view used by the Vignette effect.
-     */
-    set vignetteCameraFov(value) {
-        this.imageProcessingConfiguration.vignetteCameraFov = value;
-    }
-    /**
-     * Gets the vignette blend mode allowing different kind of effect.
-     */
-    get vignetteBlendMode() {
-        return this.imageProcessingConfiguration.vignetteBlendMode;
-    }
-    /**
-     * Sets the vignette blend mode allowing different kind of effect.
-     */
-    set vignetteBlendMode(value) {
-        this.imageProcessingConfiguration.vignetteBlendMode = value;
-    }
-    /**
-     * Gets whether the vignette effect is enabled.
-     */
-    get vignetteEnabled() {
-        return this.imageProcessingConfiguration.vignetteEnabled;
-    }
-    /**
-     * Sets whether the vignette effect is enabled.
-     */
-    set vignetteEnabled(value) {
-        this.imageProcessingConfiguration.vignetteEnabled = value;
-    }
-    /**
-     * Gets intensity of the dithering effect.
-     */
-    get ditheringIntensity() {
-        return this.imageProcessingConfiguration.ditheringIntensity;
-    }
-    /**
-     * Sets intensity of the dithering effect.
-     */
-    set ditheringIntensity(value) {
-        this.imageProcessingConfiguration.ditheringIntensity = value;
-    }
-    /**
-     * Gets whether the dithering effect is enabled.
-     */
-    get ditheringEnabled() {
-        return this.imageProcessingConfiguration.ditheringEnabled;
-    }
-    /**
-     * Sets whether the dithering effect is enabled.
-     */
-    set ditheringEnabled(value) {
-        this.imageProcessingConfiguration.ditheringEnabled = value;
-    }
-    /**
-     * Gets whether the input of the processing is in Gamma or Linear Space.
-     */
-    get fromLinearSpace() {
-        return this._fromLinearSpace;
-    }
-    /**
-     * Sets whether the input of the processing is in Gamma or Linear Space.
-     */
-    set fromLinearSpace(value) {
-        if (this._fromLinearSpace === value) {
-            return;
-        }
-        this._fromLinearSpace = value;
-        this._updateParameters();
-    }
-    constructor(name, options, camera = null, samplingMode, engine, reusable, textureType = 0, imageProcessingConfiguration) {
-        super(name, "imageProcessing", [], [], options, camera, samplingMode, engine, reusable, null, textureType, "postprocess", null, true);
-        this._fromLinearSpace = true;
-        /**
-         * Defines cache preventing GC.
-         */
-        this._defines = {
-            IMAGEPROCESSING: false,
-            VIGNETTE: false,
-            VIGNETTEBLENDMODEMULTIPLY: false,
-            VIGNETTEBLENDMODEOPAQUE: false,
-            TONEMAPPING: false,
-            TONEMAPPING_ACES: false,
-            CONTRAST: false,
-            COLORCURVES: false,
-            COLORGRADING: false,
-            COLORGRADING3D: false,
-            FROMLINEARSPACE: false,
-            SAMPLER3DGREENDEPTH: false,
-            SAMPLER3DBGRMAP: false,
-            DITHER: false,
-            IMAGEPROCESSINGPOSTPROCESS: false,
-            EXPOSURE: false,
-            SKIPFINALCOLORCLAMP: false,
-        };
-        // Setup the configuration as forced by the constructor. This would then not force the
-        // scene materials output in linear space and let untouched the default forward pass.
-        if (imageProcessingConfiguration) {
-            imageProcessingConfiguration.applyByPostProcess = true;
-            this._attachImageProcessingConfiguration(imageProcessingConfiguration, true);
-            // This will cause the shader to be compiled
-            this._updateParameters();
-        }
-        // Setup the default processing configuration to the scene.
-        else {
-            this._attachImageProcessingConfiguration(null, true);
-            this.imageProcessingConfiguration.applyByPostProcess = true;
-        }
-        this.onApply = (effect) => {
-            this.imageProcessingConfiguration.bind(effect, this.aspectRatio);
-        };
-    }
-    /**
-     *  "ImageProcessingPostProcess"
-     * @returns "ImageProcessingPostProcess"
-     */
-    getClassName() {
-        return "ImageProcessingPostProcess";
-    }
-    /**
-     * @internal
-     */
-    _updateParameters() {
-        this._defines.FROMLINEARSPACE = this._fromLinearSpace;
-        this.imageProcessingConfiguration.prepareDefines(this._defines, true);
-        let defines = "";
-        for (const define in this._defines) {
-            if (this._defines[define]) {
-                defines += `#define ${define};\r\n`;
-            }
-        }
-        const samplers = ["textureSampler"];
-        const uniforms = ["scale"];
-        if (ImageProcessingConfiguration) {
-            ImageProcessingConfiguration.PrepareSamplers(samplers, this._defines);
-            ImageProcessingConfiguration.PrepareUniforms(uniforms, this._defines);
-        }
-        this.updateEffect(defines, uniforms, samplers);
-    }
-    dispose(camera) {
-        super.dispose(camera);
-        if (this._imageProcessingConfiguration && this._imageProcessingObserver) {
-            this._imageProcessingConfiguration.onUpdateParameters.remove(this._imageProcessingObserver);
-        }
-        if (this._imageProcessingConfiguration) {
-            this.imageProcessingConfiguration.applyByPostProcess = false;
-        }
-    }
-}
-__decorate([
-    serialize()
-], ImageProcessingPostProcess.prototype, "_fromLinearSpace", void 0);
-
-// Do not edit.
-const name$q = "chromaticAberrationPixelShader";
-const shader$q = `uniform sampler2D textureSampler; 
-void main(void)
-// Sideeffect
-ShaderStore.ShadersStore[name$q] = shader$q;
-
-/**
- * The ChromaticAberrationPostProcess separates the rgb channels in an image to produce chromatic distortion around the edges of the screen
- */
-class ChromaticAberrationPostProcess extends PostProcess {
-    /**
-     * Gets a string identifying the name of the class
-     * @returns "ChromaticAberrationPostProcess" string
-     */
-    getClassName() {
-        return "ChromaticAberrationPostProcess";
-    }
-    /**
-     * Creates a new instance ChromaticAberrationPostProcess
-     * @param name The name of the effect.
-     * @param screenWidth The width of the screen to apply the effect on.
-     * @param screenHeight The height of the screen to apply the effect on.
-     * @param options The required width/height ratio to downsize to before computing the render pass.
-     * @param camera The camera to apply the render pass to.
-     * @param samplingMode The sampling mode to be used when computing the pass. (default: 0)
-     * @param engine The engine which the post process will be applied. (default: current engine)
-     * @param reusable If the post process can be reused on the same frame. (default: false)
-     * @param textureType Type of textures used when performing the post process. (default: 0)
-     * @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, screenWidth, screenHeight, options, camera, samplingMode, engine, reusable, textureType = 0, blockCompilation = false) {
-        super(name, "chromaticAberration", ["chromatic_aberration", "screen_width", "screen_height", "direction", "radialIntensity", "centerPosition"], [], options, camera, samplingMode, engine, reusable, null, textureType, undefined, null, blockCompilation);
-        /**
-         * The amount of separation of rgb channels (default: 30)
-         */
-        this.aberrationAmount = 30;
-        /**
-         * The amount the effect will increase for pixels closer to the edge of the screen. (default: 0)
-         */
-        this.radialIntensity = 0;
-        /**
-         * The normalized direction in which the rgb channels should be separated. If set to 0,0 radial direction will be used. (default: Vector2(0.707,0.707))
-         */
-        this.direction = new Vector2(0.707, 0.707);
-        /**
-         * The center position where the radialIntensity should be around. [0.5,0.5 is center of screen, 1,1 is top right corner] (default: Vector2(0.5 ,0.5))
-         */
-        this.centerPosition = new Vector2(0.5, 0.5);
-        this.screenWidth = screenWidth;
-        this.screenHeight = screenHeight;
-        this.onApplyObservable.add((effect) => {
-            effect.setFloat("chromatic_aberration", this.aberrationAmount);
-            effect.setFloat("screen_width", screenWidth);
-            effect.setFloat("screen_height", screenHeight);
-            effect.setFloat("radialIntensity", this.radialIntensity);
-            effect.setFloat2("direction", this.direction.x, this.direction.y);
-            effect.setFloat2("centerPosition", this.centerPosition.x, this.centerPosition.y);
-        });
-    }
-    /**
-     * @internal
-     */
-    static _Parse(parsedPostProcess, targetCamera, scene, rootUrl) {
-        return SerializationHelper.Parse(() => {
-            return new ChromaticAberrationPostProcess(parsedPostProcess.name, parsedPostProcess.screenWidth, parsedPostProcess.screenHeight, parsedPostProcess.options, targetCamera, parsedPostProcess.renderTargetSamplingMode, scene.getEngine(), parsedPostProcess.reusable, parsedPostProcess.textureType, false);
-        }, parsedPostProcess, scene, rootUrl);
-    }
-}
-__decorate([
-    serialize()
-], ChromaticAberrationPostProcess.prototype, "aberrationAmount", void 0);
-__decorate([
-    serialize()
-], ChromaticAberrationPostProcess.prototype, "radialIntensity", void 0);
-__decorate([
-    serialize()
-], ChromaticAberrationPostProcess.prototype, "direction", void 0);
-__decorate([
-    serialize()
-], ChromaticAberrationPostProcess.prototype, "centerPosition", void 0);
-__decorate([
-    serialize()
-], ChromaticAberrationPostProcess.prototype, "screenWidth", void 0);
-__decorate([
-    serialize()
-], ChromaticAberrationPostProcess.prototype, "screenHeight", void 0);
-RegisterClass("BABYLON.ChromaticAberrationPostProcess", ChromaticAberrationPostProcess);
-
-// Do not edit.
-const name$p = "grainPixelShader";
-const shader$p = `#include<helperFunctions>
-uniform sampler2D textureSampler; 
-void main(void)
-// Sideeffect
-ShaderStore.ShadersStore[name$p] = shader$p;
-
-/**
- * The GrainPostProcess adds noise to the image at mid luminance levels
- */
-class GrainPostProcess extends PostProcess {
-    /**
-     * Gets a string identifying the name of the class
-     * @returns "GrainPostProcess" string
-     */
-    getClassName() {
-        return "GrainPostProcess";
-    }
-    /**
-     * Creates a new instance of @see GrainPostProcess
-     * @param name The name of the effect.
-     * @param options The required width/height ratio to downsize to before computing the render pass.
-     * @param camera The camera to apply the render pass to.
-     * @param samplingMode The sampling mode to be used when computing the pass. (default: 0)
-     * @param engine The engine which the post process will be applied. (default: current engine)
-     * @param reusable If the post process can be reused on the same frame. (default: false)
-     * @param textureType Type of textures used when performing the post process. (default: 0)
-     * @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, options, camera, samplingMode, engine, reusable, textureType = 0, blockCompilation = false) {
-        super(name, "grain", ["intensity", "animatedSeed"], [], options, camera, samplingMode, engine, reusable, null, textureType, undefined, null, blockCompilation);
-        /**
-         * The intensity of the grain added (default: 30)
-         */
-        this.intensity = 30;
-        /**
-         * If the grain should be randomized on every frame
-         */
-        this.animated = false;
-        this.onApplyObservable.add((effect) => {
-            effect.setFloat("intensity", this.intensity);
-            effect.setFloat("animatedSeed", this.animated ? Math.random() + 1 : 1);
-        });
-    }
-    /**
-     * @internal
-     */
-    static _Parse(parsedPostProcess, targetCamera, scene, rootUrl) {
-        return SerializationHelper.Parse(() => {
-            return new GrainPostProcess(parsedPostProcess.name, parsedPostProcess.options, targetCamera, parsedPostProcess.renderTargetSamplingMode, scene.getEngine(), parsedPostProcess.reusable);
-        }, parsedPostProcess, scene, rootUrl);
-    }
-}
-__decorate([
-    serialize()
-], GrainPostProcess.prototype, "intensity", void 0);
-__decorate([
-    serialize()
-], GrainPostProcess.prototype, "animated", void 0);
-RegisterClass("BABYLON.GrainPostProcess", GrainPostProcess);
-
-// Do not edit.
-const name$o = "fxaaPixelShader";
-const shader$o = `#if defined(WEBGL2) || defined(WEBGPU) || defined(NATIVE)
-#define TEXTUREFUNC(s,c,l) texture2DLodEXT(s,c,l)
-#else
-#define TEXTUREFUNC(s,c,b) texture2D(s,c,b)
-#endif
-uniform sampler2D textureSampler;
-void main(){
-if(range<rangeMaxClamped) 
-float lumaNW=FxaaLuma(TEXTUREFUNC(textureSampler,sampleCoordNW,0.0));
-if(range<rangeMaxClamped) 
-gl_FragColor=TEXTUREFUNC(textureSampler,posM,0.0);
-}`;
-// Sideeffect
-ShaderStore.ShadersStore[name$o] = shader$o;
-
-// Do not edit.
-const name$n = "fxaaVertexShader";
-const shader$n = `attribute vec2 position;
-void main(void) {
-vUV=(position*madd+madd);
-}`;
-// Sideeffect
-ShaderStore.ShadersStore[name$n] = shader$n;
-
-/**
- * Fxaa post process
- * @see https://doc.babylonjs.com/features/featuresDeepDive/postProcesses/usePostProcesses#fxaa
- */
-class FxaaPostProcess extends PostProcess {
-    /**
-     * Gets a string identifying the name of the class
-     * @returns "FxaaPostProcess" string
-     */
-    getClassName() {
-        return "FxaaPostProcess";
-    }
-    constructor(name, options, camera = null, samplingMode, engine, reusable, textureType = 0) {
-        super(name, "fxaa", ["texelSize"], null, options, camera, samplingMode || Texture.BILINEAR_SAMPLINGMODE, engine, reusable, null, textureType, "fxaa", undefined, true);
-        const defines = this._getDefines();
-        this.updateEffect(defines);
-        this.onApplyObservable.add((effect) => {
-            const texelSize = this.texelSize;
-            effect.setFloat2("texelSize", texelSize.x, texelSize.y);
-        });
-    }
-    _getDefines() {
-        const engine = this.getEngine();
-        if (!engine) {
-            return null;
-        }
-        const glInfo = engine.getGlInfo();
-        if (glInfo && glInfo.renderer && glInfo.renderer.toLowerCase().indexOf("mali") > -1) {
-            return "#define MALI 1\n";
-        }
-        return null;
-    }
-    /**
-     * @internal
-     */
-    static _Parse(parsedPostProcess, targetCamera, scene, rootUrl) {
-        return SerializationHelper.Parse(() => {
-            return new FxaaPostProcess(parsedPostProcess.name, parsedPostProcess.options, targetCamera, parsedPostProcess.renderTargetSamplingMode, scene.getEngine(), parsedPostProcess.reusable);
-        }, parsedPostProcess, scene, rootUrl);
-    }
-}
-RegisterClass("BABYLON.FxaaPostProcess", FxaaPostProcess);
-
-/**
- * PostProcessRenderPipeline
- * @see https://doc.babylonjs.com/features/featuresDeepDive/postProcesses/postProcessRenderPipeline
- */
-class PostProcessRenderPipeline {
-    /**
-     * Gets pipeline name
-     */
-    get name() {
-        return this._name;
-    }
-    /** Gets the list of attached cameras */
-    get cameras() {
-        return this._cameras;
-    }
-    /**
-     * Initializes a PostProcessRenderPipeline
-     * @param _engine engine to add the pipeline to
-     * @param name name of the pipeline
-     */
-    constructor(_engine, name) {
-        this._engine = _engine;
-        this._name = name;
-        this._renderEffects = {};
-        this._renderEffectsForIsolatedPass = new Array();
-        this._cameras = [];
-    }
-    /**
-     * Gets the class name
-     * @returns "PostProcessRenderPipeline"
-     */
-    getClassName() {
-        return "PostProcessRenderPipeline";
-    }
-    /**
-     * If all the render effects in the pipeline are supported
-     */
-    get isSupported() {
-        for (const renderEffectName in this._renderEffects) {
-            if (Object.prototype.hasOwnProperty.call(this._renderEffects, renderEffectName)) {
-                if (!this._renderEffects[renderEffectName].isSupported) {
-                    return false;
-                }
-            }
-        }
-        return true;
-    }
-    /**
-     * Adds an effect to the pipeline
-     * @param renderEffect the effect to add
-     */
-    addEffect(renderEffect) {
-        this._renderEffects[renderEffect._name] = renderEffect;
-    }
-    // private
-    /** @internal */
-    _rebuild() { }
-    /**
-     * @internal
-     */
-    _enableEffect(renderEffectName, cameras) {
-        const renderEffects = this._renderEffects[renderEffectName];
-        if (!renderEffects) {
-            return;
-        }
-        renderEffects._enable(Tools.MakeArray(cameras || this._cameras));
-    }
-    /**
-     * @internal
-     */
-    _disableEffect(renderEffectName, cameras) {
-        const renderEffects = this._renderEffects[renderEffectName];
-        if (!renderEffects) {
-            return;
-        }
-        renderEffects._disable(Tools.MakeArray(cameras || this._cameras));
-    }
-    /**
-     * @internal
-     */
-    _attachCameras(cameras, unique) {
-        const cams = Tools.MakeArray(cameras || this._cameras);
-        if (!cams) {
-            return;
-        }
-        const indicesToDelete = [];
-        let i;
-        for (i = 0; i < cams.length; i++) {
-            const camera = cams[i];
-            if (!camera) {
-                continue;
-            }
-            if (this._cameras.indexOf(camera) === -1) {
-                this._cameras.push(camera);
-            }
-            else if (unique) {
-                indicesToDelete.push(i);
-            }
-        }
-        for (i = 0; i < indicesToDelete.length; i++) {
-            cams.splice(indicesToDelete[i], 1);
-        }
-        for (const renderEffectName in this._renderEffects) {
-            if (Object.prototype.hasOwnProperty.call(this._renderEffects, renderEffectName)) {
-                this._renderEffects[renderEffectName]._attachCameras(cams);
-            }
-        }
-    }
-    /**
-     * @internal
-     */
-    _detachCameras(cameras) {
-        const cams = Tools.MakeArray(cameras || this._cameras);
-        if (!cams) {
-            return;
-        }
-        for (const renderEffectName in this._renderEffects) {
-            if (Object.prototype.hasOwnProperty.call(this._renderEffects, renderEffectName)) {
-                this._renderEffects[renderEffectName]._detachCameras(cams);
-            }
-        }
-        for (let i = 0; i < cams.length; i++) {
-            this._cameras.splice(this._cameras.indexOf(cams[i]), 1);
-        }
-    }
-    /** @internal */
-    _update() {
-        for (const renderEffectName in this._renderEffects) {
-            if (Object.prototype.hasOwnProperty.call(this._renderEffects, renderEffectName)) {
-                this._renderEffects[renderEffectName]._update();
-            }
-        }
-        for (let i = 0; i < this._cameras.length; i++) {
-            if (!this._cameras[i]) {
-                continue;
-            }
-            const cameraName = this._cameras[i].name;
-            if (this._renderEffectsForIsolatedPass[cameraName]) {
-                this._renderEffectsForIsolatedPass[cameraName]._update();
-            }
-        }
-    }
-    /** @internal */
-    _reset() {
-        this._renderEffects = {};
-        this._renderEffectsForIsolatedPass = new Array();
-    }
-    _enableMSAAOnFirstPostProcess(sampleCount) {
-        if (!this._engine._features.supportMSAA) {
-            return false;
-        }
-        // Set samples of the very first post process to 4 to enable native anti-aliasing in browsers that support webGL 2.0 (See: https://github.com/BabylonJS/Babylon.js/issues/3754)
-        const effectKeys = Object.keys(this._renderEffects);
-        if (effectKeys.length > 0) {
-            const postProcesses = this._renderEffects[effectKeys[0]].getPostProcesses();
-            if (postProcesses) {
-                postProcesses[0].samples = sampleCount;
-            }
-        }
-        return true;
-    }
-    /**
-     * Sets the required values to the prepass renderer.
-     * @param prePassRenderer defines the prepass renderer to setup.
-     * @returns true if the pre pass is needed.
-     */
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    setPrePassRenderer(prePassRenderer) {
-        // Do Nothing by default
-        return false;
-    }
-    /**
-     * Disposes of the pipeline
-     */
-    dispose() {
-        // Must be implemented by children
-    }
-}
-__decorate([
-    serialize()
-], PostProcessRenderPipeline.prototype, "_name", void 0);
-
-/**
- * This represents a set of one or more post processes in Babylon.
- * A post process can be used to apply a shader to a texture after it is rendered.
- * @example https://doc.babylonjs.com/features/featuresDeepDive/postProcesses/postProcessRenderPipeline
- */
-class PostProcessRenderEffect {
-    /**
-     * Instantiates a post process render effect.
-     * A post process can be used to apply a shader to a texture after it is rendered.
-     * @param engine The engine the effect is tied to
-     * @param name The name of the effect
-     * @param getPostProcesses A function that returns a set of post processes which the effect will run in order to be run.
-     * @param singleInstance False if this post process can be run on multiple cameras. (default: true)
-     */
-    constructor(engine, name, getPostProcesses, singleInstance) {
-        this._name = name;
-        this._singleInstance = singleInstance || true;
-        this._getPostProcesses = getPostProcesses;
-        this._cameras = {};
-        this._indicesForCamera = {};
-        this._postProcesses = {};
-    }
-    /**
-     * Checks if all the post processes in the effect are supported.
-     */
-    get isSupported() {
-        for (const index in this._postProcesses) {
-            if (Object.prototype.hasOwnProperty.call(this._postProcesses, index)) {
-                const pps = this._postProcesses[index];
-                for (let ppIndex = 0; ppIndex < pps.length; ppIndex++) {
-                    if (!pps[ppIndex].isSupported) {
-                        return false;
-                    }
-                }
-            }
-        }
-        return true;
-    }
-    /**
-     * Updates the current state of the effect
-     * @internal
-     */
-    _update() { }
-    /**
-     * Attaches the effect on cameras
-     * @param cameras The camera to attach to.
-     * @internal
-     */
-    _attachCameras(cameras) {
-        let cameraKey;
-        const cams = Tools.MakeArray(cameras || this._cameras);
-        if (!cams) {
-            return;
-        }
-        for (let i = 0; i < cams.length; i++) {
-            const camera = cams[i];
-            if (!camera) {
-                continue;
-            }
-            const cameraName = camera.name;
-            if (this._singleInstance) {
-                cameraKey = 0;
-            }
-            else {
-                cameraKey = cameraName;
-            }
-            if (!this._postProcesses[cameraKey]) {
-                const postProcess = this._getPostProcesses();
-                if (postProcess) {
-                    this._postProcesses[cameraKey] = Array.isArray(postProcess) ? postProcess : [postProcess];
-                }
-            }
-            if (!this._indicesForCamera[cameraName]) {
-                this._indicesForCamera[cameraName] = [];
-            }
-            this._postProcesses[cameraKey].forEach((postProcess) => {
-                const index = camera.attachPostProcess(postProcess);
-                this._indicesForCamera[cameraName].push(index);
-            });
-            if (!this._cameras[cameraName]) {
-                this._cameras[cameraName] = camera;
-            }
-        }
-    }
-    /**
-     * Detaches the effect on cameras
-     * @param cameras The camera to detach from.
-     * @internal
-     */
-    _detachCameras(cameras) {
-        const cams = Tools.MakeArray(cameras || this._cameras);
-        if (!cams) {
-            return;
-        }
-        for (let i = 0; i < cams.length; i++) {
-            const camera = cams[i];
-            const cameraName = camera.name;
-            const postProcesses = this._postProcesses[this._singleInstance ? 0 : cameraName];
-            if (postProcesses) {
-                postProcesses.forEach((postProcess) => {
-                    camera.detachPostProcess(postProcess);
-                });
-            }
-            if (this._cameras[cameraName]) {
-                this._cameras[cameraName] = null;
-            }
-        }
-    }
-    /**
-     * Enables the effect on given cameras
-     * @param cameras The camera to enable.
-     * @internal
-     */
-    _enable(cameras) {
-        const cams = Tools.MakeArray(cameras || this._cameras);
-        if (!cams) {
-            return;
-        }
-        for (let i = 0; i < cams.length; i++) {
-            const camera = cams[i];
-            const cameraName = camera.name;
-            for (let j = 0; j < this._indicesForCamera[cameraName].length; j++) {
-                if (camera._postProcesses[this._indicesForCamera[cameraName][j]] === undefined || camera._postProcesses[this._indicesForCamera[cameraName][j]] === null) {
-                    this._postProcesses[this._singleInstance ? 0 : cameraName].forEach((postProcess) => {
-                        cams[i].attachPostProcess(postProcess, this._indicesForCamera[cameraName][j]);
-                    });
-                }
-            }
-        }
-    }
-    /**
-     * Disables the effect on the given cameras
-     * @param cameras The camera to disable.
-     * @internal
-     */
-    _disable(cameras) {
-        const cams = Tools.MakeArray(cameras || this._cameras);
-        if (!cams) {
-            return;
-        }
-        for (let i = 0; i < cams.length; i++) {
-            const camera = cams[i];
-            const cameraName = camera.name;
-            this._postProcesses[this._singleInstance ? 0 : cameraName].forEach((postProcess) => {
-                camera.detachPostProcess(postProcess);
-            });
-        }
-    }
-    /**
-     * Gets a list of the post processes contained in the effect.
-     * @param camera The camera to get the post processes on.
-     * @returns The list of the post processes in the effect.
-     */
-    getPostProcesses(camera) {
-        if (this._singleInstance) {
-            return this._postProcesses[0];
-        }
-        else {
-            if (!camera) {
-                return null;
-            }
-            return this._postProcesses[camera.name];
-        }
-    }
-}
-
-// Do not edit.
-const name$m = "circleOfConfusionPixelShader";
-const shader$m = `uniform sampler2D depthSampler;
-void main(void)
-float pixelDistance=(cameraMinMaxZ.x+cameraMinMaxZ.y*depth)*1000.0; 
-float coc=abs(cocPrecalculation*((focusDistance-pixelDistance)/pixelDistance));
-// Sideeffect
-ShaderStore.ShadersStore[name$m] = shader$m;
-
-/**
- * The CircleOfConfusionPostProcess computes the circle of confusion value for each pixel given required lens parameters. See https://en.wikipedia.org/wiki/Circle_of_confusion
- */
-class CircleOfConfusionPostProcess extends PostProcess {
-    /**
-     * Gets a string identifying the name of the class
-     * @returns "CircleOfConfusionPostProcess" string
-     */
-    getClassName() {
-        return "CircleOfConfusionPostProcess";
-    }
-    /**
-     * Creates a new instance CircleOfConfusionPostProcess
-     * @param name The name of the effect.
-     * @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 options The required width/height ratio to downsize to before computing the render pass.
-     * @param camera The camera to apply the render pass to.
-     * @param samplingMode The sampling mode to be used when computing the pass. (default: 0)
-     * @param engine The engine which the post process will be applied. (default: current engine)
-     * @param reusable If the post process can be reused on the same frame. (default: false)
-     * @param textureType Type of textures used when performing the post process. (default: 0)
-     * @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, depthTexture, options, camera, samplingMode, engine, reusable, textureType = 0, blockCompilation = false) {
-        super(name, "circleOfConfusion", ["cameraMinMaxZ", "focusDistance", "cocPrecalculation"], ["depthSampler"], options, camera, samplingMode, engine, reusable, null, textureType, undefined, null, blockCompilation);
-        /**
-         * 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;
-        this._depthTexture = null;
-        this._depthTexture = depthTexture;
-        this.onApplyObservable.add((effect) => {
-            if (!this._depthTexture) {
-                Logger.Warn("No depth texture set on CircleOfConfusionPostProcess");
-                return;
-            }
-            effect.setTexture("depthSampler", this._depthTexture);
-            // 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);
-            const activeCamera = this._depthTexture.activeCamera;
-            effect.setFloat2("cameraMinMaxZ", activeCamera.minZ, activeCamera.maxZ - activeCamera.minZ);
-        });
-    }
-    /**
-     * 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.
-     */
-    set depthTexture(value) {
-        this._depthTexture = value;
-    }
-}
-__decorate([
-    serialize()
-], CircleOfConfusionPostProcess.prototype, "lensSize", void 0);
-__decorate([
-    serialize()
-], CircleOfConfusionPostProcess.prototype, "fStop", void 0);
-__decorate([
-    serialize()
-], CircleOfConfusionPostProcess.prototype, "focusDistance", void 0);
-__decorate([
-    serialize()
-], CircleOfConfusionPostProcess.prototype, "focalLength", void 0);
-RegisterClass("BABYLON.CircleOfConfusionPostProcess", CircleOfConfusionPostProcess);
-
-/**
- * The DepthOfFieldBlurPostProcess applied a blur in a give direction.
- * This blur differs from the standard BlurPostProcess as it attempts to avoid blurring pixels
- * based on samples that have a large difference in distance than the center pixel.
- * See section 2.6.2 http://fileadmin.cs.lth.se/cs/education/edan35/lectures/12dof.pdf
- */
-class DepthOfFieldBlurPostProcess extends BlurPostProcess {
-    /**
-     * Gets a string identifying the name of the class
-     * @returns "DepthOfFieldBlurPostProcess" string
-     */
-    getClassName() {
-        return "DepthOfFieldBlurPostProcess";
-    }
-    /**
-     * Creates a new instance DepthOfFieldBlurPostProcess
-     * @param name The name of the effect.
-     * @param scene The scene the effect belongs to.
-     * @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.
-     * @param camera The camera to apply the render pass to.
-     * @param circleOfConfusion The circle of confusion + depth map to be used to avoid blurring across edges
-     * @param imageToBlur The image to apply the blur to (default: Current rendered frame)
-     * @param samplingMode The sampling mode to be used when computing the pass. (default: 0)
-     * @param engine The engine which the post process will be applied. (default: current engine)
-     * @param reusable If the post process can be reused on the same frame. (default: false)
-     * @param textureType Type of textures used when performing the post process. (default: 0)
-     * @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\r\n`, blockCompilation, textureFormat);
-        this.direction = direction;
-        this.externalTextureSamplerBinding = !!imageToBlur;
-        this.onApplyObservable.add((effect) => {
-            if (imageToBlur != null) {
-                effect.setTextureFromPostProcess("textureSampler", imageToBlur);
-            }
-            effect.setTextureFromPostProcessOutput("circleOfConfusionSampler", circleOfConfusion);
-        });
-    }
-}
-__decorate([
-    serialize()
-], DepthOfFieldBlurPostProcess.prototype, "direction", void 0);
-RegisterClass("BABYLON.DepthOfFieldBlurPostProcess", DepthOfFieldBlurPostProcess);
-
-// Do not edit.
-const name$l = "depthOfFieldMergePixelShader";
-const shader$l = `#if defined(WEBGL2) || defined(WEBGPU) || defined(NATIVE)
-#define TEXTUREFUNC(s,c,lod) texture2DLodEXT(s,c,lod)
-#else
-#define TEXTUREFUNC(s,c,bias) texture2D(s,c,bias)
-#endif
-uniform sampler2D textureSampler;
-uniform sampler2D blurStep1;
-#if BLUR_LEVEL>1
-uniform sampler2D blurStep2;
-#define CUSTOM_FRAGMENT_DEFINITIONS
-void main(void)
-vec4 original=TEXTUREFUNC(textureSampler,vUV,0.0);
-#if BLUR_LEVEL==1
-if(coc<0.5){
-#if BLUR_LEVEL==2
-if(coc<0.33){
-}
-// Sideeffect
-ShaderStore.ShadersStore[name$l] = shader$l;
-
-/**
- * The DepthOfFieldMergePostProcess merges blurred images with the original based on the values of the circle of confusion.
- */
-class DepthOfFieldMergePostProcess extends PostProcess {
-    /**
-     * Gets a string identifying the name of the class
-     * @returns "DepthOfFieldMergePostProcess" string
-     */
-    getClassName() {
-        return "DepthOfFieldMergePostProcess";
-    }
-    /**
-     * Creates a new instance of DepthOfFieldMergePostProcess
-     * @param name The name of the effect.
-     * @param originalFromInput Post process which's input will be used for the merge.
-     * @param circleOfConfusion Circle of confusion post process which's output will be used to blur each pixel.
-     * @param _blurSteps Blur post processes from low to high which will be mixed with the original image.
-     * @param options The required width/height ratio to downsize to before computing the render pass.
-     * @param camera The camera to apply the render pass to.
-     * @param samplingMode The sampling mode to be used when computing the pass. (default: 0)
-     * @param engine The engine which the post process will be applied. (default: current engine)
-     * @param reusable If the post process can be reused on the same frame. (default: false)
-     * @param textureType Type of textures used when performing the post process. (default: 0)
-     * @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);
-        this._blurSteps = _blurSteps;
-        this.externalTextureSamplerBinding = true;
-        this.onApplyObservable.add((effect) => {
-            effect.setTextureFromPostProcess("textureSampler", originalFromInput);
-            effect.setTextureFromPostProcessOutput("circleOfConfusionSampler", circleOfConfusion);
-            _blurSteps.forEach((step, index) => {
-                effect.setTextureFromPostProcessOutput("blurStep" + (_blurSteps.length - index - 1), step);
-            });
-        });
-        if (!blockCompilation) {
-            this.updateEffect();
-        }
-    }
-    /**
-     * 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)
-     * @param uniforms Set of uniform variables that will be passed to the shader. (default: null)
-     * @param samplers Set of Texture2D variables that will be passed to the shader. (default: null)
-     * @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
-     * @param onCompiled Called when the shader has been compiled.
-     * @param onError Called if there is an error when compiling a shader.
-     */
-    updateEffect(defines = null, uniforms = null, samplers = null, indexParameters, onCompiled, onError) {
-        if (!defines) {
-            defines = "";
-            defines += "#define BLUR_LEVEL " + (this._blurSteps.length - 1) + "\n";
-        }
-        super.updateEffect(defines, uniforms, samplers, indexParameters, onCompiled, onError);
-    }
-}
-
-/**
- * Specifies the level of max blur that should be applied when using the depth of field effect
- */
-var DepthOfFieldEffectBlurLevel;
-(function (DepthOfFieldEffectBlurLevel) {
-    /**
-     * Subtle blur
-     */
-    DepthOfFieldEffectBlurLevel[DepthOfFieldEffectBlurLevel["Low"] = 0] = "Low";
-    /**
-     * Medium blur
-     */
-    DepthOfFieldEffectBlurLevel[DepthOfFieldEffectBlurLevel["Medium"] = 1] = "Medium";
-    /**
-     * Large blur
-     */
-    DepthOfFieldEffectBlurLevel[DepthOfFieldEffectBlurLevel["High"] = 2] = "High";
-})(DepthOfFieldEffectBlurLevel || (DepthOfFieldEffectBlurLevel = {}));
-/**
- * The depth of field effect applies a blur to objects that are closer or further from where the camera is focusing.
- */
-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;
-    }
-    get focalLength() {
-        return this._circleOfConfusion.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;
-    }
-    get fStop() {
-        return this._circleOfConfusion.fStop;
-    }
-    /**
-     * Distance away from the camera to focus on in scene units/1000 (eg. millimeter). (default: 2000)
-     */
-    set focusDistance(value) {
-        this._circleOfConfusion.focusDistance = value;
-    }
-    get focusDistance() {
-        return this._circleOfConfusion.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;
-    }
-    get lensSize() {
-        return this._circleOfConfusion.lensSize;
-    }
-    /**
-     * Creates a new instance DepthOfFieldEffect
-     * @param scene The scene 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)
-     */
-    constructor(scene, depthTexture, blurLevel = DepthOfFieldEffectBlurLevel.Low, pipelineTextureType = 0, blockCompilation = false) {
-        super(scene.getEngine(), "depth of field", () => {
-            return this._effects;
-        }, true);
-        /**
-         * @internal Internal post processes in depth of field effect
-         */
-        this._effects = [];
-        // 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.webGLVersion > 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);
-        // 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 DepthOfFieldEffectBlurLevel.High: {
-                blurCount = 3;
-                kernelSize = 51;
-                break;
-            }
-            case 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;
-        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);
-            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);
-            blurX.autoClear = false;
-            this._depthOfFieldBlurY.push(blurY);
-            this._depthOfFieldBlurX.push(blurX);
-        }
-        // Set all post processes on the effect.
-        this._effects = [this._circleOfConfusion];
-        for (let i = 0; i < this._depthOfFieldBlurX.length; i++) {
-            this._effects.push(this._depthOfFieldBlurY[i]);
-            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.autoClear = false;
-        this._effects.push(this._dofMerge);
-    }
-    /**
-     * Get the current class name of the current effect
-     * @returns "DepthOfFieldEffect"
-     */
-    getClassName() {
-        return "DepthOfFieldEffect";
-    }
-    /**
-     * 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.
-     */
-    set depthTexture(value) {
-        this._circleOfConfusion.depthTexture = value;
-    }
-    /**
-     * Disposes each of the internal effects for a given camera.
-     * @param camera The camera to dispose the effect on.
-     */
-    disposeEffects(camera) {
-        for (let effectIndex = 0; effectIndex < this._effects.length; effectIndex++) {
-            this._effects[effectIndex].dispose(camera);
-        }
-    }
-    /**
-     * @internal Internal
-     */
-    _updateEffects() {
-        for (let effectIndex = 0; effectIndex < this._effects.length; effectIndex++) {
-            this._effects[effectIndex].updateEffect();
-        }
-    }
-    /**
-     * Internal
-     * @returns if all the contained post processes are ready.
-     * @internal
-     */
-    _isReady() {
-        for (let effectIndex = 0; effectIndex < this._effects.length; effectIndex++) {
-            if (!this._effects[effectIndex].isReady()) {
-                return false;
-            }
-        }
-        return true;
-    }
-}
-
-// Do not edit.
-const name$k = "extractHighlightsPixelShader";
-const shader$k = `#include<helperFunctions>
-varying vec2 vUV;
-void main(void) 
-// Sideeffect
-ShaderStore.ShadersStore[name$k] = shader$k;
-
-/**
- * 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.
- */
-class ExtractHighlightsPostProcess extends PostProcess {
-    /**
-     * Gets a string identifying the name of the class
-     * @returns "ExtractHighlightsPostProcess" string
-     */
-    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;
-        /**
-         * Post process which has the input texture to be used when performing highlight extraction
-         * @internal
-         */
-        this._inputPostProcess = null;
-        this.onApplyObservable.add((effect) => {
-            this.externalTextureSamplerBinding = !!this._inputPostProcess;
-            if (this._inputPostProcess) {
-                effect.setTextureFromPostProcess("textureSampler", this._inputPostProcess);
-            }
-            effect.setFloat("threshold", Math.pow(this.threshold, ToGammaSpace));
-            effect.setFloat("exposure", this._exposure);
-        });
-    }
-}
-__decorate([
-    serialize()
-], ExtractHighlightsPostProcess.prototype, "threshold", void 0);
-RegisterClass("BABYLON.ExtractHighlightsPostProcess", ExtractHighlightsPostProcess);
-
-// Do not edit.
-const name$j = "bloomMergePixelShader";
-const shader$j = `uniform sampler2D textureSampler;
-void main(void)
-// Sideeffect
-ShaderStore.ShadersStore[name$j] = shader$j;
-
-/**
- * The BloomMergePostProcess merges blurred images with the original based on the values of the circle of confusion.
- */
-class BloomMergePostProcess extends PostProcess {
-    /**
-     * Gets a string identifying the name of the class
-     * @returns "BloomMergePostProcess" string
-     */
-    getClassName() {
-        return "BloomMergePostProcess";
-    }
-    /**
-     * Creates a new instance of @see BloomMergePostProcess
-     * @param name The name of the effect.
-     * @param originalFromInput Post process which's input will be used for the merge.
-     * @param blurred Blurred highlights post process which's output will be used.
-     * @param weight Weight of the bloom to be added to the original input.
-     * @param options The required width/height ratio to downsize to before computing the render pass.
-     * @param camera The camera to apply the render pass to.
-     * @param samplingMode The sampling mode to be used when computing the pass. (default: 0)
-     * @param engine The engine which the post process will be applied. (default: current engine)
-     * @param reusable If the post process can be reused on the same frame. (default: false)
-     * @param textureType Type of textures used when performing the post process. (default: 0)
-     * @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, blurred, 
-    /** Weight of the bloom to be added to the original input. */
-    weight, options, camera, samplingMode, engine, reusable, textureType = 0, blockCompilation = false) {
-        super(name, "bloomMerge", ["bloomWeight"], ["bloomBlur"], options, camera, samplingMode, engine, reusable, null, textureType, undefined, null, true);
-        /** Weight of the bloom to be added to the original input. */
-        this.weight = 1;
-        this.weight = weight;
-        this.externalTextureSamplerBinding = true;
-        this.onApplyObservable.add((effect) => {
-            effect.setTextureFromPostProcess("textureSampler", originalFromInput);
-            effect.setTextureFromPostProcessOutput("bloomBlur", blurred);
-            effect.setFloat("bloomWeight", this.weight);
-        });
-        if (!blockCompilation) {
-            this.updateEffect();
-        }
-    }
-}
-__decorate([
-    serialize()
-], BloomMergePostProcess.prototype, "weight", void 0);
-RegisterClass("BABYLON.BloomMergePostProcess", BloomMergePostProcess);
-
-/**
- * The bloom effect spreads bright areas of an image to simulate artifacts seen in cameras
- */
-class BloomEffect extends PostProcessRenderEffect {
-    /**
-     * The luminance threshold to find bright areas of the image to bloom.
-     */
-    get threshold() {
-        return this._downscale.threshold;
-    }
-    set threshold(value) {
-        this._downscale.threshold = value;
-    }
-    /**
-     * The strength of the bloom.
-     */
-    get weight() {
-        return this._merge.weight;
-    }
-    set weight(value) {
-        this._merge.weight = value;
-    }
-    /**
-     * Specifies the size of the bloom blur kernel, relative to the final output size
-     */
-    get kernel() {
-        return this._blurX.kernel / this._bloomScale;
-    }
-    set kernel(value) {
-        this._blurX.kernel = value * this._bloomScale;
-        this._blurY.kernel = value * this._bloomScale;
-    }
-    /**
-     * Creates a new instance of @see BloomEffect
-     * @param scene The scene the effect belongs to.
-     * @param _bloomScale The ratio of the blur texture to the input texture that should be used to compute the bloom.
-     * @param bloomWeight The the strength of bloom.
-     * @param bloomKernel The size of the kernel to be used when applying the blur.
-     * @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)
-     */
-    constructor(scene, _bloomScale, bloomWeight, bloomKernel, pipelineTextureType = 0, blockCompilation = false) {
-        super(scene.getEngine(), "bloom", () => {
-            return this._effects;
-        }, true);
-        this._bloomScale = _bloomScale;
-        /**
-         * @internal Internal
-         */
-        this._effects = [];
-        this._downscale = new ExtractHighlightsPostProcess("highlights", 1.0, null, Texture.BILINEAR_SAMPLINGMODE, scene.getEngine(), false, pipelineTextureType, blockCompilation);
-        this._blurX = new BlurPostProcess("horizontal blur", new Vector2(1.0, 0), 10.0, _bloomScale, null, Texture.BILINEAR_SAMPLINGMODE, scene.getEngine(), false, pipelineTextureType, undefined, blockCompilation);
-        this._blurX.alwaysForcePOT = true;
-        this._blurX.autoClear = false;
-        this._blurY = new BlurPostProcess("vertical blur", new Vector2(0, 1.0), 10.0, _bloomScale, null, Texture.BILINEAR_SAMPLINGMODE, scene.getEngine(), false, pipelineTextureType, undefined, blockCompilation);
-        this._blurY.alwaysForcePOT = true;
-        this._blurY.autoClear = false;
-        this.kernel = bloomKernel;
-        this._effects = [this._downscale, this._blurX, this._blurY];
-        this._merge = new BloomMergePostProcess("bloomMerge", this._downscale, this._blurY, bloomWeight, _bloomScale, null, Texture.BILINEAR_SAMPLINGMODE, scene.getEngine(), false, pipelineTextureType, blockCompilation);
-        this._merge.autoClear = false;
-        this._effects.push(this._merge);
-    }
-    /**
-     * Disposes each of the internal effects for a given camera.
-     * @param camera The camera to dispose the effect on.
-     */
-    disposeEffects(camera) {
-        for (let effectIndex = 0; effectIndex < this._effects.length; effectIndex++) {
-            this._effects[effectIndex].dispose(camera);
-        }
-    }
-    /**
-     * @internal Internal
-     */
-    _updateEffects() {
-        for (let effectIndex = 0; effectIndex < this._effects.length; effectIndex++) {
-            this._effects[effectIndex].updateEffect();
-        }
-    }
-    /**
-     * Internal
-     * @returns if all the contained post processes are ready.
-     * @internal
-     */
-    _isReady() {
-        for (let effectIndex = 0; effectIndex < this._effects.length; effectIndex++) {
-            if (!this._effects[effectIndex].isReady()) {
-                return false;
-            }
-        }
-        return true;
-    }
-}
-
-/**
- * PostProcessRenderPipelineManager class
- * @see https://doc.babylonjs.com/features/featuresDeepDive/postProcesses/postProcessRenderPipeline
- */
-class PostProcessRenderPipelineManager {
-    /**
-     * Initializes a PostProcessRenderPipelineManager
-     * @see https://doc.babylonjs.com/features/featuresDeepDive/postProcesses/postProcessRenderPipeline
-     */
-    constructor() {
-        this._renderPipelines = {};
-    }
-    /**
-     * Gets the list of supported render pipelines
-     */
-    get supportedPipelines() {
-        const result = [];
-        for (const renderPipelineName in this._renderPipelines) {
-            if (Object.prototype.hasOwnProperty.call(this._renderPipelines, renderPipelineName)) {
-                const pipeline = this._renderPipelines[renderPipelineName];
-                if (pipeline.isSupported) {
-                    result.push(pipeline);
-                }
-            }
-        }
-        return result;
-    }
-    /**
-     * Adds a pipeline to the manager
-     * @param renderPipeline The pipeline to add
-     */
-    addPipeline(renderPipeline) {
-        this._renderPipelines[renderPipeline._name] = renderPipeline;
-    }
-    /**
-     * Remove the pipeline from the manager
-     * @param renderPipelineName the name of the pipeline to remove
-     */
-    removePipeline(renderPipelineName) {
-        delete this._renderPipelines[renderPipelineName];
-    }
-    /**
-     * Attaches a camera to the pipeline
-     * @param renderPipelineName The name of the pipeline to attach to
-     * @param cameras the camera to attach
-     * @param unique if the camera can be attached multiple times to the pipeline
-     */
-    attachCamerasToRenderPipeline(renderPipelineName, cameras, unique = false) {
-        const renderPipeline = this._renderPipelines[renderPipelineName];
-        if (!renderPipeline) {
-            return;
-        }
-        renderPipeline._attachCameras(cameras, unique);
-    }
-    /**
-     * Detaches a camera from the pipeline
-     * @param renderPipelineName The name of the pipeline to detach from
-     * @param cameras the camera to detach
-     */
-    detachCamerasFromRenderPipeline(renderPipelineName, cameras) {
-        const renderPipeline = this._renderPipelines[renderPipelineName];
-        if (!renderPipeline) {
-            return;
-        }
-        renderPipeline._detachCameras(cameras);
-    }
-    /**
-     * Enables an effect by name on a pipeline
-     * @param renderPipelineName the name of the pipeline to enable the effect in
-     * @param renderEffectName the name of the effect to enable
-     * @param cameras the cameras that the effect should be enabled on
-     */
-    enableEffectInPipeline(renderPipelineName, renderEffectName, cameras) {
-        const renderPipeline = this._renderPipelines[renderPipelineName];
-        if (!renderPipeline) {
-            return;
-        }
-        renderPipeline._enableEffect(renderEffectName, cameras);
-    }
-    /**
-     * Disables an effect by name on a pipeline
-     * @param renderPipelineName the name of the pipeline to disable the effect in
-     * @param renderEffectName the name of the effect to disable
-     * @param cameras the cameras that the effect should be disabled on
-     */
-    disableEffectInPipeline(renderPipelineName, renderEffectName, cameras) {
-        const renderPipeline = this._renderPipelines[renderPipelineName];
-        if (!renderPipeline) {
-            return;
-        }
-        renderPipeline._disableEffect(renderEffectName, cameras);
-    }
-    /**
-     * Updates the state of all contained render pipelines and disposes of any non supported pipelines
-     */
-    update() {
-        for (const renderPipelineName in this._renderPipelines) {
-            if (Object.prototype.hasOwnProperty.call(this._renderPipelines, renderPipelineName)) {
-                const pipeline = this._renderPipelines[renderPipelineName];
-                if (!pipeline.isSupported) {
-                    pipeline.dispose();
-                    delete this._renderPipelines[renderPipelineName];
-                }
-                else {
-                    pipeline._update();
-                }
-            }
-        }
-    }
-    /** @internal */
-    _rebuild() {
-        for (const renderPipelineName in this._renderPipelines) {
-            if (Object.prototype.hasOwnProperty.call(this._renderPipelines, renderPipelineName)) {
-                const pipeline = this._renderPipelines[renderPipelineName];
-                pipeline._rebuild();
-            }
-        }
-    }
-    /**
-     * Disposes of the manager and pipelines
-     */
-    dispose() {
-        for (const renderPipelineName in this._renderPipelines) {
-            if (Object.prototype.hasOwnProperty.call(this._renderPipelines, renderPipelineName)) {
-                const pipeline = this._renderPipelines[renderPipelineName];
-                pipeline.dispose();
-            }
-        }
-    }
-}
-
-Object.defineProperty(Scene.prototype, "postProcessRenderPipelineManager", {
-    get: function () {
-        if (!this._postProcessRenderPipelineManager) {
-            // Register the G Buffer component to the scene.
-            let component = this._getComponent(SceneComponentConstants.NAME_POSTPROCESSRENDERPIPELINEMANAGER);
-            if (!component) {
-                component = new PostProcessRenderPipelineManagerSceneComponent(this);
-                this._addComponent(component);
-            }
-            this._postProcessRenderPipelineManager = new PostProcessRenderPipelineManager();
-        }
-        return this._postProcessRenderPipelineManager;
-    },
-    enumerable: true,
-    configurable: true,
-});
-/**
- * Defines the Render Pipeline scene component responsible to rendering pipelines
- */
-class PostProcessRenderPipelineManagerSceneComponent {
-    /**
-     * Creates a new instance of the component for the given scene
-     * @param scene Defines the scene to register the component in
-     */
-    constructor(scene) {
-        /**
-         * The component name helpful to identify the component in the list of scene components.
-         */
-        this.name = SceneComponentConstants.NAME_POSTPROCESSRENDERPIPELINEMANAGER;
-        this.scene = scene;
-    }
-    /**
-     * Registers the component in a given scene
-     */
-    register() {
-        this.scene._gatherRenderTargetsStage.registerStep(SceneComponentConstants.STEP_GATHERRENDERTARGETS_POSTPROCESSRENDERPIPELINEMANAGER, this, this._gatherRenderTargets);
-    }
-    /**
-     * Rebuilds the elements related to this component in case of
-     * context lost for instance.
-     */
-    rebuild() {
-        if (this.scene._postProcessRenderPipelineManager) {
-            this.scene._postProcessRenderPipelineManager._rebuild();
-        }
-    }
-    /**
-     * Disposes the component and the associated resources
-     */
-    dispose() {
-        if (this.scene._postProcessRenderPipelineManager) {
-            this.scene._postProcessRenderPipelineManager.dispose();
-        }
-    }
-    _gatherRenderTargets() {
-        if (this.scene._postProcessRenderPipelineManager) {
-            this.scene._postProcessRenderPipelineManager.update();
-        }
-    }
-}
-
-/**
- * The default rendering pipeline can be added to a scene to apply common post processing effects such as anti-aliasing or depth of field.
- * See https://doc.babylonjs.com/features/featuresDeepDive/postProcesses/defaultRenderingPipeline
- */
-class DefaultRenderingPipeline extends PostProcessRenderPipeline {
-    /**
-     * Enable or disable automatic building of the pipeline when effects are enabled and disabled.
-     * If false, you will have to manually call prepare() to update the pipeline.
-     */
-    get automaticBuild() {
-        return this._buildAllowed;
-    }
-    set automaticBuild(value) {
-        this._buildAllowed = value;
-    }
-    /**
-     * Gets active scene
-     */
-    get scene() {
-        return this._scene;
-    }
-    /**
-     * Enable or disable the sharpen process from the pipeline
-     */
-    set sharpenEnabled(enabled) {
-        if (this._sharpenEnabled === enabled) {
-            return;
-        }
-        this._sharpenEnabled = enabled;
-        this._buildPipeline();
-    }
-    get sharpenEnabled() {
-        return this._sharpenEnabled;
-    }
-    /**
-     * Specifies the size of the bloom blur kernel, relative to the final output size
-     */
-    get bloomKernel() {
-        return this._bloomKernel;
-    }
-    set bloomKernel(value) {
-        this._bloomKernel = value;
-        this.bloom.kernel = value / this._hardwareScaleLevel;
-    }
-    /**
-     * The strength of the bloom.
-     */
-    set bloomWeight(value) {
-        if (this._bloomWeight === value) {
-            return;
-        }
-        this.bloom.weight = value;
-        this._bloomWeight = value;
-    }
-    get bloomWeight() {
-        return this._bloomWeight;
-    }
-    /**
-     * The luminance threshold to find bright areas of the image to bloom.
-     */
-    set bloomThreshold(value) {
-        if (this._bloomThreshold === value) {
-            return;
-        }
-        this.bloom.threshold = value;
-        this._bloomThreshold = value;
-    }
-    get bloomThreshold() {
-        return this._bloomThreshold;
-    }
-    /**
-     * The scale of the bloom, lower value will provide better performance.
-     */
-    set bloomScale(value) {
-        if (this._bloomScale === value) {
-            return;
-        }
-        this._bloomScale = value;
-        // recreate bloom and dispose old as this setting is not dynamic
-        this._rebuildBloom();
-        this._buildPipeline();
-    }
-    get bloomScale() {
-        return this._bloomScale;
-    }
-    /**
-     * Enable or disable the bloom from the pipeline
-     */
-    set bloomEnabled(enabled) {
-        if (this._bloomEnabled === enabled) {
-            return;
-        }
-        this._bloomEnabled = enabled;
-        this._buildPipeline();
-    }
-    get bloomEnabled() {
-        return this._bloomEnabled;
-    }
-    _rebuildBloom() {
-        // recreate bloom and dispose old as this setting is not dynamic
-        const oldBloom = this.bloom;
-        this.bloom = new BloomEffect(this._scene, this.bloomScale, this._bloomWeight, this.bloomKernel / this._hardwareScaleLevel, this._defaultPipelineTextureType, false);
-        this.bloom.threshold = oldBloom.threshold;
-        for (let i = 0; i < this._cameras.length; i++) {
-            oldBloom.disposeEffects(this._cameras[i]);
-        }
-    }
-    /**
-     * If the depth of field is enabled.
-     */
-    get depthOfFieldEnabled() {
-        return this._depthOfFieldEnabled;
-    }
-    set depthOfFieldEnabled(enabled) {
-        if (this._depthOfFieldEnabled === enabled) {
-            return;
-        }
-        this._depthOfFieldEnabled = enabled;
-        this._buildPipeline();
-    }
-    /**
-     * Blur level of the depth of field effect. (Higher blur will effect performance)
-     */
-    get depthOfFieldBlurLevel() {
-        return this._depthOfFieldBlurLevel;
-    }
-    set depthOfFieldBlurLevel(value) {
-        if (this._depthOfFieldBlurLevel === value) {
-            return;
-        }
-        this._depthOfFieldBlurLevel = value;
-        // recreate dof and dispose old as this setting is not dynamic
-        const oldDof = this.depthOfField;
-        this.depthOfField = new DepthOfFieldEffect(this._scene, null, this._depthOfFieldBlurLevel, this._defaultPipelineTextureType, false);
-        this.depthOfField.focalLength = oldDof.focalLength;
-        this.depthOfField.focusDistance = oldDof.focusDistance;
-        this.depthOfField.fStop = oldDof.fStop;
-        this.depthOfField.lensSize = oldDof.lensSize;
-        for (let i = 0; i < this._cameras.length; i++) {
-            oldDof.disposeEffects(this._cameras[i]);
-        }
-        this._buildPipeline();
-    }
-    /**
-     * If the anti aliasing is enabled.
-     */
-    set fxaaEnabled(enabled) {
-        if (this._fxaaEnabled === enabled) {
-            return;
-        }
-        this._fxaaEnabled = enabled;
-        this._buildPipeline();
-    }
-    get fxaaEnabled() {
-        return this._fxaaEnabled;
-    }
-    /**
-     * MSAA sample count, setting this to 4 will provide 4x anti aliasing. (default: 1)
-     */
-    set samples(sampleCount) {
-        if (this._samples === sampleCount) {
-            return;
-        }
-        this._samples = sampleCount;
-        this._buildPipeline();
-    }
-    get samples() {
-        return this._samples;
-    }
-    /**
-     * If image processing is enabled.
-     */
-    set imageProcessingEnabled(enabled) {
-        if (this._imageProcessingEnabled === enabled) {
-            return;
-        }
-        this._scene.imageProcessingConfiguration.isEnabled = enabled;
-    }
-    get imageProcessingEnabled() {
-        return this._imageProcessingEnabled;
-    }
-    /**
-     * If glow layer is enabled. (Adds a glow effect to emmissive materials)
-     */
-    set glowLayerEnabled(enabled) {
-        if (enabled && !this._glowLayer) {
-            this._glowLayer = new GlowLayer("", this._scene);
-        }
-        else if (!enabled && this._glowLayer) {
-            this._glowLayer.dispose();
-            this._glowLayer = null;
-        }
-    }
-    get glowLayerEnabled() {
-        return this._glowLayer != null;
-    }
-    /**
-     * Gets the glow layer (or null if not defined)
-     */
-    get glowLayer() {
-        return this._glowLayer;
-    }
-    /**
-     * Enable or disable the chromaticAberration process from the pipeline
-     */
-    set chromaticAberrationEnabled(enabled) {
-        if (this._chromaticAberrationEnabled === enabled) {
-            return;
-        }
-        this._chromaticAberrationEnabled = enabled;
-        this._buildPipeline();
-    }
-    get chromaticAberrationEnabled() {
-        return this._chromaticAberrationEnabled;
-    }
-    /**
-     * Enable or disable the grain process from the pipeline
-     */
-    set grainEnabled(enabled) {
-        if (this._grainEnabled === enabled) {
-            return;
-        }
-        this._grainEnabled = enabled;
-        this._buildPipeline();
-    }
-    get grainEnabled() {
-        return this._grainEnabled;
-    }
-    /**
-     * Instantiates a DefaultRenderingPipeline.
-     * @param name The rendering pipeline name (default: "")
-     * @param hdr If high dynamic range textures should be used (default: true)
-     * @param scene The scene linked to this pipeline (default: the last created scene)
-     * @param cameras The array of cameras that the rendering pipeline will be attached to (default: scene.cameras)
-     * @param automaticBuild If false, you will have to manually call prepare() to update the pipeline (default: true)
-     */
-    constructor(name = "", hdr = true, scene = EngineStore.LastCreatedScene, cameras, automaticBuild = true) {
-        super(scene.getEngine(), name);
-        this._camerasToBeAttached = [];
-        /**
-         * ID of the sharpen post process,
-         */
-        this.SharpenPostProcessId = "SharpenPostProcessEffect";
-        /**
-         * @ignore
-         * ID of the image processing post process;
-         */
-        this.ImageProcessingPostProcessId = "ImageProcessingPostProcessEffect";
-        /**
-         * @ignore
-         * ID of the Fast Approximate Anti-Aliasing post process;
-         */
-        this.FxaaPostProcessId = "FxaaPostProcessEffect";
-        /**
-         * ID of the chromatic aberration post process,
-         */
-        this.ChromaticAberrationPostProcessId = "ChromaticAberrationPostProcessEffect";
-        /**
-         * ID of the grain post process
-         */
-        this.GrainPostProcessId = "GrainPostProcessEffect";
-        /**
-         * Glow post process which adds a glow to emissive areas of the image
-         */
-        this._glowLayer = null;
-        /**
-         * Animations which can be used to tweak settings over a period of time
-         */
-        this.animations = [];
-        this._imageProcessingConfigurationObserver = null;
-        // Values
-        this._sharpenEnabled = false;
-        this._bloomEnabled = false;
-        this._depthOfFieldEnabled = false;
-        this._depthOfFieldBlurLevel = DepthOfFieldEffectBlurLevel.Low;
-        this._fxaaEnabled = false;
-        this._imageProcessingEnabled = true;
-        this._bloomScale = 0.5;
-        this._chromaticAberrationEnabled = false;
-        this._grainEnabled = false;
-        this._buildAllowed = true;
-        /**
-         * This is triggered each time the pipeline has been built.
-         */
-        this.onBuildObservable = new Observable();
-        this._resizeObserver = null;
-        this._hardwareScaleLevel = 1.0;
-        this._bloomKernel = 64;
-        /**
-         * Specifies the weight of the bloom in the final rendering
-         */
-        this._bloomWeight = 0.15;
-        /**
-         * Specifies the luma threshold for the area that will be blurred by the bloom
-         */
-        this._bloomThreshold = 0.9;
-        this._samples = 1;
-        this._hasCleared = false;
-        this._prevPostProcess = null;
-        this._prevPrevPostProcess = null;
-        this._depthOfFieldSceneObserver = null;
-        this._activeCameraChangedObserver = null;
-        this._activeCamerasChangedObserver = null;
-        this._cameras = cameras || scene.cameras;
-        this._cameras = this._cameras.slice();
-        this._camerasToBeAttached = this._cameras.slice();
-        this._buildAllowed = automaticBuild;
-        // Initialize
-        this._scene = scene;
-        const caps = this._scene.getEngine().getCaps();
-        this._hdr = hdr && (caps.textureHalfFloatRender || caps.textureFloatRender);
-        // Misc
-        if (this._hdr) {
-            if (caps.textureHalfFloatRender) {
-                this._defaultPipelineTextureType = 2;
-            }
-            else if (caps.textureFloatRender) {
-                this._defaultPipelineTextureType = 1;
-            }
-        }
-        else {
-            this._defaultPipelineTextureType = 0;
-        }
-        // Attach
-        scene.postProcessRenderPipelineManager.addPipeline(this);
-        const engine = this._scene.getEngine();
-        // Create post processes before hand so they can be modified before enabled.
-        // Block compilation flag is set to true to avoid compilation prior to use, these will be updated on first use in build pipeline.
-        this.sharpen = new SharpenPostProcess("sharpen", 1.0, null, Texture.BILINEAR_SAMPLINGMODE, engine, false, this._defaultPipelineTextureType, true);
-        this._sharpenEffect = new PostProcessRenderEffect(engine, this.SharpenPostProcessId, () => {
-            return this.sharpen;
-        }, true);
-        this.depthOfField = new DepthOfFieldEffect(this._scene, null, this._depthOfFieldBlurLevel, this._defaultPipelineTextureType, true);
-        // To keep the bloom sizes consistent across different display densities, factor in the hardware scaling level.
-        this._hardwareScaleLevel = engine.getHardwareScalingLevel();
-        this._resizeObserver = engine.onResizeObservable.add(() => {
-            this._hardwareScaleLevel = engine.getHardwareScalingLevel();
-            this.bloomKernel = this._bloomKernel;
-        });
-        this.bloom = new BloomEffect(this._scene, this._bloomScale, this._bloomWeight, this.bloomKernel / this._hardwareScaleLevel, this._defaultPipelineTextureType, true);
-        this.chromaticAberration = new ChromaticAberrationPostProcess("ChromaticAberration", engine.getRenderWidth(), engine.getRenderHeight(), 1.0, null, Texture.BILINEAR_SAMPLINGMODE, engine, false, this._defaultPipelineTextureType, true);
-        this._chromaticAberrationEffect = new PostProcessRenderEffect(engine, this.ChromaticAberrationPostProcessId, () => {
-            return this.chromaticAberration;
-        }, true);
-        this.grain = new GrainPostProcess("Grain", 1.0, null, Texture.BILINEAR_SAMPLINGMODE, engine, false, this._defaultPipelineTextureType, true);
-        this._grainEffect = new PostProcessRenderEffect(engine, this.GrainPostProcessId, () => {
-            return this.grain;
-        }, true);
-        this._imageProcessingConfigurationObserver = this._scene.imageProcessingConfiguration.onUpdateParameters.add(() => {
-            this.bloom._downscale._exposure = this._scene.imageProcessingConfiguration.exposure;
-            if (this.imageProcessingEnabled !== this._scene.imageProcessingConfiguration.isEnabled) {
-                this._imageProcessingEnabled = this._scene.imageProcessingConfiguration.isEnabled;
-                // Avoid re-entrant problems by deferring the call to _buildPipeline because the call to _buildPipeline
-                // at the end of the constructor could end up triggering imageProcessingConfiguration.onUpdateParameters!
-                // Note that the pipeline could have been disposed before the deferred call was executed, but in that case
-                // _buildAllowed will have been set to false, preventing _buildPipeline from being executed.
-                Tools.SetImmediate(() => {
-                    this._buildPipeline();
-                });
-            }
-        });
-        this._buildPipeline();
-    }
-    /**
-     * Get the class name
-     * @returns "DefaultRenderingPipeline"
-     */
-    getClassName() {
-        return "DefaultRenderingPipeline";
-    }
-    /**
-     * Force the compilation of the entire pipeline.
-     */
-    prepare() {
-        const previousState = this._buildAllowed;
-        this._buildAllowed = true;
-        this._buildPipeline();
-        this._buildAllowed = previousState;
-    }
-    _setAutoClearAndTextureSharing(postProcess, skipTextureSharing = false) {
-        if (this._hasCleared) {
-            postProcess.autoClear = false;
-        }
-        else {
-            postProcess.autoClear = true;
-            this._scene.autoClear = false;
-            this._hasCleared = true;
-        }
-        if (!skipTextureSharing) {
-            if (this._prevPrevPostProcess) {
-                postProcess.shareOutputWith(this._prevPrevPostProcess);
-            }
-            else {
-                postProcess.useOwnOutput();
-            }
-            if (this._prevPostProcess) {
-                this._prevPrevPostProcess = this._prevPostProcess;
-            }
-            this._prevPostProcess = postProcess;
-        }
-    }
-    _buildPipeline() {
-        if (!this._buildAllowed) {
-            return;
-        }
-        this._scene.autoClear = true;
-        const engine = this._scene.getEngine();
-        this._disposePostProcesses();
-        if (this._cameras !== null) {
-            this._scene.postProcessRenderPipelineManager.detachCamerasFromRenderPipeline(this._name, this._cameras);
-            // get back cameras to be used to reattach pipeline
-            this._cameras = this._camerasToBeAttached.slice();
-        }
-        this._reset();
-        this._prevPostProcess = null;
-        this._prevPrevPostProcess = null;
-        this._hasCleared = false;
-        if (this.depthOfFieldEnabled) {
-            // Multi camera suport
-            if (this._cameras.length > 1) {
-                for (const camera of this._cameras) {
-                    const depthRenderer = this._scene.enableDepthRenderer(camera);
-                    depthRenderer.useOnlyInActiveCamera = true;
-                }
-                this._depthOfFieldSceneObserver = this._scene.onAfterRenderTargetsRenderObservable.add((scene) => {
-                    if (this._cameras.indexOf(scene.activeCamera) > -1) {
-                        this.depthOfField.depthTexture = scene.enableDepthRenderer(scene.activeCamera).getDepthMap();
-                    }
-                });
-            }
-            else {
-                this._scene.onAfterRenderTargetsRenderObservable.remove(this._depthOfFieldSceneObserver);
-                const depthRenderer = this._scene.enableDepthRenderer(this._cameras[0]);
-                this.depthOfField.depthTexture = depthRenderer.getDepthMap();
-            }
-            if (!this.depthOfField._isReady()) {
-                this.depthOfField._updateEffects();
-            }
-            this.addEffect(this.depthOfField);
-            this._setAutoClearAndTextureSharing(this.depthOfField._effects[0], true);
-        }
-        else {
-            this._scene.onAfterRenderTargetsRenderObservable.remove(this._depthOfFieldSceneObserver);
-        }
-        if (this.bloomEnabled) {
-            if (!this.bloom._isReady()) {
-                this.bloom._updateEffects();
-            }
-            this.addEffect(this.bloom);
-            this._setAutoClearAndTextureSharing(this.bloom._effects[0], true);
-        }
-        if (this._imageProcessingEnabled) {
-            this.imageProcessing = new ImageProcessingPostProcess("imageProcessing", 1.0, null, Texture.BILINEAR_SAMPLINGMODE, engine, false, this._defaultPipelineTextureType, this.scene.imageProcessingConfiguration);
-            if (this._hdr) {
-                this.addEffect(new PostProcessRenderEffect(engine, this.ImageProcessingPostProcessId, () => {
-                    return this.imageProcessing;
-                }, true));
-                this._setAutoClearAndTextureSharing(this.imageProcessing);
-            }
-            else {
-                this._scene.imageProcessingConfiguration.applyByPostProcess = false;
-            }
-            if (!this._cameras || this._cameras.length === 0) {
-                this._scene.imageProcessingConfiguration.applyByPostProcess = false;
-            }
-            if (!this.imageProcessing.getEffect()) {
-                this.imageProcessing._updateParameters();
-            }
-        }
-        if (this.sharpenEnabled) {
-            if (!this.sharpen.isReady()) {
-                this.sharpen.updateEffect();
-            }
-            this.addEffect(this._sharpenEffect);
-            this._setAutoClearAndTextureSharing(this.sharpen);
-        }
-        if (this.grainEnabled) {
-            if (!this.grain.isReady()) {
-                this.grain.updateEffect();
-            }
-            this.addEffect(this._grainEffect);
-            this._setAutoClearAndTextureSharing(this.grain);
-        }
-        if (this.chromaticAberrationEnabled) {
-            if (!this.chromaticAberration.isReady()) {
-                this.chromaticAberration.updateEffect();
-            }
-            this.addEffect(this._chromaticAberrationEffect);
-            this._setAutoClearAndTextureSharing(this.chromaticAberration);
-        }
-        if (this.fxaaEnabled) {
-            this.fxaa = new FxaaPostProcess("fxaa", 1.0, null, Texture.BILINEAR_SAMPLINGMODE, engine, false, this._defaultPipelineTextureType);
-            this.addEffect(new PostProcessRenderEffect(engine, this.FxaaPostProcessId, () => {
-                return this.fxaa;
-            }, true));
-            this._setAutoClearAndTextureSharing(this.fxaa, true);
-        }
-        if (this._cameras !== null) {
-            this._scene.postProcessRenderPipelineManager.attachCamerasToRenderPipeline(this._name, this._cameras);
-        }
-        // In multicamera mode, the scene needs to autoclear in between cameras.
-        if ((this._scene.activeCameras && this._scene.activeCameras.length > 1) || (this._scene.activeCamera && this._cameras.indexOf(this._scene.activeCamera) === -1)) {
-            this._scene.autoClear = true;
-        }
-        // The active camera on the scene can be changed anytime
-        if (!this._activeCameraChangedObserver) {
-            this._activeCameraChangedObserver = this._scene.onActiveCameraChanged.add(() => {
-                if (this._scene.activeCamera && this._cameras.indexOf(this._scene.activeCamera) === -1) {
-                    this._scene.autoClear = true;
-                }
-            });
-        }
-        if (!this._activeCamerasChangedObserver) {
-            this._activeCamerasChangedObserver = this._scene.onActiveCamerasChanged.add(() => {
-                if (this._scene.activeCameras && this._scene.activeCameras.length > 1) {
-                    this._scene.autoClear = true;
-                }
-            });
-        }
-        if (!this._enableMSAAOnFirstPostProcess(this.samples) && this.samples > 1) {
-            Logger.Warn("MSAA failed to enable, MSAA is only supported in browsers that support webGL >= 2.0");
-        }
-        this.onBuildObservable.notifyObservers(this);
-    }
-    _disposePostProcesses(disposeNonRecreated = false) {
-        for (let i = 0; i < this._cameras.length; i++) {
-            const camera = this._cameras[i];
-            if (this.imageProcessing) {
-                this.imageProcessing.dispose(camera);
-            }
-            if (this.fxaa) {
-                this.fxaa.dispose(camera);
-            }
-            // These are created in the constructor and should not be disposed on every pipeline change
-            if (disposeNonRecreated) {
-                if (this.sharpen) {
-                    this.sharpen.dispose(camera);
-                }
-                if (this.depthOfField) {
-                    this._scene.onAfterRenderTargetsRenderObservable.remove(this._depthOfFieldSceneObserver);
-                    this.depthOfField.disposeEffects(camera);
-                }
-                if (this.bloom) {
-                    this.bloom.disposeEffects(camera);
-                }
-                if (this.chromaticAberration) {
-                    this.chromaticAberration.dispose(camera);
-                }
-                if (this.grain) {
-                    this.grain.dispose(camera);
-                }
-                if (this._glowLayer) {
-                    this._glowLayer.dispose();
-                }
-            }
-        }
-        this.imageProcessing = null;
-        this.fxaa = null;
-        if (disposeNonRecreated) {
-            this.sharpen = null;
-            this._sharpenEffect = null;
-            this.depthOfField = null;
-            this.bloom = null;
-            this.chromaticAberration = null;
-            this._chromaticAberrationEffect = null;
-            this.grain = null;
-            this._grainEffect = null;
-            this._glowLayer = null;
-        }
-    }
-    /**
-     * Adds a camera to the pipeline
-     * @param camera the camera to be added
-     */
-    addCamera(camera) {
-        this._camerasToBeAttached.push(camera);
-        this._buildPipeline();
-    }
-    /**
-     * Removes a camera from the pipeline
-     * @param camera the camera to remove
-     */
-    removeCamera(camera) {
-        const index = this._camerasToBeAttached.indexOf(camera);
-        this._camerasToBeAttached.splice(index, 1);
-        this._buildPipeline();
-    }
-    /**
-     * Dispose of the pipeline and stop all post processes
-     */
-    dispose() {
-        this._buildAllowed = false;
-        this.onBuildObservable.clear();
-        this._disposePostProcesses(true);
-        this._scene.postProcessRenderPipelineManager.detachCamerasFromRenderPipeline(this._name, this._cameras);
-        this._scene._postProcessRenderPipelineManager.removePipeline(this.name);
-        this._scene.autoClear = true;
-        if (this._resizeObserver) {
-            this._scene.getEngine().onResizeObservable.remove(this._resizeObserver);
-            this._resizeObserver = null;
-        }
-        this._scene.onActiveCameraChanged.remove(this._activeCameraChangedObserver);
-        this._scene.onActiveCamerasChanged.remove(this._activeCamerasChangedObserver);
-        this._scene.imageProcessingConfiguration.onUpdateParameters.remove(this._imageProcessingConfigurationObserver);
-        super.dispose();
-    }
-    /**
-     * Serialize the rendering pipeline (Used when exporting)
-     * @returns the serialized object
-     */
-    serialize() {
-        const serializationObject = SerializationHelper.Serialize(this);
-        serializationObject.customType = "DefaultRenderingPipeline";
-        return serializationObject;
-    }
-    /**
-     * Parse the serialized pipeline
-     * @param source Source pipeline.
-     * @param scene The scene to load the pipeline to.
-     * @param rootUrl The URL of the serialized pipeline.
-     * @returns An instantiated pipeline from the serialized object.
-     */
-    static Parse(source, scene, rootUrl) {
-        return SerializationHelper.Parse(() => new DefaultRenderingPipeline(source._name, source._name._hdr, scene), source, scene, rootUrl);
-    }
-}
-__decorate([
-    serialize()
-], DefaultRenderingPipeline.prototype, "sharpenEnabled", null);
-__decorate([
-    serialize()
-], DefaultRenderingPipeline.prototype, "bloomKernel", null);
-__decorate([
-    serialize()
-], DefaultRenderingPipeline.prototype, "_bloomWeight", void 0);
-__decorate([
-    serialize()
-], DefaultRenderingPipeline.prototype, "_bloomThreshold", void 0);
-__decorate([
-    serialize()
-], DefaultRenderingPipeline.prototype, "_hdr", void 0);
-__decorate([
-    serialize()
-], DefaultRenderingPipeline.prototype, "bloomWeight", null);
-__decorate([
-    serialize()
-], DefaultRenderingPipeline.prototype, "bloomThreshold", null);
-__decorate([
-    serialize()
-], DefaultRenderingPipeline.prototype, "bloomScale", null);
-__decorate([
-    serialize()
-], DefaultRenderingPipeline.prototype, "bloomEnabled", null);
-__decorate([
-    serialize()
-], DefaultRenderingPipeline.prototype, "depthOfFieldEnabled", null);
-__decorate([
-    serialize()
-], DefaultRenderingPipeline.prototype, "depthOfFieldBlurLevel", null);
-__decorate([
-    serialize()
-], DefaultRenderingPipeline.prototype, "fxaaEnabled", null);
-__decorate([
-    serialize()
-], DefaultRenderingPipeline.prototype, "samples", null);
-__decorate([
-    serialize()
-], DefaultRenderingPipeline.prototype, "imageProcessingEnabled", null);
-__decorate([
-    serialize()
-], DefaultRenderingPipeline.prototype, "glowLayerEnabled", null);
-__decorate([
-    serialize()
-], DefaultRenderingPipeline.prototype, "chromaticAberrationEnabled", null);
-__decorate([
-    serialize()
-], DefaultRenderingPipeline.prototype, "grainEnabled", null);
-RegisterClass("BABYLON.DefaultRenderingPipeline", DefaultRenderingPipeline);
-
-// Do not edit.
-const name$i = "lensHighlightsPixelShader";
-const shader$i = `uniform sampler2D textureSampler; 
-void main(void)
-blurred+=highlightColor(texture2D(textureSampler,vUV+vec2(-0.84*w,0.43*h)));
-blurred+=highlightColor(texture2D(textureSampler,vUV+vec2(-0.85*w,0.36*h)));
-blurred/=39.0;
-// Sideeffect
-ShaderStore.ShadersStore[name$i] = shader$i;
-
-// Do not edit.
-const name$h = "depthOfFieldPixelShader";
-const shader$h = `uniform sampler2D textureSampler;
-#define TWOPI 6.28318530
-#define inverse_focal_length 0.1 
-vec2 centered_screen_pos;
-void main(void)
-// Sideeffect
-ShaderStore.ShadersStore[name$h] = shader$h;
-
-/**
- * Contains all parameters needed for the prepass to perform
- * screen space subsurface scattering
- */
-class SSAO2Configuration {
-    constructor() {
-        /**
-         * Is subsurface enabled
-         */
-        this.enabled = false;
-        /**
-         * Name of the configuration
-         */
-        this.name = "ssao2";
-        /**
-         * Textures that should be present in the MRT for this effect to work
-         */
-        this.texturesRequired = [6, 5];
-    }
-}
-
-// Do not edit.
-const name$g = "ssao2PixelShader";
-const shader$g = `precision highp float;
-float scales[16]=float[16](
+ centered_screen_pos.y*centered_screen_pos.y;