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

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

@@ -1,437 +0,0 @@
-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

@@ -1,141 +0,0 @@
-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
-};