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

package/dist/node_modules/@babylonjs/core/PostProcesses/circleOfConfusionPostProcess.esm.js

@@ -1,62 +0,0 @@
-import { __decorate as o } from "../tslib.es6.esm.js";
-import { PostProcess as d } from "./postProcess.esm.js";
-import { Logger as x } from "../Misc/logger.esm.js";
-import "../Shaders/circleOfConfusion.fragment.esm.js";
-import { RegisterClass as C } from "../Misc/typeStore.esm.js";
-import { serialize as s } from "../Misc/decorators.esm.js";
-class t extends d {
-  /**
-   * Gets a string identifying the name of the class
-   * @returns "CircleOfConfusionPostProcess" string
-   */
-  getClassName() {
-    return "CircleOfConfusionPostProcess";
-  }
-  /**
-   * Creates a new instance CircleOfConfusionPostProcess
-   * @param name The name of the effect.
-   * @param depthTexture The depth texture of the scene to compute the circle of confusion. This must be set in order for this to function but may be set after initialization if needed.
-   * @param options The required width/height ratio to downsize to before computing the render pass.
-   * @param camera The camera to apply the render pass to.
-   * @param samplingMode The sampling mode to be used when computing the pass. (default: 0)
-   * @param engine The engine which the post process will be applied. (default: current engine)
-   * @param reusable If the post process can be reused on the same frame. (default: false)
-   * @param textureType Type of textures used when performing the post process. (default: 0)
-   * @param blockCompilation If compilation of the shader should not be done in the constructor. The updateEffect method can be used to compile the shader at a later time. (default: false)
-   */
-  constructor(r, c, a, n, l, p, u, h = 0, f = !1) {
-    super(r, "circleOfConfusion", ["cameraMinMaxZ", "focusDistance", "cocPrecalculation"], ["depthSampler"], a, n, l, p, u, null, h, void 0, null, f), this.lensSize = 50, this.fStop = 1.4, this.focusDistance = 2e3, this.focalLength = 50, this._depthTexture = null, this._depthTexture = c, this.onApplyObservable.add((e) => {
-      if (!this._depthTexture) {
-        x.Warn("No depth texture set on CircleOfConfusionPostProcess");
-        return;
-      }
-      e.setTexture("depthSampler", this._depthTexture);
-      const m = this.lensSize / this.fStop * this.focalLength / (this.focusDistance - this.focalLength);
-      e.setFloat("focusDistance", this.focusDistance), e.setFloat("cocPrecalculation", m);
-      const i = this._depthTexture.activeCamera;
-      e.setFloat2("cameraMinMaxZ", i.minZ, i.maxZ - i.minZ);
-    });
-  }
-  /**
-   * Depth texture to be used to compute the circle of confusion. This must be set here or in the constructor in order for the post process to function.
-   */
-  set depthTexture(r) {
-    this._depthTexture = r;
-  }
-}
-o([
-  s()
-], t.prototype, "lensSize", void 0);
-o([
-  s()
-], t.prototype, "fStop", void 0);
-o([
-  s()
-], t.prototype, "focusDistance", void 0);
-o([
-  s()
-], t.prototype, "focalLength", void 0);
-C("BABYLON.CircleOfConfusionPostProcess", t);
-export {
-  t as CircleOfConfusionPostProcess
-};

package/dist/node_modules/@babylonjs/core/PostProcesses/depthOfFieldBlurPostProcess.esm.js

@@ -1,58 +0,0 @@
-import { __decorate as f } from "../tslib.es6.esm.js";
-import { Texture as O } from "../Materials/Textures/texture.esm.js";
-import { BlurPostProcess as x } from "./blurPostProcess.esm.js";
-import { RegisterClass as h } from "../Misc/typeStore.esm.js";
-import { serialize as B } from "../Misc/decorators.esm.js";
-class t extends x {
-  /**
-   * Gets a string identifying the name of the class
-   * @returns "DepthOfFieldBlurPostProcess" string
-   */
-  getClassName() {
-    return "DepthOfFieldBlurPostProcess";
-  }
-  /**
-   * Creates a new instance DepthOfFieldBlurPostProcess
-   * @param name The name of the effect.
-   * @param scene The scene the effect belongs to.
-   * @param direction The direction the blur should be applied.
-   * @param kernel The size of the kernel used to blur.
-   * @param options The required width/height ratio to downsize to before computing the render pass.
-   * @param camera The camera to apply the render pass to.
-   * @param circleOfConfusion The circle of confusion + depth map to be used to avoid blurring across edges
-   * @param imageToBlur The image to apply the blur to (default: Current rendered frame)
-   * @param samplingMode The sampling mode to be used when computing the pass. (default: 0)
-   * @param engine The engine which the post process will be applied. (default: current engine)
-   * @param reusable If the post process can be reused on the same frame. (default: false)
-   * @param textureType Type of textures used when performing the post process. (default: 0)
-   * @param blockCompilation If compilation of the shader should not be done in the constructor. The updateEffect method can be used to compile the shader at a later time. (default: false)
-   * @param textureFormat Format of textures used when performing the post process. (default: TEXTUREFORMAT_RGBA)
-   */
-  constructor(o, D, r, i, l, p, n, e = null, u = O.BILINEAR_SAMPLINGMODE, m, c, P = 0, a = !1, d = 5) {
-    super(
-      o,
-      r,
-      i,
-      l,
-      p,
-      // eslint-disable-next-line @typescript-eslint/no-unused-vars
-      u = 2,
-      m,
-      c,
-      P,
-      `#define DOF 1\r
-`,
-      a,
-      d
-    ), this.direction = r, this.externalTextureSamplerBinding = !!e, this.onApplyObservable.add((s) => {
-      e != null && s.setTextureFromPostProcess("textureSampler", e), s.setTextureFromPostProcessOutput("circleOfConfusionSampler", n);
-    });
-  }
-}
-f([
-  B()
-], t.prototype, "direction", void 0);
-h("BABYLON.DepthOfFieldBlurPostProcess", t);
-export {
-  t as DepthOfFieldBlurPostProcess
-};

package/dist/node_modules/@babylonjs/core/PostProcesses/depthOfFieldEffect.esm.js

@@ -1,131 +0,0 @@
-import { Vector2 as O } from "../Maths/math.vector.esm.js";
-import { Texture as u } from "../Materials/Textures/texture.esm.js";
-import { PostProcessRenderEffect as M } from "./RenderPipeline/postProcessRenderEffect.esm.js";
-import { CircleOfConfusionPostProcess as I } from "./circleOfConfusionPostProcess.esm.js";
-import { DepthOfFieldBlurPostProcess as g } from "./depthOfFieldBlurPostProcess.esm.js";
-import { DepthOfFieldMergePostProcess as m } from "./depthOfFieldMergePostProcess.esm.js";
-var r;
-(function(s) {
-  s[s.Low = 0] = "Low", s[s.Medium = 1] = "Medium", s[s.High = 2] = "High";
-})(r || (r = {}));
-class F extends M {
-  /**
-   * The focal the length of the camera used in the effect in scene units/1000 (eg. millimeter)
-   */
-  set focalLength(e) {
-    this._circleOfConfusion.focalLength = e;
-  }
-  get focalLength() {
-    return this._circleOfConfusion.focalLength;
-  }
-  /**
-   * F-Stop of the effect's camera. The diameter of the resulting aperture can be computed by lensSize/fStop. (default: 1.4)
-   */
-  set fStop(e) {
-    this._circleOfConfusion.fStop = e;
-  }
-  get fStop() {
-    return this._circleOfConfusion.fStop;
-  }
-  /**
-   * Distance away from the camera to focus on in scene units/1000 (eg. millimeter). (default: 2000)
-   */
-  set focusDistance(e) {
-    this._circleOfConfusion.focusDistance = e;
-  }
-  get focusDistance() {
-    return this._circleOfConfusion.focusDistance;
-  }
-  /**
-   * Max lens size in scene units/1000 (eg. millimeter). Standard cameras are 50mm. (default: 50) The diameter of the resulting aperture can be computed by lensSize/fStop.
-   */
-  set lensSize(e) {
-    this._circleOfConfusion.lensSize = e;
-  }
-  get lensSize() {
-    return this._circleOfConfusion.lensSize;
-  }
-  /**
-   * Creates a new instance DepthOfFieldEffect
-   * @param scene The scene the effect belongs to.
-   * @param depthTexture The depth texture of the scene to compute the circle of confusion.This must be set in order for this to function but may be set after initialization if needed.
-   * @param blurLevel
-   * @param pipelineTextureType The type of texture to be used when performing the post processing.
-   * @param blockCompilation If compilation of the shader should not be done in the constructor. The updateEffect method can be used to compile the shader at a later time. (default: false)
-   */
-  constructor(e, i, p = r.Low, n = 0, c = !1) {
-    super(e.getEngine(), "depth of field", () => this._effects, !0), this._effects = [];
-    const f = e.getEngine(), C = f.isWebGPU || f.webGLVersion > 1 ? 6 : 5;
-    this._circleOfConfusion = new I("circleOfConfusion", i, 1, null, u.BILINEAR_SAMPLINGMODE, f, !1, n, c), this._depthOfFieldBlurY = [], this._depthOfFieldBlurX = [];
-    let o = 1, l = 15;
-    switch (p) {
-      case r.High: {
-        o = 3, l = 51;
-        break;
-      }
-      case r.Medium: {
-        o = 2, l = 31;
-        break;
-      }
-      default: {
-        l = 15, o = 1;
-        break;
-      }
-    }
-    const _ = l / Math.pow(2, o - 1);
-    let h = 1;
-    for (let t = 0; t < o; t++) {
-      const a = new g("vertical blur", e, new O(0, 1), _, h, null, this._circleOfConfusion, t == 0 ? this._circleOfConfusion : null, u.BILINEAR_SAMPLINGMODE, f, !1, n, c, t == 0 ? C : 5);
-      a.autoClear = !1, h = 0.75 / Math.pow(2, t);
-      const d = new g("horizontal blur", e, new O(1, 0), _, h, null, this._circleOfConfusion, null, u.BILINEAR_SAMPLINGMODE, f, !1, n, c);
-      d.autoClear = !1, this._depthOfFieldBlurY.push(a), this._depthOfFieldBlurX.push(d);
-    }
-    this._effects = [this._circleOfConfusion];
-    for (let t = 0; t < this._depthOfFieldBlurX.length; t++)
-      this._effects.push(this._depthOfFieldBlurY[t]), this._effects.push(this._depthOfFieldBlurX[t]);
-    this._dofMerge = new m("dofMerge", this._circleOfConfusion, this._circleOfConfusion, this._depthOfFieldBlurX, h, null, u.BILINEAR_SAMPLINGMODE, f, !1, n, c), this._dofMerge.autoClear = !1, this._effects.push(this._dofMerge);
-  }
-  /**
-   * Get the current class name of the current effect
-   * @returns "DepthOfFieldEffect"
-   */
-  getClassName() {
-    return "DepthOfFieldEffect";
-  }
-  /**
-   * Depth texture to be used to compute the circle of confusion. This must be set here or in the constructor in order for the post process to function.
-   */
-  set depthTexture(e) {
-    this._circleOfConfusion.depthTexture = e;
-  }
-  /**
-   * Disposes each of the internal effects for a given camera.
-   * @param camera The camera to dispose the effect on.
-   */
-  disposeEffects(e) {
-    for (let i = 0; i < this._effects.length; i++)
-      this._effects[i].dispose(e);
-  }
-  /**
-   * @internal Internal
-   */
-  _updateEffects() {
-    for (let e = 0; e < this._effects.length; e++)
-      this._effects[e].updateEffect();
-  }
-  /**
-   * Internal
-   * @returns if all the contained post processes are ready.
-   * @internal
-   */
-  _isReady() {
-    for (let e = 0; e < this._effects.length; e++)
-      if (!this._effects[e].isReady())
-        return !1;
-    return !0;
-  }
-}
-export {
-  F as DepthOfFieldEffect,
-  r as DepthOfFieldEffectBlurLevel
-};

package/dist/node_modules/@babylonjs/core/PostProcesses/depthOfFieldMergePostProcess.esm.js

@@ -1,48 +0,0 @@
-import { PostProcess as d } from "./postProcess.esm.js";
-import "../Shaders/depthOfFieldMerge.fragment.esm.js";
-class O extends d {
-  /**
-   * Gets a string identifying the name of the class
-   * @returns "DepthOfFieldMergePostProcess" string
-   */
-  getClassName() {
-    return "DepthOfFieldMergePostProcess";
-  }
-  /**
-   * Creates a new instance of DepthOfFieldMergePostProcess
-   * @param name The name of the effect.
-   * @param originalFromInput Post process which's input will be used for the merge.
-   * @param circleOfConfusion Circle of confusion post process which's output will be used to blur each pixel.
-   * @param _blurSteps Blur post processes from low to high which will be mixed with the original image.
-   * @param options The required width/height ratio to downsize to before computing the render pass.
-   * @param camera The camera to apply the render pass to.
-   * @param samplingMode The sampling mode to be used when computing the pass. (default: 0)
-   * @param engine The engine which the post process will be applied. (default: current engine)
-   * @param reusable If the post process can be reused on the same frame. (default: false)
-   * @param textureType Type of textures used when performing the post process. (default: 0)
-   * @param blockCompilation If compilation of the shader should not be done in the constructor. The updateEffect method can be used to compile the shader at a later time. (default: false)
-   */
-  constructor(e, r, s, t, l, u, p, n, i, a = 0, c = !1) {
-    super(e, "depthOfFieldMerge", [], ["circleOfConfusionSampler", "blurStep0", "blurStep1", "blurStep2"], l, u, p, n, i, null, a, void 0, null, !0), this._blurSteps = t, this.externalTextureSamplerBinding = !0, this.onApplyObservable.add((o) => {
-      o.setTextureFromPostProcess("textureSampler", r), o.setTextureFromPostProcessOutput("circleOfConfusionSampler", s), t.forEach((f, P) => {
-        o.setTextureFromPostProcessOutput("blurStep" + (t.length - P - 1), f);
-      });
-    }), c || this.updateEffect();
-  }
-  /**
-   * Updates the effect with the current post process compile time values and recompiles the shader.
-   * @param defines Define statements that should be added at the beginning of the shader. (default: null)
-   * @param uniforms Set of uniform variables that will be passed to the shader. (default: null)
-   * @param samplers Set of Texture2D variables that will be passed to the shader. (default: null)
-   * @param indexParameters The index parameters to be used for babylons include syntax "#include<kernelBlurVaryingDeclaration>[0..varyingCount]". (default: undefined) See usage in babylon.blurPostProcess.ts and kernelBlur.vertex.fx
-   * @param onCompiled Called when the shader has been compiled.
-   * @param onError Called if there is an error when compiling a shader.
-   */
-  updateEffect(e = null, r = null, s = null, t, l, u) {
-    e || (e = "", e += "#define BLUR_LEVEL " + (this._blurSteps.length - 1) + `
-`), super.updateEffect(e, r, s, t, l, u);
-  }
-}
-export {
-  O as DepthOfFieldMergePostProcess
-};

package/dist/node_modules/@babylonjs/core/PostProcesses/extractHighlightsPostProcess.esm.js

@@ -1,27 +0,0 @@
-import { __decorate as u } from "../tslib.es6.esm.js";
-import { PostProcess as P } from "./postProcess.esm.js";
-import { ToGammaSpace as m } from "../Maths/math.constants.esm.js";
-import "../Shaders/extractHighlights.fragment.esm.js";
-import { serialize as n } from "../Misc/decorators.esm.js";
-import { RegisterClass as c } from "../Misc/typeStore.esm.js";
-class t extends P {
-  /**
-   * Gets a string identifying the name of the class
-   * @returns "ExtractHighlightsPostProcess" string
-   */
-  getClassName() {
-    return "ExtractHighlightsPostProcess";
-  }
-  constructor(e, o, r, i, h, l, p = 0, a = !1) {
-    super(e, "extractHighlights", ["threshold", "exposure"], null, o, r, i, h, l, null, p, void 0, null, a), this.threshold = 0.9, this._exposure = 1, this._inputPostProcess = null, this.onApplyObservable.add((s) => {
-      this.externalTextureSamplerBinding = !!this._inputPostProcess, this._inputPostProcess && s.setTextureFromPostProcess("textureSampler", this._inputPostProcess), s.setFloat("threshold", Math.pow(this.threshold, m)), s.setFloat("exposure", this._exposure);
-    });
-  }
-}
-u([
-  n()
-], t.prototype, "threshold", void 0);
-c("BABYLON.ExtractHighlightsPostProcess", t);
-export {
-  t as ExtractHighlightsPostProcess
-};

package/dist/node_modules/@babylonjs/core/PostProcesses/fxaaPostProcess.esm.js

@@ -1,41 +0,0 @@
-import { Texture as m } from "../Materials/Textures/texture.esm.js";
-import { PostProcess as g } from "./postProcess.esm.js";
-import "../Shaders/fxaa.fragment.esm.js";
-import "../Shaders/fxaa.vertex.esm.js";
-import { RegisterClass as x } from "../Misc/typeStore.esm.js";
-import { SerializationHelper as p } from "../Misc/decorators.esm.js";
-class i extends g {
-  /**
-   * Gets a string identifying the name of the class
-   * @returns "FxaaPostProcess" string
-   */
-  getClassName() {
-    return "FxaaPostProcess";
-  }
-  constructor(e, t, n = null, r, o, a, s = 0) {
-    super(e, "fxaa", ["texelSize"], null, t, n, r || m.BILINEAR_SAMPLINGMODE, o, a, null, s, "fxaa", void 0, !0);
-    const f = this._getDefines();
-    this.updateEffect(f), this.onApplyObservable.add((u) => {
-      const l = this.texelSize;
-      u.setFloat2("texelSize", l.x, l.y);
-    });
-  }
-  _getDefines() {
-    const e = this.getEngine();
-    if (!e)
-      return null;
-    const t = e.getGlInfo();
-    return t && t.renderer && t.renderer.toLowerCase().indexOf("mali") > -1 ? `#define MALI 1
-` : null;
-  }
-  /**
-   * @internal
-   */
-  static _Parse(e, t, n, r) {
-    return p.Parse(() => new i(e.name, e.options, t, e.renderTargetSamplingMode, n.getEngine(), e.reusable), e, n, r);
-  }
-}
-x("BABYLON.FxaaPostProcess", i);
-export {
-  i as FxaaPostProcess
-};

package/dist/node_modules/@babylonjs/core/PostProcesses/grainPostProcess.esm.js

@@ -1,46 +0,0 @@
-import { __decorate as o } from "../tslib.es6.esm.js";
-import { PostProcess as u } from "./postProcess.esm.js";
-import "../Shaders/grain.fragment.esm.js";
-import { RegisterClass as y } from "../Misc/typeStore.esm.js";
-import { serialize as s, SerializationHelper as g } from "../Misc/decorators.esm.js";
-class e extends u {
-  /**
-   * Gets a string identifying the name of the class
-   * @returns "GrainPostProcess" string
-   */
-  getClassName() {
-    return "GrainPostProcess";
-  }
-  /**
-   * Creates a new instance of @see GrainPostProcess
-   * @param name The name of the effect.
-   * @param options The required width/height ratio to downsize to before computing the render pass.
-   * @param camera The camera to apply the render pass to.
-   * @param samplingMode The sampling mode to be used when computing the pass. (default: 0)
-   * @param engine The engine which the post process will be applied. (default: current engine)
-   * @param reusable If the post process can be reused on the same frame. (default: false)
-   * @param textureType Type of textures used when performing the post process. (default: 0)
-   * @param blockCompilation If compilation of the shader should not be done in the constructor. The updateEffect method can be used to compile the shader at a later time. (default: false)
-   */
-  constructor(t, n, i, a, l, m, d = 0, p = !1) {
-    super(t, "grain", ["intensity", "animatedSeed"], [], n, i, a, l, m, null, d, void 0, null, p), this.intensity = 30, this.animated = !1, this.onApplyObservable.add((r) => {
-      r.setFloat("intensity", this.intensity), r.setFloat("animatedSeed", this.animated ? Math.random() + 1 : 1);
-    });
-  }
-  /**
-   * @internal
-   */
-  static _Parse(t, n, i, a) {
-    return g.Parse(() => new e(t.name, t.options, n, t.renderTargetSamplingMode, i.getEngine(), t.reusable), t, i, a);
-  }
-}
-o([
-  s()
-], e.prototype, "intensity", void 0);
-o([
-  s()
-], e.prototype, "animated", void 0);
-y("BABYLON.GrainPostProcess", e);
-export {
-  e as GrainPostProcess
-};