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

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

@@ -0,0 +1,359 @@
+import { __decorate as f } from "../tslib.es6.esm.js";
+import { serialize as u } from "../Misc/decorators.esm.js";
+import { ImageProcessingConfiguration as o } from "../Materials/imageProcessingConfiguration.esm.js";
+import { PostProcess as P } from "./postProcess.esm.js";
+import { EngineStore as m } from "../Engines/engineStore.esm.js";
+import "../Shaders/imageProcessing.fragment.esm.js";
+import "../Shaders/postprocess.vertex.esm.js";
+class C extends P {
+  /**
+   * Gets the image processing configuration used either in this material.
+   */
+  get imageProcessingConfiguration() {
+    return this._imageProcessingConfiguration;
+  }
+  /**
+   * Sets the Default image processing configuration used either in the this material.
+   *
+   * If sets to null, the scene one is in use.
+   */
+  set imageProcessingConfiguration(e) {
+    e.applyByPostProcess = !0, this._attachImageProcessingConfiguration(e);
+  }
+  /**
+   * Attaches a new image processing configuration to the PBR Material.
+   * @param configuration
+   * @param doNotBuild
+   */
+  _attachImageProcessingConfiguration(e, n = !1) {
+    if (e !== this._imageProcessingConfiguration) {
+      if (this._imageProcessingConfiguration && this._imageProcessingObserver && this._imageProcessingConfiguration.onUpdateParameters.remove(this._imageProcessingObserver), e)
+        this._imageProcessingConfiguration = e;
+      else {
+        let i = null;
+        const t = this.getEngine(), s = this.getCamera();
+        if (s)
+          i = s.getScene();
+        else if (t && t.scenes) {
+          const r = t.scenes;
+          i = r[r.length - 1];
+        } else
+          i = m.LastCreatedScene;
+        i ? this._imageProcessingConfiguration = i.imageProcessingConfiguration : this._imageProcessingConfiguration = new o();
+      }
+      this._imageProcessingConfiguration && (this._imageProcessingObserver = this._imageProcessingConfiguration.onUpdateParameters.add(() => {
+        this._updateParameters();
+      })), n || this._updateParameters();
+    }
+  }
+  /**
+   * If the post process is supported.
+   */
+  get isSupported() {
+    const e = this.getEffect();
+    return !e || e.isSupported;
+  }
+  /**
+   * Gets Color curves setup used in the effect if colorCurvesEnabled is set to true .
+   */
+  get colorCurves() {
+    return this.imageProcessingConfiguration.colorCurves;
+  }
+  /**
+   * Sets Color curves setup used in the effect if colorCurvesEnabled is set to true .
+   */
+  set colorCurves(e) {
+    this.imageProcessingConfiguration.colorCurves = e;
+  }
+  /**
+   * Gets whether the color curves effect is enabled.
+   */
+  get colorCurvesEnabled() {
+    return this.imageProcessingConfiguration.colorCurvesEnabled;
+  }
+  /**
+   * Sets whether the color curves effect is enabled.
+   */
+  set colorCurvesEnabled(e) {
+    this.imageProcessingConfiguration.colorCurvesEnabled = e;
+  }
+  /**
+   * Gets Color grading LUT texture used in the effect if colorGradingEnabled is set to true.
+   */
+  get colorGradingTexture() {
+    return this.imageProcessingConfiguration.colorGradingTexture;
+  }
+  /**
+   * Sets Color grading LUT texture used in the effect if colorGradingEnabled is set to true.
+   */
+  set colorGradingTexture(e) {
+    this.imageProcessingConfiguration.colorGradingTexture = e;
+  }
+  /**
+   * Gets whether the color grading effect is enabled.
+   */
+  get colorGradingEnabled() {
+    return this.imageProcessingConfiguration.colorGradingEnabled;
+  }
+  /**
+   * Gets whether the color grading effect is enabled.
+   */
+  set colorGradingEnabled(e) {
+    this.imageProcessingConfiguration.colorGradingEnabled = e;
+  }
+  /**
+   * Gets exposure used in the effect.
+   */
+  get exposure() {
+    return this.imageProcessingConfiguration.exposure;
+  }
+  /**
+   * Sets exposure used in the effect.
+   */
+  set exposure(e) {
+    this.imageProcessingConfiguration.exposure = e;
+  }
+  /**
+   * Gets whether tonemapping is enabled or not.
+   */
+  get toneMappingEnabled() {
+    return this._imageProcessingConfiguration.toneMappingEnabled;
+  }
+  /**
+   * Sets whether tonemapping is enabled or not
+   */
+  set toneMappingEnabled(e) {
+    this._imageProcessingConfiguration.toneMappingEnabled = e;
+  }
+  /**
+   * Gets the type of tone mapping effect.
+   */
+  get toneMappingType() {
+    return this._imageProcessingConfiguration.toneMappingType;
+  }
+  /**
+   * Sets the type of tone mapping effect.
+   */
+  set toneMappingType(e) {
+    this._imageProcessingConfiguration.toneMappingType = e;
+  }
+  /**
+   * Gets contrast used in the effect.
+   */
+  get contrast() {
+    return this.imageProcessingConfiguration.contrast;
+  }
+  /**
+   * Sets contrast used in the effect.
+   */
+  set contrast(e) {
+    this.imageProcessingConfiguration.contrast = e;
+  }
+  /**
+   * Gets Vignette stretch size.
+   */
+  get vignetteStretch() {
+    return this.imageProcessingConfiguration.vignetteStretch;
+  }
+  /**
+   * Sets Vignette stretch size.
+   */
+  set vignetteStretch(e) {
+    this.imageProcessingConfiguration.vignetteStretch = e;
+  }
+  /**
+   * Gets Vignette center X Offset.
+   * @deprecated use vignetteCenterX instead
+   */
+  get vignetteCentreX() {
+    return this.imageProcessingConfiguration.vignetteCenterX;
+  }
+  /**
+   * Sets Vignette center X Offset.
+   * @deprecated use vignetteCenterX instead
+   */
+  set vignetteCentreX(e) {
+    this.imageProcessingConfiguration.vignetteCenterX = e;
+  }
+  /**
+   * Gets Vignette center Y Offset.
+   * @deprecated use vignetteCenterY instead
+   */
+  get vignetteCentreY() {
+    return this.imageProcessingConfiguration.vignetteCenterY;
+  }
+  /**
+   * Sets Vignette center Y Offset.
+   * @deprecated use vignetteCenterY instead
+   */
+  set vignetteCentreY(e) {
+    this.imageProcessingConfiguration.vignetteCenterY = e;
+  }
+  /**
+   * Vignette center Y Offset.
+   */
+  get vignetteCenterY() {
+    return this.imageProcessingConfiguration.vignetteCenterY;
+  }
+  set vignetteCenterY(e) {
+    this.imageProcessingConfiguration.vignetteCenterY = e;
+  }
+  /**
+   * Vignette center X Offset.
+   */
+  get vignetteCenterX() {
+    return this.imageProcessingConfiguration.vignetteCenterX;
+  }
+  set vignetteCenterX(e) {
+    this.imageProcessingConfiguration.vignetteCenterX = e;
+  }
+  /**
+   * Gets Vignette weight or intensity of the vignette effect.
+   */
+  get vignetteWeight() {
+    return this.imageProcessingConfiguration.vignetteWeight;
+  }
+  /**
+   * Sets Vignette weight or intensity of the vignette effect.
+   */
+  set vignetteWeight(e) {
+    this.imageProcessingConfiguration.vignetteWeight = e;
+  }
+  /**
+   * Gets Color of the vignette applied on the screen through the chosen blend mode (vignetteBlendMode)
+   * if vignetteEnabled is set to true.
+   */
+  get vignetteColor() {
+    return this.imageProcessingConfiguration.vignetteColor;
+  }
+  /**
+   * Sets Color of the vignette applied on the screen through the chosen blend mode (vignetteBlendMode)
+   * if vignetteEnabled is set to true.
+   */
+  set vignetteColor(e) {
+    this.imageProcessingConfiguration.vignetteColor = e;
+  }
+  /**
+   * Gets Camera field of view used by the Vignette effect.
+   */
+  get vignetteCameraFov() {
+    return this.imageProcessingConfiguration.vignetteCameraFov;
+  }
+  /**
+   * Sets Camera field of view used by the Vignette effect.
+   */
+  set vignetteCameraFov(e) {
+    this.imageProcessingConfiguration.vignetteCameraFov = e;
+  }
+  /**
+   * Gets the vignette blend mode allowing different kind of effect.
+   */
+  get vignetteBlendMode() {
+    return this.imageProcessingConfiguration.vignetteBlendMode;
+  }
+  /**
+   * Sets the vignette blend mode allowing different kind of effect.
+   */
+  set vignetteBlendMode(e) {
+    this.imageProcessingConfiguration.vignetteBlendMode = e;
+  }
+  /**
+   * Gets whether the vignette effect is enabled.
+   */
+  get vignetteEnabled() {
+    return this.imageProcessingConfiguration.vignetteEnabled;
+  }
+  /**
+   * Sets whether the vignette effect is enabled.
+   */
+  set vignetteEnabled(e) {
+    this.imageProcessingConfiguration.vignetteEnabled = e;
+  }
+  /**
+   * Gets intensity of the dithering effect.
+   */
+  get ditheringIntensity() {
+    return this.imageProcessingConfiguration.ditheringIntensity;
+  }
+  /**
+   * Sets intensity of the dithering effect.
+   */
+  set ditheringIntensity(e) {
+    this.imageProcessingConfiguration.ditheringIntensity = e;
+  }
+  /**
+   * Gets whether the dithering effect is enabled.
+   */
+  get ditheringEnabled() {
+    return this.imageProcessingConfiguration.ditheringEnabled;
+  }
+  /**
+   * Sets whether the dithering effect is enabled.
+   */
+  set ditheringEnabled(e) {
+    this.imageProcessingConfiguration.ditheringEnabled = e;
+  }
+  /**
+   * Gets whether the input of the processing is in Gamma or Linear Space.
+   */
+  get fromLinearSpace() {
+    return this._fromLinearSpace;
+  }
+  /**
+   * Sets whether the input of the processing is in Gamma or Linear Space.
+   */
+  set fromLinearSpace(e) {
+    this._fromLinearSpace !== e && (this._fromLinearSpace = e, this._updateParameters());
+  }
+  constructor(e, n, i = null, t, s, r, a = 0, g) {
+    super(e, "imageProcessing", [], [], n, i, t, s, r, null, a, "postprocess", null, !0), this._fromLinearSpace = !0, this._defines = {
+      IMAGEPROCESSING: !1,
+      VIGNETTE: !1,
+      VIGNETTEBLENDMODEMULTIPLY: !1,
+      VIGNETTEBLENDMODEOPAQUE: !1,
+      TONEMAPPING: !1,
+      TONEMAPPING_ACES: !1,
+      CONTRAST: !1,
+      COLORCURVES: !1,
+      COLORGRADING: !1,
+      COLORGRADING3D: !1,
+      FROMLINEARSPACE: !1,
+      SAMPLER3DGREENDEPTH: !1,
+      SAMPLER3DBGRMAP: !1,
+      DITHER: !1,
+      IMAGEPROCESSINGPOSTPROCESS: !1,
+      EXPOSURE: !1,
+      SKIPFINALCOLORCLAMP: !1
+    }, g ? (g.applyByPostProcess = !0, this._attachImageProcessingConfiguration(g, !0), this._updateParameters()) : (this._attachImageProcessingConfiguration(null, !0), this.imageProcessingConfiguration.applyByPostProcess = !0), this.onApply = (c) => {
+      this.imageProcessingConfiguration.bind(c, this.aspectRatio);
+    };
+  }
+  /**
+   *  "ImageProcessingPostProcess"
+   * @returns "ImageProcessingPostProcess"
+   */
+  getClassName() {
+    return "ImageProcessingPostProcess";
+  }
+  /**
+   * @internal
+   */
+  _updateParameters() {
+    this._defines.FROMLINEARSPACE = this._fromLinearSpace, this.imageProcessingConfiguration.prepareDefines(this._defines, !0);
+    let e = "";
+    for (const t in this._defines)
+      this._defines[t] && (e += `#define ${t};\r
+`);
+    const n = ["textureSampler"], i = ["scale"];
+    o && (o.PrepareSamplers(n, this._defines), o.PrepareUniforms(i, this._defines)), this.updateEffect(e, i, n);
+  }
+  dispose(e) {
+    super.dispose(e), this._imageProcessingConfiguration && this._imageProcessingObserver && this._imageProcessingConfiguration.onUpdateParameters.remove(this._imageProcessingObserver), this._imageProcessingConfiguration && (this.imageProcessingConfiguration.applyByPostProcess = !1);
+  }
+}
+f([
+  u()
+], C.prototype, "_fromLinearSpace", void 0);
+export {
+  C as ImageProcessingPostProcess
+};

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

@@ -0,0 +1,178 @@
+import { __decorate as o } from "../tslib.es6.esm.js";
+import { Logger as _ } from "../Misc/logger.esm.js";
+import { Matrix as c, Vector2 as d, TmpVectors as g } from "../Maths/math.vector.esm.js";
+import { PostProcess as B } from "./postProcess.esm.js";
+import { GeometryBufferRenderer as f } from "../Rendering/geometryBufferRenderer.esm.js";
+import { MotionBlurConfiguration as R } from "../Rendering/motionBlurConfiguration.esm.js";
+import "../Animations/animatable.esm.js";
+import "../Rendering/geometryBufferRendererSceneComponent.esm.js";
+import "../Shaders/motionBlur.fragment.esm.js";
+import { serialize as n, SerializationHelper as y } from "../Misc/decorators.esm.js";
+import { RegisterClass as P } from "../Misc/typeStore.esm.js";
+class i extends B {
+  /**
+   * Gets the number of iterations are used for motion blur quality. Default value is equal to 32
+   */
+  get motionBlurSamples() {
+    return this._motionBlurSamples;
+  }
+  /**
+   * Sets the number of iterations to be used for motion blur quality
+   */
+  set motionBlurSamples(e) {
+    this._motionBlurSamples = e, this._updateEffect();
+  }
+  /**
+   * Gets whether or not the motion blur post-process is in object based mode.
+   */
+  get isObjectBased() {
+    return this._isObjectBased;
+  }
+  /**
+   * Sets whether or not the motion blur post-process is in object based mode.
+   */
+  set isObjectBased(e) {
+    this._isObjectBased !== e && (this._isObjectBased = e, this._applyMode());
+  }
+  get _geometryBufferRenderer() {
+    return this._forceGeometryBuffer ? this._scene.geometryBufferRenderer : null;
+  }
+  get _prePassRenderer() {
+    return this._forceGeometryBuffer ? null : this._scene.prePassRenderer;
+  }
+  /**
+   * Gets a string identifying the name of the class
+   * @returns "MotionBlurPostProcess" string
+   */
+  getClassName() {
+    return "MotionBlurPostProcess";
+  }
+  /**
+   * Creates a new instance MotionBlurPostProcess
+   * @param name The name of the effect.
+   * @param scene The scene containing the objects to blur according to their velocity.
+   * @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: true)
+   * @param forceGeometryBuffer If this post process should use geometry buffer instead of prepass (default: false)
+   */
+  constructor(e, t, r, s, a, u, h, l = 0, p = !1, m = !1) {
+    super(e, "motionBlur", ["motionStrength", "motionScale", "screenSize", "inverseViewProjection", "prevViewProjection", "projection"], ["velocitySampler", "depthSampler"], r, s, a, u, h, `#define GEOMETRY_SUPPORTED
+#define SAMPLES 64.0
+#define OBJECT_BASED`, l, void 0, null, p), this.motionStrength = 1, this._motionBlurSamples = 32, this._isObjectBased = !0, this._forceGeometryBuffer = !1, this._invViewProjection = null, this._previousViewProjection = null, this._forceGeometryBuffer = m, this._forceGeometryBuffer ? (t.enableGeometryBufferRenderer(), this._geometryBufferRenderer && (this._geometryBufferRenderer.enableVelocity = !0)) : (t.enablePrePassRenderer(), this._prePassRenderer && (this._prePassRenderer.markAsDirty(), this._prePassEffectConfiguration = new R())), this._applyMode();
+  }
+  /**
+   * Excludes the given skinned mesh from computing bones velocities.
+   * Computing bones velocities can have a cost and that cost. The cost can be saved by calling this function and by passing the skinned mesh reference to ignore.
+   * @param skinnedMesh The mesh containing the skeleton to ignore when computing the velocity map.
+   */
+  excludeSkinnedMesh(e) {
+    if (e.skeleton) {
+      let t;
+      if (this._geometryBufferRenderer)
+        t = this._geometryBufferRenderer.excludedSkinnedMeshesFromVelocity;
+      else if (this._prePassRenderer)
+        t = this._prePassRenderer.excludedSkinnedMesh;
+      else
+        return;
+      t.push(e);
+    }
+  }
+  /**
+   * Removes the given skinned mesh from the excluded meshes to integrate bones velocities while rendering the velocity map.
+   * @param skinnedMesh The mesh containing the skeleton that has been ignored previously.
+   * @see excludeSkinnedMesh to exclude a skinned mesh from bones velocity computation.
+   */
+  removeExcludedSkinnedMesh(e) {
+    if (e.skeleton) {
+      let t;
+      if (this._geometryBufferRenderer)
+        t = this._geometryBufferRenderer.excludedSkinnedMeshesFromVelocity;
+      else if (this._prePassRenderer)
+        t = this._prePassRenderer.excludedSkinnedMesh;
+      else
+        return;
+      const r = t.indexOf(e);
+      r !== -1 && t.splice(r, 1);
+    }
+  }
+  /**
+   * Disposes the post process.
+   * @param camera The camera to dispose the post process on.
+   */
+  dispose(e) {
+    this._geometryBufferRenderer && (this._geometryBufferRenderer._previousTransformationMatrices = {}, this._geometryBufferRenderer._previousBonesTransformationMatrices = {}, this._geometryBufferRenderer.excludedSkinnedMeshesFromVelocity = []), super.dispose(e);
+  }
+  /**
+   * Called on the mode changed (object based or screen based).
+   */
+  _applyMode() {
+    if (!this._geometryBufferRenderer && !this._prePassRenderer)
+      return _.Warn("Multiple Render Target support needed to compute object based motion blur"), this.updateEffect();
+    this._updateEffect(), this._invViewProjection = null, this._previousViewProjection = null, this.isObjectBased ? (this._prePassRenderer && this._prePassEffectConfiguration && (this._prePassEffectConfiguration.texturesRequired[0] = 2), this.onApply = (e) => this._onApplyObjectBased(e)) : (this._invViewProjection = c.Identity(), this._previousViewProjection = this._scene.getTransformMatrix().clone(), this._prePassRenderer && this._prePassEffectConfiguration && (this._prePassEffectConfiguration.texturesRequired[0] = 5), this.onApply = (e) => this._onApplyScreenBased(e));
+  }
+  /**
+   * Called on the effect is applied when the motion blur post-process is in object based mode.
+   * @param effect
+   */
+  _onApplyObjectBased(e) {
+    if (e.setVector2("screenSize", new d(this.width, this.height)), e.setFloat("motionScale", this._scene.getAnimationRatio()), e.setFloat("motionStrength", this.motionStrength), this._geometryBufferRenderer) {
+      const t = this._geometryBufferRenderer.getTextureIndex(f.VELOCITY_TEXTURE_TYPE);
+      e.setTexture("velocitySampler", this._geometryBufferRenderer.getGBuffer().textures[t]);
+    } else if (this._prePassRenderer) {
+      const t = this._prePassRenderer.getIndex(2);
+      e.setTexture("velocitySampler", this._prePassRenderer.getRenderTarget().textures[t]);
+    }
+  }
+  /**
+   * Called on the effect is applied when the motion blur post-process is in screen based mode.
+   * @param effect
+   */
+  _onApplyScreenBased(e) {
+    const t = g.Matrix[0];
+    if (t.copyFrom(this._scene.getTransformMatrix()), t.invertToRef(this._invViewProjection), e.setMatrix("inverseViewProjection", this._invViewProjection), e.setMatrix("prevViewProjection", this._previousViewProjection), this._previousViewProjection.copyFrom(t), e.setMatrix("projection", this._scene.getProjectionMatrix()), e.setVector2("screenSize", new d(this.width, this.height)), e.setFloat("motionScale", this._scene.getAnimationRatio()), e.setFloat("motionStrength", this.motionStrength), this._geometryBufferRenderer) {
+      const r = this._geometryBufferRenderer.getTextureIndex(f.DEPTH_TEXTURE_TYPE);
+      e.setTexture("depthSampler", this._geometryBufferRenderer.getGBuffer().textures[r]);
+    } else if (this._prePassRenderer) {
+      const r = this._prePassRenderer.getIndex(5);
+      e.setTexture("depthSampler", this._prePassRenderer.getRenderTarget().textures[r]);
+    }
+  }
+  /**
+   * Called on the effect must be updated (changed mode, samples count, etc.).
+   */
+  _updateEffect() {
+    if (this._geometryBufferRenderer || this._prePassRenderer) {
+      const e = [
+        "#define GEOMETRY_SUPPORTED",
+        "#define SAMPLES " + this._motionBlurSamples.toFixed(1),
+        this._isObjectBased ? "#define OBJECT_BASED" : "#define SCREEN_BASED"
+      ];
+      this.updateEffect(e.join(`
+`));
+    }
+  }
+  /**
+   * @internal
+   */
+  static _Parse(e, t, r, s) {
+    return y.Parse(() => new i(e.name, r, e.options, t, e.renderTargetSamplingMode, r.getEngine(), e.reusable, e.textureType, !1), e, r, s);
+  }
+}
+o([
+  n()
+], i.prototype, "motionStrength", void 0);
+o([
+  n()
+], i.prototype, "motionBlurSamples", null);
+o([
+  n()
+], i.prototype, "isObjectBased", null);
+P("BABYLON.MotionBlurPostProcess", i);
+export {
+  i as MotionBlurPostProcess
+};

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

@@ -0,0 +1,40 @@
+import { PostProcess as m } from "./postProcess.esm.js";
+import { Engine as f } from "../Engines/engine.esm.js";
+import "../Shaders/pass.fragment.esm.js";
+import "../Shaders/passCube.fragment.esm.js";
+import { RegisterClass as p } from "../Misc/typeStore.esm.js";
+import { SerializationHelper as c } from "../Misc/decorators.esm.js";
+class r extends m {
+  /**
+   * Gets a string identifying the name of the class
+   * @returns "PassPostProcess" string
+   */
+  getClassName() {
+    return "PassPostProcess";
+  }
+  /**
+   * Creates the PassPostProcess
+   * @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 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, n, l = null, t, s, a, o = 0, u = !1) {
+    super(e, "pass", null, null, n, l, t, s, a, void 0, o, void 0, null, u);
+  }
+  /**
+   * @internal
+   */
+  static _Parse(e, n, l, t) {
+    return c.Parse(() => new r(e.name, e.options, n, e.renderTargetSamplingMode, e._engine, e.reusable), e, l, t);
+  }
+}
+p("BABYLON.PassPostProcess", r);
+f._RescalePostProcessFactory = (i) => new r("rescale", 1, null, 2, i, !1, 0);
+export {
+  r as PassPostProcess
+};