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

package/dist/node_modules/@babylonjs/core/PostProcesses/RenderPipeline/postProcessRenderPipeline.esm.js

@@ -1,139 +0,0 @@
-import { __decorate as i } from "../../tslib.es6.esm.js";
-import { Tools as f } from "../../Misc/tools.esm.js";
-import { serialize as c } from "../../Misc/decorators.esm.js";
-class o {
-  /**
-   * Gets pipeline name
-   */
-  get name() {
-    return this._name;
-  }
-  /** Gets the list of attached cameras */
-  get cameras() {
-    return this._cameras;
-  }
-  /**
-   * Initializes a PostProcessRenderPipeline
-   * @param _engine engine to add the pipeline to
-   * @param name name of the pipeline
-   */
-  constructor(e, s) {
-    this._engine = e, this._name = s, this._renderEffects = {}, this._renderEffectsForIsolatedPass = new Array(), this._cameras = [];
-  }
-  /**
-   * Gets the class name
-   * @returns "PostProcessRenderPipeline"
-   */
-  getClassName() {
-    return "PostProcessRenderPipeline";
-  }
-  /**
-   * If all the render effects in the pipeline are supported
-   */
-  get isSupported() {
-    for (const e in this._renderEffects)
-      if (Object.prototype.hasOwnProperty.call(this._renderEffects, e) && !this._renderEffects[e].isSupported)
-        return !1;
-    return !0;
-  }
-  /**
-   * Adds an effect to the pipeline
-   * @param renderEffect the effect to add
-   */
-  addEffect(e) {
-    this._renderEffects[e._name] = e;
-  }
-  // private
-  /** @internal */
-  _rebuild() {
-  }
-  /**
-   * @internal
-   */
-  _enableEffect(e, s) {
-    const r = this._renderEffects[e];
-    r && r._enable(f.MakeArray(s || this._cameras));
-  }
-  /**
-   * @internal
-   */
-  _disableEffect(e, s) {
-    const r = this._renderEffects[e];
-    r && r._disable(f.MakeArray(s || this._cameras));
-  }
-  /**
-   * @internal
-   */
-  _attachCameras(e, s) {
-    const r = f.MakeArray(e || this._cameras);
-    if (!r)
-      return;
-    const n = [];
-    let t;
-    for (t = 0; t < r.length; t++) {
-      const a = r[t];
-      a && (this._cameras.indexOf(a) === -1 ? this._cameras.push(a) : s && n.push(t));
-    }
-    for (t = 0; t < n.length; t++)
-      r.splice(n[t], 1);
-    for (const a in this._renderEffects)
-      Object.prototype.hasOwnProperty.call(this._renderEffects, a) && this._renderEffects[a]._attachCameras(r);
-  }
-  /**
-   * @internal
-   */
-  _detachCameras(e) {
-    const s = f.MakeArray(e || this._cameras);
-    if (s) {
-      for (const r in this._renderEffects)
-        Object.prototype.hasOwnProperty.call(this._renderEffects, r) && this._renderEffects[r]._detachCameras(s);
-      for (let r = 0; r < s.length; r++)
-        this._cameras.splice(this._cameras.indexOf(s[r]), 1);
-    }
-  }
-  /** @internal */
-  _update() {
-    for (const e in this._renderEffects)
-      Object.prototype.hasOwnProperty.call(this._renderEffects, e) && this._renderEffects[e]._update();
-    for (let e = 0; e < this._cameras.length; e++) {
-      if (!this._cameras[e])
-        continue;
-      const s = this._cameras[e].name;
-      this._renderEffectsForIsolatedPass[s] && this._renderEffectsForIsolatedPass[s]._update();
-    }
-  }
-  /** @internal */
-  _reset() {
-    this._renderEffects = {}, this._renderEffectsForIsolatedPass = new Array();
-  }
-  _enableMSAAOnFirstPostProcess(e) {
-    if (!this._engine._features.supportMSAA)
-      return !1;
-    const s = Object.keys(this._renderEffects);
-    if (s.length > 0) {
-      const r = this._renderEffects[s[0]].getPostProcesses();
-      r && (r[0].samples = e);
-    }
-    return !0;
-  }
-  /**
-   * Sets the required values to the prepass renderer.
-   * @param prePassRenderer defines the prepass renderer to setup.
-   * @returns true if the pre pass is needed.
-   */
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  setPrePassRenderer(e) {
-    return !1;
-  }
-  /**
-   * Disposes of the pipeline
-   */
-  dispose() {
-  }
-}
-i([
-  c()
-], o.prototype, "_name", void 0);
-export {
-  o as PostProcessRenderPipeline
-};

package/dist/node_modules/@babylonjs/core/PostProcesses/RenderPipeline/postProcessRenderPipelineManager.esm.js

@@ -1,99 +0,0 @@
-class t {
-  /**
-   * Initializes a PostProcessRenderPipelineManager
-   * @see https://doc.babylonjs.com/features/featuresDeepDive/postProcesses/postProcessRenderPipeline
-   */
-  constructor() {
-    this._renderPipelines = {};
-  }
-  /**
-   * Gets the list of supported render pipelines
-   */
-  get supportedPipelines() {
-    const e = [];
-    for (const i in this._renderPipelines)
-      if (Object.prototype.hasOwnProperty.call(this._renderPipelines, i)) {
-        const n = this._renderPipelines[i];
-        n.isSupported && e.push(n);
-      }
-    return e;
-  }
-  /**
-   * Adds a pipeline to the manager
-   * @param renderPipeline The pipeline to add
-   */
-  addPipeline(e) {
-    this._renderPipelines[e._name] = e;
-  }
-  /**
-   * Remove the pipeline from the manager
-   * @param renderPipelineName the name of the pipeline to remove
-   */
-  removePipeline(e) {
-    delete this._renderPipelines[e];
-  }
-  /**
-   * Attaches a camera to the pipeline
-   * @param renderPipelineName The name of the pipeline to attach to
-   * @param cameras the camera to attach
-   * @param unique if the camera can be attached multiple times to the pipeline
-   */
-  attachCamerasToRenderPipeline(e, i, n = !1) {
-    const r = this._renderPipelines[e];
-    r && r._attachCameras(i, n);
-  }
-  /**
-   * Detaches a camera from the pipeline
-   * @param renderPipelineName The name of the pipeline to detach from
-   * @param cameras the camera to detach
-   */
-  detachCamerasFromRenderPipeline(e, i) {
-    const n = this._renderPipelines[e];
-    n && n._detachCameras(i);
-  }
-  /**
-   * Enables an effect by name on a pipeline
-   * @param renderPipelineName the name of the pipeline to enable the effect in
-   * @param renderEffectName the name of the effect to enable
-   * @param cameras the cameras that the effect should be enabled on
-   */
-  enableEffectInPipeline(e, i, n) {
-    const r = this._renderPipelines[e];
-    r && r._enableEffect(i, n);
-  }
-  /**
-   * Disables an effect by name on a pipeline
-   * @param renderPipelineName the name of the pipeline to disable the effect in
-   * @param renderEffectName the name of the effect to disable
-   * @param cameras the cameras that the effect should be disabled on
-   */
-  disableEffectInPipeline(e, i, n) {
-    const r = this._renderPipelines[e];
-    r && r._disableEffect(i, n);
-  }
-  /**
-   * Updates the state of all contained render pipelines and disposes of any non supported pipelines
-   */
-  update() {
-    for (const e in this._renderPipelines)
-      if (Object.prototype.hasOwnProperty.call(this._renderPipelines, e)) {
-        const i = this._renderPipelines[e];
-        i.isSupported ? i._update() : (i.dispose(), delete this._renderPipelines[e]);
-      }
-  }
-  /** @internal */
-  _rebuild() {
-    for (const e in this._renderPipelines)
-      Object.prototype.hasOwnProperty.call(this._renderPipelines, e) && this._renderPipelines[e]._rebuild();
-  }
-  /**
-   * Disposes of the manager and pipelines
-   */
-  dispose() {
-    for (const e in this._renderPipelines)
-      Object.prototype.hasOwnProperty.call(this._renderPipelines, e) && this._renderPipelines[e].dispose();
-  }
-}
-export {
-  t as PostProcessRenderPipelineManager
-};

package/dist/node_modules/@babylonjs/core/PostProcesses/RenderPipeline/postProcessRenderPipelineManagerSceneComponent.esm.js

@@ -1,48 +0,0 @@
-import { SceneComponentConstants as s } from "../../sceneComponent.esm.js";
-import { PostProcessRenderPipelineManager as r } from "./postProcessRenderPipelineManager.esm.js";
-import { Scene as t } from "../../scene.esm.js";
-Object.defineProperty(t.prototype, "postProcessRenderPipelineManager", {
-  get: function() {
-    if (!this._postProcessRenderPipelineManager) {
-      let e = this._getComponent(s.NAME_POSTPROCESSRENDERPIPELINEMANAGER);
-      e || (e = new i(this), this._addComponent(e)), this._postProcessRenderPipelineManager = new r();
-    }
-    return this._postProcessRenderPipelineManager;
-  },
-  enumerable: !0,
-  configurable: !0
-});
-class i {
-  /**
-   * Creates a new instance of the component for the given scene
-   * @param scene Defines the scene to register the component in
-   */
-  constructor(n) {
-    this.name = s.NAME_POSTPROCESSRENDERPIPELINEMANAGER, this.scene = n;
-  }
-  /**
-   * Registers the component in a given scene
-   */
-  register() {
-    this.scene._gatherRenderTargetsStage.registerStep(s.STEP_GATHERRENDERTARGETS_POSTPROCESSRENDERPIPELINEMANAGER, this, this._gatherRenderTargets);
-  }
-  /**
-   * Rebuilds the elements related to this component in case of
-   * context lost for instance.
-   */
-  rebuild() {
-    this.scene._postProcessRenderPipelineManager && this.scene._postProcessRenderPipelineManager._rebuild();
-  }
-  /**
-   * Disposes the component and the associated resources
-   */
-  dispose() {
-    this.scene._postProcessRenderPipelineManager && this.scene._postProcessRenderPipelineManager.dispose();
-  }
-  _gatherRenderTargets() {
-    this.scene._postProcessRenderPipelineManager && this.scene._postProcessRenderPipelineManager.update();
-  }
-}
-export {
-  i as PostProcessRenderPipelineManagerSceneComponent
-};

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

@@ -1,76 +0,0 @@
-import { PostProcessRenderEffect as n } from "./RenderPipeline/postProcessRenderEffect.esm.js";
-import { ExtractHighlightsPostProcess as _ } from "./extractHighlightsPostProcess.esm.js";
-import { BlurPostProcess as l } from "./blurPostProcess.esm.js";
-import { BloomMergePostProcess as u } from "./bloomMergePostProcess.esm.js";
-import { Vector2 as f } from "../Maths/math.vector.esm.js";
-import { Texture as h } from "../Materials/Textures/texture.esm.js";
-class I extends n {
-  /**
-   * The luminance threshold to find bright areas of the image to bloom.
-   */
-  get threshold() {
-    return this._downscale.threshold;
-  }
-  set threshold(e) {
-    this._downscale.threshold = e;
-  }
-  /**
-   * The strength of the bloom.
-   */
-  get weight() {
-    return this._merge.weight;
-  }
-  set weight(e) {
-    this._merge.weight = e;
-  }
-  /**
-   * Specifies the size of the bloom blur kernel, relative to the final output size
-   */
-  get kernel() {
-    return this._blurX.kernel / this._bloomScale;
-  }
-  set kernel(e) {
-    this._blurX.kernel = e * this._bloomScale, this._blurY.kernel = e * this._bloomScale;
-  }
-  /**
-   * Creates a new instance of @see BloomEffect
-   * @param scene The scene the effect belongs to.
-   * @param _bloomScale The ratio of the blur texture to the input texture that should be used to compute the bloom.
-   * @param bloomWeight The the strength of bloom.
-   * @param bloomKernel The size of the kernel to be used when applying the blur.
-   * @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, t, i, o, s = 0, r = !1) {
-    super(e.getEngine(), "bloom", () => this._effects, !0), this._bloomScale = t, this._effects = [], this._downscale = new _("highlights", 1, null, h.BILINEAR_SAMPLINGMODE, e.getEngine(), !1, s, r), this._blurX = new l("horizontal blur", new f(1, 0), 10, t, null, h.BILINEAR_SAMPLINGMODE, e.getEngine(), !1, s, void 0, r), this._blurX.alwaysForcePOT = !0, this._blurX.autoClear = !1, this._blurY = new l("vertical blur", new f(0, 1), 10, t, null, h.BILINEAR_SAMPLINGMODE, e.getEngine(), !1, s, void 0, r), this._blurY.alwaysForcePOT = !0, this._blurY.autoClear = !1, this.kernel = o, this._effects = [this._downscale, this._blurX, this._blurY], this._merge = new u("bloomMerge", this._downscale, this._blurY, i, t, null, h.BILINEAR_SAMPLINGMODE, e.getEngine(), !1, s, r), this._merge.autoClear = !1, this._effects.push(this._merge);
-  }
-  /**
-   * Disposes each of the internal effects for a given camera.
-   * @param camera The camera to dispose the effect on.
-   */
-  disposeEffects(e) {
-    for (let t = 0; t < this._effects.length; t++)
-      this._effects[t].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 {
-  I as BloomEffect
-};

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

@@ -1,40 +0,0 @@
-import { __decorate as P } from "../tslib.es6.esm.js";
-import { PostProcess as n } from "./postProcess.esm.js";
-import "../Shaders/bloomMerge.fragment.esm.js";
-import { RegisterClass as c } from "../Misc/typeStore.esm.js";
-import { serialize as d } from "../Misc/decorators.esm.js";
-class o extends n {
-  /**
-   * Gets a string identifying the name of the class
-   * @returns "BloomMergePostProcess" string
-   */
-  getClassName() {
-    return "BloomMergePostProcess";
-  }
-  /**
-   * Creates a new instance of @see BloomMergePostProcess
-   * @param name The name of the effect.
-   * @param originalFromInput Post process which's input will be used for the merge.
-   * @param blurred Blurred highlights post process which's output will be used.
-   * @param weight Weight of the bloom to be added to the original input.
-   * @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, r, s, i, l, m, u, p, a, g = 0, h = !1) {
-    super(t, "bloomMerge", ["bloomWeight"], ["bloomBlur"], l, m, u, p, a, null, g, void 0, null, !0), this.weight = 1, this.weight = i, this.externalTextureSamplerBinding = !0, this.onApplyObservable.add((e) => {
-      e.setTextureFromPostProcess("textureSampler", r), e.setTextureFromPostProcessOutput("bloomBlur", s), e.setFloat("bloomWeight", this.weight);
-    }), h || this.updateEffect();
-  }
-}
-P([
-  d()
-], o.prototype, "weight", void 0);
-c("BABYLON.BloomMergePostProcess", o);
-export {
-  o as BloomMergePostProcess
-};

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

@@ -1,165 +0,0 @@
-import { __decorate as F } from "../tslib.es6.esm.js";
-import { PostProcess as w } from "./postProcess.esm.js";
-import { Texture as y } from "../Materials/Textures/texture.esm.js";
-import "../Shaders/kernelBlur.fragment.esm.js";
-import "../Shaders/kernelBlur.vertex.esm.js";
-import { RegisterClass as T } from "../Misc/typeStore.esm.js";
-import { SerializationHelper as S, serialize as C, serializeAsVector2 as K } from "../Misc/decorators.esm.js";
-class p extends w {
-  /**
-   * Sets the length in pixels of the blur sample region
-   */
-  set kernel(t) {
-    this._idealKernel !== t && (t = Math.max(t, 1), this._idealKernel = t, this._kernel = this._nearestBestKernel(t), this._blockCompilation || this._updateParameters());
-  }
-  /**
-   * Gets the length in pixels of the blur sample region
-   */
-  get kernel() {
-    return this._idealKernel;
-  }
-  /**
-   * Sets whether or not the blur needs to unpack/repack floats
-   */
-  set packedFloat(t) {
-    this._packedFloat !== t && (this._packedFloat = t, this._blockCompilation || this._updateParameters());
-  }
-  /**
-   * Gets whether or not the blur is unpacking/repacking floats
-   */
-  get packedFloat() {
-    return this._packedFloat;
-  }
-  /**
-   * Gets a string identifying the name of the class
-   * @returns "BlurPostProcess" string
-   */
-  getClassName() {
-    return "BlurPostProcess";
-  }
-  /**
-   * Creates a new instance BlurPostProcess
-   * @param name The name of the effect.
-   * @param direction The direction in which to blur the image.
-   * @param kernel The size of the kernel to be used when computing the blur. eg. Size of 3 will blur the center pixel by 2 pixels surrounding it.
-   * @param options The required width/height ratio to downsize to before computing the render pass. (Use 1.0 for full size)
-   * @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 defines
-   * @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(t, i, r, s, l, n = y.BILINEAR_SAMPLINGMODE, f, c, d = 0, a = "", m = !1, _ = 5) {
-    super(t, "kernelBlur", ["delta", "direction"], ["circleOfConfusionSampler"], s, l, n, f, c, null, d, "kernelBlur", { varyingCount: 0, depCount: 0 }, !0, _), this._blockCompilation = m, this._packedFloat = !1, this._staticDefines = "", this._staticDefines = a, this.direction = i, this.onApplyObservable.add((h) => {
-      this._outputTexture ? h.setFloat2("delta", 1 / this._outputTexture.width * this.direction.x, 1 / this._outputTexture.height * this.direction.y) : h.setFloat2("delta", 1 / this.width * this.direction.x, 1 / this.height * this.direction.y);
-    }), this.kernel = r;
-  }
-  /**
-   * 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(t = null, i = null, r = null, s, l, n) {
-    this._updateParameters(l, n);
-  }
-  _updateParameters(t, i) {
-    const r = this._kernel, s = (r - 1) / 2;
-    let l = [], n = [], f = 0;
-    for (let e = 0; e < r; e++) {
-      const u = e / (r - 1), k = this._gaussianWeight(u * 2 - 1);
-      l[e] = e - s, n[e] = k, f += k;
-    }
-    for (let e = 0; e < n.length; e++)
-      n[e] /= f;
-    const c = [], d = [], a = [];
-    for (let e = 0; e <= s; e += 2) {
-      const u = Math.min(e + 1, Math.floor(s));
-      if (e === u)
-        a.push({ o: l[e], w: n[e] });
-      else {
-        const M = u === s, x = n[e] + n[u] * (M ? 0.5 : 1), E = l[e] + 1 / (1 + n[e] / n[u]);
-        E === 0 ? (a.push({ o: l[e], w: n[e] }), a.push({ o: l[e + 1], w: n[e + 1] })) : (a.push({ o: E, w: x }), a.push({ o: -E, w: x }));
-      }
-    }
-    for (let e = 0; e < a.length; e++)
-      d[e] = a[e].o, c[e] = a[e].w;
-    l = d, n = c;
-    const m = this.getEngine().getCaps().maxVaryingVectors, _ = Math.max(m, 0) - 1;
-    let h = Math.min(l.length, _), o = "";
-    o += this._staticDefines, this._staticDefines.indexOf("DOF") != -1 && (o += `#define CENTER_WEIGHT ${this._glslFloat(n[h - 1])}\r
-`, h--);
-    for (let e = 0; e < h; e++)
-      o += `#define KERNEL_OFFSET${e} ${this._glslFloat(l[e])}\r
-`, o += `#define KERNEL_WEIGHT${e} ${this._glslFloat(n[e])}\r
-`;
-    let g = 0;
-    for (let e = _; e < l.length; e++)
-      o += `#define KERNEL_DEP_OFFSET${g} ${this._glslFloat(l[e])}\r
-`, o += `#define KERNEL_DEP_WEIGHT${g} ${this._glslFloat(n[e])}\r
-`, g++;
-    this.packedFloat && (o += "#define PACKEDFLOAT 1"), this._blockCompilation = !1, super.updateEffect(o, null, null, {
-      varyingCount: h,
-      depCount: g
-    }, t, i);
-  }
-  /**
-   * Best kernels are odd numbers that when divided by 2, their integer part is even, so 5, 9 or 13.
-   * Other odd kernels optimize correctly but require proportionally more samples, even kernels are
-   * possible but will produce minor visual artifacts. Since each new kernel requires a new shader we
-   * want to minimize kernel changes, having gaps between physical kernels is helpful in that regard.
-   * The gaps between physical kernels are compensated for in the weighting of the samples
-   * @param idealKernel Ideal blur kernel.
-   * @returns Nearest best kernel.
-   */
-  _nearestBestKernel(t) {
-    const i = Math.round(t);
-    for (const r of [i, i - 1, i + 1, i - 2, i + 2])
-      if (r % 2 !== 0 && Math.floor(r / 2) % 2 === 0 && r > 0)
-        return Math.max(r, 3);
-    return Math.max(i, 3);
-  }
-  /**
-   * Calculates the value of a Gaussian distribution with sigma 3 at a given point.
-   * @param x The point on the Gaussian distribution to sample.
-   * @returns the value of the Gaussian function at x.
-   */
-  _gaussianWeight(t) {
-    const i = 0.3333333333333333, r = Math.sqrt(2 * Math.PI) * i, s = -(t * t / (2 * i * i));
-    return 1 / r * Math.exp(s);
-  }
-  /**
-   * Generates a string that can be used as a floating point number in GLSL.
-   * @param x Value to print.
-   * @param decimalFigures Number of decimal places to print the number to (excluding trailing 0s).
-   * @returns GLSL float string.
-   */
-  _glslFloat(t, i = 8) {
-    return t.toFixed(i).replace(/0+$/, "");
-  }
-  /**
-   * @internal
-   */
-  static _Parse(t, i, r, s) {
-    return S.Parse(() => new p(t.name, t.direction, t.kernel, t.options, i, t.renderTargetSamplingMode, r.getEngine(), t.reusable, t.textureType, void 0, !1), t, r, s);
-  }
-}
-F([
-  C("kernel")
-], p.prototype, "_kernel", void 0);
-F([
-  C("packedFloat")
-], p.prototype, "_packedFloat", void 0);
-F([
-  K()
-], p.prototype, "direction", void 0);
-T("BABYLON.BlurPostProcess", p);
-export {
-  p as BlurPostProcess
-};

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

@@ -1,61 +0,0 @@
-import { __decorate as r } from "../tslib.es6.esm.js";
-import { Vector2 as h } from "../Maths/math.vector.esm.js";
-import { PostProcess as u } from "./postProcess.esm.js";
-import "../Shaders/chromaticAberration.fragment.esm.js";
-import { RegisterClass as b } from "../Misc/typeStore.esm.js";
-import { serialize as o, SerializationHelper as g } from "../Misc/decorators.esm.js";
-class i extends u {
-  /**
-   * Gets a string identifying the name of the class
-   * @returns "ChromaticAberrationPostProcess" string
-   */
-  getClassName() {
-    return "ChromaticAberrationPostProcess";
-  }
-  /**
-   * Creates a new instance ChromaticAberrationPostProcess
-   * @param name The name of the effect.
-   * @param screenWidth The width of the screen to apply the effect on.
-   * @param screenHeight The height of the screen to apply the effect on.
-   * @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, a, n, s, l, c, d, m, p = 0, y = !1) {
-    super(t, "chromaticAberration", ["chromatic_aberration", "screen_width", "screen_height", "direction", "radialIntensity", "centerPosition"], [], s, l, c, d, m, null, p, void 0, null, y), this.aberrationAmount = 30, this.radialIntensity = 0, this.direction = new h(0.707, 0.707), this.centerPosition = new h(0.5, 0.5), this.screenWidth = a, this.screenHeight = n, this.onApplyObservable.add((e) => {
-      e.setFloat("chromatic_aberration", this.aberrationAmount), e.setFloat("screen_width", a), e.setFloat("screen_height", n), e.setFloat("radialIntensity", this.radialIntensity), e.setFloat2("direction", this.direction.x, this.direction.y), e.setFloat2("centerPosition", this.centerPosition.x, this.centerPosition.y);
-    });
-  }
-  /**
-   * @internal
-   */
-  static _Parse(t, a, n, s) {
-    return g.Parse(() => new i(t.name, t.screenWidth, t.screenHeight, t.options, a, t.renderTargetSamplingMode, n.getEngine(), t.reusable, t.textureType, !1), t, n, s);
-  }
-}
-r([
-  o()
-], i.prototype, "aberrationAmount", void 0);
-r([
-  o()
-], i.prototype, "radialIntensity", void 0);
-r([
-  o()
-], i.prototype, "direction", void 0);
-r([
-  o()
-], i.prototype, "centerPosition", void 0);
-r([
-  o()
-], i.prototype, "screenWidth", void 0);
-r([
-  o()
-], i.prototype, "screenHeight", void 0);
-b("BABYLON.ChromaticAberrationPostProcess", i);
-export {
-  i as ChromaticAberrationPostProcess
-};