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

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

@@ -0,0 +1,512 @@
+import { __decorate as n } from "../../../tslib.es6.esm.js";
+import { serialize as a, serializeAsTexture as F, SerializationHelper as E } from "../../../Misc/decorators.esm.js";
+import { Logger as D } from "../../../Misc/logger.esm.js";
+import { Vector2 as _, Matrix as S, Vector3 as L, Vector4 as b } from "../../../Maths/math.vector.esm.js";
+import { Scalar as x } from "../../../Maths/math.scalar.esm.js";
+import { Texture as P } from "../../../Materials/Textures/texture.esm.js";
+import { PostProcess as d } from "../../postProcess.esm.js";
+import { PostProcessRenderPipeline as B } from "../postProcessRenderPipeline.esm.js";
+import { PostProcessRenderEffect as u } from "../postProcessRenderEffect.esm.js";
+import { BlurPostProcess as R } from "../../blurPostProcess.esm.js";
+import { FxaaPostProcess as A } from "../../fxaaPostProcess.esm.js";
+import { RegisterClass as w } from "../../../Misc/typeStore.esm.js";
+import { MotionBlurPostProcess as M } from "../../motionBlurPostProcess.esm.js";
+import { ScreenSpaceReflectionPostProcess as O } from "../../screenSpaceReflectionPostProcess.esm.js";
+import "../postProcessRenderPipelineManagerSceneComponent.esm.js";
+import "../../../Shaders/standard.fragment.esm.js";
+class o extends B {
+  /**
+   * Gets the overall exposure used by the pipeline
+   */
+  get exposure() {
+    return this._fixedExposure;
+  }
+  /**
+   * Sets the overall exposure used by the pipeline
+   */
+  set exposure(e) {
+    this._fixedExposure = e, this._currentExposure = e;
+  }
+  /**
+   * Gets whether or not the exposure of the overall pipeline should be automatically adjusted by the HDR post-process
+   */
+  get hdrAutoExposure() {
+    return this._hdrAutoExposure;
+  }
+  /**
+   * Sets whether or not the exposure of the overall pipeline should be automatically adjusted by the HDR post-process
+   */
+  set hdrAutoExposure(e) {
+    if (this._hdrAutoExposure = e, this.hdrPostProcess) {
+      const t = ["#define HDR"];
+      e && t.push("#define AUTO_EXPOSURE"), this.hdrPostProcess.updateEffect(t.join(`
+`));
+    }
+  }
+  /**
+   * Gets how much the image is blurred by the movement while using the motion blur post-process
+   */
+  get motionStrength() {
+    return this._motionStrength;
+  }
+  /**
+   * Sets how much the image is blurred by the movement while using the motion blur post-process
+   */
+  set motionStrength(e) {
+    this._motionStrength = e, this._isObjectBasedMotionBlur && this.motionBlurPostProcess && (this.motionBlurPostProcess.motionStrength = e);
+  }
+  /**
+   * Gets whether or not the motion blur post-process is object based or screen based.
+   */
+  get objectBasedMotionBlur() {
+    return this._isObjectBasedMotionBlur;
+  }
+  /**
+   * Sets whether or not the motion blur post-process should be object based or screen based
+   */
+  set objectBasedMotionBlur(e) {
+    const t = this._isObjectBasedMotionBlur !== e;
+    this._isObjectBasedMotionBlur = e, t && this._buildPipeline();
+  }
+  /**
+   * @ignore
+   * Specifies if the bloom pipeline is enabled
+   */
+  get BloomEnabled() {
+    return this._bloomEnabled;
+  }
+  set BloomEnabled(e) {
+    this._bloomEnabled !== e && (this._bloomEnabled = e, this._buildPipeline());
+  }
+  /**
+   * @ignore
+   * Specifies if the depth of field pipeline is enabled
+   */
+  get DepthOfFieldEnabled() {
+    return this._depthOfFieldEnabled;
+  }
+  set DepthOfFieldEnabled(e) {
+    this._depthOfFieldEnabled !== e && (this._depthOfFieldEnabled = e, this._buildPipeline());
+  }
+  /**
+   * @ignore
+   * Specifies if the lens flare pipeline is enabled
+   */
+  get LensFlareEnabled() {
+    return this._lensFlareEnabled;
+  }
+  set LensFlareEnabled(e) {
+    this._lensFlareEnabled !== e && (this._lensFlareEnabled = e, this._buildPipeline());
+  }
+  /**
+   * @ignore
+   * Specifies if the HDR pipeline is enabled
+   */
+  get HDREnabled() {
+    return this._hdrEnabled;
+  }
+  set HDREnabled(e) {
+    this._hdrEnabled !== e && (this._hdrEnabled = e, this._buildPipeline());
+  }
+  /**
+   * @ignore
+   * Specifies if the volumetric lights scattering effect is enabled
+   */
+  get VLSEnabled() {
+    return this._vlsEnabled;
+  }
+  // eslint-disable-next-line @typescript-eslint/naming-convention
+  set VLSEnabled(e) {
+    if (this._vlsEnabled !== e) {
+      if (e && !this._scene.enableGeometryBufferRenderer()) {
+        D.Warn("Geometry renderer is not supported, cannot create volumetric lights in Standard Rendering Pipeline");
+        return;
+      }
+      this._vlsEnabled = e, this._buildPipeline();
+    }
+  }
+  /**
+   * @ignore
+   * Specifies if the motion blur effect is enabled
+   */
+  get MotionBlurEnabled() {
+    return this._motionBlurEnabled;
+  }
+  set MotionBlurEnabled(e) {
+    this._motionBlurEnabled !== e && (this._motionBlurEnabled = e, this._buildPipeline());
+  }
+  /**
+   * Specifies if anti-aliasing is enabled
+   */
+  get fxaaEnabled() {
+    return this._fxaaEnabled;
+  }
+  set fxaaEnabled(e) {
+    this._fxaaEnabled !== e && (this._fxaaEnabled = e, this._buildPipeline());
+  }
+  /**
+   * Specifies if screen space reflections are enabled.
+   */
+  get screenSpaceReflectionsEnabled() {
+    return this._screenSpaceReflectionsEnabled;
+  }
+  set screenSpaceReflectionsEnabled(e) {
+    this._screenSpaceReflectionsEnabled !== e && (this._screenSpaceReflectionsEnabled = e, this._buildPipeline());
+  }
+  /**
+   * Specifies the number of steps used to calculate the volumetric lights
+   * Typically in interval [50, 200]
+   */
+  get volumetricLightStepsCount() {
+    return this._volumetricLightStepsCount;
+  }
+  set volumetricLightStepsCount(e) {
+    this.volumetricLightPostProcess && this.volumetricLightPostProcess.updateEffect(`#define VLS
+#define NB_STEPS ` + e.toFixed(1)), this._volumetricLightStepsCount = e;
+  }
+  /**
+   * Specifies the number of samples used for the motion blur effect
+   * Typically in interval [16, 64]
+   */
+  get motionBlurSamples() {
+    return this._motionBlurSamples;
+  }
+  set motionBlurSamples(e) {
+    this.motionBlurPostProcess && (this._isObjectBasedMotionBlur ? this.motionBlurPostProcess.motionBlurSamples = e : this.motionBlurPostProcess.updateEffect(`#define MOTION_BLUR
+#define MAX_MOTION_SAMPLES ` + e.toFixed(1))), this._motionBlurSamples = e;
+  }
+  /**
+   * Specifies MSAA sample count, setting this to 4 will provide 4x anti aliasing. (default: 1)
+   */
+  get samples() {
+    return this._samples;
+  }
+  set samples(e) {
+    this._samples !== e && (this._samples = e, this._buildPipeline());
+  }
+  /**
+   * Default pipeline should be used going forward but the standard pipeline will be kept for backwards compatibility.
+   * @constructor
+   * @param name The rendering pipeline name
+   * @param scene The scene linked to this pipeline
+   * @param ratio The size of the postprocesses (0.5 means that your postprocess will have a width = canvas.width 0.5 and a height = canvas.height 0.5)
+   * @param originalPostProcess the custom original color post-process. Must be "reusable". Can be null.
+   * @param cameras The array of cameras that the rendering pipeline will be attached to
+   */
+  constructor(e, t, s, r = null, l) {
+    super(t.getEngine(), e), this.downSampleX4PostProcess = null, this.brightPassPostProcess = null, this.blurHPostProcesses = [], this.blurVPostProcesses = [], this.textureAdderPostProcess = null, this.volumetricLightPostProcess = null, this.volumetricLightSmoothXPostProcess = null, this.volumetricLightSmoothYPostProcess = null, this.volumetricLightMergePostProces = null, this.volumetricLightFinalPostProcess = null, this.luminancePostProcess = null, this.luminanceDownSamplePostProcesses = [], this.hdrPostProcess = null, this.textureAdderFinalPostProcess = null, this.lensFlareFinalPostProcess = null, this.hdrFinalPostProcess = null, this.lensFlarePostProcess = null, this.lensFlareComposePostProcess = null, this.motionBlurPostProcess = null, this.depthOfFieldPostProcess = null, this.fxaaPostProcess = null, this.screenSpaceReflectionPostProcess = null, this.brightThreshold = 1, this.blurWidth = 512, this.horizontalBlur = !1, this.lensTexture = null, this.volumetricLightCoefficient = 0.2, this.volumetricLightPower = 4, this.volumetricLightBlurScale = 64, this.sourceLight = null, this.hdrMinimumLuminance = 1, this.hdrDecreaseRate = 0.5, this.hdrIncreaseRate = 0.5, this.lensColorTexture = null, this.lensFlareStrength = 20, this.lensFlareGhostDispersal = 1.4, this.lensFlareHaloWidth = 0.7, this.lensFlareDistortionStrength = 16, this.lensFlareBlurWidth = 512, this.lensStarTexture = null, this.lensFlareDirtTexture = null, this.depthOfFieldDistance = 10, this.depthOfFieldBlurWidth = 64, this.animations = [], this._currentDepthOfFieldSource = null, this._fixedExposure = 1, this._currentExposure = 1, this._hdrAutoExposure = !1, this._hdrCurrentLuminance = 1, this._motionStrength = 1, this._isObjectBasedMotionBlur = !1, this._camerasToBeAttached = [], this._bloomEnabled = !1, this._depthOfFieldEnabled = !1, this._vlsEnabled = !1, this._lensFlareEnabled = !1, this._hdrEnabled = !1, this._motionBlurEnabled = !1, this._fxaaEnabled = !1, this._screenSpaceReflectionsEnabled = !1, this._motionBlurSamples = 64, this._volumetricLightStepsCount = 50, this._samples = 1, this._cameras = l || t.cameras, this._cameras = this._cameras.slice(), this._camerasToBeAttached = this._cameras.slice(), this._scene = t, this._basePostProcess = r, this._ratio = s, this._floatTextureType = t.getEngine().getCaps().textureFloatRender ? 1 : 2, t.postProcessRenderPipelineManager.addPipeline(this), this._buildPipeline();
+  }
+  _buildPipeline() {
+    const e = this._ratio, t = this._scene;
+    this._disposePostProcesses(), this._cameras !== null && (this._scene.postProcessRenderPipelineManager.detachCamerasFromRenderPipeline(this._name, this._cameras), this._cameras = this._camerasToBeAttached.slice()), this._reset(), this._screenSpaceReflectionsEnabled && (this.screenSpaceReflectionPostProcess = new O("HDRPass", t, e, null, P.BILINEAR_SAMPLINGMODE, t.getEngine(), !1, this._floatTextureType), this.screenSpaceReflectionPostProcess.onApplyObservable.add(() => {
+      this._currentDepthOfFieldSource = this.screenSpaceReflectionPostProcess;
+    }), this.addEffect(new u(t.getEngine(), "HDRScreenSpaceReflections", () => this.screenSpaceReflectionPostProcess, !0))), this._basePostProcess ? this.originalPostProcess = this._basePostProcess : this.originalPostProcess = new d("HDRPass", "standard", [], [], e, null, P.BILINEAR_SAMPLINGMODE, t.getEngine(), !1, "#define PASS_POST_PROCESS", this._floatTextureType), this.originalPostProcess.autoClear = !this.screenSpaceReflectionPostProcess, this.originalPostProcess.onApplyObservable.add(() => {
+      this._currentDepthOfFieldSource = this.originalPostProcess;
+    }), this.addEffect(new u(t.getEngine(), "HDRPassPostProcess", () => this.originalPostProcess, !0)), this._bloomEnabled && (this._createDownSampleX4PostProcess(t, e / 4), this._createBrightPassPostProcess(t, e / 4), this._createBlurPostProcesses(t, e / 4, 1), this._createTextureAdderPostProcess(t, e), this.textureAdderFinalPostProcess = new d("HDRDepthOfFieldSource", "standard", [], [], e, null, P.BILINEAR_SAMPLINGMODE, t.getEngine(), !1, "#define PASS_POST_PROCESS", 0), this.addEffect(new u(t.getEngine(), "HDRBaseDepthOfFieldSource", () => this.textureAdderFinalPostProcess, !0))), this._vlsEnabled && (this._createVolumetricLightPostProcess(t, e), this.volumetricLightFinalPostProcess = new d("HDRVLSFinal", "standard", [], [], e, null, P.BILINEAR_SAMPLINGMODE, t.getEngine(), !1, "#define PASS_POST_PROCESS", 0), this.addEffect(new u(t.getEngine(), "HDRVLSFinal", () => this.volumetricLightFinalPostProcess, !0))), this._lensFlareEnabled && (this._createLensFlarePostProcess(t, e), this.lensFlareFinalPostProcess = new d("HDRPostLensFlareDepthOfFieldSource", "standard", [], [], e, null, P.BILINEAR_SAMPLINGMODE, t.getEngine(), !1, "#define PASS_POST_PROCESS", 0), this.addEffect(new u(t.getEngine(), "HDRPostLensFlareDepthOfFieldSource", () => this.lensFlareFinalPostProcess, !0))), this._hdrEnabled && (this._createLuminancePostProcesses(t, this._floatTextureType), this._createHdrPostProcess(t, e), this.hdrFinalPostProcess = new d("HDRPostHDReDepthOfFieldSource", "standard", [], [], e, null, P.BILINEAR_SAMPLINGMODE, t.getEngine(), !1, "#define PASS_POST_PROCESS", 0), this.addEffect(new u(t.getEngine(), "HDRPostHDReDepthOfFieldSource", () => this.hdrFinalPostProcess, !0))), this._depthOfFieldEnabled && (this._createBlurPostProcesses(t, e / 2, 3, "depthOfFieldBlurWidth"), this._createDepthOfFieldPostProcess(t, e)), this._motionBlurEnabled && this._createMotionBlurPostProcess(t, e), this._fxaaEnabled && (this.fxaaPostProcess = new A("fxaa", 1, null, P.BILINEAR_SAMPLINGMODE, t.getEngine(), !1, 0), this.addEffect(new u(t.getEngine(), "HDRFxaa", () => this.fxaaPostProcess, !0))), this._cameras !== null && this._scene.postProcessRenderPipelineManager.attachCamerasToRenderPipeline(this._name, this._cameras), !this._enableMSAAOnFirstPostProcess(this._samples) && this._samples > 1 && D.Warn("MSAA failed to enable, MSAA is only supported in browsers that support webGL >= 2.0");
+  }
+  // Down Sample X4 Post-Process
+  _createDownSampleX4PostProcess(e, t) {
+    const s = new Array(32);
+    this.downSampleX4PostProcess = new d("HDRDownSampleX4", "standard", ["dsOffsets"], [], t, null, P.BILINEAR_SAMPLINGMODE, e.getEngine(), !1, "#define DOWN_SAMPLE_X4", this._floatTextureType), this.downSampleX4PostProcess.onApply = (r) => {
+      let l = 0;
+      const i = this.downSampleX4PostProcess.width, c = this.downSampleX4PostProcess.height;
+      for (let h = -2; h < 2; h++)
+        for (let p = -2; p < 2; p++)
+          s[l] = (h + 0.5) * (1 / i), s[l + 1] = (p + 0.5) * (1 / c), l += 2;
+      r.setArray2("dsOffsets", s);
+    }, this.addEffect(new u(e.getEngine(), "HDRDownSampleX4", () => this.downSampleX4PostProcess, !0));
+  }
+  // Brightpass Post-Process
+  _createBrightPassPostProcess(e, t) {
+    const s = new Array(8);
+    this.brightPassPostProcess = new d("HDRBrightPass", "standard", ["dsOffsets", "brightThreshold"], [], t, null, P.BILINEAR_SAMPLINGMODE, e.getEngine(), !1, "#define BRIGHT_PASS", this._floatTextureType), this.brightPassPostProcess.onApply = (r) => {
+      const l = 1 / this.brightPassPostProcess.width, i = 1 / this.brightPassPostProcess.height;
+      s[0] = -0.5 * l, s[1] = 0.5 * i, s[2] = 0.5 * l, s[3] = 0.5 * i, s[4] = -0.5 * l, s[5] = -0.5 * i, s[6] = 0.5 * l, s[7] = -0.5 * i, r.setArray2("dsOffsets", s), r.setFloat("brightThreshold", this.brightThreshold);
+    }, this.addEffect(new u(e.getEngine(), "HDRBrightPass", () => this.brightPassPostProcess, !0));
+  }
+  // Create blur H&V post-processes
+  _createBlurPostProcesses(e, t, s, r = "blurWidth") {
+    const l = e.getEngine(), i = new R("HDRBlurH_" + s, new _(1, 0), this[r], t, null, P.BILINEAR_SAMPLINGMODE, e.getEngine(), !1, this._floatTextureType), c = new R("HDRBlurV_" + s, new _(0, 1), this[r], t, null, P.BILINEAR_SAMPLINGMODE, e.getEngine(), !1, this._floatTextureType);
+    i.onActivateObservable.add(() => {
+      const h = i.width / l.getRenderWidth();
+      i.kernel = this[r] * h;
+    }), c.onActivateObservable.add(() => {
+      const h = c.height / l.getRenderHeight();
+      c.kernel = this.horizontalBlur ? 64 * h : this[r] * h;
+    }), this.addEffect(new u(e.getEngine(), "HDRBlurH" + s, () => i, !0)), this.addEffect(new u(e.getEngine(), "HDRBlurV" + s, () => c, !0)), this.blurHPostProcesses.push(i), this.blurVPostProcesses.push(c);
+  }
+  // Create texture adder post-process
+  _createTextureAdderPostProcess(e, t) {
+    this.textureAdderPostProcess = new d("HDRTextureAdder", "standard", ["exposure"], ["otherSampler", "lensSampler"], t, null, P.BILINEAR_SAMPLINGMODE, e.getEngine(), !1, "#define TEXTURE_ADDER", this._floatTextureType), this.textureAdderPostProcess.onApply = (s) => {
+      s.setTextureFromPostProcess("otherSampler", this._vlsEnabled ? this._currentDepthOfFieldSource : this.originalPostProcess), s.setTexture("lensSampler", this.lensTexture), s.setFloat("exposure", this._currentExposure), this._currentDepthOfFieldSource = this.textureAdderFinalPostProcess;
+    }, this.addEffect(new u(e.getEngine(), "HDRTextureAdder", () => this.textureAdderPostProcess, !0));
+  }
+  _createVolumetricLightPostProcess(e, t) {
+    const s = e.enableGeometryBufferRenderer();
+    s.enablePosition = !0;
+    const r = s.getGBuffer();
+    this.volumetricLightPostProcess = new d("HDRVLS", "standard", ["shadowViewProjection", "cameraPosition", "sunDirection", "sunColor", "scatteringCoefficient", "scatteringPower", "depthValues"], ["shadowMapSampler", "positionSampler"], t / 8, null, P.BILINEAR_SAMPLINGMODE, e.getEngine(), !1, `#define VLS
+#define NB_STEPS ` + this._volumetricLightStepsCount.toFixed(1));
+    const l = _.Zero();
+    this.volumetricLightPostProcess.onApply = (i) => {
+      if (this.sourceLight && this.sourceLight.getShadowGenerator() && this._scene.activeCamera) {
+        const c = this.sourceLight.getShadowGenerator();
+        i.setTexture("shadowMapSampler", c.getShadowMap()), i.setTexture("positionSampler", r.textures[2]), i.setColor3("sunColor", this.sourceLight.diffuse), i.setVector3("sunDirection", this.sourceLight.getShadowDirection()), i.setVector3("cameraPosition", this._scene.activeCamera.globalPosition), i.setMatrix("shadowViewProjection", c.getTransformMatrix()), i.setFloat("scatteringCoefficient", this.volumetricLightCoefficient), i.setFloat("scatteringPower", this.volumetricLightPower), l.x = this.sourceLight.getDepthMinZ(this._scene.activeCamera), l.y = this.sourceLight.getDepthMaxZ(this._scene.activeCamera), i.setVector2("depthValues", l);
+      }
+    }, this.addEffect(new u(e.getEngine(), "HDRVLS", () => this.volumetricLightPostProcess, !0)), this._createBlurPostProcesses(e, t / 4, 0, "volumetricLightBlurScale"), this.volumetricLightMergePostProces = new d("HDRVLSMerge", "standard", [], ["originalSampler"], t, null, P.BILINEAR_SAMPLINGMODE, e.getEngine(), !1, "#define VLSMERGE"), this.volumetricLightMergePostProces.onApply = (i) => {
+      i.setTextureFromPostProcess("originalSampler", this._bloomEnabled ? this.textureAdderFinalPostProcess : this.originalPostProcess), this._currentDepthOfFieldSource = this.volumetricLightFinalPostProcess;
+    }, this.addEffect(new u(e.getEngine(), "HDRVLSMerge", () => this.volumetricLightMergePostProces, !0));
+  }
+  // Create luminance
+  _createLuminancePostProcesses(e, t) {
+    let s = Math.pow(3, o.LuminanceSteps);
+    this.luminancePostProcess = new d("HDRLuminance", "standard", ["lumOffsets"], [], { width: s, height: s }, null, P.BILINEAR_SAMPLINGMODE, e.getEngine(), !1, "#define LUMINANCE", t);
+    const r = [];
+    this.luminancePostProcess.onApply = (i) => {
+      const c = 1 / this.luminancePostProcess.width, h = 1 / this.luminancePostProcess.height;
+      r[0] = -0.5 * c, r[1] = 0.5 * h, r[2] = 0.5 * c, r[3] = 0.5 * h, r[4] = -0.5 * c, r[5] = -0.5 * h, r[6] = 0.5 * c, r[7] = -0.5 * h, i.setArray2("lumOffsets", r);
+    }, this.addEffect(new u(e.getEngine(), "HDRLuminance", () => this.luminancePostProcess, !0));
+    for (let i = o.LuminanceSteps - 1; i >= 0; i--) {
+      s = Math.pow(3, i);
+      let c = `#define LUMINANCE_DOWN_SAMPLE
+`;
+      i === 0 && (c += "#define FINAL_DOWN_SAMPLER");
+      const h = new d("HDRLuminanceDownSample" + i, "standard", ["dsOffsets", "halfDestPixelSize"], [], { width: s, height: s }, null, P.BILINEAR_SAMPLINGMODE, e.getEngine(), !1, c, t);
+      this.luminanceDownSamplePostProcesses.push(h);
+    }
+    let l = this.luminancePostProcess;
+    this.luminanceDownSamplePostProcesses.forEach((i, c) => {
+      const h = new Array(18);
+      i.onApply = (p) => {
+        if (!l)
+          return;
+        let m = 0;
+        for (let f = -1; f < 2; f++)
+          for (let g = -1; g < 2; g++)
+            h[m] = f / l.width, h[m + 1] = g / l.height, m += 2;
+        p.setArray2("dsOffsets", h), p.setFloat("halfDestPixelSize", 0.5 / l.width), c === this.luminanceDownSamplePostProcesses.length - 1 ? l = this.luminancePostProcess : l = i;
+      }, c === this.luminanceDownSamplePostProcesses.length - 1 && (i.onAfterRender = () => {
+        const p = e.getEngine().readPixels(0, 0, 1, 1), m = new b(1 / (255 * 255 * 255), 1 / (255 * 255), 1 / 255, 1);
+        p.then((f) => {
+          const g = new Uint8Array(f.buffer);
+          this._hdrCurrentLuminance = (g[0] * m.x + g[1] * m.y + g[2] * m.z + g[3] * m.w) / 100;
+        });
+      }), this.addEffect(new u(e.getEngine(), "HDRLuminanceDownSample" + c, () => i, !0));
+    });
+  }
+  // Create HDR post-process
+  _createHdrPostProcess(e, t) {
+    const s = ["#define HDR"];
+    this._hdrAutoExposure && s.push("#define AUTO_EXPOSURE"), this.hdrPostProcess = new d("HDR", "standard", ["averageLuminance"], ["textureAdderSampler"], t, null, P.BILINEAR_SAMPLINGMODE, e.getEngine(), !1, s.join(`
+`), 0);
+    let r = 1, l = 0, i = 0;
+    this.hdrPostProcess.onApply = (c) => {
+      if (c.setTextureFromPostProcess("textureAdderSampler", this._currentDepthOfFieldSource), l += e.getEngine().getDeltaTime(), r < 0)
+        r = this._hdrCurrentLuminance;
+      else {
+        const h = (i - l) / 1e3;
+        this._hdrCurrentLuminance < r + this.hdrDecreaseRate * h ? r += this.hdrDecreaseRate * h : this._hdrCurrentLuminance > r - this.hdrIncreaseRate * h ? r -= this.hdrIncreaseRate * h : r = this._hdrCurrentLuminance;
+      }
+      this.hdrAutoExposure ? this._currentExposure = this._fixedExposure / r : (r = x.Clamp(r, this.hdrMinimumLuminance, 1e20), c.setFloat("averageLuminance", r)), i = l, this._currentDepthOfFieldSource = this.hdrFinalPostProcess;
+    }, this.addEffect(new u(e.getEngine(), "HDR", () => this.hdrPostProcess, !0));
+  }
+  // Create lens flare post-process
+  _createLensFlarePostProcess(e, t) {
+    this.lensFlarePostProcess = new d("HDRLensFlare", "standard", ["strength", "ghostDispersal", "haloWidth", "resolution", "distortionStrength"], ["lensColorSampler"], t / 2, null, P.BILINEAR_SAMPLINGMODE, e.getEngine(), !1, "#define LENS_FLARE", 0), this.addEffect(new u(e.getEngine(), "HDRLensFlare", () => this.lensFlarePostProcess, !0)), this._createBlurPostProcesses(e, t / 4, 2, "lensFlareBlurWidth"), this.lensFlareComposePostProcess = new d("HDRLensFlareCompose", "standard", ["lensStarMatrix"], ["otherSampler", "lensDirtSampler", "lensStarSampler"], t, null, P.BILINEAR_SAMPLINGMODE, e.getEngine(), !1, "#define LENS_FLARE_COMPOSE", 0), this.addEffect(new u(e.getEngine(), "HDRLensFlareCompose", () => this.lensFlareComposePostProcess, !0));
+    const s = new _(0, 0);
+    this.lensFlarePostProcess.externalTextureSamplerBinding = !0, this.lensFlarePostProcess.onApply = (i) => {
+      i.setTextureFromPostProcess("textureSampler", this._bloomEnabled ? this.blurHPostProcesses[0] : this.originalPostProcess), i.setTexture("lensColorSampler", this.lensColorTexture), i.setFloat("strength", this.lensFlareStrength), i.setFloat("ghostDispersal", this.lensFlareGhostDispersal), i.setFloat("haloWidth", this.lensFlareHaloWidth), s.x = this.lensFlarePostProcess.width, s.y = this.lensFlarePostProcess.height, i.setVector2("resolution", s), i.setFloat("distortionStrength", this.lensFlareDistortionStrength);
+    };
+    const r = S.FromValues(2, 0, -1, 0, 0, 2, -1, 0, 0, 0, 1, 0, 0, 0, 0, 1), l = S.FromValues(0.5, 0, 0.5, 0, 0, 0.5, 0.5, 0, 0, 0, 1, 0, 0, 0, 0, 1);
+    this.lensFlareComposePostProcess.onApply = (i) => {
+      if (!this._scene.activeCamera)
+        return;
+      i.setTextureFromPostProcess("otherSampler", this.lensFlarePostProcess), i.setTexture("lensDirtSampler", this.lensFlareDirtTexture), i.setTexture("lensStarSampler", this.lensStarTexture);
+      const c = this._scene.activeCamera.getViewMatrix().getRow(0), h = this._scene.activeCamera.getViewMatrix().getRow(2);
+      let p = L.Dot(c.toVector3(), new L(1, 0, 0)) + L.Dot(h.toVector3(), new L(0, 0, 1));
+      p *= 4;
+      const m = S.FromValues(Math.cos(p) * 0.5, -Math.sin(p), 0, 0, Math.sin(p), Math.cos(p) * 0.5, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1), f = l.multiply(m).multiply(r);
+      i.setMatrix("lensStarMatrix", f), this._currentDepthOfFieldSource = this.lensFlareFinalPostProcess;
+    };
+  }
+  // Create depth-of-field post-process
+  _createDepthOfFieldPostProcess(e, t) {
+    this.depthOfFieldPostProcess = new d("HDRDepthOfField", "standard", ["distance"], ["otherSampler", "depthSampler"], t, null, P.BILINEAR_SAMPLINGMODE, e.getEngine(), !1, "#define DEPTH_OF_FIELD", 0), this.depthOfFieldPostProcess.onApply = (s) => {
+      s.setTextureFromPostProcess("otherSampler", this._currentDepthOfFieldSource), s.setTexture("depthSampler", this._getDepthTexture()), s.setFloat("distance", this.depthOfFieldDistance);
+    }, this.addEffect(new u(e.getEngine(), "HDRDepthOfField", () => this.depthOfFieldPostProcess, !0));
+  }
+  // Create motion blur post-process
+  _createMotionBlurPostProcess(e, t) {
+    if (this._isObjectBasedMotionBlur) {
+      const s = new M("HDRMotionBlur", e, t, null, P.BILINEAR_SAMPLINGMODE, e.getEngine(), !1, 0);
+      s.motionStrength = this.motionStrength, s.motionBlurSamples = this.motionBlurSamples, this.motionBlurPostProcess = s;
+    } else {
+      this.motionBlurPostProcess = new d("HDRMotionBlur", "standard", ["inverseViewProjection", "prevViewProjection", "screenSize", "motionScale", "motionStrength"], ["depthSampler"], t, null, P.BILINEAR_SAMPLINGMODE, e.getEngine(), !1, `#define MOTION_BLUR
+#define MAX_MOTION_SAMPLES ` + this.motionBlurSamples.toFixed(1), 0);
+      let s = 0, r = S.Identity();
+      const l = S.Identity();
+      let i = S.Identity();
+      const c = _.Zero();
+      this.motionBlurPostProcess.onApply = (h) => {
+        i = e.getProjectionMatrix().multiply(e.getViewMatrix()), i.invertToRef(l), h.setMatrix("inverseViewProjection", l), h.setMatrix("prevViewProjection", r), r = i, c.x = this.motionBlurPostProcess.width, c.y = this.motionBlurPostProcess.height, h.setVector2("screenSize", c), s = e.getEngine().getFps() / 60, h.setFloat("motionScale", s), h.setFloat("motionStrength", this.motionStrength), h.setTexture("depthSampler", this._getDepthTexture());
+      };
+    }
+    this.addEffect(new u(e.getEngine(), "HDRMotionBlur", () => this.motionBlurPostProcess, !0));
+  }
+  _getDepthTexture() {
+    return this._scene.getEngine().getCaps().drawBuffersExtension ? this._scene.enableGeometryBufferRenderer().getGBuffer().textures[0] : this._scene.enableDepthRenderer().getDepthMap();
+  }
+  _disposePostProcesses() {
+    for (let e = 0; e < this._cameras.length; e++) {
+      const t = this._cameras[e];
+      this.originalPostProcess && this.originalPostProcess.dispose(t), this.screenSpaceReflectionPostProcess && this.screenSpaceReflectionPostProcess.dispose(t), this.downSampleX4PostProcess && this.downSampleX4PostProcess.dispose(t), this.brightPassPostProcess && this.brightPassPostProcess.dispose(t), this.textureAdderPostProcess && this.textureAdderPostProcess.dispose(t), this.volumetricLightPostProcess && this.volumetricLightPostProcess.dispose(t), this.volumetricLightSmoothXPostProcess && this.volumetricLightSmoothXPostProcess.dispose(t), this.volumetricLightSmoothYPostProcess && this.volumetricLightSmoothYPostProcess.dispose(t), this.volumetricLightMergePostProces && this.volumetricLightMergePostProces.dispose(t), this.volumetricLightFinalPostProcess && this.volumetricLightFinalPostProcess.dispose(t), this.lensFlarePostProcess && this.lensFlarePostProcess.dispose(t), this.lensFlareComposePostProcess && this.lensFlareComposePostProcess.dispose(t);
+      for (let s = 0; s < this.luminanceDownSamplePostProcesses.length; s++)
+        this.luminanceDownSamplePostProcesses[s].dispose(t);
+      this.luminancePostProcess && this.luminancePostProcess.dispose(t), this.hdrPostProcess && this.hdrPostProcess.dispose(t), this.hdrFinalPostProcess && this.hdrFinalPostProcess.dispose(t), this.depthOfFieldPostProcess && this.depthOfFieldPostProcess.dispose(t), this.motionBlurPostProcess && this.motionBlurPostProcess.dispose(t), this.fxaaPostProcess && this.fxaaPostProcess.dispose(t);
+      for (let s = 0; s < this.blurHPostProcesses.length; s++)
+        this.blurHPostProcesses[s].dispose(t);
+      for (let s = 0; s < this.blurVPostProcesses.length; s++)
+        this.blurVPostProcesses[s].dispose(t);
+    }
+    this.originalPostProcess = null, this.downSampleX4PostProcess = null, this.brightPassPostProcess = null, this.textureAdderPostProcess = null, this.textureAdderFinalPostProcess = null, this.volumetricLightPostProcess = null, this.volumetricLightSmoothXPostProcess = null, this.volumetricLightSmoothYPostProcess = null, this.volumetricLightMergePostProces = null, this.volumetricLightFinalPostProcess = null, this.lensFlarePostProcess = null, this.lensFlareComposePostProcess = null, this.luminancePostProcess = null, this.hdrPostProcess = null, this.hdrFinalPostProcess = null, this.depthOfFieldPostProcess = null, this.motionBlurPostProcess = null, this.fxaaPostProcess = null, this.screenSpaceReflectionPostProcess = null, this.luminanceDownSamplePostProcesses.length = 0, this.blurHPostProcesses.length = 0, this.blurVPostProcesses.length = 0;
+  }
+  /**
+   * Dispose of the pipeline and stop all post processes
+   */
+  dispose() {
+    this._disposePostProcesses(), this._scene.postProcessRenderPipelineManager.detachCamerasFromRenderPipeline(this._name, this._cameras), super.dispose();
+  }
+  /**
+   * Serialize the rendering pipeline (Used when exporting)
+   * @returns the serialized object
+   */
+  serialize() {
+    const e = E.Serialize(this);
+    return this.sourceLight && (e.sourceLightId = this.sourceLight.id), this.screenSpaceReflectionPostProcess && (e.screenSpaceReflectionPostProcess = E.Serialize(this.screenSpaceReflectionPostProcess)), e.customType = "StandardRenderingPipeline", 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) {
+    const r = E.Parse(() => new o(e._name, t, e._ratio), e, t, s);
+    return e.sourceLightId && (r.sourceLight = t.getLightById(e.sourceLightId)), e.screenSpaceReflectionPostProcess && E.Parse(() => r.screenSpaceReflectionPostProcess, e.screenSpaceReflectionPostProcess, t, s), r;
+  }
+}
+o.LuminanceSteps = 6;
+n([
+  a()
+], o.prototype, "brightThreshold", void 0);
+n([
+  a()
+], o.prototype, "blurWidth", void 0);
+n([
+  a()
+], o.prototype, "horizontalBlur", void 0);
+n([
+  a()
+], o.prototype, "exposure", null);
+n([
+  F("lensTexture")
+], o.prototype, "lensTexture", void 0);
+n([
+  a()
+], o.prototype, "volumetricLightCoefficient", void 0);
+n([
+  a()
+], o.prototype, "volumetricLightPower", void 0);
+n([
+  a()
+], o.prototype, "volumetricLightBlurScale", void 0);
+n([
+  a()
+], o.prototype, "hdrMinimumLuminance", void 0);
+n([
+  a()
+], o.prototype, "hdrDecreaseRate", void 0);
+n([
+  a()
+], o.prototype, "hdrIncreaseRate", void 0);
+n([
+  a()
+], o.prototype, "hdrAutoExposure", null);
+n([
+  F("lensColorTexture")
+], o.prototype, "lensColorTexture", void 0);
+n([
+  a()
+], o.prototype, "lensFlareStrength", void 0);
+n([
+  a()
+], o.prototype, "lensFlareGhostDispersal", void 0);
+n([
+  a()
+], o.prototype, "lensFlareHaloWidth", void 0);
+n([
+  a()
+], o.prototype, "lensFlareDistortionStrength", void 0);
+n([
+  a()
+], o.prototype, "lensFlareBlurWidth", void 0);
+n([
+  F("lensStarTexture")
+], o.prototype, "lensStarTexture", void 0);
+n([
+  F("lensFlareDirtTexture")
+], o.prototype, "lensFlareDirtTexture", void 0);
+n([
+  a()
+], o.prototype, "depthOfFieldDistance", void 0);
+n([
+  a()
+], o.prototype, "depthOfFieldBlurWidth", void 0);
+n([
+  a()
+], o.prototype, "motionStrength", null);
+n([
+  a()
+], o.prototype, "objectBasedMotionBlur", null);
+n([
+  a()
+], o.prototype, "_ratio", void 0);
+n([
+  a()
+], o.prototype, "BloomEnabled", null);
+n([
+  a()
+], o.prototype, "DepthOfFieldEnabled", null);
+n([
+  a()
+], o.prototype, "LensFlareEnabled", null);
+n([
+  a()
+], o.prototype, "HDREnabled", null);
+n([
+  a()
+  // eslint-disable-next-line @typescript-eslint/naming-convention
+], o.prototype, "VLSEnabled", null);
+n([
+  a()
+], o.prototype, "MotionBlurEnabled", null);
+n([
+  a()
+], o.prototype, "fxaaEnabled", null);
+n([
+  a()
+], o.prototype, "screenSpaceReflectionsEnabled", null);
+n([
+  a()
+], o.prototype, "volumetricLightStepsCount", null);
+n([
+  a()
+], o.prototype, "motionBlurSamples", null);
+n([
+  a()
+], o.prototype, "samples", null);
+w("BABYLON.StandardRenderingPipeline", o);
+export {
+  o as StandardRenderingPipeline
+};

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

@@ -0,0 +1,114 @@
+import { Tools as i } from "../../Misc/tools.esm.js";
+class m {
+  /**
+   * Instantiates a post process render effect.
+   * A post process can be used to apply a shader to a texture after it is rendered.
+   * @param engine The engine the effect is tied to
+   * @param name The name of the effect
+   * @param getPostProcesses A function that returns a set of post processes which the effect will run in order to be run.
+   * @param singleInstance False if this post process can be run on multiple cameras. (default: true)
+   */
+  constructor(o, s, e, a) {
+    this._name = s, this._singleInstance = a || !0, this._getPostProcesses = e, this._cameras = {}, this._indicesForCamera = {}, this._postProcesses = {};
+  }
+  /**
+   * Checks if all the post processes in the effect are supported.
+   */
+  get isSupported() {
+    for (const o in this._postProcesses)
+      if (Object.prototype.hasOwnProperty.call(this._postProcesses, o)) {
+        const s = this._postProcesses[o];
+        for (let e = 0; e < s.length; e++)
+          if (!s[e].isSupported)
+            return !1;
+      }
+    return !0;
+  }
+  /**
+   * Updates the current state of the effect
+   * @internal
+   */
+  _update() {
+  }
+  /**
+   * Attaches the effect on cameras
+   * @param cameras The camera to attach to.
+   * @internal
+   */
+  _attachCameras(o) {
+    let s;
+    const e = i.MakeArray(o || this._cameras);
+    if (e)
+      for (let a = 0; a < e.length; a++) {
+        const r = e[a];
+        if (!r)
+          continue;
+        const t = r.name;
+        if (this._singleInstance ? s = 0 : s = t, !this._postProcesses[s]) {
+          const c = this._getPostProcesses();
+          c && (this._postProcesses[s] = Array.isArray(c) ? c : [c]);
+        }
+        this._indicesForCamera[t] || (this._indicesForCamera[t] = []), this._postProcesses[s].forEach((c) => {
+          const n = r.attachPostProcess(c);
+          this._indicesForCamera[t].push(n);
+        }), this._cameras[t] || (this._cameras[t] = r);
+      }
+  }
+  /**
+   * Detaches the effect on cameras
+   * @param cameras The camera to detach from.
+   * @internal
+   */
+  _detachCameras(o) {
+    const s = i.MakeArray(o || this._cameras);
+    if (s)
+      for (let e = 0; e < s.length; e++) {
+        const a = s[e], r = a.name, t = this._postProcesses[this._singleInstance ? 0 : r];
+        t && t.forEach((c) => {
+          a.detachPostProcess(c);
+        }), this._cameras[r] && (this._cameras[r] = null);
+      }
+  }
+  /**
+   * Enables the effect on given cameras
+   * @param cameras The camera to enable.
+   * @internal
+   */
+  _enable(o) {
+    const s = i.MakeArray(o || this._cameras);
+    if (s)
+      for (let e = 0; e < s.length; e++) {
+        const a = s[e], r = a.name;
+        for (let t = 0; t < this._indicesForCamera[r].length; t++)
+          (a._postProcesses[this._indicesForCamera[r][t]] === void 0 || a._postProcesses[this._indicesForCamera[r][t]] === null) && this._postProcesses[this._singleInstance ? 0 : r].forEach((c) => {
+            s[e].attachPostProcess(c, this._indicesForCamera[r][t]);
+          });
+      }
+  }
+  /**
+   * Disables the effect on the given cameras
+   * @param cameras The camera to disable.
+   * @internal
+   */
+  _disable(o) {
+    const s = i.MakeArray(o || this._cameras);
+    if (s)
+      for (let e = 0; e < s.length; e++) {
+        const a = s[e], r = a.name;
+        this._postProcesses[this._singleInstance ? 0 : r].forEach((t) => {
+          a.detachPostProcess(t);
+        });
+      }
+  }
+  /**
+   * Gets a list of the post processes contained in the effect.
+   * @param camera The camera to get the post processes on.
+   * @returns The list of the post processes in the effect.
+   */
+  getPostProcesses(o) {
+    return this._singleInstance ? this._postProcesses[0] : o ? this._postProcesses[o.name] : null;
+  }
+}
+export {
+  m as PostProcessRenderEffect
+};