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

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

@@ -0,0 +1,349 @@
+import { __decorate as r } from "../../../tslib.es6.esm.js";
+import { serialize as a, SerializationHelper as d } from "../../../Misc/decorators.esm.js";
+import { Observable as p } from "../../../Misc/observable.esm.js";
+import { Logger as u } from "../../../Misc/logger.esm.js";
+import { Texture as h } from "../../../Materials/Textures/texture.esm.js";
+import { GlowLayer as b } from "../../../Layers/glowLayer.esm.js";
+import { SharpenPostProcess as g } from "../../sharpenPostProcess.esm.js";
+import { ImageProcessingPostProcess as P } from "../../imageProcessingPostProcess.esm.js";
+import { ChromaticAberrationPostProcess as E } from "../../chromaticAberrationPostProcess.esm.js";
+import { GrainPostProcess as v } from "../../grainPostProcess.esm.js";
+import { FxaaPostProcess as O } from "../../fxaaPostProcess.esm.js";
+import { PostProcessRenderPipeline as A } from "../postProcessRenderPipeline.esm.js";
+import { PostProcessRenderEffect as n } from "../postProcessRenderEffect.esm.js";
+import { DepthOfFieldEffect as c, DepthOfFieldEffectBlurLevel as C } from "../../depthOfFieldEffect.esm.js";
+import { BloomEffect as f } from "../../bloomEffect.esm.js";
+import { RegisterClass as y } from "../../../Misc/typeStore.esm.js";
+import { EngineStore as w } from "../../../Engines/engineStore.esm.js";
+import { Tools as T } from "../../../Misc/tools.esm.js";
+import "../postProcessRenderPipelineManagerSceneComponent.esm.js";
+class i extends A {
+  /**
+   * Enable or disable automatic building of the pipeline when effects are enabled and disabled.
+   * If false, you will have to manually call prepare() to update the pipeline.
+   */
+  get automaticBuild() {
+    return this._buildAllowed;
+  }
+  set automaticBuild(e) {
+    this._buildAllowed = e;
+  }
+  /**
+   * Gets active scene
+   */
+  get scene() {
+    return this._scene;
+  }
+  /**
+   * Enable or disable the sharpen process from the pipeline
+   */
+  set sharpenEnabled(e) {
+    this._sharpenEnabled !== e && (this._sharpenEnabled = e, this._buildPipeline());
+  }
+  get sharpenEnabled() {
+    return this._sharpenEnabled;
+  }
+  /**
+   * Specifies the size of the bloom blur kernel, relative to the final output size
+   */
+  get bloomKernel() {
+    return this._bloomKernel;
+  }
+  set bloomKernel(e) {
+    this._bloomKernel = e, this.bloom.kernel = e / this._hardwareScaleLevel;
+  }
+  /**
+   * The strength of the bloom.
+   */
+  set bloomWeight(e) {
+    this._bloomWeight !== e && (this.bloom.weight = e, this._bloomWeight = e);
+  }
+  get bloomWeight() {
+    return this._bloomWeight;
+  }
+  /**
+   * The luminance threshold to find bright areas of the image to bloom.
+   */
+  set bloomThreshold(e) {
+    this._bloomThreshold !== e && (this.bloom.threshold = e, this._bloomThreshold = e);
+  }
+  get bloomThreshold() {
+    return this._bloomThreshold;
+  }
+  /**
+   * The scale of the bloom, lower value will provide better performance.
+   */
+  set bloomScale(e) {
+    this._bloomScale !== e && (this._bloomScale = e, this._rebuildBloom(), this._buildPipeline());
+  }
+  get bloomScale() {
+    return this._bloomScale;
+  }
+  /**
+   * Enable or disable the bloom from the pipeline
+   */
+  set bloomEnabled(e) {
+    this._bloomEnabled !== e && (this._bloomEnabled = e, this._buildPipeline());
+  }
+  get bloomEnabled() {
+    return this._bloomEnabled;
+  }
+  _rebuildBloom() {
+    const e = this.bloom;
+    this.bloom = new f(this._scene, this.bloomScale, this._bloomWeight, this.bloomKernel / this._hardwareScaleLevel, this._defaultPipelineTextureType, !1), this.bloom.threshold = e.threshold;
+    for (let t = 0; t < this._cameras.length; t++)
+      e.disposeEffects(this._cameras[t]);
+  }
+  /**
+   * If the depth of field is enabled.
+   */
+  get depthOfFieldEnabled() {
+    return this._depthOfFieldEnabled;
+  }
+  set depthOfFieldEnabled(e) {
+    this._depthOfFieldEnabled !== e && (this._depthOfFieldEnabled = e, this._buildPipeline());
+  }
+  /**
+   * Blur level of the depth of field effect. (Higher blur will effect performance)
+   */
+  get depthOfFieldBlurLevel() {
+    return this._depthOfFieldBlurLevel;
+  }
+  set depthOfFieldBlurLevel(e) {
+    if (this._depthOfFieldBlurLevel === e)
+      return;
+    this._depthOfFieldBlurLevel = e;
+    const t = this.depthOfField;
+    this.depthOfField = new c(this._scene, null, this._depthOfFieldBlurLevel, this._defaultPipelineTextureType, !1), this.depthOfField.focalLength = t.focalLength, this.depthOfField.focusDistance = t.focusDistance, this.depthOfField.fStop = t.fStop, this.depthOfField.lensSize = t.lensSize;
+    for (let s = 0; s < this._cameras.length; s++)
+      t.disposeEffects(this._cameras[s]);
+    this._buildPipeline();
+  }
+  /**
+   * If the anti aliasing is enabled.
+   */
+  set fxaaEnabled(e) {
+    this._fxaaEnabled !== e && (this._fxaaEnabled = e, this._buildPipeline());
+  }
+  get fxaaEnabled() {
+    return this._fxaaEnabled;
+  }
+  /**
+   * MSAA sample count, setting this to 4 will provide 4x anti aliasing. (default: 1)
+   */
+  set samples(e) {
+    this._samples !== e && (this._samples = e, this._buildPipeline());
+  }
+  get samples() {
+    return this._samples;
+  }
+  /**
+   * If image processing is enabled.
+   */
+  set imageProcessingEnabled(e) {
+    this._imageProcessingEnabled !== e && (this._scene.imageProcessingConfiguration.isEnabled = e);
+  }
+  get imageProcessingEnabled() {
+    return this._imageProcessingEnabled;
+  }
+  /**
+   * If glow layer is enabled. (Adds a glow effect to emmissive materials)
+   */
+  set glowLayerEnabled(e) {
+    e && !this._glowLayer ? this._glowLayer = new b("", this._scene) : !e && this._glowLayer && (this._glowLayer.dispose(), this._glowLayer = null);
+  }
+  get glowLayerEnabled() {
+    return this._glowLayer != null;
+  }
+  /**
+   * Gets the glow layer (or null if not defined)
+   */
+  get glowLayer() {
+    return this._glowLayer;
+  }
+  /**
+   * Enable or disable the chromaticAberration process from the pipeline
+   */
+  set chromaticAberrationEnabled(e) {
+    this._chromaticAberrationEnabled !== e && (this._chromaticAberrationEnabled = e, this._buildPipeline());
+  }
+  get chromaticAberrationEnabled() {
+    return this._chromaticAberrationEnabled;
+  }
+  /**
+   * Enable or disable the grain process from the pipeline
+   */
+  set grainEnabled(e) {
+    this._grainEnabled !== e && (this._grainEnabled = e, this._buildPipeline());
+  }
+  get grainEnabled() {
+    return this._grainEnabled;
+  }
+  /**
+   * Instantiates a DefaultRenderingPipeline.
+   * @param name The rendering pipeline name (default: "")
+   * @param hdr If high dynamic range textures should be used (default: true)
+   * @param scene The scene linked to this pipeline (default: the last created scene)
+   * @param cameras The array of cameras that the rendering pipeline will be attached to (default: scene.cameras)
+   * @param automaticBuild If false, you will have to manually call prepare() to update the pipeline (default: true)
+   */
+  constructor(e = "", t = !0, s = w.LastCreatedScene, _, m = !0) {
+    super(s.getEngine(), e), this._camerasToBeAttached = [], this.SharpenPostProcessId = "SharpenPostProcessEffect", this.ImageProcessingPostProcessId = "ImageProcessingPostProcessEffect", this.FxaaPostProcessId = "FxaaPostProcessEffect", this.ChromaticAberrationPostProcessId = "ChromaticAberrationPostProcessEffect", this.GrainPostProcessId = "GrainPostProcessEffect", this._glowLayer = null, this.animations = [], this._imageProcessingConfigurationObserver = null, this._sharpenEnabled = !1, this._bloomEnabled = !1, this._depthOfFieldEnabled = !1, this._depthOfFieldBlurLevel = C.Low, this._fxaaEnabled = !1, this._imageProcessingEnabled = !0, this._bloomScale = 0.5, this._chromaticAberrationEnabled = !1, this._grainEnabled = !1, this._buildAllowed = !0, this.onBuildObservable = new p(), this._resizeObserver = null, this._hardwareScaleLevel = 1, this._bloomKernel = 64, this._bloomWeight = 0.15, this._bloomThreshold = 0.9, this._samples = 1, this._hasCleared = !1, this._prevPostProcess = null, this._prevPrevPostProcess = null, this._depthOfFieldSceneObserver = null, this._activeCameraChangedObserver = null, this._activeCamerasChangedObserver = null, this._cameras = _ || s.cameras, this._cameras = this._cameras.slice(), this._camerasToBeAttached = this._cameras.slice(), this._buildAllowed = m, this._scene = s;
+    const o = this._scene.getEngine().getCaps();
+    this._hdr = t && (o.textureHalfFloatRender || o.textureFloatRender), this._hdr ? o.textureHalfFloatRender ? this._defaultPipelineTextureType = 2 : o.textureFloatRender && (this._defaultPipelineTextureType = 1) : this._defaultPipelineTextureType = 0, s.postProcessRenderPipelineManager.addPipeline(this);
+    const l = this._scene.getEngine();
+    this.sharpen = new g("sharpen", 1, null, h.BILINEAR_SAMPLINGMODE, l, !1, this._defaultPipelineTextureType, !0), this._sharpenEffect = new n(l, this.SharpenPostProcessId, () => this.sharpen, !0), this.depthOfField = new c(this._scene, null, this._depthOfFieldBlurLevel, this._defaultPipelineTextureType, !0), this._hardwareScaleLevel = l.getHardwareScalingLevel(), this._resizeObserver = l.onResizeObservable.add(() => {
+      this._hardwareScaleLevel = l.getHardwareScalingLevel(), this.bloomKernel = this._bloomKernel;
+    }), this.bloom = new f(this._scene, this._bloomScale, this._bloomWeight, this.bloomKernel / this._hardwareScaleLevel, this._defaultPipelineTextureType, !0), this.chromaticAberration = new E("ChromaticAberration", l.getRenderWidth(), l.getRenderHeight(), 1, null, h.BILINEAR_SAMPLINGMODE, l, !1, this._defaultPipelineTextureType, !0), this._chromaticAberrationEffect = new n(l, this.ChromaticAberrationPostProcessId, () => this.chromaticAberration, !0), this.grain = new v("Grain", 1, null, h.BILINEAR_SAMPLINGMODE, l, !1, this._defaultPipelineTextureType, !0), this._grainEffect = new n(l, this.GrainPostProcessId, () => this.grain, !0), this._imageProcessingConfigurationObserver = this._scene.imageProcessingConfiguration.onUpdateParameters.add(() => {
+      this.bloom._downscale._exposure = this._scene.imageProcessingConfiguration.exposure, this.imageProcessingEnabled !== this._scene.imageProcessingConfiguration.isEnabled && (this._imageProcessingEnabled = this._scene.imageProcessingConfiguration.isEnabled, T.SetImmediate(() => {
+        this._buildPipeline();
+      }));
+    }), this._buildPipeline();
+  }
+  /**
+   * Get the class name
+   * @returns "DefaultRenderingPipeline"
+   */
+  getClassName() {
+    return "DefaultRenderingPipeline";
+  }
+  /**
+   * Force the compilation of the entire pipeline.
+   */
+  prepare() {
+    const e = this._buildAllowed;
+    this._buildAllowed = !0, this._buildPipeline(), this._buildAllowed = e;
+  }
+  _setAutoClearAndTextureSharing(e, t = !1) {
+    this._hasCleared ? e.autoClear = !1 : (e.autoClear = !0, this._scene.autoClear = !1, this._hasCleared = !0), t || (this._prevPrevPostProcess ? e.shareOutputWith(this._prevPrevPostProcess) : e.useOwnOutput(), this._prevPostProcess && (this._prevPrevPostProcess = this._prevPostProcess), this._prevPostProcess = e);
+  }
+  _buildPipeline() {
+    if (!this._buildAllowed)
+      return;
+    this._scene.autoClear = !0;
+    const e = this._scene.getEngine();
+    if (this._disposePostProcesses(), this._cameras !== null && (this._scene.postProcessRenderPipelineManager.detachCamerasFromRenderPipeline(this._name, this._cameras), this._cameras = this._camerasToBeAttached.slice()), this._reset(), this._prevPostProcess = null, this._prevPrevPostProcess = null, this._hasCleared = !1, this.depthOfFieldEnabled) {
+      if (this._cameras.length > 1) {
+        for (const t of this._cameras) {
+          const s = this._scene.enableDepthRenderer(t);
+          s.useOnlyInActiveCamera = !0;
+        }
+        this._depthOfFieldSceneObserver = this._scene.onAfterRenderTargetsRenderObservable.add((t) => {
+          this._cameras.indexOf(t.activeCamera) > -1 && (this.depthOfField.depthTexture = t.enableDepthRenderer(t.activeCamera).getDepthMap());
+        });
+      } else {
+        this._scene.onAfterRenderTargetsRenderObservable.remove(this._depthOfFieldSceneObserver);
+        const t = this._scene.enableDepthRenderer(this._cameras[0]);
+        this.depthOfField.depthTexture = t.getDepthMap();
+      }
+      this.depthOfField._isReady() || this.depthOfField._updateEffects(), this.addEffect(this.depthOfField), this._setAutoClearAndTextureSharing(this.depthOfField._effects[0], !0);
+    } else
+      this._scene.onAfterRenderTargetsRenderObservable.remove(this._depthOfFieldSceneObserver);
+    this.bloomEnabled && (this.bloom._isReady() || this.bloom._updateEffects(), this.addEffect(this.bloom), this._setAutoClearAndTextureSharing(this.bloom._effects[0], !0)), this._imageProcessingEnabled && (this.imageProcessing = new P("imageProcessing", 1, null, h.BILINEAR_SAMPLINGMODE, e, !1, this._defaultPipelineTextureType, this.scene.imageProcessingConfiguration), this._hdr ? (this.addEffect(new n(e, this.ImageProcessingPostProcessId, () => this.imageProcessing, !0)), this._setAutoClearAndTextureSharing(this.imageProcessing)) : this._scene.imageProcessingConfiguration.applyByPostProcess = !1, (!this._cameras || this._cameras.length === 0) && (this._scene.imageProcessingConfiguration.applyByPostProcess = !1), this.imageProcessing.getEffect() || this.imageProcessing._updateParameters()), this.sharpenEnabled && (this.sharpen.isReady() || this.sharpen.updateEffect(), this.addEffect(this._sharpenEffect), this._setAutoClearAndTextureSharing(this.sharpen)), this.grainEnabled && (this.grain.isReady() || this.grain.updateEffect(), this.addEffect(this._grainEffect), this._setAutoClearAndTextureSharing(this.grain)), this.chromaticAberrationEnabled && (this.chromaticAberration.isReady() || this.chromaticAberration.updateEffect(), this.addEffect(this._chromaticAberrationEffect), this._setAutoClearAndTextureSharing(this.chromaticAberration)), this.fxaaEnabled && (this.fxaa = new O("fxaa", 1, null, h.BILINEAR_SAMPLINGMODE, e, !1, this._defaultPipelineTextureType), this.addEffect(new n(e, this.FxaaPostProcessId, () => this.fxaa, !0)), this._setAutoClearAndTextureSharing(this.fxaa, !0)), this._cameras !== null && this._scene.postProcessRenderPipelineManager.attachCamerasToRenderPipeline(this._name, this._cameras), (this._scene.activeCameras && this._scene.activeCameras.length > 1 || this._scene.activeCamera && this._cameras.indexOf(this._scene.activeCamera) === -1) && (this._scene.autoClear = !0), this._activeCameraChangedObserver || (this._activeCameraChangedObserver = this._scene.onActiveCameraChanged.add(() => {
+      this._scene.activeCamera && this._cameras.indexOf(this._scene.activeCamera) === -1 && (this._scene.autoClear = !0);
+    })), this._activeCamerasChangedObserver || (this._activeCamerasChangedObserver = this._scene.onActiveCamerasChanged.add(() => {
+      this._scene.activeCameras && this._scene.activeCameras.length > 1 && (this._scene.autoClear = !0);
+    })), !this._enableMSAAOnFirstPostProcess(this.samples) && this.samples > 1 && u.Warn("MSAA failed to enable, MSAA is only supported in browsers that support webGL >= 2.0"), this.onBuildObservable.notifyObservers(this);
+  }
+  _disposePostProcesses(e = !1) {
+    for (let t = 0; t < this._cameras.length; t++) {
+      const s = this._cameras[t];
+      this.imageProcessing && this.imageProcessing.dispose(s), this.fxaa && this.fxaa.dispose(s), e && (this.sharpen && this.sharpen.dispose(s), this.depthOfField && (this._scene.onAfterRenderTargetsRenderObservable.remove(this._depthOfFieldSceneObserver), this.depthOfField.disposeEffects(s)), this.bloom && this.bloom.disposeEffects(s), this.chromaticAberration && this.chromaticAberration.dispose(s), this.grain && this.grain.dispose(s), this._glowLayer && this._glowLayer.dispose());
+    }
+    this.imageProcessing = null, this.fxaa = null, e && (this.sharpen = null, this._sharpenEffect = null, this.depthOfField = null, this.bloom = null, this.chromaticAberration = null, this._chromaticAberrationEffect = null, this.grain = null, this._grainEffect = null, this._glowLayer = null);
+  }
+  /**
+   * Adds a camera to the pipeline
+   * @param camera the camera to be added
+   */
+  addCamera(e) {
+    this._camerasToBeAttached.push(e), this._buildPipeline();
+  }
+  /**
+   * Removes a camera from the pipeline
+   * @param camera the camera to remove
+   */
+  removeCamera(e) {
+    const t = this._camerasToBeAttached.indexOf(e);
+    this._camerasToBeAttached.splice(t, 1), this._buildPipeline();
+  }
+  /**
+   * Dispose of the pipeline and stop all post processes
+   */
+  dispose() {
+    this._buildAllowed = !1, this.onBuildObservable.clear(), this._disposePostProcesses(!0), this._scene.postProcessRenderPipelineManager.detachCamerasFromRenderPipeline(this._name, this._cameras), this._scene._postProcessRenderPipelineManager.removePipeline(this.name), this._scene.autoClear = !0, this._resizeObserver && (this._scene.getEngine().onResizeObservable.remove(this._resizeObserver), this._resizeObserver = null), this._scene.onActiveCameraChanged.remove(this._activeCameraChangedObserver), this._scene.onActiveCamerasChanged.remove(this._activeCamerasChangedObserver), this._scene.imageProcessingConfiguration.onUpdateParameters.remove(this._imageProcessingConfigurationObserver), super.dispose();
+  }
+  /**
+   * Serialize the rendering pipeline (Used when exporting)
+   * @returns the serialized object
+   */
+  serialize() {
+    const e = d.Serialize(this);
+    return e.customType = "DefaultRenderingPipeline", e;
+  }
+  /**
+   * Parse the serialized pipeline
+   * @param source Source pipeline.
+   * @param scene The scene to load the pipeline to.
+   * @param rootUrl The URL of the serialized pipeline.
+   * @returns An instantiated pipeline from the serialized object.
+   */
+  static Parse(e, t, s) {
+    return d.Parse(() => new i(e._name, e._name._hdr, t), e, t, s);
+  }
+}
+r([
+  a()
+], i.prototype, "sharpenEnabled", null);
+r([
+  a()
+], i.prototype, "bloomKernel", null);
+r([
+  a()
+], i.prototype, "_bloomWeight", void 0);
+r([
+  a()
+], i.prototype, "_bloomThreshold", void 0);
+r([
+  a()
+], i.prototype, "_hdr", void 0);
+r([
+  a()
+], i.prototype, "bloomWeight", null);
+r([
+  a()
+], i.prototype, "bloomThreshold", null);
+r([
+  a()
+], i.prototype, "bloomScale", null);
+r([
+  a()
+], i.prototype, "bloomEnabled", null);
+r([
+  a()
+], i.prototype, "depthOfFieldEnabled", null);
+r([
+  a()
+], i.prototype, "depthOfFieldBlurLevel", null);
+r([
+  a()
+], i.prototype, "fxaaEnabled", null);
+r([
+  a()
+], i.prototype, "samples", null);
+r([
+  a()
+], i.prototype, "imageProcessingEnabled", null);
+r([
+  a()
+], i.prototype, "glowLayerEnabled", null);
+r([
+  a()
+], i.prototype, "chromaticAberrationEnabled", null);
+r([
+  a()
+], i.prototype, "grainEnabled", null);
+y("BABYLON.DefaultRenderingPipeline", i);
+export {
+  i as DefaultRenderingPipeline
+};

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

@@ -0,0 +1,306 @@
+import { __decorate as a } from "../../../tslib.es6.esm.js";
+import { Logger as b } from "../../../Misc/logger.esm.js";
+import { serialize as n, SerializationHelper as P } from "../../../Misc/decorators.esm.js";
+import { Vector3 as S, TmpVectors as B } from "../../../Maths/math.vector.esm.js";
+import { Camera as y } from "../../../Cameras/camera.esm.js";
+import { Texture as _ } from "../../../Materials/Textures/texture.esm.js";
+import { DynamicTexture as C } from "../../../Materials/Textures/dynamicTexture.esm.js";
+import { PostProcess as d } from "../../postProcess.esm.js";
+import { PostProcessRenderPipeline as A } from "../postProcessRenderPipeline.esm.js";
+import { PostProcessRenderEffect as m } from "../postProcessRenderEffect.esm.js";
+import { PassPostProcess as O } from "../../passPostProcess.esm.js";
+import { RegisterClass as v } from "../../../Misc/typeStore.esm.js";
+import { EngineStore as T } from "../../../Engines/engineStore.esm.js";
+import { SSAO2Configuration as F } from "../../../Rendering/ssao2Configuration.esm.js";
+import "../postProcessRenderPipelineManagerSceneComponent.esm.js";
+import "../../../Shaders/ssao2.fragment.esm.js";
+import "../../../Shaders/ssaoCombine.fragment.esm.js";
+class o extends A {
+  /**
+   * Used in SSAO calculations to compensate for accuracy issues with depth values. Default 0.02.
+   *
+   * Normally you do not need to change this value, but you can experiment with it if you get a lot of in false self-occlusion on flat surfaces when using fewer than 16 samples. Useful range is normally [0..0.1] but higher values is allowed.
+   */
+  set epsilon(e) {
+    this._epsilon = e, this._ssaoPostProcess.updateEffect(this._getDefinesForSSAO());
+  }
+  get epsilon() {
+    return this._epsilon;
+  }
+  /**
+   * Number of samples used for the SSAO calculations. Default value is 8.
+   */
+  set samples(e) {
+    this._samples = e, this._ssaoPostProcess.updateEffect(this._getDefinesForSSAO()), this._sampleSphere = this._generateHemisphere();
+  }
+  get samples() {
+    return this._samples;
+  }
+  /**
+   * Number of samples to use for antialiasing.
+   */
+  set textureSamples(e) {
+    this._textureSamples = e, this._prePassRenderer ? this._prePassRenderer.samples = e : this._originalColorPostProcess.samples = e;
+  }
+  get textureSamples() {
+    return this._textureSamples;
+  }
+  get _geometryBufferRenderer() {
+    return this._forceGeometryBuffer ? this._scene.geometryBufferRenderer : null;
+  }
+  get _prePassRenderer() {
+    return this._forceGeometryBuffer ? null : this._scene.prePassRenderer;
+  }
+  /**
+   * Skips the denoising (blur) stage of the SSAO calculations.
+   *
+   * Useful to temporarily set while experimenting with the other SSAO2 settings.
+   */
+  set bypassBlur(e) {
+    const t = this._getDefinesForBlur(this.expensiveBlur, e), r = this._getSamplersForBlur(e);
+    this._blurHPostProcess.updateEffect(t.h, null, r), this._blurVPostProcess.updateEffect(t.v, null, r), this._bypassBlur = e;
+  }
+  get bypassBlur() {
+    return this._bypassBlur;
+  }
+  /**
+   * Enables the configurable bilateral denoising (blurring) filter. Default is true.
+   * Set to false to instead use a legacy bilateral filter that can't be configured.
+   *
+   * The denoising filter runs after the SSAO calculations and is a very important step. Both options results in a so called bilateral being used, but the "expensive" one can be
+   * configured in several ways to fit your scene.
+   */
+  set expensiveBlur(e) {
+    const t = this._getDefinesForBlur(e, this._bypassBlur);
+    this._blurHPostProcess.updateEffect(t.h), this._blurVPostProcess.updateEffect(t.v), this._expensiveBlur = e;
+  }
+  get expensiveBlur() {
+    return this._expensiveBlur;
+  }
+  /**
+   *  Support test.
+   */
+  static get IsSupported() {
+    const e = T.LastCreatedEngine;
+    return e ? e._features.supportSSAO2 : !1;
+  }
+  /**
+   * Gets active scene
+   */
+  get scene() {
+    return this._scene;
+  }
+  /**
+   * @constructor
+   * @param name The rendering pipeline name
+   * @param scene The scene linked to this pipeline
+   * @param ratio The size of the postprocesses. Can be a number shared between passes or an object for more precision: { ssaoRatio: 0.5, blurRatio: 1.0 }
+   * @param cameras The array of cameras that the rendering pipeline will be attached to
+   * @param forceGeometryBuffer Set to true if you want to use the legacy geometry buffer renderer
+   * @param textureType The texture type used by the different post processes created by SSAO (default: 0)
+   */
+  constructor(e, t, r, i, s = !1, l = 0) {
+    if (super(t.getEngine(), e), this.SSAOOriginalSceneColorEffect = "SSAOOriginalSceneColorEffect", this.SSAORenderEffect = "SSAORenderEffect", this.SSAOBlurHRenderEffect = "SSAOBlurHRenderEffect", this.SSAOBlurVRenderEffect = "SSAOBlurVRenderEffect", this.SSAOCombineRenderEffect = "SSAOCombineRenderEffect", this.totalStrength = 1, this.maxZ = 100, this.minZAspect = 0.2, this._epsilon = 0.02, this._samples = 8, this._textureSamples = 1, this._forceGeometryBuffer = !1, this.radius = 2, this.base = 0, this._bypassBlur = !1, this._expensiveBlur = !0, this.bilateralSamples = 16, this.bilateralSoften = 0, this.bilateralTolerance = 0, this._bits = new Uint32Array(1), this._scene = t, this._ratio = r, this._textureType = l, this._forceGeometryBuffer = s, !this.isSupported) {
+      b.Error("The current engine does not support SSAO 2.");
+      return;
+    }
+    const p = this._ratio.ssaoRatio || r, h = this._ratio.blurRatio || r;
+    this._forceGeometryBuffer ? t.enableGeometryBufferRenderer() : t.enablePrePassRenderer(), this._createRandomTexture(), this._originalColorPostProcess = new O("SSAOOriginalSceneColor", 1, null, _.BILINEAR_SAMPLINGMODE, t.getEngine(), void 0, this._textureType), this._originalColorPostProcess.samples = this.textureSamples, this._createSSAOPostProcess(1, l), this._createBlurPostProcess(p, h, this._textureType), this._createSSAOCombinePostProcess(h, this._textureType), this.addEffect(new m(t.getEngine(), this.SSAOOriginalSceneColorEffect, () => this._originalColorPostProcess, !0)), this.addEffect(new m(t.getEngine(), this.SSAORenderEffect, () => this._ssaoPostProcess, !0)), this.addEffect(new m(t.getEngine(), this.SSAOBlurHRenderEffect, () => this._blurHPostProcess, !0)), this.addEffect(new m(t.getEngine(), this.SSAOBlurVRenderEffect, () => this._blurVPostProcess, !0)), this.addEffect(new m(t.getEngine(), this.SSAOCombineRenderEffect, () => this._ssaoCombinePostProcess, !0)), t.postProcessRenderPipelineManager.addPipeline(this), i && t.postProcessRenderPipelineManager.attachCamerasToRenderPipeline(e, i);
+  }
+  // Public Methods
+  /**
+   * Get the class name
+   * @returns "SSAO2RenderingPipeline"
+   */
+  getClassName() {
+    return "SSAO2RenderingPipeline";
+  }
+  /**
+   * Removes the internal pipeline assets and detaches the pipeline from the scene cameras
+   * @param disableGeometryBufferRenderer
+   */
+  dispose(e = !1) {
+    for (let t = 0; t < this._scene.cameras.length; t++) {
+      const r = this._scene.cameras[t];
+      this._originalColorPostProcess.dispose(r), this._ssaoPostProcess.dispose(r), this._blurHPostProcess.dispose(r), this._blurVPostProcess.dispose(r), this._ssaoCombinePostProcess.dispose(r);
+    }
+    this._randomTexture.dispose(), e && this._scene.disableGeometryBufferRenderer(), this._scene.postProcessRenderPipelineManager.detachCamerasFromRenderPipeline(this._name, this._scene.cameras), super.dispose();
+  }
+  // Private Methods
+  /** @internal */
+  _rebuild() {
+    super._rebuild();
+  }
+  _getSamplersForBlur(e) {
+    return e ? ["textureSampler"] : ["textureSampler", "depthSampler"];
+  }
+  _getDefinesForBlur(e, t) {
+    let r = `#define BLUR
+`;
+    return t && (r += `#define BLUR_BYPASS
+`), e || (r += `#define BLUR_LEGACY
+`), { h: r + `#define BLUR_H
+`, v: r };
+  }
+  _createBlurPostProcess(e, t, r) {
+    const i = this._getDefinesForBlur(this.expensiveBlur, this.bypassBlur), s = this._getSamplersForBlur(this.bypassBlur);
+    this._blurHPostProcess = this._createBlurFilter("BlurH", s, e, i.h, r, !0), this._blurVPostProcess = this._createBlurFilter("BlurV", s, t, i.v, r, !1);
+  }
+  _createBlurFilter(e, t, r, i, s, l) {
+    const p = new d(e, "ssao2", ["outSize", "samples", "soften", "tolerance"], t, r, null, _.BILINEAR_SAMPLINGMODE, this._scene.getEngine(), !1, i, s);
+    return p.onApply = (h) => {
+      if (!this._scene.activeCamera)
+        return;
+      const u = l ? this._ssaoCombinePostProcess.width : this._ssaoCombinePostProcess.height, c = l ? this._originalColorPostProcess.width : this._originalColorPostProcess.height;
+      h.setFloat("outSize", u > 0 ? u : c), h.setInt("samples", this.bilateralSamples), h.setFloat("soften", this.bilateralSoften), h.setFloat("tolerance", this.bilateralTolerance), this._geometryBufferRenderer ? h.setTexture("depthSampler", this._geometryBufferRenderer.getGBuffer().textures[0]) : this._prePassRenderer && h.setTexture("depthSampler", this._prePassRenderer.getRenderTarget().textures[this._prePassRenderer.getIndex(5)]);
+    }, p.samples = this.textureSamples, p;
+  }
+  //Van der Corput radical inverse
+  _radicalInverse_VdC(e) {
+    return this._bits[0] = e, this._bits[0] = (this._bits[0] << 16 | this._bits[0] >> 16) >>> 0, this._bits[0] = (this._bits[0] & 1431655765) << 1 | (this._bits[0] & 2863311530) >>> 1 >>> 0, this._bits[0] = (this._bits[0] & 858993459) << 2 | (this._bits[0] & 3435973836) >>> 2 >>> 0, this._bits[0] = (this._bits[0] & 252645135) << 4 | (this._bits[0] & 4042322160) >>> 4 >>> 0, this._bits[0] = (this._bits[0] & 16711935) << 8 | (this._bits[0] & 4278255360) >>> 8 >>> 0, this._bits[0] * 23283064365386963e-26;
+  }
+  _hammersley(e, t) {
+    return [e / t, this._radicalInverse_VdC(e)];
+  }
+  _hemisphereSample_uniform(e, t) {
+    const r = t * 2 * Math.PI, i = 1 - e * 0.85, s = Math.sqrt(1 - i * i);
+    return new S(Math.cos(r) * s, Math.sin(r) * s, i);
+  }
+  _generateHemisphere() {
+    const e = this.samples, t = [];
+    let r, i = 0;
+    for (; i < e; ) {
+      if (e < 16)
+        r = this._hemisphereSample_uniform(Math.random(), Math.random());
+      else {
+        const s = this._hammersley(i, e);
+        r = this._hemisphereSample_uniform(s[0], s[1]);
+      }
+      t.push(r.x, r.y, r.z), i++;
+    }
+    return t;
+  }
+  _getDefinesForSSAO() {
+    return `#define SSAO
+#define SAMPLES ${this.samples}
+#define EPSILON ${this.epsilon.toFixed(4)}`;
+  }
+  _createSSAOPostProcess(e, t) {
+    this._sampleSphere = this._generateHemisphere();
+    const r = this._getDefinesForSSAO(), i = ["randomSampler", "depthSampler", "normalSampler"];
+    this._ssaoPostProcess = new d("ssao2", "ssao2", [
+      "sampleSphere",
+      "samplesFactor",
+      "randTextureTiles",
+      "totalStrength",
+      "radius",
+      "base",
+      "range",
+      "projection",
+      "near",
+      "texelSize",
+      "xViewport",
+      "yViewport",
+      "maxZ",
+      "minZAspect",
+      "depthProjection"
+    ], i, e, null, _.BILINEAR_SAMPLINGMODE, this._scene.getEngine(), !1, r, t), this._ssaoPostProcess.onApply = (s) => {
+      var l, p, h, u;
+      if (this._scene.activeCamera) {
+        if (s.setArray3("sampleSphere", this._sampleSphere), s.setFloat("randTextureTiles", 32), s.setFloat("samplesFactor", 1 / this.samples), s.setFloat("totalStrength", this.totalStrength), s.setFloat2("texelSize", 1 / this._ssaoPostProcess.width, 1 / this._ssaoPostProcess.height), s.setFloat("radius", this.radius), s.setFloat("maxZ", this.maxZ), s.setFloat("minZAspect", this.minZAspect), s.setFloat("base", this.base), s.setFloat("near", this._scene.activeCamera.minZ), this._scene.activeCamera.mode === y.PERSPECTIVE_CAMERA)
+          s.setMatrix3x3("depthProjection", o.PERSPECTIVE_DEPTH_PROJECTION), s.setFloat("xViewport", Math.tan(this._scene.activeCamera.fov / 2) * this._scene.getEngine().getAspectRatio(this._scene.activeCamera, !0)), s.setFloat("yViewport", Math.tan(this._scene.activeCamera.fov / 2));
+        else {
+          const c = this._scene.getEngine().getRenderWidth() / 2, f = this._scene.getEngine().getRenderHeight() / 2, g = (l = this._scene.activeCamera.orthoLeft) !== null && l !== void 0 ? l : -c, x = (p = this._scene.activeCamera.orthoRight) !== null && p !== void 0 ? p : c, R = (h = this._scene.activeCamera.orthoBottom) !== null && h !== void 0 ? h : -f, E = (u = this._scene.activeCamera.orthoTop) !== null && u !== void 0 ? u : f;
+          s.setMatrix3x3("depthProjection", o.ORTHO_DEPTH_PROJECTION), s.setFloat("xViewport", (x - g) * 0.5), s.setFloat("yViewport", (E - R) * 0.5);
+        }
+        s.setMatrix("projection", this._scene.getProjectionMatrix()), this._geometryBufferRenderer ? (s.setTexture("depthSampler", this._geometryBufferRenderer.getGBuffer().textures[0]), s.setTexture("normalSampler", this._geometryBufferRenderer.getGBuffer().textures[1])) : this._prePassRenderer && (s.setTexture("depthSampler", this._prePassRenderer.getRenderTarget().textures[this._prePassRenderer.getIndex(5)]), s.setTexture("normalSampler", this._prePassRenderer.getRenderTarget().textures[this._prePassRenderer.getIndex(6)])), s.setTexture("randomSampler", this._randomTexture);
+      }
+    }, this._ssaoPostProcess.samples = this.textureSamples, this._forceGeometryBuffer || (this._ssaoPostProcess._prePassEffectConfiguration = new F());
+  }
+  _createSSAOCombinePostProcess(e, t) {
+    this._ssaoCombinePostProcess = new d("ssaoCombine", "ssaoCombine", [], ["originalColor", "viewport"], e, null, _.BILINEAR_SAMPLINGMODE, this._scene.getEngine(), !1, void 0, t), this._ssaoCombinePostProcess.onApply = (r) => {
+      const i = this._scene.activeCamera.viewport;
+      r.setVector4("viewport", B.Vector4[0].copyFromFloats(i.x, i.y, i.width, i.height)), r.setTextureFromPostProcessOutput("originalColor", this._originalColorPostProcess);
+    }, this._ssaoCombinePostProcess.samples = this.textureSamples;
+  }
+  _createRandomTexture() {
+    this._randomTexture = new C("SSAORandomTexture", 128, this._scene, !1, _.BILINEAR_SAMPLINGMODE), this._randomTexture.wrapU = _.WRAP_ADDRESSMODE, this._randomTexture.wrapV = _.WRAP_ADDRESSMODE;
+    const t = this._randomTexture.getContext(), r = (s, l) => Math.random() * (l - s) + s, i = S.Zero();
+    for (let s = 0; s < 128; s++)
+      for (let l = 0; l < 128; l++)
+        i.x = r(0, 1), i.y = r(0, 1), i.z = 0, i.normalize(), i.scaleInPlace(255), i.x = Math.floor(i.x), i.y = Math.floor(i.y), t.fillStyle = "rgb(" + i.x + ", " + i.y + ", " + i.z + ")", t.fillRect(s, l, 1, 1);
+    this._randomTexture.update(!1);
+  }
+  /**
+   * Serialize the rendering pipeline (Used when exporting)
+   * @returns the serialized object
+   */
+  serialize() {
+    const e = P.Serialize(this);
+    return e.customType = "SSAO2RenderingPipeline", e;
+  }
+  /**
+   * Parse the serialized pipeline
+   * @param source Source pipeline.
+   * @param scene The scene to load the pipeline to.
+   * @param rootUrl The URL of the serialized pipeline.
+   * @returns An instantiated pipeline from the serialized object.
+   */
+  static Parse(e, t, r) {
+    return P.Parse(() => new o(e._name, t, e._ratio, void 0, e._forceGeometryBuffer, e._textureType), e, t, r);
+  }
+}
+o.ORTHO_DEPTH_PROJECTION = [1, 0, 0, 0, 1, 0, 0, 0, 1];
+o.PERSPECTIVE_DEPTH_PROJECTION = [0, 0, 0, 0, 0, 0, 1, 1, 1];
+a([
+  n()
+], o.prototype, "totalStrength", void 0);
+a([
+  n()
+], o.prototype, "maxZ", void 0);
+a([
+  n()
+], o.prototype, "minZAspect", void 0);
+a([
+  n("epsilon")
+], o.prototype, "_epsilon", void 0);
+a([
+  n("samples")
+], o.prototype, "_samples", void 0);
+a([
+  n("textureSamples")
+], o.prototype, "_textureSamples", void 0);
+a([
+  n()
+], o.prototype, "_forceGeometryBuffer", void 0);
+a([
+  n()
+], o.prototype, "_ratio", void 0);
+a([
+  n()
+], o.prototype, "_textureType", void 0);
+a([
+  n()
+], o.prototype, "radius", void 0);
+a([
+  n()
+], o.prototype, "base", void 0);
+a([
+  n("bypassBlur")
+], o.prototype, "_bypassBlur", void 0);
+a([
+  n("expensiveBlur")
+], o.prototype, "_expensiveBlur", void 0);
+a([
+  n()
+], o.prototype, "bilateralSamples", void 0);
+a([
+  n()
+], o.prototype, "bilateralSoften", void 0);
+a([
+  n()
+], o.prototype, "bilateralTolerance", void 0);
+v("BABYLON.SSAO2RenderingPipeline", o);
+export {
+  o as SSAO2RenderingPipeline
+};