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

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

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

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

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

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

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

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

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