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

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

@@ -0,0 +1,343 @@
+import { __decorate as c } from "../tslib.es6.esm.js";
+import { SerializationHelper as f, serialize as _ } from "../Misc/decorators.esm.js";
+import { Vector2 as a } from "../Maths/math.vector.esm.js";
+import { VertexBuffer as M } from "../Buffers/buffer.esm.js";
+import { Texture as o } from "../Materials/Textures/texture.esm.js";
+import { RenderTargetTexture as x } from "../Materials/Textures/renderTargetTexture.esm.js";
+import { Material as T } from "../Materials/material.esm.js";
+import { BlurPostProcess as d } from "../PostProcesses/blurPostProcess.esm.js";
+import { EffectLayer as g } from "./effectLayer.esm.js";
+import { AbstractScene as B } from "../abstractScene.esm.js";
+import { RegisterClass as S } from "../Misc/typeStore.esm.js";
+import { Engine as p } from "../Engines/engine.esm.js";
+import { Color4 as P } from "../Maths/math.color.esm.js";
+import "../Shaders/glowMapMerge.fragment.esm.js";
+import "../Shaders/glowMapMerge.vertex.esm.js";
+import "./effectLayerSceneComponent.esm.js";
+B.prototype.getGlowLayerByName = function(m) {
+  var e;
+  for (let t = 0; t < ((e = this.effectLayers) === null || e === void 0 ? void 0 : e.length); t++)
+    if (this.effectLayers[t].name === m && this.effectLayers[t].getEffectName() === l.EffectName)
+      return this.effectLayers[t];
+  return null;
+};
+class l extends g {
+  /**
+   * Sets the kernel size of the blur.
+   */
+  set blurKernelSize(e) {
+    if (e === this._options.blurKernelSize)
+      return;
+    this._options.blurKernelSize = e;
+    const t = this._getEffectiveBlurKernelSize();
+    this._horizontalBlurPostprocess1.kernel = t, this._verticalBlurPostprocess1.kernel = t, this._horizontalBlurPostprocess2.kernel = t, this._verticalBlurPostprocess2.kernel = t;
+  }
+  /**
+   * Gets the kernel size of the blur.
+   */
+  get blurKernelSize() {
+    return this._options.blurKernelSize;
+  }
+  /**
+   * Sets the glow intensity.
+   */
+  set intensity(e) {
+    this._intensity = e;
+  }
+  /**
+   * 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(e, t, s) {
+    super(e, t), this._intensity = 1, this._includedOnlyMeshes = [], this._excludedMeshes = [], this._meshesUsingTheirOwnMaterials = [], this.neutralColor = new P(0, 0, 0, 1), this._options = Object.assign({ mainTextureRatio: l.DefaultTextureRatio, blurKernelSize: 32, mainTextureFixedSize: void 0, camera: null, mainTextureSamples: 1, renderingGroupId: -1, ldrMerge: !1, alphaBlendingMode: 1, mainTextureType: 0, generateStencilBuffer: !1 }, s), 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 l.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 e = `#define EMISSIVE 
+`;
+    return this._options.ldrMerge && (e += `#define LDR 
+`), this._engine.createEffect("glowMapMerge", [M.PositionKind], ["offset"], ["textureSampler", "textureSampler2"], e);
+  }
+  /**
+   * Creates the render target textures and post processes used in the glow layer.
+   */
+  _createTextureAndPostProcesses() {
+    let e = this._mainTextureDesiredSize.width, t = this._mainTextureDesiredSize.height;
+    e = this._engine.needPOTTextures ? p.GetExponentOfTwo(e, this._maxSize) : e, t = this._engine.needPOTTextures ? p.GetExponentOfTwo(t, this._maxSize) : t;
+    let s = 0;
+    this._engine.getCaps().textureHalfFloatRender ? s = 2 : s = 0, this._blurTexture1 = new x("GlowLayerBlurRTT", {
+      width: e,
+      height: t
+    }, this._scene, !1, !0, s), this._blurTexture1.wrapU = o.CLAMP_ADDRESSMODE, this._blurTexture1.wrapV = o.CLAMP_ADDRESSMODE, this._blurTexture1.updateSamplingMode(o.BILINEAR_SAMPLINGMODE), this._blurTexture1.renderParticles = !1, this._blurTexture1.ignoreCameraViewport = !0;
+    const r = Math.floor(e / 2), i = Math.floor(t / 2);
+    this._blurTexture2 = new x("GlowLayerBlurRTT2", {
+      width: r,
+      height: i
+    }, this._scene, !1, !0, s), this._blurTexture2.wrapU = o.CLAMP_ADDRESSMODE, this._blurTexture2.wrapV = o.CLAMP_ADDRESSMODE, this._blurTexture2.updateSamplingMode(o.BILINEAR_SAMPLINGMODE), this._blurTexture2.renderParticles = !1, this._blurTexture2.ignoreCameraViewport = !0, this._textures = [this._blurTexture1, this._blurTexture2];
+    const n = this._getEffectiveBlurKernelSize();
+    this._horizontalBlurPostprocess1 = new d("GlowLayerHBP1", new a(1, 0), n, {
+      width: e,
+      height: t
+    }, null, o.BILINEAR_SAMPLINGMODE, this._scene.getEngine(), !1, s), this._horizontalBlurPostprocess1.width = e, this._horizontalBlurPostprocess1.height = t, this._horizontalBlurPostprocess1.externalTextureSamplerBinding = !0, this._horizontalBlurPostprocess1.onApplyObservable.add((u) => {
+      u.setTexture("textureSampler", this._mainTexture);
+    }), this._verticalBlurPostprocess1 = new d("GlowLayerVBP1", new a(0, 1), n, {
+      width: e,
+      height: t
+    }, null, o.BILINEAR_SAMPLINGMODE, this._scene.getEngine(), !1, s), this._horizontalBlurPostprocess2 = new d("GlowLayerHBP2", new a(1, 0), n, {
+      width: r,
+      height: i
+    }, null, o.BILINEAR_SAMPLINGMODE, this._scene.getEngine(), !1, s), this._horizontalBlurPostprocess2.width = r, this._horizontalBlurPostprocess2.height = i, this._horizontalBlurPostprocess2.externalTextureSamplerBinding = !0, this._horizontalBlurPostprocess2.onApplyObservable.add((u) => {
+      u.setTexture("textureSampler", this._blurTexture1);
+    }), this._verticalBlurPostprocess2 = new d("GlowLayerVBP2", new a(0, 1), n, {
+      width: r,
+      height: i
+    }, null, o.BILINEAR_SAMPLINGMODE, this._scene.getEngine(), !1, s), 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 u = this._blurTexture1.renderTarget;
+      if (u) {
+        this._scene.postProcessManager.directRender(this._postProcesses1, u, !0);
+        const h = this._blurTexture2.renderTarget;
+        h && this._scene.postProcessManager.directRender(this._postProcesses2, h, !0), this._engine.unBindFramebuffer(h ?? u, !0);
+      }
+    }), this._postProcesses.map((u) => {
+      u.autoClear = !1;
+    });
+  }
+  /**
+   * @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(e, t) {
+    const s = e.getMaterial(), r = e.getRenderingMesh();
+    if (!s || !r)
+      return !1;
+    const i = s.emissiveTexture;
+    return super._isReady(e, t, i);
+  }
+  /**
+   * Returns whether or not the layer needs stencil enabled during the mesh rendering.
+   */
+  needStencil() {
+    return !1;
+  }
+  /**
+   * 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, t) {
+    return !0;
+  }
+  /**
+   * Implementation specific of rendering the generating effect on the main canvas.
+   * @param effect The effect used to render through
+   */
+  _internalRender(e) {
+    e.setTexture("textureSampler", this._blurTexture1), e.setTexture("textureSampler2", this._blurTexture2), e.setFloat("offset", this._intensity);
+    const t = this._engine, s = t.getStencilBuffer();
+    t.setStencilBuffer(!1), t.drawElementsType(T.TriangleFillMode, 0, 6), t.setStencilBuffer(s);
+  }
+  /**
+   * Sets the required values for both the emissive texture and and the main color.
+   * @param mesh
+   * @param subMesh
+   * @param material
+   */
+  _setEmissiveTextureAndColor(e, t, s) {
+    var r;
+    let i = 1;
+    if (this.customEmissiveTextureSelector ? this._emissiveTextureAndColor.texture = this.customEmissiveTextureSelector(e, t, s) : s ? (this._emissiveTextureAndColor.texture = s.emissiveTexture, this._emissiveTextureAndColor.texture && (i = this._emissiveTextureAndColor.texture.level)) : this._emissiveTextureAndColor.texture = null, this.customEmissiveColorSelector)
+      this.customEmissiveColorSelector(e, t, s, this._emissiveTextureAndColor.color);
+    else if (s.emissiveColor) {
+      const n = (r = s.emissiveIntensity) !== null && r !== void 0 ? r : 1;
+      i *= n, this._emissiveTextureAndColor.color.set(s.emissiveColor.r * i, s.emissiveColor.g * i, s.emissiveColor.b * i, s.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(e) {
+    return this.hasMesh(e);
+  }
+  /**
+   * Adds specific effects defines.
+   * @param defines The defines to add specifics to.
+   */
+  _addCustomEffectDefines(e) {
+    e.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(e) {
+    this._excludedMeshes.indexOf(e.uniqueId) === -1 && this._excludedMeshes.push(e.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(e) {
+    const t = this._excludedMeshes.indexOf(e.uniqueId);
+    t !== -1 && this._excludedMeshes.splice(t, 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(e) {
+    this._includedOnlyMeshes.indexOf(e.uniqueId) === -1 && this._includedOnlyMeshes.push(e.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(e) {
+    const t = this._includedOnlyMeshes.indexOf(e.uniqueId);
+    t !== -1 && this._includedOnlyMeshes.splice(t, 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(e) {
+    return super.hasMesh(e) ? this._includedOnlyMeshes.length ? this._includedOnlyMeshes.indexOf(e.uniqueId) !== -1 : this._excludedMeshes.length ? this._excludedMeshes.indexOf(e.uniqueId) === -1 : !0 : !1;
+  }
+  /**
+   * Defines whether the current material of the mesh should be use to render the effect.
+   * @param mesh defines the current mesh to render
+   */
+  _useMeshMaterial(e) {
+    return this._meshesUsingTheirOwnMaterials.length == 0 ? !1 : this._meshesUsingTheirOwnMaterials.indexOf(e.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(e) {
+    e.resetDrawCache(this._mainTexture.renderPassId), this._meshesUsingTheirOwnMaterials.push(e.uniqueId), e.onDisposeObservable.add(() => {
+      this._disposeMesh(e);
+    });
+  }
+  /**
+   * 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(e) {
+    let t = this._meshesUsingTheirOwnMaterials.indexOf(e.uniqueId);
+    for (; t >= 0; )
+      this._meshesUsingTheirOwnMaterials.splice(t, 1), t = this._meshesUsingTheirOwnMaterials.indexOf(e.uniqueId);
+    e.resetDrawCache(this._mainTexture.renderPassId);
+  }
+  /**
+   * Free any resources and references associated to a mesh.
+   * Internal use
+   * @param mesh The mesh to free.
+   * @internal
+   */
+  _disposeMesh(e) {
+    this.removeIncludedOnlyMesh(e), this.removeExcludedMesh(e);
+  }
+  /**
+   * 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 e = f.Serialize(this);
+    e.customType = "BABYLON.GlowLayer";
+    let t;
+    if (e.includedMeshes = [], this._includedOnlyMeshes.length)
+      for (t = 0; t < this._includedOnlyMeshes.length; t++) {
+        const s = this._scene.getMeshByUniqueId(this._includedOnlyMeshes[t]);
+        s && e.includedMeshes.push(s.id);
+      }
+    if (e.excludedMeshes = [], this._excludedMeshes.length)
+      for (t = 0; t < this._excludedMeshes.length; t++) {
+        const s = this._scene.getMeshByUniqueId(this._excludedMeshes[t]);
+        s && e.excludedMeshes.push(s.id);
+      }
+    return e;
+  }
+  /**
+   * 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(e, t, s) {
+    const r = f.Parse(() => new l(e.name, t, e.options), e, t, s);
+    let i;
+    for (i = 0; i < e.excludedMeshes.length; i++) {
+      const n = t.getMeshById(e.excludedMeshes[i]);
+      n && r.addExcludedMesh(n);
+    }
+    for (i = 0; i < e.includedMeshes.length; i++) {
+      const n = t.getMeshById(e.includedMeshes[i]);
+      n && r.addIncludedOnlyMesh(n);
+    }
+    return r;
+  }
+}
+l.EffectName = "GlowLayer";
+l.DefaultBlurKernelSize = 32;
+l.DefaultTextureRatio = 0.5;
+c([
+  _()
+], l.prototype, "blurKernelSize", null);
+c([
+  _()
+], l.prototype, "intensity", null);
+c([
+  _("options")
+], l.prototype, "_options", void 0);
+S("BABYLON.GlowLayer", l);
+export {
+  l as GlowLayer
+};