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

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

@@ -0,0 +1,457 @@
+import { __decorate as u } from "../tslib.es6.esm.js";
+import { SmartArray as C } from "../Misc/smartArray.esm.js";
+import { Observable as v } from "../Misc/observable.esm.js";
+import { Vector2 as O } from "../Maths/math.vector.esm.js";
+import "../Shaders/postprocess.vertex.esm.js";
+import { Engine as T } from "../Engines/engine.esm.js";
+import "../Engines/Extensions/engine.renderTarget.esm.js";
+import { serialize as p, serializeAsColor4 as S, SerializationHelper as w } from "../Misc/decorators.esm.js";
+import { GetClass as y, RegisterClass as P } from "../Misc/typeStore.esm.js";
+import { DrawWrapper as A } from "../Materials/drawWrapper.esm.js";
+import { ShaderLanguage as R } from "../Materials/shaderLanguage.esm.js";
+class r {
+  /**
+   * Registers a shader code processing with a post process name.
+   * @param postProcessName name of the post process. Use null for the fallback shader code processing. This is the shader code processing that will be used in case no specific shader code processing has been associated to a post process name
+   * @param customShaderCodeProcessing shader code processing to associate to the post process name
+   * @returns
+   */
+  static RegisterShaderCodeProcessing(e, t) {
+    if (!t) {
+      delete r._CustomShaderCodeProcessing[e ?? ""];
+      return;
+    }
+    r._CustomShaderCodeProcessing[e ?? ""] = t;
+  }
+  static _GetShaderCodeProcessing(e) {
+    var t;
+    return (t = r._CustomShaderCodeProcessing[e]) !== null && t !== void 0 ? t : r._CustomShaderCodeProcessing[""];
+  }
+  /**
+   * Number of sample textures (default: 1)
+   */
+  get samples() {
+    return this._samples;
+  }
+  set samples(e) {
+    this._samples = Math.min(e, this._engine.getCaps().maxMSAASamples), this._textures.forEach((t) => {
+      t.setSamples(this._samples);
+    });
+  }
+  /**
+   * Returns the fragment url or shader name used in the post process.
+   * @returns the fragment url or name in the shader store.
+   */
+  getEffectName() {
+    return this._fragmentUrl;
+  }
+  /**
+   * A function that is added to the onActivateObservable
+   */
+  set onActivate(e) {
+    this._onActivateObserver && this.onActivateObservable.remove(this._onActivateObserver), e && (this._onActivateObserver = this.onActivateObservable.add(e));
+  }
+  /**
+   * A function that is added to the onSizeChangedObservable
+   */
+  set onSizeChanged(e) {
+    this._onSizeChangedObserver && this.onSizeChangedObservable.remove(this._onSizeChangedObserver), this._onSizeChangedObserver = this.onSizeChangedObservable.add(e);
+  }
+  /**
+   * A function that is added to the onApplyObservable
+   */
+  set onApply(e) {
+    this._onApplyObserver && this.onApplyObservable.remove(this._onApplyObserver), this._onApplyObserver = this.onApplyObservable.add(e);
+  }
+  /**
+   * A function that is added to the onBeforeRenderObservable
+   */
+  set onBeforeRender(e) {
+    this._onBeforeRenderObserver && this.onBeforeRenderObservable.remove(this._onBeforeRenderObserver), this._onBeforeRenderObserver = this.onBeforeRenderObservable.add(e);
+  }
+  /**
+   * A function that is added to the onAfterRenderObservable
+   */
+  set onAfterRender(e) {
+    this._onAfterRenderObserver && this.onAfterRenderObservable.remove(this._onAfterRenderObserver), this._onAfterRenderObserver = this.onAfterRenderObservable.add(e);
+  }
+  /**
+   * The input texture for this post process and the output texture of the previous post process. When added to a pipeline the previous post process will
+   * render it's output into this texture and this texture will be used as textureSampler in the fragment shader of this post process.
+   */
+  get inputTexture() {
+    return this._textures.data[this._currentRenderTextureInd];
+  }
+  set inputTexture(e) {
+    this._forcedOutputTexture = e;
+  }
+  /**
+   * Since inputTexture should always be defined, if we previously manually set `inputTexture`,
+   * the only way to unset it is to use this function to restore its internal state
+   */
+  restoreDefaultInputTexture() {
+    this._forcedOutputTexture && (this._forcedOutputTexture = null, this.markTextureDirty());
+  }
+  /**
+   * Gets the camera which post process is applied to.
+   * @returns The camera the post process is applied to.
+   */
+  getCamera() {
+    return this._camera;
+  }
+  /**
+   * Gets the texel size of the postprocess.
+   * See https://en.wikipedia.org/wiki/Texel_(graphics)
+   */
+  get texelSize() {
+    return this._shareOutputWithPostProcess ? this._shareOutputWithPostProcess.texelSize : (this._forcedOutputTexture && this._texelSize.copyFromFloats(1 / this._forcedOutputTexture.width, 1 / this._forcedOutputTexture.height), this._texelSize);
+  }
+  /**
+   * Creates a new instance PostProcess
+   * @param name The name of the PostProcess.
+   * @param fragmentUrl The url of the fragment shader to be used.
+   * @param parameters Array of the names of uniform non-sampler2D variables that will be passed to the shader.
+   * @param samplers Array of the names of uniform sampler2D variables that will be passed to the shader.
+   * @param options The required width/height ratio to downsize to before computing the render pass. (Use 1.0 for full size)
+   * @param camera The camera to apply the render pass to.
+   * @param samplingMode The sampling mode to be used when computing the pass. (default: 0)
+   * @param engine The engine which the post process will be applied. (default: current engine)
+   * @param reusable If the post process can be reused on the same frame. (default: false)
+   * @param defines String of defines that will be set when running the fragment shader. (default: null)
+   * @param textureType Type of textures used when performing the post process. (default: 0)
+   * @param vertexUrl The url of the vertex shader to be used. (default: "postprocess")
+   * @param indexParameters The index parameters to be used for babylons include syntax "#include<kernelBlurVaryingDeclaration>[0..varyingCount]". (default: undefined) See usage in babylon.blurPostProcess.ts and kernelBlur.vertex.fx
+   * @param blockCompilation If the shader should not be compiled immediatly. (default: false)
+   * @param textureFormat Format of textures used when performing the post process. (default: TEXTUREFORMAT_RGBA)
+   */
+  constructor(e, t, s, i, n, l, _ = 1, f, d, g = null, h = 0, a = "postprocess", o, b = !1, x = 5, c = R.GLSL) {
+    this._parentContainer = null, this.width = -1, this.height = -1, this.nodeMaterialSource = null, this._outputTexture = null, this.autoClear = !0, this.forceAutoClearInAlphaMode = !1, this.alphaMode = 0, this.animations = new Array(), this.enablePixelPerfectMode = !1, this.forceFullscreenViewport = !0, this.scaleMode = 1, this.alwaysForcePOT = !1, this._samples = 1, this.adaptScaleToCurrentViewport = !1, this._reusable = !1, this._renderId = 0, this.externalTextureSamplerBinding = !1, this._textures = new C(2), this._textureCache = [], this._currentRenderTextureInd = 0, this._scaleRatio = new O(1, 1), this._texelSize = O.Zero(), this.onActivateObservable = new v(), this.onSizeChangedObservable = new v(), this.onApplyObservable = new v(), this.onBeforeRenderObservable = new v(), this.onAfterRenderObservable = new v(), this.name = e, l != null ? (this._camera = l, this._scene = l.getScene(), l.attachPostProcess(this), this._engine = this._scene.getEngine(), this._scene.postProcesses.push(this), this.uniqueId = this._scene.getUniqueId()) : f && (this._engine = f, this._engine.postProcesses.push(this)), this._options = n, this.renderTargetSamplingMode = _ || 1, this._reusable = d || !1, this._textureType = h, this._textureFormat = x, this._shaderLanguage = c, this._samplers = i || [], this._samplers.push("textureSampler"), this._fragmentUrl = t, this._vertexUrl = a, this._parameters = s || [], this._parameters.push("scale"), this._indexParameters = o, this._drawWrapper = new A(this._engine), b || this.updateEffect(g);
+  }
+  /**
+   * Gets a string identifying the name of the class
+   * @returns "PostProcess" string
+   */
+  getClassName() {
+    return "PostProcess";
+  }
+  /**
+   * Gets the engine which this post process belongs to.
+   * @returns The engine the post process was enabled with.
+   */
+  getEngine() {
+    return this._engine;
+  }
+  /**
+   * The effect that is created when initializing the post process.
+   * @returns The created effect corresponding the the postprocess.
+   */
+  getEffect() {
+    return this._drawWrapper.effect;
+  }
+  /**
+   * To avoid multiple redundant textures for multiple post process, the output the output texture for this post process can be shared with another.
+   * @param postProcess The post process to share the output with.
+   * @returns This post process.
+   */
+  shareOutputWith(e) {
+    return this._disposeTextures(), this._shareOutputWithPostProcess = e, this;
+  }
+  /**
+   * Reverses the effect of calling shareOutputWith and returns the post process back to its original state.
+   * This should be called if the post process that shares output with this post process is disabled/disposed.
+   */
+  useOwnOutput() {
+    this._textures.length == 0 && (this._textures = new C(2)), this._shareOutputWithPostProcess = null;
+  }
+  /**
+   * Updates the effect with the current post process compile time values and recompiles the shader.
+   * @param defines Define statements that should be added at the beginning of the shader. (default: null)
+   * @param uniforms Set of uniform variables that will be passed to the shader. (default: null)
+   * @param samplers Set of Texture2D variables that will be passed to the shader. (default: null)
+   * @param indexParameters The index parameters to be used for babylons include syntax "#include<kernelBlurVaryingDeclaration>[0..varyingCount]". (default: undefined) See usage in babylon.blurPostProcess.ts and kernelBlur.vertex.fx
+   * @param onCompiled Called when the shader has been compiled.
+   * @param onError Called if there is an error when compiling a shader.
+   * @param vertexUrl The url of the vertex shader to be used (default: the one given at construction time)
+   * @param fragmentUrl The url of the fragment shader to be used (default: the one given at construction time)
+   */
+  updateEffect(e = null, t = null, s = null, i, n, l, _, f) {
+    var d, g;
+    const h = r._GetShaderCodeProcessing(this.name);
+    if (h != null && h.defineCustomBindings) {
+      const a = (d = t == null ? void 0 : t.slice()) !== null && d !== void 0 ? d : [];
+      a.push(...this._parameters);
+      const o = (g = s == null ? void 0 : s.slice()) !== null && g !== void 0 ? g : [];
+      o.push(...this._samplers), e = h.defineCustomBindings(this.name, e, a, o), t = a, s = o;
+    }
+    this._postProcessDefines = e, this._drawWrapper.effect = this._engine.createEffect({ vertex: _ ?? this._vertexUrl, fragment: f ?? this._fragmentUrl }, {
+      attributes: ["position"],
+      uniformsNames: t || this._parameters,
+      uniformBuffersNames: [],
+      samplers: s || this._samplers,
+      defines: e !== null ? e : "",
+      fallbacks: null,
+      onCompiled: n ?? null,
+      onError: l ?? null,
+      indexParameters: i || this._indexParameters,
+      processCodeAfterIncludes: h != null && h.processCodeAfterIncludes ? (a, o) => h.processCodeAfterIncludes(this.name, a, o) : null,
+      processFinalCode: h != null && h.processFinalCode ? (a, o) => h.processFinalCode(this.name, a, o) : null,
+      shaderLanguage: this._shaderLanguage
+    }, this._engine);
+  }
+  /**
+   * The post process is reusable if it can be used multiple times within one frame.
+   * @returns If the post process is reusable
+   */
+  isReusable() {
+    return this._reusable;
+  }
+  /** invalidate frameBuffer to hint the postprocess to create a depth buffer */
+  markTextureDirty() {
+    this.width = -1;
+  }
+  _createRenderTargetTexture(e, t, s = 0) {
+    for (let n = 0; n < this._textureCache.length; n++)
+      if (this._textureCache[n].texture.width === e.width && this._textureCache[n].texture.height === e.height && this._textureCache[n].postProcessChannel === s && this._textureCache[n].texture._generateDepthBuffer === t.generateDepthBuffer && this._textureCache[n].texture.samples === t.samples)
+        return this._textureCache[n].texture;
+    const i = this._engine.createRenderTargetTexture(e, t);
+    return this._textureCache.push({ texture: i, postProcessChannel: s, lastUsedRenderId: -1 }), i;
+  }
+  _flushTextureCache() {
+    const e = this._renderId;
+    for (let t = this._textureCache.length - 1; t >= 0; t--)
+      if (e - this._textureCache[t].lastUsedRenderId > 100) {
+        let s = !1;
+        for (let i = 0; i < this._textures.length; i++)
+          if (this._textures.data[i] === this._textureCache[t].texture) {
+            s = !0;
+            break;
+          }
+        s || (this._textureCache[t].texture.dispose(), this._textureCache.splice(t, 1));
+      }
+  }
+  _resize(e, t, s, i, n) {
+    this._textures.length > 0 && this._textures.reset(), this.width = e, this.height = t;
+    let l = null;
+    for (let d = 0; d < s._postProcesses.length; d++)
+      if (s._postProcesses[d] !== null) {
+        l = s._postProcesses[d];
+        break;
+      }
+    const _ = { width: this.width, height: this.height }, f = {
+      generateMipMaps: i,
+      generateDepthBuffer: n || l === this,
+      generateStencilBuffer: (n || l === this) && this._engine.isStencilEnable,
+      samplingMode: this.renderTargetSamplingMode,
+      type: this._textureType,
+      format: this._textureFormat,
+      samples: this._samples,
+      label: "PostProcessRTT-" + this.name
+    };
+    this._textures.push(this._createRenderTargetTexture(_, f, 0)), this._reusable && this._textures.push(this._createRenderTargetTexture(_, f, 1)), this._texelSize.copyFromFloats(1 / this.width, 1 / this.height), this.onSizeChangedObservable.notifyObservers(this);
+  }
+  /**
+   * Activates the post process by intializing the textures to be used when executed. Notifies onActivateObservable.
+   * When this post process is used in a pipeline, this is call will bind the input texture of this post process to the output of the previous.
+   * @param camera The camera that will be used in the post process. This camera will be used when calling onActivateObservable.
+   * @param sourceTexture The source texture to be inspected to get the width and height if not specified in the post process constructor. (default: null)
+   * @param forceDepthStencil If true, a depth and stencil buffer will be generated. (default: false)
+   * @returns The render target wrapper that was bound to be written to.
+   */
+  activate(e, t = null, s) {
+    var i, n;
+    e = e || this._camera;
+    const l = e.getScene(), _ = l.getEngine(), f = _.getCaps().maxTextureSize;
+    let d = (t ? t.width : this._engine.getRenderWidth(!0)) * this._options | 0;
+    const g = (t ? t.height : this._engine.getRenderHeight(!0)) * this._options | 0, h = e.parent;
+    h && (h.leftCamera == e || h.rightCamera == e) && (d /= 2);
+    let a = this._options.width || d, o = this._options.height || g;
+    const b = this.renderTargetSamplingMode !== 7 && this.renderTargetSamplingMode !== 1 && this.renderTargetSamplingMode !== 2;
+    if (!this._shareOutputWithPostProcess && !this._forcedOutputTexture) {
+      if (this.adaptScaleToCurrentViewport) {
+        const c = _.currentViewport;
+        c && (a *= c.width, o *= c.height);
+      }
+      (b || this.alwaysForcePOT) && (this._options.width || (a = _.needPOTTextures ? T.GetExponentOfTwo(a, f, this.scaleMode) : a), this._options.height || (o = _.needPOTTextures ? T.GetExponentOfTwo(o, f, this.scaleMode) : o)), (this.width !== a || this.height !== o) && this._resize(a, o, e, b, s), this._textures.forEach((c) => {
+        c.samples !== this.samples && this._engine.updateRenderTargetTextureSampleCount(c, this.samples);
+      }), this._flushTextureCache(), this._renderId++;
+    }
+    let x;
+    if (this._shareOutputWithPostProcess)
+      x = this._shareOutputWithPostProcess.inputTexture;
+    else if (this._forcedOutputTexture)
+      x = this._forcedOutputTexture, this.width = this._forcedOutputTexture.width, this.height = this._forcedOutputTexture.height;
+    else {
+      x = this.inputTexture;
+      let c;
+      for (let m = 0; m < this._textureCache.length; m++)
+        if (this._textureCache[m].texture === x) {
+          c = this._textureCache[m];
+          break;
+        }
+      c && (c.lastUsedRenderId = this._renderId);
+    }
+    return this.enablePixelPerfectMode ? (this._scaleRatio.copyFromFloats(d / a, g / o), this._engine.bindFramebuffer(x, 0, d, g, this.forceFullscreenViewport)) : (this._scaleRatio.copyFromFloats(1, 1), this._engine.bindFramebuffer(x, 0, void 0, void 0, this.forceFullscreenViewport)), (n = (i = this._engine)._debugInsertMarker) === null || n === void 0 || n.call(i, `post process ${this.name} input`), this.onActivateObservable.notifyObservers(e), this.autoClear && (this.alphaMode === 0 || this.forceAutoClearInAlphaMode) && this._engine.clear(this.clearColor ? this.clearColor : l.clearColor, l._allowPostProcessClearColor, !0, !0), this._reusable && (this._currentRenderTextureInd = (this._currentRenderTextureInd + 1) % 2), x;
+  }
+  /**
+   * If the post process is supported.
+   */
+  get isSupported() {
+    return this._drawWrapper.effect.isSupported;
+  }
+  /**
+   * The aspect ratio of the output texture.
+   */
+  get aspectRatio() {
+    return this._shareOutputWithPostProcess ? this._shareOutputWithPostProcess.aspectRatio : this._forcedOutputTexture ? this._forcedOutputTexture.width / this._forcedOutputTexture.height : this.width / this.height;
+  }
+  /**
+   * Get a value indicating if the post-process is ready to be used
+   * @returns true if the post-process is ready (shader is compiled)
+   */
+  isReady() {
+    var e, t;
+    return (t = (e = this._drawWrapper.effect) === null || e === void 0 ? void 0 : e.isReady()) !== null && t !== void 0 ? t : !1;
+  }
+  /**
+   * Binds all textures and uniforms to the shader, this will be run on every pass.
+   * @returns the effect corresponding to this post process. Null if not compiled or not ready.
+   */
+  apply() {
+    var e, t, s;
+    if (!(!((e = this._drawWrapper.effect) === null || e === void 0) && e.isReady()))
+      return null;
+    this._engine.enableEffect(this._drawWrapper), this._engine.setState(!1), this._engine.setDepthBuffer(!1), this._engine.setDepthWrite(!1), this._engine.setAlphaMode(this.alphaMode), this.alphaConstants && this.getEngine().setAlphaConstants(this.alphaConstants.r, this.alphaConstants.g, this.alphaConstants.b, this.alphaConstants.a);
+    let i;
+    return this._shareOutputWithPostProcess ? i = this._shareOutputWithPostProcess.inputTexture : this._forcedOutputTexture ? i = this._forcedOutputTexture : i = this.inputTexture, this.externalTextureSamplerBinding || this._drawWrapper.effect._bindTexture("textureSampler", i == null ? void 0 : i.texture), this._drawWrapper.effect.setVector2("scale", this._scaleRatio), this.onApplyObservable.notifyObservers(this._drawWrapper.effect), (s = (t = r._GetShaderCodeProcessing(this.name)) === null || t === void 0 ? void 0 : t.bindCustomBindings) === null || s === void 0 || s.call(t, this.name, this._drawWrapper.effect), this._drawWrapper.effect;
+  }
+  _disposeTextures() {
+    if (this._shareOutputWithPostProcess || this._forcedOutputTexture) {
+      this._disposeTextureCache();
+      return;
+    }
+    this._disposeTextureCache(), this._textures.dispose();
+  }
+  _disposeTextureCache() {
+    for (let e = this._textureCache.length - 1; e >= 0; e--)
+      this._textureCache[e].texture.dispose();
+    this._textureCache.length = 0;
+  }
+  /**
+   * Sets the required values to the prepass renderer.
+   * @param prePassRenderer defines the prepass renderer to setup.
+   * @returns true if the pre pass is needed.
+   */
+  setPrePassRenderer(e) {
+    return this._prePassEffectConfiguration ? (this._prePassEffectConfiguration = e.addEffectConfiguration(this._prePassEffectConfiguration), this._prePassEffectConfiguration.enabled = !0, !0) : !1;
+  }
+  /**
+   * Disposes the post process.
+   * @param camera The camera to dispose the post process on.
+   */
+  dispose(e) {
+    e = e || this._camera, this._disposeTextures();
+    let t;
+    if (this._scene && (t = this._scene.postProcesses.indexOf(this), t !== -1 && this._scene.postProcesses.splice(t, 1)), this._parentContainer) {
+      const s = this._parentContainer.postProcesses.indexOf(this);
+      s > -1 && this._parentContainer.postProcesses.splice(s, 1), this._parentContainer = null;
+    }
+    if (t = this._engine.postProcesses.indexOf(this), t !== -1 && this._engine.postProcesses.splice(t, 1), !!e) {
+      if (e.detachPostProcess(this), t = e._postProcesses.indexOf(this), t === 0 && e._postProcesses.length > 0) {
+        const s = this._camera._getFirstPostProcess();
+        s && s.markTextureDirty();
+      }
+      this.onActivateObservable.clear(), this.onAfterRenderObservable.clear(), this.onApplyObservable.clear(), this.onBeforeRenderObservable.clear(), this.onSizeChangedObservable.clear();
+    }
+  }
+  /**
+   * Serializes the post process to a JSON object
+   * @returns the JSON object
+   */
+  serialize() {
+    const e = w.Serialize(this), t = this.getCamera() || this._scene && this._scene.activeCamera;
+    return e.customType = "BABYLON." + this.getClassName(), e.cameraId = t ? t.id : null, e.reusable = this._reusable, e.textureType = this._textureType, e.fragmentUrl = this._fragmentUrl, e.parameters = this._parameters, e.samplers = this._samplers, e.options = this._options, e.defines = this._postProcessDefines, e.textureFormat = this._textureFormat, e.vertexUrl = this._vertexUrl, e.indexParameters = this._indexParameters, e;
+  }
+  /**
+   * Clones this post process
+   * @returns a new post process similar to this one
+   */
+  clone() {
+    const e = this.serialize();
+    e._engine = this._engine, e.cameraId = null;
+    const t = r.Parse(e, this._scene, "");
+    return t ? (t.onActivateObservable = this.onActivateObservable.clone(), t.onSizeChangedObservable = this.onSizeChangedObservable.clone(), t.onApplyObservable = this.onApplyObservable.clone(), t.onBeforeRenderObservable = this.onBeforeRenderObservable.clone(), t.onAfterRenderObservable = this.onAfterRenderObservable.clone(), t._prePassEffectConfiguration = this._prePassEffectConfiguration, t) : null;
+  }
+  /**
+   * Creates a material from parsed material data
+   * @param parsedPostProcess defines parsed post process data
+   * @param scene defines the hosting scene
+   * @param rootUrl defines the root URL to use to load textures
+   * @returns a new post process
+   */
+  static Parse(e, t, s) {
+    const i = y(e.customType);
+    if (!i || !i._Parse)
+      return null;
+    const n = t ? t.getCameraById(e.cameraId) : null;
+    return i._Parse(e, n, t, s);
+  }
+  /**
+   * @internal
+   */
+  static _Parse(e, t, s, i) {
+    return w.Parse(() => new r(e.name, e.fragmentUrl, e.parameters, e.samplers, e.options, t, e.renderTargetSamplingMode, e._engine, e.reusable, e.defines, e.textureType, e.vertexUrl, e.indexParameters, !1, e.textureFormat), e, s, i);
+  }
+}
+r._CustomShaderCodeProcessing = {};
+u([
+  p()
+], r.prototype, "uniqueId", void 0);
+u([
+  p()
+], r.prototype, "name", void 0);
+u([
+  p()
+], r.prototype, "width", void 0);
+u([
+  p()
+], r.prototype, "height", void 0);
+u([
+  p()
+], r.prototype, "renderTargetSamplingMode", void 0);
+u([
+  S()
+], r.prototype, "clearColor", void 0);
+u([
+  p()
+], r.prototype, "autoClear", void 0);
+u([
+  p()
+], r.prototype, "forceAutoClearInAlphaMode", void 0);
+u([
+  p()
+], r.prototype, "alphaMode", void 0);
+u([
+  p()
+], r.prototype, "alphaConstants", void 0);
+u([
+  p()
+], r.prototype, "enablePixelPerfectMode", void 0);
+u([
+  p()
+], r.prototype, "forceFullscreenViewport", void 0);
+u([
+  p()
+], r.prototype, "scaleMode", void 0);
+u([
+  p()
+], r.prototype, "alwaysForcePOT", void 0);
+u([
+  p("samples")
+], r.prototype, "_samples", void 0);
+u([
+  p()
+], r.prototype, "adaptScaleToCurrentViewport", void 0);
+P("BABYLON.PostProcess", r);
+export {
+  r as PostProcess
+};

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

@@ -0,0 +1,94 @@
+import { VertexBuffer as l } from "../Buffers/buffer.esm.js";
+class v {
+  /**
+   * Creates a new instance PostProcess
+   * @param scene The scene that the post process is associated with.
+   */
+  constructor(e) {
+    this._vertexBuffers = {}, this._scene = e;
+  }
+  _prepareBuffers() {
+    if (this._vertexBuffers[l.PositionKind])
+      return;
+    const e = [];
+    e.push(1, 1), e.push(-1, 1), e.push(-1, -1), e.push(1, -1), this._vertexBuffers[l.PositionKind] = new l(this._scene.getEngine(), e, l.PositionKind, !1, !1, 2), this._buildIndexBuffer();
+  }
+  _buildIndexBuffer() {
+    const e = [];
+    e.push(0), e.push(1), e.push(2), e.push(0), e.push(2), e.push(3), this._indexBuffer = this._scene.getEngine().createIndexBuffer(e);
+  }
+  /**
+   * Rebuilds the vertex buffers of the manager.
+   * @internal
+   */
+  _rebuild() {
+    const e = this._vertexBuffers[l.PositionKind];
+    e && (e._rebuild(), this._buildIndexBuffer());
+  }
+  // Methods
+  /**
+   * Prepares a frame to be run through a post process.
+   * @param sourceTexture The input texture to the post processes. (default: null)
+   * @param postProcesses An array of post processes to be run. (default: null)
+   * @returns True if the post processes were able to be run.
+   * @internal
+   */
+  _prepareFrame(e = null, n = null) {
+    const u = this._scene.activeCamera;
+    return !u || (n = n || u._postProcesses.filter((f) => f != null), !n || n.length === 0 || !this._scene.postProcessesEnabled) ? !1 : (n[0].activate(u, e, n != null), !0);
+  }
+  /**
+   * Manually render a set of post processes to a texture.
+   * Please note, the frame buffer won't be unbound after the call in case you have more render to do.
+   * @param postProcesses An array of post processes to be run.
+   * @param targetTexture The render target wrapper to render to.
+   * @param forceFullscreenViewport force gl.viewport to be full screen eg. 0,0,textureWidth,textureHeight
+   * @param faceIndex defines the face to render to if a cubemap is defined as the target
+   * @param lodLevel defines which lod of the texture to render to
+   * @param doNotBindFrambuffer If set to true, assumes that the framebuffer has been bound previously
+   */
+  directRender(e, n = null, u = !1, f = 0, _ = 0, a = !1) {
+    var s;
+    const i = this._scene.getEngine();
+    for (let r = 0; r < e.length; r++) {
+      r < e.length - 1 ? e[r + 1].activate(this._scene.activeCamera, n == null ? void 0 : n.texture) : (n ? i.bindFramebuffer(n, f, void 0, void 0, u, _) : a || i.restoreDefaultFramebuffer(), (s = i._debugInsertMarker) === null || s === void 0 || s.call(i, `post process ${e[r].name} output`));
+      const d = e[r], t = d.apply();
+      t && (d.onBeforeRenderObservable.notifyObservers(t), this._prepareBuffers(), i.bindBuffers(this._vertexBuffers, this._indexBuffer, t), i.drawElementsType(0, 0, 6), d.onAfterRenderObservable.notifyObservers(t));
+    }
+    i.setDepthBuffer(!0), i.setDepthWrite(!0);
+  }
+  /**
+   * Finalize the result of the output of the postprocesses.
+   * @param doNotPresent If true the result will not be displayed to the screen.
+   * @param targetTexture The render target wrapper to render to.
+   * @param faceIndex The index of the face to bind the target texture to.
+   * @param postProcesses The array of post processes to render.
+   * @param forceFullscreenViewport force gl.viewport to be full screen eg. 0,0,textureWidth,textureHeight (default: false)
+   * @internal
+   */
+  _finalizeFrame(e, n, u, f, _ = !1) {
+    var a;
+    const s = this._scene.activeCamera;
+    if (!s || (f = f || s._postProcesses.filter((r) => r != null), f.length === 0 || !this._scene.postProcessesEnabled))
+      return;
+    const i = this._scene.getEngine();
+    for (let r = 0, d = f.length; r < d; r++) {
+      const t = f[r];
+      if (r < d - 1 ? t._outputTexture = f[r + 1].activate(s, n == null ? void 0 : n.texture) : (n ? (i.bindFramebuffer(n, u, void 0, void 0, _), t._outputTexture = n) : (i.restoreDefaultFramebuffer(), t._outputTexture = null), (a = i._debugInsertMarker) === null || a === void 0 || a.call(i, `post process ${f[r].name} output`)), e)
+        break;
+      const h = t.apply();
+      h && (t.onBeforeRenderObservable.notifyObservers(h), this._prepareBuffers(), i.bindBuffers(this._vertexBuffers, this._indexBuffer, h), i.drawElementsType(0, 0, 6), t.onAfterRenderObservable.notifyObservers(h));
+    }
+    i.setDepthBuffer(!0), i.setDepthWrite(!0), i.setAlphaMode(0);
+  }
+  /**
+   * Disposes of the post process manager.
+   */
+  dispose() {
+    const e = this._vertexBuffers[l.PositionKind];
+    e && (e.dispose(), this._vertexBuffers[l.PositionKind] = null), this._indexBuffer && (this._scene.getEngine()._releaseBuffer(this._indexBuffer), this._indexBuffer = null);
+  }
+}
+export {
+  v as PostProcessManager
+};