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

package/dist/node_modules/@babylonjs/core/Materials/effectFallbacks.esm.js

@@ -0,0 +1,73 @@
+class o {
+  constructor() {
+    this._defines = {}, this._currentRank = 32, this._maxRank = -1, this._mesh = null;
+  }
+  /**
+   * Removes the fallback from the bound mesh.
+   */
+  unBindMesh() {
+    this._mesh = null;
+  }
+  /**
+   * Adds a fallback on the specified property.
+   * @param rank The rank of the fallback (Lower ranks will be fallbacked to first)
+   * @param define The name of the define in the shader
+   */
+  addFallback(e, n) {
+    this._defines[e] || (e < this._currentRank && (this._currentRank = e), e > this._maxRank && (this._maxRank = e), this._defines[e] = new Array()), this._defines[e].push(n);
+  }
+  /**
+   * Sets the mesh to use CPU skinning when needing to fallback.
+   * @param rank The rank of the fallback (Lower ranks will be fallbacked to first)
+   * @param mesh The mesh to use the fallbacks.
+   */
+  addCPUSkinningFallback(e, n) {
+    this._mesh = n, e < this._currentRank && (this._currentRank = e), e > this._maxRank && (this._maxRank = e);
+  }
+  /**
+   * Checks to see if more fallbacks are still available.
+   */
+  get hasMoreFallbacks() {
+    return this._currentRank <= this._maxRank;
+  }
+  /**
+   * Removes the defines that should be removed when falling back.
+   * @param currentDefines defines the current define statements for the shader.
+   * @param effect defines the current effect we try to compile
+   * @returns The resulting defines with defines of the current rank removed.
+   */
+  reduce(e, n) {
+    if (this._mesh && this._mesh.computeBonesUsingShaders && this._mesh.numBoneInfluencers > 0) {
+      this._mesh.computeBonesUsingShaders = !1, e = e.replace("#define NUM_BONE_INFLUENCERS " + this._mesh.numBoneInfluencers, "#define NUM_BONE_INFLUENCERS 0"), n._bonesComputationForcedToCPU = !0;
+      const i = this._mesh.getScene();
+      for (let t = 0; t < i.meshes.length; t++) {
+        const s = i.meshes[t];
+        if (!s.material) {
+          !this._mesh.material && s.computeBonesUsingShaders && s.numBoneInfluencers > 0 && (s.computeBonesUsingShaders = !1);
+          continue;
+        }
+        if (!(!s.computeBonesUsingShaders || s.numBoneInfluencers === 0)) {
+          if (s.material.getEffect() === n)
+            s.computeBonesUsingShaders = !1;
+          else if (s.subMeshes) {
+            for (const h of s.subMeshes)
+              if (h.effect === n) {
+                s.computeBonesUsingShaders = !1;
+                break;
+              }
+          }
+        }
+      }
+    } else {
+      const i = this._defines[this._currentRank];
+      if (i)
+        for (let t = 0; t < i.length; t++)
+          e = e.replace("#define " + i[t], "");
+      this._currentRank++;
+    }
+    return e;
+  }
+}
+export {
+  o as EffectFallbacks
+};

package/dist/node_modules/@babylonjs/core/Materials/effectRenderer.esm.js

@@ -0,0 +1,132 @@
+import { VertexBuffer as f } from "../Buffers/buffer.esm.js";
+import { Viewport as l } from "../Maths/math.viewport.esm.js";
+import { Observable as h } from "../Misc/observable.esm.js";
+import { Effect as u } from "./effect.esm.js";
+import { DrawWrapper as p } from "./drawWrapper.esm.js";
+import "../Shaders/postprocess.vertex.esm.js";
+const i = {
+  positions: [1, 1, -1, 1, -1, -1, 1, -1],
+  indices: [0, 1, 2, 0, 2, 3]
+};
+class B {
+  /**
+   * Creates an effect renderer
+   * @param engine the engine to use for rendering
+   * @param options defines the options of the effect renderer
+   */
+  constructor(e, t = i) {
+    var r, s;
+    this._fullscreenViewport = new l(0, 0, 1, 1);
+    const o = (r = t.positions) !== null && r !== void 0 ? r : i.positions, n = (s = t.indices) !== null && s !== void 0 ? s : i.indices;
+    this.engine = e, this._vertexBuffers = {
+      [f.PositionKind]: new f(e, o, f.PositionKind, !1, !1, 2)
+    }, this._indexBuffer = e.createIndexBuffer(n), this._onContextRestoredObserver = e.onContextRestoredObservable.add(() => {
+      this._indexBuffer = e.createIndexBuffer(n);
+      for (const a in this._vertexBuffers)
+        this._vertexBuffers[a]._rebuild();
+    });
+  }
+  /**
+   * Sets the current viewport in normalized coordinates 0-1
+   * @param viewport Defines the viewport to set (defaults to 0 0 1 1)
+   */
+  setViewport(e = this._fullscreenViewport) {
+    this.engine.setViewport(e);
+  }
+  /**
+   * Binds the embedded attributes buffer to the effect.
+   * @param effect Defines the effect to bind the attributes for
+   */
+  bindBuffers(e) {
+    this.engine.bindBuffers(this._vertexBuffers, this._indexBuffer, e);
+  }
+  /**
+   * Sets the current effect wrapper to use during draw.
+   * The effect needs to be ready before calling this api.
+   * This also sets the default full screen position attribute.
+   * @param effectWrapper Defines the effect to draw with
+   */
+  applyEffectWrapper(e) {
+    this.engine.setState(!0), this.engine.depthCullingState.depthTest = !1, this.engine.stencilState.stencilTest = !1, this.engine.enableEffect(e._drawWrapper), this.bindBuffers(e.effect), e.onApplyObservable.notifyObservers({});
+  }
+  /**
+   * Restores engine states
+   */
+  restoreStates() {
+    this.engine.depthCullingState.depthTest = !0, this.engine.stencilState.stencilTest = !0;
+  }
+  /**
+   * Draws a full screen quad.
+   */
+  draw() {
+    this.engine.drawElementsType(0, 0, 6);
+  }
+  _isRenderTargetTexture(e) {
+    return e.renderTarget !== void 0;
+  }
+  /**
+   * renders one or more effects to a specified texture
+   * @param effectWrapper the effect to renderer
+   * @param outputTexture texture to draw to, if null it will render to the screen.
+   */
+  render(e, t = null) {
+    if (!e.effect.isReady())
+      return;
+    this.setViewport();
+    const r = t === null ? null : this._isRenderTargetTexture(t) ? t.renderTarget : t;
+    r && this.engine.bindFramebuffer(r), this.applyEffectWrapper(e), this.draw(), r && this.engine.unBindFramebuffer(r), this.restoreStates();
+  }
+  /**
+   * Disposes of the effect renderer
+   */
+  dispose() {
+    const e = this._vertexBuffers[f.PositionKind];
+    e && (e.dispose(), delete this._vertexBuffers[f.PositionKind]), this._indexBuffer && this.engine._releaseBuffer(this._indexBuffer), this._onContextRestoredObserver && (this.engine.onContextRestoredObservable.remove(this._onContextRestoredObserver), this._onContextRestoredObserver = null);
+  }
+}
+class w {
+  /**
+   * The underlying effect
+   */
+  get effect() {
+    return this._drawWrapper.effect;
+  }
+  set effect(e) {
+    this._drawWrapper.effect = e;
+  }
+  /**
+   * Creates an effect to be renderer
+   * @param creationOptions options to create the effect
+   */
+  constructor(e) {
+    this.onApplyObservable = new h();
+    let t;
+    const r = e.uniformNames || [];
+    e.vertexShader ? t = {
+      fragmentSource: e.fragmentShader,
+      vertexSource: e.vertexShader,
+      spectorName: e.name || "effectWrapper"
+    } : (r.push("scale"), t = {
+      fragmentSource: e.fragmentShader,
+      vertex: "postprocess",
+      spectorName: e.name || "effectWrapper"
+    }, this.onApplyObservable.add(() => {
+      this.effect.setFloat2("scale", 1, 1);
+    }));
+    const s = e.defines ? e.defines.join(`
+`) : "";
+    this._drawWrapper = new p(e.engine), e.useShaderStore ? (t.fragment = t.fragmentSource, t.vertex || (t.vertex = t.vertexSource), delete t.fragmentSource, delete t.vertexSource, this.effect = e.engine.createEffect(t, e.attributeNames || ["position"], r, e.samplerNames, s, void 0, e.onCompiled, void 0, void 0, e.shaderLanguage)) : (this.effect = new u(t, e.attributeNames || ["position"], r, e.samplerNames, e.engine, s, void 0, e.onCompiled, void 0, void 0, void 0, e.shaderLanguage), this._onContextRestoredObserver = e.engine.onContextRestoredObservable.add(() => {
+      this.effect._pipelineContext = null, this.effect._wasPreviouslyReady = !1, this.effect._prepareEffect();
+    }));
+  }
+  /**
+   * Disposes of the effect wrapper
+   */
+  dispose() {
+    this._onContextRestoredObserver && (this.effect.getEngine().onContextRestoredObservable.remove(this._onContextRestoredObserver), this._onContextRestoredObserver = null), this.effect.dispose();
+  }
+}
+export {
+  B as EffectRenderer,
+  w as EffectWrapper
+};

package/dist/node_modules/@babylonjs/core/Materials/imageProcessingConfiguration.esm.js

@@ -0,0 +1,428 @@
+import { __decorate as r } from "../tslib.es6.esm.js";
+import { serializeAsColorCurves as G, serialize as i, serializeAsTexture as C, serializeAsColor4 as T, SerializationHelper as l } from "../Misc/decorators.esm.js";
+import { Observable as v } from "../Misc/observable.esm.js";
+import { Tools as E } from "../Misc/tools.esm.js";
+import { Color4 as P } from "../Maths/math.color.esm.js";
+import { ColorCurves as h } from "./colorCurves.esm.js";
+class e {
+  constructor() {
+    this.colorCurves = new h(), this._colorCurvesEnabled = !1, this._colorGradingEnabled = !1, this._colorGradingWithGreenDepth = !0, this._colorGradingBGR = !0, this._exposure = 1, this._toneMappingEnabled = !1, this._toneMappingType = e.TONEMAPPING_STANDARD, this._contrast = 1, this.vignetteStretch = 0, this.vignetteCenterX = 0, this.vignetteCenterY = 0, this.vignetteWeight = 1.5, this.vignetteColor = new P(0, 0, 0, 0), this.vignetteCameraFov = 0.5, this._vignetteBlendMode = e.VIGNETTEMODE_MULTIPLY, this._vignetteEnabled = !1, this._ditheringEnabled = !1, this._ditheringIntensity = 1 / 255, this._skipFinalColorClamp = !1, this._applyByPostProcess = !1, this._isEnabled = !0, this.onUpdateParameters = new v();
+  }
+  /**
+   * Gets whether the color curves effect is enabled.
+   */
+  get colorCurvesEnabled() {
+    return this._colorCurvesEnabled;
+  }
+  /**
+   * Sets whether the color curves effect is enabled.
+   */
+  set colorCurvesEnabled(t) {
+    this._colorCurvesEnabled !== t && (this._colorCurvesEnabled = t, this._updateParameters());
+  }
+  /**
+   * Color grading LUT texture used in the effect if colorGradingEnabled is set to true
+   */
+  get colorGradingTexture() {
+    return this._colorGradingTexture;
+  }
+  /**
+   * Color grading LUT texture used in the effect if colorGradingEnabled is set to true
+   */
+  set colorGradingTexture(t) {
+    this._colorGradingTexture !== t && (this._colorGradingTexture = t, this._updateParameters());
+  }
+  /**
+   * Gets whether the color grading effect is enabled.
+   */
+  get colorGradingEnabled() {
+    return this._colorGradingEnabled;
+  }
+  /**
+   * Sets whether the color grading effect is enabled.
+   */
+  set colorGradingEnabled(t) {
+    this._colorGradingEnabled !== t && (this._colorGradingEnabled = t, this._updateParameters());
+  }
+  /**
+   * Gets whether the color grading effect is using a green depth for the 3d Texture.
+   */
+  get colorGradingWithGreenDepth() {
+    return this._colorGradingWithGreenDepth;
+  }
+  /**
+   * Sets whether the color grading effect is using a green depth for the 3d Texture.
+   */
+  set colorGradingWithGreenDepth(t) {
+    this._colorGradingWithGreenDepth !== t && (this._colorGradingWithGreenDepth = t, this._updateParameters());
+  }
+  /**
+   * Gets whether the color grading texture contains BGR values.
+   */
+  get colorGradingBGR() {
+    return this._colorGradingBGR;
+  }
+  /**
+   * Sets whether the color grading texture contains BGR values.
+   */
+  set colorGradingBGR(t) {
+    this._colorGradingBGR !== t && (this._colorGradingBGR = t, this._updateParameters());
+  }
+  /**
+   * Gets the Exposure used in the effect.
+   */
+  get exposure() {
+    return this._exposure;
+  }
+  /**
+   * Sets the Exposure used in the effect.
+   */
+  set exposure(t) {
+    this._exposure !== t && (this._exposure = t, this._updateParameters());
+  }
+  /**
+   * Gets whether the tone mapping effect is enabled.
+   */
+  get toneMappingEnabled() {
+    return this._toneMappingEnabled;
+  }
+  /**
+   * Sets whether the tone mapping effect is enabled.
+   */
+  set toneMappingEnabled(t) {
+    this._toneMappingEnabled !== t && (this._toneMappingEnabled = t, this._updateParameters());
+  }
+  /**
+   * Gets the type of tone mapping effect.
+   */
+  get toneMappingType() {
+    return this._toneMappingType;
+  }
+  /**
+   * Sets the type of tone mapping effect used in BabylonJS.
+   */
+  set toneMappingType(t) {
+    this._toneMappingType !== t && (this._toneMappingType = t, this._updateParameters());
+  }
+  /**
+   * Gets the contrast used in the effect.
+   */
+  get contrast() {
+    return this._contrast;
+  }
+  /**
+   * Sets the contrast used in the effect.
+   */
+  set contrast(t) {
+    this._contrast !== t && (this._contrast = t, this._updateParameters());
+  }
+  /**
+   * Back Compat: Vignette center Y Offset.
+   * @deprecated use vignetteCenterY instead
+   */
+  get vignetteCentreY() {
+    return this.vignetteCenterY;
+  }
+  set vignetteCentreY(t) {
+    this.vignetteCenterY = t;
+  }
+  /**
+   * Back Compat: Vignette center X Offset.
+   * @deprecated use vignetteCenterX instead
+   */
+  get vignetteCentreX() {
+    return this.vignetteCenterX;
+  }
+  set vignetteCentreX(t) {
+    this.vignetteCenterX = t;
+  }
+  /**
+   * Gets the vignette blend mode allowing different kind of effect.
+   */
+  get vignetteBlendMode() {
+    return this._vignetteBlendMode;
+  }
+  /**
+   * Sets the vignette blend mode allowing different kind of effect.
+   */
+  set vignetteBlendMode(t) {
+    this._vignetteBlendMode !== t && (this._vignetteBlendMode = t, this._updateParameters());
+  }
+  /**
+   * Gets whether the vignette effect is enabled.
+   */
+  get vignetteEnabled() {
+    return this._vignetteEnabled;
+  }
+  /**
+   * Sets whether the vignette effect is enabled.
+   */
+  set vignetteEnabled(t) {
+    this._vignetteEnabled !== t && (this._vignetteEnabled = t, this._updateParameters());
+  }
+  /**
+   * Gets whether the dithering effect is enabled.
+   * The dithering effect can be used to reduce banding.
+   */
+  get ditheringEnabled() {
+    return this._ditheringEnabled;
+  }
+  /**
+   * Sets whether the dithering effect is enabled.
+   * The dithering effect can be used to reduce banding.
+   */
+  set ditheringEnabled(t) {
+    this._ditheringEnabled !== t && (this._ditheringEnabled = t, this._updateParameters());
+  }
+  /**
+   * Gets the dithering intensity. 0 is no dithering. Default is 1.0 / 255.0.
+   */
+  get ditheringIntensity() {
+    return this._ditheringIntensity;
+  }
+  /**
+   * Sets the dithering intensity. 0 is no dithering. Default is 1.0 / 255.0.
+   */
+  set ditheringIntensity(t) {
+    this._ditheringIntensity !== t && (this._ditheringIntensity = t, this._updateParameters());
+  }
+  /**
+   * If apply by post process is set to true, setting this to true will skip the the final color clamp step in the fragment shader
+   * Applies to PBR materials.
+   */
+  get skipFinalColorClamp() {
+    return this._skipFinalColorClamp;
+  }
+  /**
+   * If apply by post process is set to true, setting this to true will skip the the final color clamp step in the fragment shader
+   * Applies to PBR materials.
+   */
+  set skipFinalColorClamp(t) {
+    this._skipFinalColorClamp !== t && (this._skipFinalColorClamp = t, this._updateParameters());
+  }
+  /**
+   * Gets whether the image processing is applied through a post process or not.
+   */
+  get applyByPostProcess() {
+    return this._applyByPostProcess;
+  }
+  /**
+   * Sets whether the image processing is applied through a post process or not.
+   */
+  set applyByPostProcess(t) {
+    this._applyByPostProcess !== t && (this._applyByPostProcess = t, this._updateParameters());
+  }
+  /**
+   * Gets whether the image processing is enabled or not.
+   */
+  get isEnabled() {
+    return this._isEnabled;
+  }
+  /**
+   * Sets whether the image processing is enabled or not.
+   */
+  set isEnabled(t) {
+    this._isEnabled !== t && (this._isEnabled = t, this._updateParameters());
+  }
+  /**
+   * Method called each time the image processing information changes requires to recompile the effect.
+   */
+  _updateParameters() {
+    this.onUpdateParameters.notifyObservers(this);
+  }
+  /**
+   * Gets the current class name.
+   * @returns "ImageProcessingConfiguration"
+   */
+  getClassName() {
+    return "ImageProcessingConfiguration";
+  }
+  /**
+   * Prepare the list of uniforms associated with the Image Processing effects.
+   * @param uniforms The list of uniforms used in the effect
+   * @param defines the list of defines currently in use
+   */
+  static PrepareUniforms(t, n) {
+    n.EXPOSURE && t.push("exposureLinear"), n.CONTRAST && t.push("contrast"), n.COLORGRADING && t.push("colorTransformSettings"), (n.VIGNETTE || n.DITHER) && t.push("vInverseScreenSize"), n.VIGNETTE && (t.push("vignetteSettings1"), t.push("vignetteSettings2")), n.COLORCURVES && h.PrepareUniforms(t), n.DITHER && t.push("ditherIntensity");
+  }
+  /**
+   * Prepare the list of samplers associated with the Image Processing effects.
+   * @param samplersList The list of uniforms used in the effect
+   * @param defines the list of defines currently in use
+   */
+  static PrepareSamplers(t, n) {
+    n.COLORGRADING && t.push("txColorTransform");
+  }
+  /**
+   * Prepare the list of defines associated to the shader.
+   * @param defines the list of defines to complete
+   * @param forPostProcess Define if we are currently in post process mode or not
+   */
+  prepareDefines(t, n = !1) {
+    if (n !== this.applyByPostProcess || !this._isEnabled) {
+      t.VIGNETTE = !1, t.TONEMAPPING = !1, t.TONEMAPPING_ACES = !1, t.CONTRAST = !1, t.EXPOSURE = !1, t.COLORCURVES = !1, t.COLORGRADING = !1, t.COLORGRADING3D = !1, t.DITHER = !1, t.IMAGEPROCESSING = !1, t.SKIPFINALCOLORCLAMP = this.skipFinalColorClamp, t.IMAGEPROCESSINGPOSTPROCESS = this.applyByPostProcess && this._isEnabled;
+      return;
+    }
+    switch (t.VIGNETTE = this.vignetteEnabled, t.VIGNETTEBLENDMODEMULTIPLY = this.vignetteBlendMode === e._VIGNETTEMODE_MULTIPLY, t.VIGNETTEBLENDMODEOPAQUE = !t.VIGNETTEBLENDMODEMULTIPLY, t.TONEMAPPING = this.toneMappingEnabled, this._toneMappingType) {
+      case e.TONEMAPPING_ACES:
+        t.TONEMAPPING_ACES = !0;
+        break;
+      default:
+        t.TONEMAPPING_ACES = !1;
+        break;
+    }
+    t.CONTRAST = this.contrast !== 1, t.EXPOSURE = this.exposure !== 1, t.COLORCURVES = this.colorCurvesEnabled && !!this.colorCurves, t.COLORGRADING = this.colorGradingEnabled && !!this.colorGradingTexture, t.COLORGRADING ? t.COLORGRADING3D = this.colorGradingTexture.is3D : t.COLORGRADING3D = !1, t.SAMPLER3DGREENDEPTH = this.colorGradingWithGreenDepth, t.SAMPLER3DBGRMAP = this.colorGradingBGR, t.DITHER = this._ditheringEnabled, t.IMAGEPROCESSINGPOSTPROCESS = this.applyByPostProcess, t.SKIPFINALCOLORCLAMP = this.skipFinalColorClamp, t.IMAGEPROCESSING = t.VIGNETTE || t.TONEMAPPING || t.CONTRAST || t.EXPOSURE || t.COLORCURVES || t.COLORGRADING || t.DITHER;
+  }
+  /**
+   * Returns true if all the image processing information are ready.
+   * @returns True if ready, otherwise, false
+   */
+  isReady() {
+    return !this.colorGradingEnabled || !this.colorGradingTexture || this.colorGradingTexture.isReady();
+  }
+  /**
+   * Binds the image processing to the shader.
+   * @param effect The effect to bind to
+   * @param overrideAspectRatio Override the aspect ratio of the effect
+   */
+  bind(t, n) {
+    if (this._colorCurvesEnabled && this.colorCurves && h.Bind(this.colorCurves, t), this._vignetteEnabled || this._ditheringEnabled) {
+      const o = 1 / t.getEngine().getRenderWidth(), p = 1 / t.getEngine().getRenderHeight();
+      if (t.setFloat2("vInverseScreenSize", o, p), this._ditheringEnabled && t.setFloat("ditherIntensity", 0.5 * this._ditheringIntensity), this._vignetteEnabled) {
+        const d = n ?? p / o;
+        let s = Math.tan(this.vignetteCameraFov * 0.5), a = s * d;
+        const g = Math.sqrt(a * s);
+        a = E.Mix(a, g, this.vignetteStretch), s = E.Mix(s, g, this.vignetteStretch), t.setFloat4("vignetteSettings1", a, s, -a * this.vignetteCenterX, -s * this.vignetteCenterY);
+        const _ = -2 * this.vignetteWeight;
+        t.setFloat4("vignetteSettings2", this.vignetteColor.r, this.vignetteColor.g, this.vignetteColor.b, _);
+      }
+    }
+    if (t.setFloat("exposureLinear", this.exposure), t.setFloat("contrast", this.contrast), this.colorGradingTexture) {
+      t.setTexture("txColorTransform", this.colorGradingTexture);
+      const o = this.colorGradingTexture.getSize().height;
+      t.setFloat4(
+        "colorTransformSettings",
+        (o - 1) / o,
+        // textureScale
+        0.5 / o,
+        // textureOffset
+        o,
+        // textureSize
+        this.colorGradingTexture.level
+        // weight
+      );
+    }
+  }
+  /**
+   * Clones the current image processing instance.
+   * @returns The cloned image processing
+   */
+  clone() {
+    return l.Clone(() => new e(), this);
+  }
+  /**
+   * Serializes the current image processing instance to a json representation.
+   * @returns a JSON representation
+   */
+  serialize() {
+    return l.Serialize(this);
+  }
+  /**
+   * Parses the image processing from a json representation.
+   * @param source the JSON source to parse
+   * @returns The parsed image processing
+   */
+  static Parse(t) {
+    const n = l.Parse(() => new e(), t, null, null);
+    return t.vignetteCentreX !== void 0 && (n.vignetteCenterX = t.vignetteCentreX), t.vignetteCentreY !== void 0 && (n.vignetteCenterY = t.vignetteCentreY), n;
+  }
+  /**
+   * Used to apply the vignette as a mix with the pixel color.
+   */
+  static get VIGNETTEMODE_MULTIPLY() {
+    return this._VIGNETTEMODE_MULTIPLY;
+  }
+  /**
+   * Used to apply the vignette as a replacement of the pixel color.
+   */
+  static get VIGNETTEMODE_OPAQUE() {
+    return this._VIGNETTEMODE_OPAQUE;
+  }
+}
+e.TONEMAPPING_STANDARD = 0;
+e.TONEMAPPING_ACES = 1;
+e._VIGNETTEMODE_MULTIPLY = 0;
+e._VIGNETTEMODE_OPAQUE = 1;
+r([
+  G()
+], e.prototype, "colorCurves", void 0);
+r([
+  i()
+], e.prototype, "_colorCurvesEnabled", void 0);
+r([
+  C("colorGradingTexture")
+], e.prototype, "_colorGradingTexture", void 0);
+r([
+  i()
+], e.prototype, "_colorGradingEnabled", void 0);
+r([
+  i()
+], e.prototype, "_colorGradingWithGreenDepth", void 0);
+r([
+  i()
+], e.prototype, "_colorGradingBGR", void 0);
+r([
+  i()
+], e.prototype, "_exposure", void 0);
+r([
+  i()
+], e.prototype, "_toneMappingEnabled", void 0);
+r([
+  i()
+], e.prototype, "_toneMappingType", void 0);
+r([
+  i()
+], e.prototype, "_contrast", void 0);
+r([
+  i()
+], e.prototype, "vignetteStretch", void 0);
+r([
+  i()
+], e.prototype, "vignetteCenterX", void 0);
+r([
+  i()
+], e.prototype, "vignetteCenterY", void 0);
+r([
+  i()
+], e.prototype, "vignetteWeight", void 0);
+r([
+  T()
+], e.prototype, "vignetteColor", void 0);
+r([
+  i()
+], e.prototype, "vignetteCameraFov", void 0);
+r([
+  i()
+], e.prototype, "_vignetteBlendMode", void 0);
+r([
+  i()
+], e.prototype, "_vignetteEnabled", void 0);
+r([
+  i()
+], e.prototype, "_ditheringEnabled", void 0);
+r([
+  i()
+], e.prototype, "_ditheringIntensity", void 0);
+r([
+  i()
+], e.prototype, "_skipFinalColorClamp", void 0);
+r([
+  i()
+], e.prototype, "_applyByPostProcess", void 0);
+r([
+  i()
+], e.prototype, "_isEnabled", void 0);
+l._ImageProcessingConfigurationParser = e.Parse;
+export {
+  e as ImageProcessingConfiguration
+};