@spiffcommerce/preview 3.6.2-rc.3 → 3.6.2-rc.5

package/dist/node_modules/@babylonjs/core/Layers/effectLayer.esm.js

@@ -0,0 +1,437 @@
+import { __decorate as R } from "../tslib.es6.esm.js";
+import { serialize as B, serializeAsColor4 as F, serializeAsCameraReference as z } from "../Misc/decorators.esm.js";
+import { Tools as L } from "../Misc/tools.esm.js";
+import { Observable as I } from "../Misc/observable.esm.js";
+import { Color4 as w } from "../Maths/math.color.esm.js";
+import { Engine as P } from "../Engines/engine.esm.js";
+import { EngineStore as U } from "../Engines/engineStore.esm.js";
+import { VertexBuffer as d } from "../Buffers/buffer.esm.js";
+import { Texture as y } from "../Materials/Textures/texture.esm.js";
+import { RenderTargetTexture as V } from "../Materials/Textures/renderTargetTexture.esm.js";
+import { Material as A } from "../Materials/material.esm.js";
+import { MaterialHelper as C } from "../Materials/materialHelper.esm.js";
+import "../Shaders/glowMapGeneration.fragment.esm.js";
+import "../Shaders/glowMapGeneration.vertex.esm.js";
+import { _WarnImport as W } from "../Misc/devTools.esm.js";
+import { EffectFallbacks as N } from "../Materials/effectFallbacks.esm.js";
+import { DrawWrapper as K } from "../Materials/drawWrapper.esm.js";
+import { prepareStringDefinesForClipPlanes as G, addClipPlaneUniforms as k, bindClipPlane as H } from "../Materials/clipPlaneMaterialHelper.esm.js";
+class g {
+  /**
+   * 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(e) {
+    this._effectLayerOptions.renderingGroupId = e;
+  }
+  /**
+   * 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(e, r) {
+    if (this._mainTexture.setMaterialForRendering(e, r), Array.isArray(e))
+      for (let o = 0; o < e.length; ++o) {
+        const h = e[o];
+        r ? this._materialForRendering[h.uniqueId] = [h, r] : delete this._materialForRendering[h.uniqueId];
+      }
+    else
+      r ? this._materialForRendering[e.uniqueId] = [e, r] : delete this._materialForRendering[e.uniqueId];
+  }
+  /**
+   * 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(e) {
+    var r;
+    return (r = this._effectIntensity[e.uniqueId]) !== null && r !== void 0 ? r : 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(e, r) {
+    this._effectIntensity[e.uniqueId] = r;
+  }
+  /**
+   * 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(e, r) {
+    this._vertexBuffers = {}, this._maxSize = 0, this._mainTextureDesiredSize = { width: 0, height: 0 }, this._shouldRender = !0, this._postProcesses = [], this._textures = [], this._emissiveTextureAndColor = { texture: null, color: new w() }, this._effectIntensity = {}, this.neutralColor = new w(), this.isEnabled = !0, this.disableBoundingBoxesFromEffectLayer = !1, this.onDisposeObservable = new I(), this.onBeforeRenderMainTextureObservable = new I(), this.onBeforeComposeObservable = new I(), this.onBeforeRenderMeshToEffect = new I(), this.onAfterRenderMeshToEffect = new I(), this.onAfterComposeObservable = new I(), this.onSizeChangedObservable = new I(), this._materialForRendering = {}, this.name = e, this._scene = r || U.LastCreatedScene, g._SceneComponentInitialization(this._scene), this._engine = this._scene.getEngine(), this._maxSize = this._engine.getCaps().maxTextureSize, this._scene.effectLayers.push(this), this._mergeDrawWrapper = [], 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(e) {
+    this._effectLayerOptions = Object.assign({ mainTextureRatio: 0.5, alphaBlendingMode: 2, camera: null, renderingGroupId: -1, mainTextureType: 0, generateStencilBuffer: !1 }, e), this._setMainTextureSize(), this._createMainTexture(), this._createTextureAndPostProcesses();
+  }
+  /**
+   * Generates the index buffer of the full screen quad blending to the main canvas.
+   */
+  _generateIndexBuffer() {
+    const e = [];
+    e.push(0), e.push(1), e.push(2), e.push(0), e.push(2), e.push(3), this._indexBuffer = this._engine.createIndexBuffer(e);
+  }
+  /**
+   * Generates the vertex buffer of the full screen quad blending to the main canvas.
+   */
+  _generateVertexBuffer() {
+    const e = [];
+    e.push(1, 1), e.push(-1, 1), e.push(-1, -1), e.push(1, -1);
+    const r = new d(this._engine, e, d.PositionKind, !1, !1, 2);
+    this._vertexBuffers[d.PositionKind] = r;
+  }
+  /**
+   * Sets the main texture desired size which is the closest power of two
+   * of the engine canvas size.
+   */
+  _setMainTextureSize() {
+    this._effectLayerOptions.mainTextureFixedSize ? (this._mainTextureDesiredSize.width = this._effectLayerOptions.mainTextureFixedSize, this._mainTextureDesiredSize.height = this._effectLayerOptions.mainTextureFixedSize) : (this._mainTextureDesiredSize.width = this._engine.getRenderWidth() * this._effectLayerOptions.mainTextureRatio, this._mainTextureDesiredSize.height = this._engine.getRenderHeight() * this._effectLayerOptions.mainTextureRatio, this._mainTextureDesiredSize.width = this._engine.needPOTTextures ? P.GetExponentOfTwo(this._mainTextureDesiredSize.width, this._maxSize) : this._mainTextureDesiredSize.width, this._mainTextureDesiredSize.height = this._engine.needPOTTextures ? P.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 V("EffectLayerMainRTT", {
+      width: this._mainTextureDesiredSize.width,
+      height: this._mainTextureDesiredSize.height
+    }, this._scene, !1, !0, this._effectLayerOptions.mainTextureType, !1, y.TRILINEAR_SAMPLINGMODE, !0, this._effectLayerOptions.generateStencilBuffer), this._mainTexture.activeCamera = this._effectLayerOptions.camera, this._mainTexture.wrapU = y.CLAMP_ADDRESSMODE, this._mainTexture.wrapV = y.CLAMP_ADDRESSMODE, this._mainTexture.anisotropicFilteringLevel = 1, this._mainTexture.updateSamplingMode(y.BILINEAR_SAMPLINGMODE), this._mainTexture.renderParticles = !1, this._mainTexture.renderList = null, this._mainTexture.ignoreCameraViewport = !0;
+    for (const e in this._materialForRendering) {
+      const [r, o] = this._materialForRendering[e];
+      this._mainTexture.setMaterialForRendering(r, o);
+    }
+    if (this._mainTexture.customIsReadyFunction = (e, r, o) => {
+      if ((o || r === 0) && e.subMeshes)
+        for (let h = 0; h < e.subMeshes.length; ++h) {
+          const t = e.subMeshes[h], i = t.getMaterial(), f = t.getRenderingMesh();
+          if (!i)
+            continue;
+          const s = f._getInstancesRenderList(t._id, !!t.getReplacementMesh()).hardwareInstancedRendering[t._id] || f.hasThinInstances;
+          if (this._setEmissiveTextureAndColor(f, t, i), !this._isReady(t, s, this._emissiveTextureAndColor.texture))
+            return !1;
+        }
+      return !0;
+    }, this._mainTexture.customRenderFunction = (e, r, o, h) => {
+      this.onBeforeRenderMainTextureObservable.notifyObservers(this);
+      let t;
+      const i = this._scene.getEngine();
+      if (h.length) {
+        for (i.setColorWrite(!1), t = 0; t < h.length; t++)
+          this._renderSubMesh(h.data[t]);
+        i.setColorWrite(!0);
+      }
+      for (t = 0; t < e.length; t++)
+        this._renderSubMesh(e.data[t]);
+      for (t = 0; t < r.length; t++)
+        this._renderSubMesh(r.data[t]);
+      const f = i.getAlphaMode();
+      for (t = 0; t < o.length; t++)
+        this._renderSubMesh(o.data[t], !0);
+      i.setAlphaMode(f);
+    }, this._mainTexture.onClearObservable.add((e) => {
+      e.clear(this.neutralColor, !0, !0, !0);
+    }), this._scene.getBoundingBoxRenderer) {
+      const e = this._scene.getBoundingBoxRenderer().enabled;
+      this._mainTexture.onBeforeBindObservable.add(() => {
+        this._scene.getBoundingBoxRenderer().enabled = !this.disableBoundingBoxesFromEffectLayer && e;
+      }), this._mainTexture.onAfterUnbindObservable.add(() => {
+        this._scene.getBoundingBoxRenderer().enabled = e;
+      });
+    }
+  }
+  /**
+   * Adds specific effects defines.
+   * @param defines The defines to add specifics to.
+   */
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  _addCustomEffectDefines(e) {
+  }
+  /**
+   * 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(e, r, o) {
+    var h;
+    const t = this._scene.getEngine(), i = e.getMesh(), f = (h = i._internalAbstractMeshDataInfo._materialForRenderPass) === null || h === void 0 ? void 0 : h[t.currentRenderPassId];
+    if (f)
+      return f.isReadyForSubMesh(i, e, r);
+    const n = e.getMaterial();
+    if (!n)
+      return !1;
+    if (this._useMeshMaterial(e.getRenderingMesh()))
+      return n.isReadyForSubMesh(e.getMesh(), e, r);
+    const s = [], u = [d.PositionKind];
+    let c = !1, m = !1;
+    if (n) {
+      const a = n.needAlphaTesting(), T = n.getAlphaTestTexture(), _ = T && T.hasAlpha && (n.useAlphaFromDiffuseTexture || n._useAlphaFromAlbedoTexture);
+      T && (a || _) && (s.push("#define DIFFUSE"), i.isVerticesDataPresent(d.UV2Kind) && T.coordinatesIndex === 1 ? (s.push("#define DIFFUSEUV2"), m = !0) : i.isVerticesDataPresent(d.UVKind) && (s.push("#define DIFFUSEUV1"), c = !0), a && (s.push("#define ALPHATEST"), s.push("#define ALPHATESTVALUE 0.4")), T.gammaSpace || s.push("#define DIFFUSE_ISLINEAR"));
+      const b = n.opacityTexture;
+      b && (s.push("#define OPACITY"), i.isVerticesDataPresent(d.UV2Kind) && b.coordinatesIndex === 1 ? (s.push("#define OPACITYUV2"), m = !0) : i.isVerticesDataPresent(d.UVKind) && (s.push("#define OPACITYUV1"), c = !0));
+    }
+    o && (s.push("#define EMISSIVE"), i.isVerticesDataPresent(d.UV2Kind) && o.coordinatesIndex === 1 ? (s.push("#define EMISSIVEUV2"), m = !0) : i.isVerticesDataPresent(d.UVKind) && (s.push("#define EMISSIVEUV1"), c = !0), o.gammaSpace || s.push("#define EMISSIVE_ISLINEAR")), i.useVertexColors && i.isVerticesDataPresent(d.ColorKind) && i.hasVertexAlpha && n.transparencyMode !== A.MATERIAL_OPAQUE && (u.push(d.ColorKind), s.push("#define VERTEXALPHA")), c && (u.push(d.UVKind), s.push("#define UV1")), m && (u.push(d.UV2Kind), s.push("#define UV2"));
+    const D = new N();
+    if (i.useBones && i.computeBonesUsingShaders) {
+      u.push(d.MatricesIndicesKind), u.push(d.MatricesWeightsKind), i.numBoneInfluencers > 4 && (u.push(d.MatricesIndicesExtraKind), u.push(d.MatricesWeightsExtraKind)), s.push("#define NUM_BONE_INFLUENCERS " + i.numBoneInfluencers);
+      const a = i.skeleton;
+      a && a.isUsingTextureForMatrices ? s.push("#define BONETEXTURE") : s.push("#define BonesPerMesh " + (a ? a.bones.length + 1 : 0)), i.numBoneInfluencers > 0 && D.addCPUSkinningFallback(0, i);
+    } else
+      s.push("#define NUM_BONE_INFLUENCERS 0");
+    const E = i.morphTargetManager;
+    let x = 0;
+    E && E.numInfluencers > 0 && (s.push("#define MORPHTARGETS"), x = E.numInfluencers, s.push("#define NUM_MORPH_INFLUENCERS " + x), E.isUsingTextureForTargets && s.push("#define MORPHTARGETS_TEXTURE"), C.PrepareAttributesForMorphTargetsInfluencers(u, i, x)), r && (s.push("#define INSTANCES"), C.PushAttributesForInstances(u), e.getRenderingMesh().hasThinInstances && s.push("#define THIN_INSTANCES")), G(n, this._scene, s), this._addCustomEffectDefines(s);
+    const M = e._getDrawWrapper(void 0, !0), S = M.defines, p = s.join(`
+`);
+    if (S !== p) {
+      const a = [
+        "world",
+        "mBones",
+        "viewProjection",
+        "glowColor",
+        "morphTargetInfluences",
+        "boneTextureWidth",
+        "diffuseMatrix",
+        "emissiveMatrix",
+        "opacityMatrix",
+        "opacityIntensity",
+        "morphTargetTextureInfo",
+        "morphTargetTextureIndices",
+        "glowIntensity"
+      ];
+      k(a), M.setEffect(this._engine.createEffect("glowMapGeneration", u, a, ["diffuseSampler", "emissiveSampler", "opacitySampler", "boneSampler", "morphTargets"], p, D, void 0, void 0, { maxSimultaneousMorphTargets: x }), p);
+    }
+    return M.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 e = this._scene.getEngine(), r = this._numInternalDraws();
+    let o = !0;
+    for (let i = 0; i < r; ++i) {
+      let f = this._mergeDrawWrapper[i];
+      f || (f = this._mergeDrawWrapper[i] = new K(this._engine), f.setEffect(this._createMergeEffect())), o = o && f.effect.isReady();
+    }
+    if (!o)
+      return;
+    this.onBeforeComposeObservable.notifyObservers(this);
+    const h = e.getAlphaMode();
+    for (let i = 0; i < r; ++i) {
+      const f = this._mergeDrawWrapper[i];
+      e.enableEffect(f), e.setState(!1), e.bindBuffers(this._vertexBuffers, this._indexBuffer, f.effect), e.setAlphaMode(this._effectLayerOptions.alphaBlendingMode), this._internalRender(f.effect, i);
+    }
+    e.setAlphaMode(h), this.onAfterComposeObservable.notifyObservers(this);
+    const t = this._mainTexture.getSize();
+    this._setMainTextureSize(), (t.width !== this._mainTextureDesiredSize.width || t.height !== this._mainTextureDesiredSize.height) && this._mainTextureDesiredSize.width !== 0 && this._mainTextureDesiredSize.height !== 0 && (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(e) {
+    return this.renderingGroupId === -1 || e.renderingGroupId === this.renderingGroupId;
+  }
+  /**
+   * 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(e) {
+    return !0;
+  }
+  /**
+   * 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(e, r) {
+    return !r.needAlphaBlendingForMesh(e);
+  }
+  /**
+   * Returns true if the mesh should render, otherwise false.
+   * @returns true if it should render otherwise false
+   */
+  _shouldRenderEmissiveTextureForMesh() {
+    return !0;
+  }
+  /**
+   * Renders the submesh passed in parameter to the generation map.
+   * @param subMesh
+   * @param enableAlphaMode
+   */
+  _renderSubMesh(e, r = !1) {
+    var o, h;
+    if (!this.shouldRender())
+      return;
+    const t = e.getMaterial(), i = e.getMesh(), f = e.getReplacementMesh(), n = e.getRenderingMesh(), s = e.getEffectiveMesh(), u = this._scene, c = u.getEngine();
+    if (s._internalAbstractMeshDataInfo._isActiveIntermediate = !1, !t || !this._canRenderMesh(n, t))
+      return;
+    let m = (o = n.overrideMaterialSideOrientation) !== null && o !== void 0 ? o : t.sideOrientation;
+    s._getWorldMatrixDeterminant() < 0 && (m = m === A.ClockWiseSideOrientation ? A.CounterClockWiseSideOrientation : A.ClockWiseSideOrientation);
+    const E = m === A.ClockWiseSideOrientation;
+    c.setState(t.backFaceCulling, t.zOffset, void 0, E, t.cullBackFaces, void 0, t.zOffsetUnits);
+    const x = n._getInstancesRenderList(e._id, !!f);
+    if (x.mustReturn || !this._shouldRenderMesh(n))
+      return;
+    const M = x.hardwareInstancedRendering[e._id] || n.hasThinInstances;
+    if (this._setEmissiveTextureAndColor(n, e, t), this.onBeforeRenderMeshToEffect.notifyObservers(i), this._useMeshMaterial(n))
+      n.render(e, r, f || void 0);
+    else if (this._isReady(e, M, this._emissiveTextureAndColor.texture)) {
+      const S = (h = s._internalAbstractMeshDataInfo._materialForRenderPass) === null || h === void 0 ? void 0 : h[c.currentRenderPassId];
+      let p = e._getDrawWrapper();
+      if (!p && S && (p = S._getDrawWrapper()), !p)
+        return;
+      const a = p.effect;
+      if (c.enableEffect(p), M || n._bind(e, a, t.fillMode), S ? S.bindForSubMesh(s.getWorldMatrix(), s, e) : (a.setMatrix("viewProjection", u.getTransformMatrix()), a.setMatrix("world", s.getWorldMatrix()), a.setFloat4("glowColor", this._emissiveTextureAndColor.color.r, this._emissiveTextureAndColor.color.g, this._emissiveTextureAndColor.color.b, this._emissiveTextureAndColor.color.a)), !S) {
+        const T = t.needAlphaTesting(), _ = t.getAlphaTestTexture(), b = _ && _.hasAlpha && (t.useAlphaFromDiffuseTexture || t._useAlphaFromAlbedoTexture);
+        if (_ && (T || b)) {
+          a.setTexture("diffuseSampler", _);
+          const l = _.getTextureMatrix();
+          l && a.setMatrix("diffuseMatrix", l);
+        }
+        const v = t.opacityTexture;
+        if (v) {
+          a.setTexture("opacitySampler", v), a.setFloat("opacityIntensity", v.level);
+          const l = v.getTextureMatrix();
+          l && a.setMatrix("opacityMatrix", l);
+        }
+        if (this._emissiveTextureAndColor.texture && (a.setTexture("emissiveSampler", this._emissiveTextureAndColor.texture), a.setMatrix("emissiveMatrix", this._emissiveTextureAndColor.texture.getTextureMatrix())), n.useBones && n.computeBonesUsingShaders && n.skeleton) {
+          const l = n.skeleton;
+          if (l.isUsingTextureForMatrices) {
+            const O = l.getTransformMatrixTexture(n);
+            if (!O)
+              return;
+            a.setTexture("boneSampler", O), a.setFloat("boneTextureWidth", 4 * (l.bones.length + 1));
+          } else
+            a.setMatrices("mBones", l.getTransformMatrices(n));
+        }
+        C.BindMorphTargetParameters(n, a), n.morphTargetManager && n.morphTargetManager.isUsingTextureForTargets && n.morphTargetManager._bind(a), r && c.setAlphaMode(t.alphaMode), a.setFloat("glowIntensity", this.getEffectIntensity(n)), H(a, t, u);
+      }
+      n._processRendering(s, e, a, t.fillMode, x, M, (T, _) => a.setMatrix("world", _));
+    } else
+      this._mainTexture.resetRefreshCounter();
+    this.onAfterRenderMeshToEffect.notifyObservers(i);
+  }
+  /**
+   * 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(e) {
+    return !1;
+  }
+  /**
+   * Rebuild the required buffers.
+   * @internal Internal use only.
+   */
+  _rebuild() {
+    const e = this._vertexBuffers[d.PositionKind];
+    e && e._rebuild(), this._generateIndexBuffer();
+  }
+  /**
+   * Dispose only the render target textures and post process.
+   */
+  _disposeTextureAndPostProcesses() {
+    this._mainTexture.dispose();
+    for (let e = 0; e < this._postProcesses.length; e++)
+      this._postProcesses[e] && this._postProcesses[e].dispose();
+    this._postProcesses = [];
+    for (let e = 0; e < this._textures.length; e++)
+      this._textures[e] && this._textures[e].dispose();
+    this._textures = [];
+  }
+  /**
+   * Dispose the highlight layer and free resources.
+   */
+  dispose() {
+    const e = this._vertexBuffers[d.PositionKind];
+    e && (e.dispose(), this._vertexBuffers[d.PositionKind] = null), this._indexBuffer && (this._scene.getEngine()._releaseBuffer(this._indexBuffer), this._indexBuffer = null);
+    for (const o of this._mergeDrawWrapper)
+      o.dispose();
+    this._mergeDrawWrapper = [], this._disposeTextureAndPostProcesses();
+    const r = this._scene.effectLayers.indexOf(this, 0);
+    r > -1 && this._scene.effectLayers.splice(r, 1), 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(e, r, o) {
+    return L.Instantiate(e.customType).Parse(e, r, o);
+  }
+}
+g._SceneComponentInitialization = (j) => {
+  throw W("EffectLayerSceneComponent");
+};
+R([
+  B()
+], g.prototype, "name", void 0);
+R([
+  F()
+], g.prototype, "neutralColor", void 0);
+R([
+  B()
+], g.prototype, "isEnabled", void 0);
+R([
+  z()
+], g.prototype, "camera", null);
+R([
+  B()
+], g.prototype, "renderingGroupId", null);
+R([
+  B()
+], g.prototype, "disableBoundingBoxesFromEffectLayer", void 0);
+export {
+  g as EffectLayer
+};

package/dist/node_modules/@babylonjs/core/Layers/effectLayerSceneComponent.esm.js

@@ -0,0 +1,141 @@
+import { Camera as c } from "../Cameras/camera.esm.js";
+import { SceneComponentConstants as i } from "../sceneComponent.esm.js";
+import { EffectLayer as o } from "./effectLayer.esm.js";
+import { AbstractScene as a } from "../abstractScene.esm.js";
+import { EngineStore as _ } from "../Engines/engineStore.esm.js";
+a.AddParser(i.NAME_EFFECTLAYER, (n, e, t, r) => {
+  if (n.effectLayers) {
+    t.effectLayers || (t.effectLayers = new Array());
+    for (let s = 0; s < n.effectLayers.length; s++) {
+      const f = o.Parse(n.effectLayers[s], e, r);
+      t.effectLayers.push(f);
+    }
+  }
+});
+a.prototype.removeEffectLayer = function(n) {
+  const e = this.effectLayers.indexOf(n);
+  return e !== -1 && this.effectLayers.splice(e, 1), e;
+};
+a.prototype.addEffectLayer = function(n) {
+  this.effectLayers.push(n);
+};
+class E {
+  /**
+   * Creates a new instance of the component for the given scene
+   * @param scene Defines the scene to register the component in
+   */
+  constructor(e) {
+    this.name = i.NAME_EFFECTLAYER, this._renderEffects = !1, this._needStencil = !1, this._previousStencilState = !1, this.scene = e || _.LastCreatedScene, this.scene && (this._engine = this.scene.getEngine(), this.scene.effectLayers = new Array());
+  }
+  /**
+   * Registers the component in a given scene
+   */
+  register() {
+    this.scene._isReadyForMeshStage.registerStep(i.STEP_ISREADYFORMESH_EFFECTLAYER, this, this._isReadyForMesh), this.scene._cameraDrawRenderTargetStage.registerStep(i.STEP_CAMERADRAWRENDERTARGET_EFFECTLAYER, this, this._renderMainTexture), this.scene._beforeCameraDrawStage.registerStep(i.STEP_BEFORECAMERADRAW_EFFECTLAYER, this, this._setStencil), this.scene._afterRenderingGroupDrawStage.registerStep(i.STEP_AFTERRENDERINGGROUPDRAW_EFFECTLAYER_DRAW, this, this._drawRenderingGroup), this.scene._afterCameraDrawStage.registerStep(i.STEP_AFTERCAMERADRAW_EFFECTLAYER, this, this._setStencilBack), this.scene._afterCameraDrawStage.registerStep(i.STEP_AFTERCAMERADRAW_EFFECTLAYER_DRAW, this, this._drawCamera);
+  }
+  /**
+   * Rebuilds the elements related to this component in case of
+   * context lost for instance.
+   */
+  rebuild() {
+    const e = this.scene.effectLayers;
+    for (const t of e)
+      t._rebuild();
+  }
+  /**
+   * Serializes the component data to the specified json object
+   * @param serializationObject The object to serialize to
+   */
+  serialize(e) {
+    e.effectLayers = [];
+    const t = this.scene.effectLayers;
+    for (const r of t)
+      r.serialize && e.effectLayers.push(r.serialize());
+  }
+  /**
+   * Adds all the elements from the container to the scene
+   * @param container the container holding the elements
+   */
+  addFromContainer(e) {
+    e.effectLayers && e.effectLayers.forEach((t) => {
+      this.scene.addEffectLayer(t);
+    });
+  }
+  /**
+   * 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(e, t) {
+    e.effectLayers && e.effectLayers.forEach((r) => {
+      this.scene.removeEffectLayer(r), t && r.dispose();
+    });
+  }
+  /**
+   * Disposes the component and the associated resources.
+   */
+  dispose() {
+    const e = this.scene.effectLayers;
+    for (; e.length; )
+      e[0].dispose();
+  }
+  _isReadyForMesh(e, t) {
+    const r = this._engine.currentRenderPassId, s = this.scene.effectLayers;
+    for (const f of s) {
+      if (!f.hasMesh(e))
+        continue;
+      const h = f._mainTexture;
+      this._engine.currentRenderPassId = h.renderPassId;
+      for (const d of e.subMeshes)
+        if (!f.isReady(d, t))
+          return this._engine.currentRenderPassId = r, !1;
+    }
+    return this._engine.currentRenderPassId = r, !0;
+  }
+  _renderMainTexture(e) {
+    this._renderEffects = !1, this._needStencil = !1;
+    let t = !1;
+    const r = this.scene.effectLayers;
+    if (r && r.length > 0) {
+      this._previousStencilState = this._engine.getStencilBuffer();
+      for (const s of r)
+        if (s.shouldRender() && (!s.camera || s.camera.cameraRigMode === c.RIG_MODE_NONE && e === s.camera || s.camera.cameraRigMode !== c.RIG_MODE_NONE && s.camera._rigCameras.indexOf(e) > -1)) {
+          this._renderEffects = !0, this._needStencil = this._needStencil || s.needStencil();
+          const f = s._mainTexture;
+          f._shouldRender() && (this.scene.incrementRenderId(), f.render(!1, !1), t = !0);
+        }
+      this.scene.incrementRenderId();
+    }
+    return t;
+  }
+  _setStencil() {
+    this._needStencil && this._engine.setStencilBuffer(!0);
+  }
+  _setStencilBack() {
+    this._needStencil && this._engine.setStencilBuffer(this._previousStencilState);
+  }
+  _draw(e) {
+    if (this._renderEffects) {
+      this._engine.setDepthBuffer(!1);
+      const t = this.scene.effectLayers;
+      for (let r = 0; r < t.length; r++) {
+        const s = t[r];
+        s.renderingGroupId === e && s.shouldRender() && s.render();
+      }
+      this._engine.setDepthBuffer(!0);
+    }
+  }
+  _drawCamera() {
+    this._renderEffects && this._draw(-1);
+  }
+  _drawRenderingGroup(e) {
+    !this.scene._isInIntermediateRendering() && this._renderEffects && this._draw(e);
+  }
+}
+o._SceneComponentInitialization = (n) => {
+  let e = n._getComponent(i.NAME_EFFECTLAYER);
+  e || (e = new E(n), n._addComponent(e));
+};
+export {
+  E as EffectLayerSceneComponent
+};