@spiffcommerce/preview 3.6.2-rc.8 → 4.0.0

package/dist/glowLayer.esm.js

@@ -1,1621 +0,0 @@
-import { _ as __decorate, O as Observable, E as EngineStore, a as _WarnImport, s as serialize, f as serializeAsColor4, g as serializeAsCameraReference, b as Vector2, S as SerializationHelper } from './webRequest.esm.js';
-import { e as ShaderStore, V as VertexBuffer, E as Engine, g as DrawWrapper, c as Tools, A as AbstractScene, h as SceneComponentConstants } from './engine.esm.js';
-import { R as RenderTargetTexture, T as Texture } from './helperFunctions.esm.js';
-import { M as Material, a as MaterialHelper, p as prepareStringDefinesForClipPlanes, b as addClipPlaneUniforms, c as bindClipPlane, C as Camera } from './material.esm2.js';
-import { B as BlurPostProcess } from './blurPostProcess.esm.js';
-import { C as Color4, R as RegisterClass } from './math.color.esm.js';
-import { E as EffectFallbacks } from './effectFallbacks.esm.js';
-
-// Do not edit.
-const name$3 = "glowMapGenerationPixelShader";
-const shader$3 = `#if defined(DIFFUSE_ISLINEAR) || defined(EMISSIVE_ISLINEAR)
-#include<helperFunctions>
-#endif
-#ifdef DIFFUSE
-varying vec2 vUVDiffuse;
-#ifdef OPACITY
-varying vec2 vUVOpacity;
-#ifdef EMISSIVE
-varying vec2 vUVEmissive;
-#ifdef VERTEXALPHA
-varying vec4 vColor;
-uniform vec4 glowColor;
-#define CUSTOM_FRAGMENT_DEFINITIONS
-void main(void)
-vec4 finalColor=glowColor;
-vec4 albedoTexture=texture2D(diffuseSampler,vUVDiffuse);
-albedoTexture=toGammaSpace(albedoTexture);
-#ifdef GLOW
-finalColor.a*=albedoTexture.a;
-#ifdef HIGHLIGHT
-finalColor.a=albedoTexture.a;
-#endif
-#ifdef OPACITY
-vec4 opacityMap=texture2D(opacitySampler,vUVOpacity);
-finalColor.a*=getLuminance(opacityMap.rgb);
-finalColor.a*=opacityMap.a;
-finalColor.a*=opacityIntensity;
-#ifdef VERTEXALPHA
-finalColor.a*=vColor.a;
-#ifdef ALPHATEST
-if (finalColor.a<ALPHATESTVALUE)
-#ifdef EMISSIVE
-vec4 emissive=texture2D(emissiveSampler,vUVEmissive);
-emissive=toGammaSpace(emissive);
-gl_FragColor=emissive*finalColor*glowIntensity;
-gl_FragColor=finalColor*glowIntensity;
-#ifdef HIGHLIGHT
-gl_FragColor.a=glowColor.a;
-}`;
-// Sideeffect
-ShaderStore.ShadersStore[name$3] = shader$3;
-
-// Do not edit.
-const name$2 = "glowMapGenerationVertexShader";
-const shader$2 = `attribute vec3 position;
-#include<bakedVertexAnimationDeclaration>
-#include<morphTargetsVertexGlobalDeclaration>
-#include<morphTargetsVertexDeclaration>[0..maxSimultaneousMorphTargets]
-#include<clipPlaneVertexDeclaration>
-#include<instancesDeclaration>
-uniform mat4 viewProjection;
-attribute vec2 uv;
-#ifdef UV2
-attribute vec2 uv2;
-#ifdef DIFFUSE
-varying vec2 vUVDiffuse;
-#ifdef OPACITY
-varying vec2 vUVOpacity;
-#ifdef EMISSIVE
-varying vec2 vUVEmissive;
-#ifdef VERTEXALPHA
-attribute vec4 color;
-#define CUSTOM_VERTEX_DEFINITIONS
-void main(void)
-vec2 uvUpdated=uv;
-#include<morphTargetsVertexGlobal>
-#include<morphTargetsVertex>[0..maxSimultaneousMorphTargets]
-#include<instancesVertex>
-#include<bonesVertex>
-#include<bakedVertexAnimation>
-vec4 worldPos=finalWorld*vec4(positionUpdated,1.0);
-vPosition=worldPos;
-vPosition=viewProjection*worldPos;
-#ifdef DIFFUSE
-#ifdef DIFFUSEUV1
-vUVDiffuse=vec2(diffuseMatrix*vec4(uvUpdated,1.0,0.0));
-#ifdef DIFFUSEUV2
-vUVDiffuse=vec2(diffuseMatrix*vec4(uv2,1.0,0.0));
-#endif
-#ifdef OPACITY
-#ifdef OPACITYUV1
-vUVOpacity=vec2(opacityMatrix*vec4(uvUpdated,1.0,0.0));
-#ifdef OPACITYUV2
-vUVOpacity=vec2(opacityMatrix*vec4(uv2,1.0,0.0));
-#endif
-#ifdef EMISSIVE
-#ifdef EMISSIVEUV1
-vUVEmissive=vec2(emissiveMatrix*vec4(uvUpdated,1.0,0.0));
-#ifdef EMISSIVEUV2
-vUVEmissive=vec2(emissiveMatrix*vec4(uv2,1.0,0.0));
-#endif
-#ifdef VERTEXALPHA
-vColor=color;
-#include<clipPlaneVertex>
-}`;
-// Sideeffect
-ShaderStore.ShadersStore[name$2] = shader$2;
-
-/**
- * The effect layer Helps adding post process effect blended with the main pass.
- *
- * This can be for instance use to generate glow or highlight effects on the scene.
- *
- * The effect layer class can not be used directly and is intented to inherited from to be
- * customized per effects.
- */
-class EffectLayer {
-    /**
-     * Gets the camera attached to the layer.
-     */
-    get camera() {
-        return this._effectLayerOptions.camera;
-    }
-    /**
-     * Gets the rendering group id the layer should render in.
-     */
-    get renderingGroupId() {
-        return this._effectLayerOptions.renderingGroupId;
-    }
-    set renderingGroupId(renderingGroupId) {
-        this._effectLayerOptions.renderingGroupId = renderingGroupId;
-    }
-    /**
-     * Gets the main texture where the effect is rendered
-     */
-    get mainTexture() {
-        return this._mainTexture;
-    }
-    /**
-     * Sets a specific material to be used to render a mesh/a list of meshes in the layer
-     * @param mesh mesh or array of meshes
-     * @param material material to use by the layer when rendering the mesh(es). If undefined is passed, the specific material created by the layer will be used.
-     */
-    setMaterialForRendering(mesh, material) {
-        this._mainTexture.setMaterialForRendering(mesh, material);
-        if (Array.isArray(mesh)) {
-            for (let i = 0; i < mesh.length; ++i) {
-                const currentMesh = mesh[i];
-                if (!material) {
-                    delete this._materialForRendering[currentMesh.uniqueId];
-                }
-                else {
-                    this._materialForRendering[currentMesh.uniqueId] = [currentMesh, material];
-                }
-            }
-        }
-        else {
-            if (!material) {
-                delete this._materialForRendering[mesh.uniqueId];
-            }
-            else {
-                this._materialForRendering[mesh.uniqueId] = [mesh, material];
-            }
-        }
-    }
-    /**
-     * Gets the intensity of the effect for a specific mesh.
-     * @param mesh The mesh to get the effect intensity for
-     * @returns The intensity of the effect for the mesh
-     */
-    getEffectIntensity(mesh) {
-        var _a;
-        return (_a = this._effectIntensity[mesh.uniqueId]) !== null && _a !== void 0 ? _a : 1;
-    }
-    /**
-     * Sets the intensity of the effect for a specific mesh.
-     * @param mesh The mesh to set the effect intensity for
-     * @param intensity The intensity of the effect for the mesh
-     */
-    setEffectIntensity(mesh, intensity) {
-        this._effectIntensity[mesh.uniqueId] = intensity;
-    }
-    /**
-     * Instantiates a new effect Layer and references it in the scene.
-     * @param name The name of the layer
-     * @param scene The scene to use the layer in
-     */
-    constructor(
-    /** The Friendly of the effect in the scene */
-    name, scene) {
-        this._vertexBuffers = {};
-        this._maxSize = 0;
-        this._mainTextureDesiredSize = { width: 0, height: 0 };
-        this._shouldRender = true;
-        this._postProcesses = [];
-        this._textures = [];
-        this._emissiveTextureAndColor = { texture: null, color: new Color4() };
-        this._effectIntensity = {};
-        /**
-         * The clear color of the texture used to generate the glow map.
-         */
-        this.neutralColor = new Color4();
-        /**
-         * Specifies whether the highlight layer is enabled or not.
-         */
-        this.isEnabled = true;
-        /**
-         * Specifies if the bounding boxes should be rendered normally or if they should undergo the effect of the layer
-         */
-        this.disableBoundingBoxesFromEffectLayer = false;
-        /**
-         * An event triggered when the effect layer has been disposed.
-         */
-        this.onDisposeObservable = new Observable();
-        /**
-         * An event triggered when the effect layer is about rendering the main texture with the glowy parts.
-         */
-        this.onBeforeRenderMainTextureObservable = new Observable();
-        /**
-         * An event triggered when the generated texture is being merged in the scene.
-         */
-        this.onBeforeComposeObservable = new Observable();
-        /**
-         * An event triggered when the mesh is rendered into the effect render target.
-         */
-        this.onBeforeRenderMeshToEffect = new Observable();
-        /**
-         * An event triggered after the mesh has been rendered into the effect render target.
-         */
-        this.onAfterRenderMeshToEffect = new Observable();
-        /**
-         * An event triggered when the generated texture has been merged in the scene.
-         */
-        this.onAfterComposeObservable = new Observable();
-        /**
-         * An event triggered when the effect layer changes its size.
-         */
-        this.onSizeChangedObservable = new Observable();
-        this._materialForRendering = {};
-        this.name = name;
-        this._scene = scene || EngineStore.LastCreatedScene;
-        EffectLayer._SceneComponentInitialization(this._scene);
-        this._engine = this._scene.getEngine();
-        this._maxSize = this._engine.getCaps().maxTextureSize;
-        this._scene.effectLayers.push(this);
-        this._mergeDrawWrapper = [];
-        // Generate Buffers
-        this._generateIndexBuffer();
-        this._generateVertexBuffer();
-    }
-    /**
-     * Number of times _internalRender will be called. Some effect layers need to render the mesh several times, so they should override this method with the number of times the mesh should be rendered
-     * @returns Number of times a mesh must be rendered in the layer
-     */
-    _numInternalDraws() {
-        return 1;
-    }
-    /**
-     * Initializes the effect layer with the required options.
-     * @param options Sets of none mandatory options to use with the layer (see IEffectLayerOptions for more information)
-     */
-    _init(options) {
-        // Adapt options
-        this._effectLayerOptions = Object.assign({ mainTextureRatio: 0.5, alphaBlendingMode: 2, camera: null, renderingGroupId: -1, mainTextureType: 0, generateStencilBuffer: false }, options);
-        this._setMainTextureSize();
-        this._createMainTexture();
-        this._createTextureAndPostProcesses();
-    }
-    /**
-     * Generates the index buffer of the full screen quad blending to the main canvas.
-     */
-    _generateIndexBuffer() {
-        // Indices
-        const indices = [];
-        indices.push(0);
-        indices.push(1);
-        indices.push(2);
-        indices.push(0);
-        indices.push(2);
-        indices.push(3);
-        this._indexBuffer = this._engine.createIndexBuffer(indices);
-    }
-    /**
-     * Generates the vertex buffer of the full screen quad blending to the main canvas.
-     */
-    _generateVertexBuffer() {
-        // VBO
-        const vertices = [];
-        vertices.push(1, 1);
-        vertices.push(-1, 1);
-        vertices.push(-1, -1);
-        vertices.push(1, -1);
-        const vertexBuffer = new VertexBuffer(this._engine, vertices, VertexBuffer.PositionKind, false, false, 2);
-        this._vertexBuffers[VertexBuffer.PositionKind] = vertexBuffer;
-    }
-    /**
-     * Sets the main texture desired size which is the closest power of two
-     * of the engine canvas size.
-     */
-    _setMainTextureSize() {
-        if (this._effectLayerOptions.mainTextureFixedSize) {
-            this._mainTextureDesiredSize.width = this._effectLayerOptions.mainTextureFixedSize;
-            this._mainTextureDesiredSize.height = this._effectLayerOptions.mainTextureFixedSize;
-        }
-        else {
-            this._mainTextureDesiredSize.width = this._engine.getRenderWidth() * this._effectLayerOptions.mainTextureRatio;
-            this._mainTextureDesiredSize.height = this._engine.getRenderHeight() * this._effectLayerOptions.mainTextureRatio;
-            this._mainTextureDesiredSize.width = this._engine.needPOTTextures
-                ? Engine.GetExponentOfTwo(this._mainTextureDesiredSize.width, this._maxSize)
-                : this._mainTextureDesiredSize.width;
-            this._mainTextureDesiredSize.height = this._engine.needPOTTextures
-                ? Engine.GetExponentOfTwo(this._mainTextureDesiredSize.height, this._maxSize)
-                : this._mainTextureDesiredSize.height;
-        }
-        this._mainTextureDesiredSize.width = Math.floor(this._mainTextureDesiredSize.width);
-        this._mainTextureDesiredSize.height = Math.floor(this._mainTextureDesiredSize.height);
-    }
-    /**
-     * Creates the main texture for the effect layer.
-     */
-    _createMainTexture() {
-        this._mainTexture = new RenderTargetTexture("EffectLayerMainRTT", {
-            width: this._mainTextureDesiredSize.width,
-            height: this._mainTextureDesiredSize.height,
-        }, this._scene, false, true, this._effectLayerOptions.mainTextureType, false, Texture.TRILINEAR_SAMPLINGMODE, true, this._effectLayerOptions.generateStencilBuffer);
-        this._mainTexture.activeCamera = this._effectLayerOptions.camera;
-        this._mainTexture.wrapU = Texture.CLAMP_ADDRESSMODE;
-        this._mainTexture.wrapV = Texture.CLAMP_ADDRESSMODE;
-        this._mainTexture.anisotropicFilteringLevel = 1;
-        this._mainTexture.updateSamplingMode(Texture.BILINEAR_SAMPLINGMODE);
-        this._mainTexture.renderParticles = false;
-        this._mainTexture.renderList = null;
-        this._mainTexture.ignoreCameraViewport = true;
-        for (const id in this._materialForRendering) {
-            const [mesh, material] = this._materialForRendering[id];
-            this._mainTexture.setMaterialForRendering(mesh, material);
-        }
-        this._mainTexture.customIsReadyFunction = (mesh, refreshRate, preWarm) => {
-            if ((preWarm || refreshRate === 0) && mesh.subMeshes) {
-                for (let i = 0; i < mesh.subMeshes.length; ++i) {
-                    const subMesh = mesh.subMeshes[i];
-                    const material = subMesh.getMaterial();
-                    const renderingMesh = subMesh.getRenderingMesh();
-                    if (!material) {
-                        continue;
-                    }
-                    const batch = renderingMesh._getInstancesRenderList(subMesh._id, !!subMesh.getReplacementMesh());
-                    const hardwareInstancedRendering = batch.hardwareInstancedRendering[subMesh._id] || renderingMesh.hasThinInstances;
-                    this._setEmissiveTextureAndColor(renderingMesh, subMesh, material);
-                    if (!this._isReady(subMesh, hardwareInstancedRendering, this._emissiveTextureAndColor.texture)) {
-                        return false;
-                    }
-                }
-            }
-            return true;
-        };
-        // Custom render function
-        this._mainTexture.customRenderFunction = (opaqueSubMeshes, alphaTestSubMeshes, transparentSubMeshes, depthOnlySubMeshes) => {
-            this.onBeforeRenderMainTextureObservable.notifyObservers(this);
-            let index;
-            const engine = this._scene.getEngine();
-            if (depthOnlySubMeshes.length) {
-                engine.setColorWrite(false);
-                for (index = 0; index < depthOnlySubMeshes.length; index++) {
-                    this._renderSubMesh(depthOnlySubMeshes.data[index]);
-                }
-                engine.setColorWrite(true);
-            }
-            for (index = 0; index < opaqueSubMeshes.length; index++) {
-                this._renderSubMesh(opaqueSubMeshes.data[index]);
-            }
-            for (index = 0; index < alphaTestSubMeshes.length; index++) {
-                this._renderSubMesh(alphaTestSubMeshes.data[index]);
-            }
-            const previousAlphaMode = engine.getAlphaMode();
-            for (index = 0; index < transparentSubMeshes.length; index++) {
-                this._renderSubMesh(transparentSubMeshes.data[index], true);
-            }
-            engine.setAlphaMode(previousAlphaMode);
-        };
-        this._mainTexture.onClearObservable.add((engine) => {
-            engine.clear(this.neutralColor, true, true, true);
-        });
-        // Prevent package size in es6 (getBoundingBoxRenderer might not be present)
-        if (this._scene.getBoundingBoxRenderer) {
-            const boundingBoxRendererEnabled = this._scene.getBoundingBoxRenderer().enabled;
-            this._mainTexture.onBeforeBindObservable.add(() => {
-                this._scene.getBoundingBoxRenderer().enabled = !this.disableBoundingBoxesFromEffectLayer && boundingBoxRendererEnabled;
-            });
-            this._mainTexture.onAfterUnbindObservable.add(() => {
-                this._scene.getBoundingBoxRenderer().enabled = boundingBoxRendererEnabled;
-            });
-        }
-    }
-    /**
-     * Adds specific effects defines.
-     * @param defines The defines to add specifics to.
-     */
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    _addCustomEffectDefines(defines) {
-        // Nothing to add by default.
-    }
-    /**
-     * Checks for the readiness of the element composing the layer.
-     * @param subMesh the mesh to check for
-     * @param useInstances specify whether or not to use instances to render the mesh
-     * @param emissiveTexture the associated emissive texture used to generate the glow
-     * @returns true if ready otherwise, false
-     */
-    _isReady(subMesh, useInstances, emissiveTexture) {
-        var _a;
-        const engine = this._scene.getEngine();
-        const mesh = subMesh.getMesh();
-        const renderingMaterial = (_a = mesh._internalAbstractMeshDataInfo._materialForRenderPass) === null || _a === void 0 ? void 0 : _a[engine.currentRenderPassId];
-        if (renderingMaterial) {
-            return renderingMaterial.isReadyForSubMesh(mesh, subMesh, useInstances);
-        }
-        const material = subMesh.getMaterial();
-        if (!material) {
-            return false;
-        }
-        if (this._useMeshMaterial(subMesh.getRenderingMesh())) {
-            return material.isReadyForSubMesh(subMesh.getMesh(), subMesh, useInstances);
-        }
-        const defines = [];
-        const attribs = [VertexBuffer.PositionKind];
-        let uv1 = false;
-        let uv2 = false;
-        // Diffuse
-        if (material) {
-            const needAlphaTest = material.needAlphaTesting();
-            const diffuseTexture = material.getAlphaTestTexture();
-            const needAlphaBlendFromDiffuse = diffuseTexture && diffuseTexture.hasAlpha && (material.useAlphaFromDiffuseTexture || material._useAlphaFromAlbedoTexture);
-            if (diffuseTexture && (needAlphaTest || needAlphaBlendFromDiffuse)) {
-                defines.push("#define DIFFUSE");
-                if (mesh.isVerticesDataPresent(VertexBuffer.UV2Kind) && diffuseTexture.coordinatesIndex === 1) {
-                    defines.push("#define DIFFUSEUV2");
-                    uv2 = true;
-                }
-                else if (mesh.isVerticesDataPresent(VertexBuffer.UVKind)) {
-                    defines.push("#define DIFFUSEUV1");
-                    uv1 = true;
-                }
-                if (needAlphaTest) {
-                    defines.push("#define ALPHATEST");
-                    defines.push("#define ALPHATESTVALUE 0.4");
-                }
-                if (!diffuseTexture.gammaSpace) {
-                    defines.push("#define DIFFUSE_ISLINEAR");
-                }
-            }
-            const opacityTexture = material.opacityTexture;
-            if (opacityTexture) {
-                defines.push("#define OPACITY");
-                if (mesh.isVerticesDataPresent(VertexBuffer.UV2Kind) && opacityTexture.coordinatesIndex === 1) {
-                    defines.push("#define OPACITYUV2");
-                    uv2 = true;
-                }
-                else if (mesh.isVerticesDataPresent(VertexBuffer.UVKind)) {
-                    defines.push("#define OPACITYUV1");
-                    uv1 = true;
-                }
-            }
-        }
-        // Emissive
-        if (emissiveTexture) {
-            defines.push("#define EMISSIVE");
-            if (mesh.isVerticesDataPresent(VertexBuffer.UV2Kind) && emissiveTexture.coordinatesIndex === 1) {
-                defines.push("#define EMISSIVEUV2");
-                uv2 = true;
-            }
-            else if (mesh.isVerticesDataPresent(VertexBuffer.UVKind)) {
-                defines.push("#define EMISSIVEUV1");
-                uv1 = true;
-            }
-            if (!emissiveTexture.gammaSpace) {
-                defines.push("#define EMISSIVE_ISLINEAR");
-            }
-        }
-        // Vertex
-        if (mesh.useVertexColors && mesh.isVerticesDataPresent(VertexBuffer.ColorKind) && mesh.hasVertexAlpha && material.transparencyMode !== Material.MATERIAL_OPAQUE) {
-            attribs.push(VertexBuffer.ColorKind);
-            defines.push("#define VERTEXALPHA");
-        }
-        if (uv1) {
-            attribs.push(VertexBuffer.UVKind);
-            defines.push("#define UV1");
-        }
-        if (uv2) {
-            attribs.push(VertexBuffer.UV2Kind);
-            defines.push("#define UV2");
-        }
-        // Bones
-        const fallbacks = new EffectFallbacks();
-        if (mesh.useBones && mesh.computeBonesUsingShaders) {
-            attribs.push(VertexBuffer.MatricesIndicesKind);
-            attribs.push(VertexBuffer.MatricesWeightsKind);
-            if (mesh.numBoneInfluencers > 4) {
-                attribs.push(VertexBuffer.MatricesIndicesExtraKind);
-                attribs.push(VertexBuffer.MatricesWeightsExtraKind);
-            }
-            defines.push("#define NUM_BONE_INFLUENCERS " + mesh.numBoneInfluencers);
-            const skeleton = mesh.skeleton;
-            if (skeleton && skeleton.isUsingTextureForMatrices) {
-                defines.push("#define BONETEXTURE");
-            }
-            else {
-                defines.push("#define BonesPerMesh " + (skeleton ? skeleton.bones.length + 1 : 0));
-            }
-            if (mesh.numBoneInfluencers > 0) {
-                fallbacks.addCPUSkinningFallback(0, mesh);
-            }
-        }
-        else {
-            defines.push("#define NUM_BONE_INFLUENCERS 0");
-        }
-        // Morph targets
-        const manager = mesh.morphTargetManager;
-        let morphInfluencers = 0;
-        if (manager) {
-            if (manager.numInfluencers > 0) {
-                defines.push("#define MORPHTARGETS");
-                morphInfluencers = manager.numInfluencers;
-                defines.push("#define NUM_MORPH_INFLUENCERS " + morphInfluencers);
-                if (manager.isUsingTextureForTargets) {
-                    defines.push("#define MORPHTARGETS_TEXTURE");
-                }
-                MaterialHelper.PrepareAttributesForMorphTargetsInfluencers(attribs, mesh, morphInfluencers);
-            }
-        }
-        // Instances
-        if (useInstances) {
-            defines.push("#define INSTANCES");
-            MaterialHelper.PushAttributesForInstances(attribs);
-            if (subMesh.getRenderingMesh().hasThinInstances) {
-                defines.push("#define THIN_INSTANCES");
-            }
-        }
-        // ClipPlanes
-        prepareStringDefinesForClipPlanes(material, this._scene, defines);
-        this._addCustomEffectDefines(defines);
-        // Get correct effect
-        const drawWrapper = subMesh._getDrawWrapper(undefined, true);
-        const cachedDefines = drawWrapper.defines;
-        const join = defines.join("\n");
-        if (cachedDefines !== join) {
-            const uniforms = [
-                "world",
-                "mBones",
-                "viewProjection",
-                "glowColor",
-                "morphTargetInfluences",
-                "boneTextureWidth",
-                "diffuseMatrix",
-                "emissiveMatrix",
-                "opacityMatrix",
-                "opacityIntensity",
-                "morphTargetTextureInfo",
-                "morphTargetTextureIndices",
-                "glowIntensity",
-            ];
-            addClipPlaneUniforms(uniforms);
-            drawWrapper.setEffect(this._engine.createEffect("glowMapGeneration", attribs, uniforms, ["diffuseSampler", "emissiveSampler", "opacitySampler", "boneSampler", "morphTargets"], join, fallbacks, undefined, undefined, { maxSimultaneousMorphTargets: morphInfluencers }), join);
-        }
-        return drawWrapper.effect.isReady();
-    }
-    /**
-     * Renders the glowing part of the scene by blending the blurred glowing meshes on top of the rendered scene.
-     */
-    render() {
-        for (let i = 0; i < this._postProcesses.length; i++) {
-            if (!this._postProcesses[i].isReady()) {
-                return;
-            }
-        }
-        const engine = this._scene.getEngine();
-        const numDraws = this._numInternalDraws();
-        // Check
-        let isReady = true;
-        for (let i = 0; i < numDraws; ++i) {
-            let currentEffect = this._mergeDrawWrapper[i];
-            if (!currentEffect) {
-                currentEffect = this._mergeDrawWrapper[i] = new DrawWrapper(this._engine);
-                currentEffect.setEffect(this._createMergeEffect());
-            }
-            isReady = isReady && currentEffect.effect.isReady();
-        }
-        if (!isReady) {
-            return;
-        }
-        this.onBeforeComposeObservable.notifyObservers(this);
-        const previousAlphaMode = engine.getAlphaMode();
-        for (let i = 0; i < numDraws; ++i) {
-            const currentEffect = this._mergeDrawWrapper[i];
-            // Render
-            engine.enableEffect(currentEffect);
-            engine.setState(false);
-            // VBOs
-            engine.bindBuffers(this._vertexBuffers, this._indexBuffer, currentEffect.effect);
-            // Go Blend.
-            engine.setAlphaMode(this._effectLayerOptions.alphaBlendingMode);
-            // Blends the map on the main canvas.
-            this._internalRender(currentEffect.effect, i);
-        }
-        // Restore Alpha
-        engine.setAlphaMode(previousAlphaMode);
-        this.onAfterComposeObservable.notifyObservers(this);
-        // Handle size changes.
-        const size = this._mainTexture.getSize();
-        this._setMainTextureSize();
-        if ((size.width !== this._mainTextureDesiredSize.width || size.height !== this._mainTextureDesiredSize.height) &&
-            this._mainTextureDesiredSize.width !== 0 &&
-            this._mainTextureDesiredSize.height !== 0) {
-            // Recreate RTT and post processes on size change.
-            this.onSizeChangedObservable.notifyObservers(this);
-            this._disposeTextureAndPostProcesses();
-            this._createMainTexture();
-            this._createTextureAndPostProcesses();
-        }
-    }
-    /**
-     * Determine if a given mesh will be used in the current effect.
-     * @param mesh mesh to test
-     * @returns true if the mesh will be used
-     */
-    hasMesh(mesh) {
-        if (this.renderingGroupId === -1 || mesh.renderingGroupId === this.renderingGroupId) {
-            return true;
-        }
-        return false;
-    }
-    /**
-     * Returns true if the layer contains information to display, otherwise false.
-     * @returns true if the glow layer should be rendered
-     */
-    shouldRender() {
-        return this.isEnabled && this._shouldRender;
-    }
-    /**
-     * Returns true if the mesh should render, otherwise false.
-     * @param mesh The mesh to render
-     * @returns true if it should render otherwise false
-     */
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    _shouldRenderMesh(mesh) {
-        return true;
-    }
-    /**
-     * Returns true if the mesh can be rendered, otherwise false.
-     * @param mesh The mesh to render
-     * @param material The material used on the mesh
-     * @returns true if it can be rendered otherwise false
-     */
-    _canRenderMesh(mesh, material) {
-        return !material.needAlphaBlendingForMesh(mesh);
-    }
-    /**
-     * Returns true if the mesh should render, otherwise false.
-     * @returns true if it should render otherwise false
-     */
-    _shouldRenderEmissiveTextureForMesh() {
-        return true;
-    }
-    /**
-     * Renders the submesh passed in parameter to the generation map.
-     * @param subMesh
-     * @param enableAlphaMode
-     */
-    _renderSubMesh(subMesh, enableAlphaMode = false) {
-        var _a, _b;
-        if (!this.shouldRender()) {
-            return;
-        }
-        const material = subMesh.getMaterial();
-        const ownerMesh = subMesh.getMesh();
-        const replacementMesh = subMesh.getReplacementMesh();
-        const renderingMesh = subMesh.getRenderingMesh();
-        const effectiveMesh = subMesh.getEffectiveMesh();
-        const scene = this._scene;
-        const engine = scene.getEngine();
-        effectiveMesh._internalAbstractMeshDataInfo._isActiveIntermediate = false;
-        if (!material) {
-            return;
-        }
-        // Do not block in blend mode.
-        if (!this._canRenderMesh(renderingMesh, material)) {
-            return;
-        }
-        // Culling
-        let sideOrientation = (_a = renderingMesh.overrideMaterialSideOrientation) !== null && _a !== void 0 ? _a : material.sideOrientation;
-        const mainDeterminant = effectiveMesh._getWorldMatrixDeterminant();
-        if (mainDeterminant < 0) {
-            sideOrientation = sideOrientation === Material.ClockWiseSideOrientation ? Material.CounterClockWiseSideOrientation : Material.ClockWiseSideOrientation;
-        }
-        const reverse = sideOrientation === Material.ClockWiseSideOrientation;
-        engine.setState(material.backFaceCulling, material.zOffset, undefined, reverse, material.cullBackFaces, undefined, material.zOffsetUnits);
-        // Managing instances
-        const batch = renderingMesh._getInstancesRenderList(subMesh._id, !!replacementMesh);
-        if (batch.mustReturn) {
-            return;
-        }
-        // Early Exit per mesh
-        if (!this._shouldRenderMesh(renderingMesh)) {
-            return;
-        }
-        const hardwareInstancedRendering = batch.hardwareInstancedRendering[subMesh._id] || renderingMesh.hasThinInstances;
-        this._setEmissiveTextureAndColor(renderingMesh, subMesh, material);
-        this.onBeforeRenderMeshToEffect.notifyObservers(ownerMesh);
-        if (this._useMeshMaterial(renderingMesh)) {
-            renderingMesh.render(subMesh, enableAlphaMode, replacementMesh || undefined);
-        }
-        else if (this._isReady(subMesh, hardwareInstancedRendering, this._emissiveTextureAndColor.texture)) {
-            const renderingMaterial = (_b = effectiveMesh._internalAbstractMeshDataInfo._materialForRenderPass) === null || _b === void 0 ? void 0 : _b[engine.currentRenderPassId];
-            let drawWrapper = subMesh._getDrawWrapper();
-            if (!drawWrapper && renderingMaterial) {
-                drawWrapper = renderingMaterial._getDrawWrapper();
-            }
-            if (!drawWrapper) {
-                return;
-            }
-            const effect = drawWrapper.effect;
-            engine.enableEffect(drawWrapper);
-            if (!hardwareInstancedRendering) {
-                renderingMesh._bind(subMesh, effect, material.fillMode);
-            }
-            if (!renderingMaterial) {
-                effect.setMatrix("viewProjection", scene.getTransformMatrix());
-                effect.setMatrix("world", effectiveMesh.getWorldMatrix());
-                effect.setFloat4("glowColor", this._emissiveTextureAndColor.color.r, this._emissiveTextureAndColor.color.g, this._emissiveTextureAndColor.color.b, this._emissiveTextureAndColor.color.a);
-            }
-            else {
-                renderingMaterial.bindForSubMesh(effectiveMesh.getWorldMatrix(), effectiveMesh, subMesh);
-            }
-            if (!renderingMaterial) {
-                const needAlphaTest = material.needAlphaTesting();
-                const diffuseTexture = material.getAlphaTestTexture();
-                const needAlphaBlendFromDiffuse = diffuseTexture && diffuseTexture.hasAlpha && (material.useAlphaFromDiffuseTexture || material._useAlphaFromAlbedoTexture);
-                if (diffuseTexture && (needAlphaTest || needAlphaBlendFromDiffuse)) {
-                    effect.setTexture("diffuseSampler", diffuseTexture);
-                    const textureMatrix = diffuseTexture.getTextureMatrix();
-                    if (textureMatrix) {
-                        effect.setMatrix("diffuseMatrix", textureMatrix);
-                    }
-                }
-                const opacityTexture = material.opacityTexture;
-                if (opacityTexture) {
-                    effect.setTexture("opacitySampler", opacityTexture);
-                    effect.setFloat("opacityIntensity", opacityTexture.level);
-                    const textureMatrix = opacityTexture.getTextureMatrix();
-                    if (textureMatrix) {
-                        effect.setMatrix("opacityMatrix", textureMatrix);
-                    }
-                }
-                // Glow emissive only
-                if (this._emissiveTextureAndColor.texture) {
-                    effect.setTexture("emissiveSampler", this._emissiveTextureAndColor.texture);
-                    effect.setMatrix("emissiveMatrix", this._emissiveTextureAndColor.texture.getTextureMatrix());
-                }
-                // Bones
-                if (renderingMesh.useBones && renderingMesh.computeBonesUsingShaders && renderingMesh.skeleton) {
-                    const skeleton = renderingMesh.skeleton;
-                    if (skeleton.isUsingTextureForMatrices) {
-                        const boneTexture = skeleton.getTransformMatrixTexture(renderingMesh);
-                        if (!boneTexture) {
-                            return;
-                        }
-                        effect.setTexture("boneSampler", boneTexture);
-                        effect.setFloat("boneTextureWidth", 4.0 * (skeleton.bones.length + 1));
-                    }
-                    else {
-                        effect.setMatrices("mBones", skeleton.getTransformMatrices(renderingMesh));
-                    }
-                }
-                // Morph targets
-                MaterialHelper.BindMorphTargetParameters(renderingMesh, effect);
-                if (renderingMesh.morphTargetManager && renderingMesh.morphTargetManager.isUsingTextureForTargets) {
-                    renderingMesh.morphTargetManager._bind(effect);
-                }
-                // Alpha mode
-                if (enableAlphaMode) {
-                    engine.setAlphaMode(material.alphaMode);
-                }
-                // Intensity of effect
-                effect.setFloat("glowIntensity", this.getEffectIntensity(renderingMesh));
-                // Clip planes
-                bindClipPlane(effect, material, scene);
-            }
-            // Draw
-            renderingMesh._processRendering(effectiveMesh, subMesh, effect, material.fillMode, batch, hardwareInstancedRendering, (isInstance, world) => effect.setMatrix("world", world));
-        }
-        else {
-            // Need to reset refresh rate of the main map
-            this._mainTexture.resetRefreshCounter();
-        }
-        this.onAfterRenderMeshToEffect.notifyObservers(ownerMesh);
-    }
-    /**
-     * Defines whether the current material of the mesh should be use to render the effect.
-     * @param mesh defines the current mesh to render
-     */
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    _useMeshMaterial(mesh) {
-        return false;
-    }
-    /**
-     * Rebuild the required buffers.
-     * @internal Internal use only.
-     */
-    _rebuild() {
-        const vb = this._vertexBuffers[VertexBuffer.PositionKind];
-        if (vb) {
-            vb._rebuild();
-        }
-        this._generateIndexBuffer();
-    }
-    /**
-     * Dispose only the render target textures and post process.
-     */
-    _disposeTextureAndPostProcesses() {
-        this._mainTexture.dispose();
-        for (let i = 0; i < this._postProcesses.length; i++) {
-            if (this._postProcesses[i]) {
-                this._postProcesses[i].dispose();
-            }
-        }
-        this._postProcesses = [];
-        for (let i = 0; i < this._textures.length; i++) {
-            if (this._textures[i]) {
-                this._textures[i].dispose();
-            }
-        }
-        this._textures = [];
-    }
-    /**
-     * Dispose the highlight layer and free resources.
-     */
-    dispose() {
-        const vertexBuffer = this._vertexBuffers[VertexBuffer.PositionKind];
-        if (vertexBuffer) {
-            vertexBuffer.dispose();
-            this._vertexBuffers[VertexBuffer.PositionKind] = null;
-        }
-        if (this._indexBuffer) {
-            this._scene.getEngine()._releaseBuffer(this._indexBuffer);
-            this._indexBuffer = null;
-        }
-        for (const drawWrapper of this._mergeDrawWrapper) {
-            drawWrapper.dispose();
-        }
-        this._mergeDrawWrapper = [];
-        // Clean textures and post processes
-        this._disposeTextureAndPostProcesses();
-        // Remove from scene
-        const index = this._scene.effectLayers.indexOf(this, 0);
-        if (index > -1) {
-            this._scene.effectLayers.splice(index, 1);
-        }
-        // Callback
-        this.onDisposeObservable.notifyObservers(this);
-        this.onDisposeObservable.clear();
-        this.onBeforeRenderMainTextureObservable.clear();
-        this.onBeforeComposeObservable.clear();
-        this.onBeforeRenderMeshToEffect.clear();
-        this.onAfterRenderMeshToEffect.clear();
-        this.onAfterComposeObservable.clear();
-        this.onSizeChangedObservable.clear();
-    }
-    /**
-     * Gets the class name of the effect layer
-     * @returns the string with the class name of the effect layer
-     */
-    getClassName() {
-        return "EffectLayer";
-    }
-    /**
-     * Creates an effect layer from parsed effect layer data
-     * @param parsedEffectLayer defines effect layer data
-     * @param scene defines the current scene
-     * @param rootUrl defines the root URL containing the effect layer information
-     * @returns a parsed effect Layer
-     */
-    static Parse(parsedEffectLayer, scene, rootUrl) {
-        const effectLayerType = Tools.Instantiate(parsedEffectLayer.customType);
-        return effectLayerType.Parse(parsedEffectLayer, scene, rootUrl);
-    }
-}
-/**
- * @internal
- */
-EffectLayer._SceneComponentInitialization = (_) => {
-    throw _WarnImport("EffectLayerSceneComponent");
-};
-__decorate([
-    serialize()
-], EffectLayer.prototype, "name", void 0);
-__decorate([
-    serializeAsColor4()
-], EffectLayer.prototype, "neutralColor", void 0);
-__decorate([
-    serialize()
-], EffectLayer.prototype, "isEnabled", void 0);
-__decorate([
-    serializeAsCameraReference()
-], EffectLayer.prototype, "camera", null);
-__decorate([
-    serialize()
-], EffectLayer.prototype, "renderingGroupId", null);
-__decorate([
-    serialize()
-], EffectLayer.prototype, "disableBoundingBoxesFromEffectLayer", void 0);
-
-// Do not edit.
-const name$1 = "glowMapMergePixelShader";
-const shader$1 = `varying vec2 vUV;
-uniform sampler2D textureSampler2;
-uniform float offset;
-void main(void) {
-vec4 baseColor=texture2D(textureSampler,vUV);
-baseColor+=texture2D(textureSampler2,vUV);
-baseColor.a=abs(offset-baseColor.a);
-float alpha=smoothstep(.0,.1,baseColor.a);
-#endif
-#if LDR
-baseColor=clamp(baseColor,0.,1.0);
-gl_FragColor=baseColor;
-}`;
-// Sideeffect
-ShaderStore.ShadersStore[name$1] = shader$1;
-
-// Do not edit.
-const name = "glowMapMergeVertexShader";
-const shader = `attribute vec2 position;
-void main(void) {
-vUV=position*madd+madd;
-}`;
-// Sideeffect
-ShaderStore.ShadersStore[name] = shader;
-
-// Adds the parser to the scene parsers.
-AbstractScene.AddParser(SceneComponentConstants.NAME_EFFECTLAYER, (parsedData, scene, container, rootUrl) => {
-    if (parsedData.effectLayers) {
-        if (!container.effectLayers) {
-            container.effectLayers = new Array();
-        }
-        for (let index = 0; index < parsedData.effectLayers.length; index++) {
-            const effectLayer = EffectLayer.Parse(parsedData.effectLayers[index], scene, rootUrl);
-            container.effectLayers.push(effectLayer);
-        }
-    }
-});
-AbstractScene.prototype.removeEffectLayer = function (toRemove) {
-    const index = this.effectLayers.indexOf(toRemove);
-    if (index !== -1) {
-        this.effectLayers.splice(index, 1);
-    }
-    return index;
-};
-AbstractScene.prototype.addEffectLayer = function (newEffectLayer) {
-    this.effectLayers.push(newEffectLayer);
-};
-/**
- * Defines the layer scene component responsible to manage any effect layers
- * in a given scene.
- */
-class EffectLayerSceneComponent {
-    /**
-     * 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_EFFECTLAYER;
-        this._renderEffects = false;
-        this._needStencil = false;
-        this._previousStencilState = false;
-        this.scene = scene || EngineStore.LastCreatedScene;
-        if (!this.scene) {
-            return;
-        }
-        this._engine = this.scene.getEngine();
-        this.scene.effectLayers = new Array();
-    }
-    /**
-     * Registers the component in a given scene
-     */
-    register() {
-        this.scene._isReadyForMeshStage.registerStep(SceneComponentConstants.STEP_ISREADYFORMESH_EFFECTLAYER, this, this._isReadyForMesh);
-        this.scene._cameraDrawRenderTargetStage.registerStep(SceneComponentConstants.STEP_CAMERADRAWRENDERTARGET_EFFECTLAYER, this, this._renderMainTexture);
-        this.scene._beforeCameraDrawStage.registerStep(SceneComponentConstants.STEP_BEFORECAMERADRAW_EFFECTLAYER, this, this._setStencil);
-        this.scene._afterRenderingGroupDrawStage.registerStep(SceneComponentConstants.STEP_AFTERRENDERINGGROUPDRAW_EFFECTLAYER_DRAW, this, this._drawRenderingGroup);
-        this.scene._afterCameraDrawStage.registerStep(SceneComponentConstants.STEP_AFTERCAMERADRAW_EFFECTLAYER, this, this._setStencilBack);
-        this.scene._afterCameraDrawStage.registerStep(SceneComponentConstants.STEP_AFTERCAMERADRAW_EFFECTLAYER_DRAW, this, this._drawCamera);
-    }
-    /**
-     * Rebuilds the elements related to this component in case of
-     * context lost for instance.
-     */
-    rebuild() {
-        const layers = this.scene.effectLayers;
-        for (const effectLayer of layers) {
-            effectLayer._rebuild();
-        }
-    }
-    /**
-     * Serializes the component data to the specified json object
-     * @param serializationObject The object to serialize to
-     */
-    serialize(serializationObject) {
-        // Effect layers
-        serializationObject.effectLayers = [];
-        const layers = this.scene.effectLayers;
-        for (const effectLayer of layers) {
-            if (effectLayer.serialize) {
-                serializationObject.effectLayers.push(effectLayer.serialize());
-            }
-        }
-    }
-    /**
-     * Adds all the elements from the container to the scene
-     * @param container the container holding the elements
-     */
-    addFromContainer(container) {
-        if (!container.effectLayers) {
-            return;
-        }
-        container.effectLayers.forEach((o) => {
-            this.scene.addEffectLayer(o);
-        });
-    }
-    /**
-     * Removes all the elements in the container from the scene
-     * @param container contains the elements to remove
-     * @param dispose if the removed element should be disposed (default: false)
-     */
-    removeFromContainer(container, dispose) {
-        if (!container.effectLayers) {
-            return;
-        }
-        container.effectLayers.forEach((o) => {
-            this.scene.removeEffectLayer(o);
-            if (dispose) {
-                o.dispose();
-            }
-        });
-    }
-    /**
-     * Disposes the component and the associated resources.
-     */
-    dispose() {
-        const layers = this.scene.effectLayers;
-        while (layers.length) {
-            layers[0].dispose();
-        }
-    }
-    _isReadyForMesh(mesh, hardwareInstancedRendering) {
-        const currentRenderPassId = this._engine.currentRenderPassId;
-        const layers = this.scene.effectLayers;
-        for (const layer of layers) {
-            if (!layer.hasMesh(mesh)) {
-                continue;
-            }
-            const renderTarget = layer._mainTexture;
-            this._engine.currentRenderPassId = renderTarget.renderPassId;
-            for (const subMesh of mesh.subMeshes) {
-                if (!layer.isReady(subMesh, hardwareInstancedRendering)) {
-                    this._engine.currentRenderPassId = currentRenderPassId;
-                    return false;
-                }
-            }
-        }
-        this._engine.currentRenderPassId = currentRenderPassId;
-        return true;
-    }
-    _renderMainTexture(camera) {
-        this._renderEffects = false;
-        this._needStencil = false;
-        let needRebind = false;
-        const layers = this.scene.effectLayers;
-        if (layers && layers.length > 0) {
-            this._previousStencilState = this._engine.getStencilBuffer();
-            for (const effectLayer of layers) {
-                if (effectLayer.shouldRender() &&
-                    (!effectLayer.camera ||
-                        (effectLayer.camera.cameraRigMode === Camera.RIG_MODE_NONE && camera === effectLayer.camera) ||
-                        (effectLayer.camera.cameraRigMode !== Camera.RIG_MODE_NONE && effectLayer.camera._rigCameras.indexOf(camera) > -1))) {
-                    this._renderEffects = true;
-                    this._needStencil = this._needStencil || effectLayer.needStencil();
-                    const renderTarget = effectLayer._mainTexture;
-                    if (renderTarget._shouldRender()) {
-                        this.scene.incrementRenderId();
-                        renderTarget.render(false, false);
-                        needRebind = true;
-                    }
-                }
-            }
-            this.scene.incrementRenderId();
-        }
-        return needRebind;
-    }
-    _setStencil() {
-        // Activate effect Layer stencil
-        if (this._needStencil) {
-            this._engine.setStencilBuffer(true);
-        }
-    }
-    _setStencilBack() {
-        // Restore effect Layer stencil
-        if (this._needStencil) {
-            this._engine.setStencilBuffer(this._previousStencilState);
-        }
-    }
-    _draw(renderingGroupId) {
-        if (this._renderEffects) {
-            this._engine.setDepthBuffer(false);
-            const layers = this.scene.effectLayers;
-            for (let i = 0; i < layers.length; i++) {
-                const effectLayer = layers[i];
-                if (effectLayer.renderingGroupId === renderingGroupId) {
-                    if (effectLayer.shouldRender()) {
-                        effectLayer.render();
-                    }
-                }
-            }
-            this._engine.setDepthBuffer(true);
-        }
-    }
-    _drawCamera() {
-        if (this._renderEffects) {
-            this._draw(-1);
-        }
-    }
-    _drawRenderingGroup(index) {
-        if (!this.scene._isInIntermediateRendering() && this._renderEffects) {
-            this._draw(index);
-        }
-    }
-}
-EffectLayer._SceneComponentInitialization = (scene) => {
-    let component = scene._getComponent(SceneComponentConstants.NAME_EFFECTLAYER);
-    if (!component) {
-        component = new EffectLayerSceneComponent(scene);
-        scene._addComponent(component);
-    }
-};
-
-AbstractScene.prototype.getGlowLayerByName = function (name) {
-    var _a;
-    for (let index = 0; index < ((_a = this.effectLayers) === null || _a === void 0 ? void 0 : _a.length); index++) {
-        if (this.effectLayers[index].name === name && this.effectLayers[index].getEffectName() === GlowLayer.EffectName) {
-            return this.effectLayers[index];
-        }
-    }
-    return null;
-};
-/**
- * The glow layer Helps adding a glow effect around the emissive parts of a mesh.
- *
- * Once instantiated in a scene, by default, all the emissive meshes will glow.
- *
- * Documentation: https://doc.babylonjs.com/features/featuresDeepDive/mesh/glowLayer
- */
-class GlowLayer extends EffectLayer {
-    /**
-     * Sets the kernel size of the blur.
-     */
-    set blurKernelSize(value) {
-        if (value === this._options.blurKernelSize) {
-            return;
-        }
-        this._options.blurKernelSize = value;
-        const effectiveKernel = this._getEffectiveBlurKernelSize();
-        this._horizontalBlurPostprocess1.kernel = effectiveKernel;
-        this._verticalBlurPostprocess1.kernel = effectiveKernel;
-        this._horizontalBlurPostprocess2.kernel = effectiveKernel;
-        this._verticalBlurPostprocess2.kernel = effectiveKernel;
-    }
-    /**
-     * Gets the kernel size of the blur.
-     */
-    get blurKernelSize() {
-        return this._options.blurKernelSize;
-    }
-    /**
-     * Sets the glow intensity.
-     */
-    set intensity(value) {
-        this._intensity = value;
-    }
-    /**
-     * Gets the glow intensity.
-     */
-    get intensity() {
-        return this._intensity;
-    }
-    /**
-     * Instantiates a new glow Layer and references it to the scene.
-     * @param name The name of the layer
-     * @param scene The scene to use the layer in
-     * @param options Sets of none mandatory options to use with the layer (see IGlowLayerOptions for more information)
-     */
-    constructor(name, scene, options) {
-        super(name, scene);
-        this._intensity = 1.0;
-        this._includedOnlyMeshes = [];
-        this._excludedMeshes = [];
-        this._meshesUsingTheirOwnMaterials = [];
-        this.neutralColor = new Color4(0, 0, 0, 1);
-        // Adapt options
-        this._options = Object.assign({ mainTextureRatio: GlowLayer.DefaultTextureRatio, blurKernelSize: 32, mainTextureFixedSize: undefined, camera: null, mainTextureSamples: 1, renderingGroupId: -1, ldrMerge: false, alphaBlendingMode: 1, mainTextureType: 0, generateStencilBuffer: false }, options);
-        // Initialize the layer
-        this._init({
-            alphaBlendingMode: this._options.alphaBlendingMode,
-            camera: this._options.camera,
-            mainTextureFixedSize: this._options.mainTextureFixedSize,
-            mainTextureRatio: this._options.mainTextureRatio,
-            renderingGroupId: this._options.renderingGroupId,
-            mainTextureType: this._options.mainTextureType,
-            generateStencilBuffer: this._options.generateStencilBuffer,
-        });
-    }
-    /**
-     * Get the effect name of the layer.
-     * @returns The effect name
-     */
-    getEffectName() {
-        return GlowLayer.EffectName;
-    }
-    /**
-     * Create the merge effect. This is the shader use to blit the information back
-     * to the main canvas at the end of the scene rendering.
-     */
-    _createMergeEffect() {
-        let defines = "#define EMISSIVE \n";
-        if (this._options.ldrMerge) {
-            defines += "#define LDR \n";
-        }
-        // Effect
-        return this._engine.createEffect("glowMapMerge", [VertexBuffer.PositionKind], ["offset"], ["textureSampler", "textureSampler2"], defines);
-    }
-    /**
-     * Creates the render target textures and post processes used in the glow layer.
-     */
-    _createTextureAndPostProcesses() {
-        let blurTextureWidth = this._mainTextureDesiredSize.width;
-        let blurTextureHeight = this._mainTextureDesiredSize.height;
-        blurTextureWidth = this._engine.needPOTTextures ? Engine.GetExponentOfTwo(blurTextureWidth, this._maxSize) : blurTextureWidth;
-        blurTextureHeight = this._engine.needPOTTextures ? Engine.GetExponentOfTwo(blurTextureHeight, this._maxSize) : blurTextureHeight;
-        let textureType = 0;
-        if (this._engine.getCaps().textureHalfFloatRender) {
-            textureType = 2;
-        }
-        else {
-            textureType = 0;
-        }
-        this._blurTexture1 = new RenderTargetTexture("GlowLayerBlurRTT", {
-            width: blurTextureWidth,
-            height: blurTextureHeight,
-        }, this._scene, false, true, textureType);
-        this._blurTexture1.wrapU = Texture.CLAMP_ADDRESSMODE;
-        this._blurTexture1.wrapV = Texture.CLAMP_ADDRESSMODE;
-        this._blurTexture1.updateSamplingMode(Texture.BILINEAR_SAMPLINGMODE);
-        this._blurTexture1.renderParticles = false;
-        this._blurTexture1.ignoreCameraViewport = true;
-        const blurTextureWidth2 = Math.floor(blurTextureWidth / 2);
-        const blurTextureHeight2 = Math.floor(blurTextureHeight / 2);
-        this._blurTexture2 = new RenderTargetTexture("GlowLayerBlurRTT2", {
-            width: blurTextureWidth2,
-            height: blurTextureHeight2,
-        }, this._scene, false, true, textureType);
-        this._blurTexture2.wrapU = Texture.CLAMP_ADDRESSMODE;
-        this._blurTexture2.wrapV = Texture.CLAMP_ADDRESSMODE;
-        this._blurTexture2.updateSamplingMode(Texture.BILINEAR_SAMPLINGMODE);
-        this._blurTexture2.renderParticles = false;
-        this._blurTexture2.ignoreCameraViewport = true;
-        this._textures = [this._blurTexture1, this._blurTexture2];
-        const effectiveKernel = this._getEffectiveBlurKernelSize();
-        this._horizontalBlurPostprocess1 = new BlurPostProcess("GlowLayerHBP1", new Vector2(1.0, 0), effectiveKernel, {
-            width: blurTextureWidth,
-            height: blurTextureHeight,
-        }, null, Texture.BILINEAR_SAMPLINGMODE, this._scene.getEngine(), false, textureType);
-        this._horizontalBlurPostprocess1.width = blurTextureWidth;
-        this._horizontalBlurPostprocess1.height = blurTextureHeight;
-        this._horizontalBlurPostprocess1.externalTextureSamplerBinding = true;
-        this._horizontalBlurPostprocess1.onApplyObservable.add((effect) => {
-            effect.setTexture("textureSampler", this._mainTexture);
-        });
-        this._verticalBlurPostprocess1 = new BlurPostProcess("GlowLayerVBP1", new Vector2(0, 1.0), effectiveKernel, {
-            width: blurTextureWidth,
-            height: blurTextureHeight,
-        }, null, Texture.BILINEAR_SAMPLINGMODE, this._scene.getEngine(), false, textureType);
-        this._horizontalBlurPostprocess2 = new BlurPostProcess("GlowLayerHBP2", new Vector2(1.0, 0), effectiveKernel, {
-            width: blurTextureWidth2,
-            height: blurTextureHeight2,
-        }, null, Texture.BILINEAR_SAMPLINGMODE, this._scene.getEngine(), false, textureType);
-        this._horizontalBlurPostprocess2.width = blurTextureWidth2;
-        this._horizontalBlurPostprocess2.height = blurTextureHeight2;
-        this._horizontalBlurPostprocess2.externalTextureSamplerBinding = true;
-        this._horizontalBlurPostprocess2.onApplyObservable.add((effect) => {
-            effect.setTexture("textureSampler", this._blurTexture1);
-        });
-        this._verticalBlurPostprocess2 = new BlurPostProcess("GlowLayerVBP2", new Vector2(0, 1.0), effectiveKernel, {
-            width: blurTextureWidth2,
-            height: blurTextureHeight2,
-        }, null, Texture.BILINEAR_SAMPLINGMODE, this._scene.getEngine(), false, textureType);
-        this._postProcesses = [this._horizontalBlurPostprocess1, this._verticalBlurPostprocess1, this._horizontalBlurPostprocess2, this._verticalBlurPostprocess2];
-        this._postProcesses1 = [this._horizontalBlurPostprocess1, this._verticalBlurPostprocess1];
-        this._postProcesses2 = [this._horizontalBlurPostprocess2, this._verticalBlurPostprocess2];
-        this._mainTexture.samples = this._options.mainTextureSamples;
-        this._mainTexture.onAfterUnbindObservable.add(() => {
-            const internalTexture = this._blurTexture1.renderTarget;
-            if (internalTexture) {
-                this._scene.postProcessManager.directRender(this._postProcesses1, internalTexture, true);
-                const internalTexture2 = this._blurTexture2.renderTarget;
-                if (internalTexture2) {
-                    this._scene.postProcessManager.directRender(this._postProcesses2, internalTexture2, true);
-                }
-                this._engine.unBindFramebuffer(internalTexture2 !== null && internalTexture2 !== void 0 ? internalTexture2 : internalTexture, true);
-            }
-        });
-        // Prevent autoClear.
-        this._postProcesses.map((pp) => {
-            pp.autoClear = false;
-        });
-    }
-    /**
-     * @returns The blur kernel size used by the glow.
-     * Note: The value passed in the options is divided by 2 for back compatibility.
-     */
-    _getEffectiveBlurKernelSize() {
-        return this._options.blurKernelSize / 2;
-    }
-    /**
-     * Checks for the readiness of the element composing the layer.
-     * @param subMesh the mesh to check for
-     * @param useInstances specify whether or not to use instances to render the mesh
-     * @returns true if ready otherwise, false
-     */
-    isReady(subMesh, useInstances) {
-        const material = subMesh.getMaterial();
-        const mesh = subMesh.getRenderingMesh();
-        if (!material || !mesh) {
-            return false;
-        }
-        const emissiveTexture = material.emissiveTexture;
-        return super._isReady(subMesh, useInstances, emissiveTexture);
-    }
-    /**
-     * Returns whether or not the layer needs stencil enabled during the mesh rendering.
-     */
-    needStencil() {
-        return false;
-    }
-    /**
-     * Returns true if the mesh can be rendered, otherwise false.
-     * @param mesh The mesh to render
-     * @param material The material used on the mesh
-     * @returns true if it can be rendered otherwise false
-     */
-    _canRenderMesh(mesh, material) {
-        return true;
-    }
-    /**
-     * Implementation specific of rendering the generating effect on the main canvas.
-     * @param effect The effect used to render through
-     */
-    _internalRender(effect) {
-        // Texture
-        effect.setTexture("textureSampler", this._blurTexture1);
-        effect.setTexture("textureSampler2", this._blurTexture2);
-        effect.setFloat("offset", this._intensity);
-        // Cache
-        const engine = this._engine;
-        const previousStencilBuffer = engine.getStencilBuffer();
-        // Draw order
-        engine.setStencilBuffer(false);
-        engine.drawElementsType(Material.TriangleFillMode, 0, 6);
-        // Draw order
-        engine.setStencilBuffer(previousStencilBuffer);
-    }
-    /**
-     * Sets the required values for both the emissive texture and and the main color.
-     * @param mesh
-     * @param subMesh
-     * @param material
-     */
-    _setEmissiveTextureAndColor(mesh, subMesh, material) {
-        var _a;
-        let textureLevel = 1.0;
-        if (this.customEmissiveTextureSelector) {
-            this._emissiveTextureAndColor.texture = this.customEmissiveTextureSelector(mesh, subMesh, material);
-        }
-        else {
-            if (material) {
-                this._emissiveTextureAndColor.texture = material.emissiveTexture;
-                if (this._emissiveTextureAndColor.texture) {
-                    textureLevel = this._emissiveTextureAndColor.texture.level;
-                }
-            }
-            else {
-                this._emissiveTextureAndColor.texture = null;
-            }
-        }
-        if (this.customEmissiveColorSelector) {
-            this.customEmissiveColorSelector(mesh, subMesh, material, this._emissiveTextureAndColor.color);
-        }
-        else {
-            if (material.emissiveColor) {
-                const emissiveIntensity = (_a = material.emissiveIntensity) !== null && _a !== void 0 ? _a : 1;
-                textureLevel *= emissiveIntensity;
-                this._emissiveTextureAndColor.color.set(material.emissiveColor.r * textureLevel, material.emissiveColor.g * textureLevel, material.emissiveColor.b * textureLevel, material.alpha);
-            }
-            else {
-                this._emissiveTextureAndColor.color.set(this.neutralColor.r, this.neutralColor.g, this.neutralColor.b, this.neutralColor.a);
-            }
-        }
-    }
-    /**
-     * Returns true if the mesh should render, otherwise false.
-     * @param mesh The mesh to render
-     * @returns true if it should render otherwise false
-     */
-    _shouldRenderMesh(mesh) {
-        return this.hasMesh(mesh);
-    }
-    /**
-     * Adds specific effects defines.
-     * @param defines The defines to add specifics to.
-     */
-    _addCustomEffectDefines(defines) {
-        defines.push("#define GLOW");
-    }
-    /**
-     * Add a mesh in the exclusion list to prevent it to impact or being impacted by the glow layer.
-     * @param mesh The mesh to exclude from the glow layer
-     */
-    addExcludedMesh(mesh) {
-        if (this._excludedMeshes.indexOf(mesh.uniqueId) === -1) {
-            this._excludedMeshes.push(mesh.uniqueId);
-        }
-    }
-    /**
-     * Remove a mesh from the exclusion list to let it impact or being impacted by the glow layer.
-     * @param mesh The mesh to remove
-     */
-    removeExcludedMesh(mesh) {
-        const index = this._excludedMeshes.indexOf(mesh.uniqueId);
-        if (index !== -1) {
-            this._excludedMeshes.splice(index, 1);
-        }
-    }
-    /**
-     * Add a mesh in the inclusion list to impact or being impacted by the glow layer.
-     * @param mesh The mesh to include in the glow layer
-     */
-    addIncludedOnlyMesh(mesh) {
-        if (this._includedOnlyMeshes.indexOf(mesh.uniqueId) === -1) {
-            this._includedOnlyMeshes.push(mesh.uniqueId);
-        }
-    }
-    /**
-     * Remove a mesh from the Inclusion list to prevent it to impact or being impacted by the glow layer.
-     * @param mesh The mesh to remove
-     */
-    removeIncludedOnlyMesh(mesh) {
-        const index = this._includedOnlyMeshes.indexOf(mesh.uniqueId);
-        if (index !== -1) {
-            this._includedOnlyMeshes.splice(index, 1);
-        }
-    }
-    /**
-     * Determine if a given mesh will be used in the glow layer
-     * @param mesh The mesh to test
-     * @returns true if the mesh will be highlighted by the current glow layer
-     */
-    hasMesh(mesh) {
-        if (!super.hasMesh(mesh)) {
-            return false;
-        }
-        // Included Mesh
-        if (this._includedOnlyMeshes.length) {
-            return this._includedOnlyMeshes.indexOf(mesh.uniqueId) !== -1;
-        }
-        // Excluded Mesh
-        if (this._excludedMeshes.length) {
-            return this._excludedMeshes.indexOf(mesh.uniqueId) === -1;
-        }
-        return true;
-    }
-    /**
-     * Defines whether the current material of the mesh should be use to render the effect.
-     * @param mesh defines the current mesh to render
-     */
-    _useMeshMaterial(mesh) {
-        if (this._meshesUsingTheirOwnMaterials.length == 0) {
-            return false;
-        }
-        return this._meshesUsingTheirOwnMaterials.indexOf(mesh.uniqueId) > -1;
-    }
-    /**
-     * Add a mesh to be rendered through its own material and not with emissive only.
-     * @param mesh The mesh for which we need to use its material
-     */
-    referenceMeshToUseItsOwnMaterial(mesh) {
-        mesh.resetDrawCache(this._mainTexture.renderPassId);
-        this._meshesUsingTheirOwnMaterials.push(mesh.uniqueId);
-        mesh.onDisposeObservable.add(() => {
-            this._disposeMesh(mesh);
-        });
-    }
-    /**
-     * Remove a mesh from being rendered through its own material and not with emissive only.
-     * @param mesh The mesh for which we need to not use its material
-     */
-    unReferenceMeshFromUsingItsOwnMaterial(mesh) {
-        let index = this._meshesUsingTheirOwnMaterials.indexOf(mesh.uniqueId);
-        while (index >= 0) {
-            this._meshesUsingTheirOwnMaterials.splice(index, 1);
-            index = this._meshesUsingTheirOwnMaterials.indexOf(mesh.uniqueId);
-        }
-        mesh.resetDrawCache(this._mainTexture.renderPassId);
-    }
-    /**
-     * Free any resources and references associated to a mesh.
-     * Internal use
-     * @param mesh The mesh to free.
-     * @internal
-     */
-    _disposeMesh(mesh) {
-        this.removeIncludedOnlyMesh(mesh);
-        this.removeExcludedMesh(mesh);
-    }
-    /**
-     * Gets the class name of the effect layer
-     * @returns the string with the class name of the effect layer
-     */
-    getClassName() {
-        return "GlowLayer";
-    }
-    /**
-     * Serializes this glow layer
-     * @returns a serialized glow layer object
-     */
-    serialize() {
-        const serializationObject = SerializationHelper.Serialize(this);
-        serializationObject.customType = "BABYLON.GlowLayer";
-        let index;
-        // Included meshes
-        serializationObject.includedMeshes = [];
-        if (this._includedOnlyMeshes.length) {
-            for (index = 0; index < this._includedOnlyMeshes.length; index++) {
-                const mesh = this._scene.getMeshByUniqueId(this._includedOnlyMeshes[index]);
-                if (mesh) {
-                    serializationObject.includedMeshes.push(mesh.id);
-                }
-            }
-        }
-        // Excluded meshes
-        serializationObject.excludedMeshes = [];
-        if (this._excludedMeshes.length) {
-            for (index = 0; index < this._excludedMeshes.length; index++) {
-                const mesh = this._scene.getMeshByUniqueId(this._excludedMeshes[index]);
-                if (mesh) {
-                    serializationObject.excludedMeshes.push(mesh.id);
-                }
-            }
-        }
-        return serializationObject;
-    }
-    /**
-     * Creates a Glow Layer from parsed glow layer data
-     * @param parsedGlowLayer defines glow layer data
-     * @param scene defines the current scene
-     * @param rootUrl defines the root URL containing the glow layer information
-     * @returns a parsed Glow Layer
-     */
-    static Parse(parsedGlowLayer, scene, rootUrl) {
-        const gl = SerializationHelper.Parse(() => new GlowLayer(parsedGlowLayer.name, scene, parsedGlowLayer.options), parsedGlowLayer, scene, rootUrl);
-        let index;
-        // Excluded meshes
-        for (index = 0; index < parsedGlowLayer.excludedMeshes.length; index++) {
-            const mesh = scene.getMeshById(parsedGlowLayer.excludedMeshes[index]);
-            if (mesh) {
-                gl.addExcludedMesh(mesh);
-            }
-        }
-        // Included meshes
-        for (index = 0; index < parsedGlowLayer.includedMeshes.length; index++) {
-            const mesh = scene.getMeshById(parsedGlowLayer.includedMeshes[index]);
-            if (mesh) {
-                gl.addIncludedOnlyMesh(mesh);
-            }
-        }
-        return gl;
-    }
-}
-/**
- * Effect Name of the layer.
- */
-GlowLayer.EffectName = "GlowLayer";
-/**
- * The default blur kernel size used for the glow.
- */
-GlowLayer.DefaultBlurKernelSize = 32;
-/**
- * The default texture size ratio used for the glow.
- */
-GlowLayer.DefaultTextureRatio = 0.5;
-__decorate([
-    serialize()
-], GlowLayer.prototype, "blurKernelSize", null);
-__decorate([
-    serialize()
-], GlowLayer.prototype, "intensity", null);
-__decorate([
-    serialize("options")
-], GlowLayer.prototype, "_options", void 0);
-RegisterClass("BABYLON.GlowLayer", GlowLayer);
-
-export { EffectLayer as E, GlowLayer as G };