@tresjs/post-processing 1.0.0 → 2.0.0

package/dist/{three.js → tres-post-processing.js}

@@ -1,16 +1,374 @@
 /**
  * name: @tresjs/post-processing
- * version: v1.0.0
- * (c) 2024
+ * version: v2.0.0
+ * (c) 2025
  * description: Post-processing library for TresJS
  * author: Alvaro Saburido <hola@alvarosaburido.dev> (https://github.com/alvarosabu/)
  */
-import { useTresContext as w, useLoop as G } from "@tresjs/core";
-import { defineComponent as S, shallowRef as I, provide as k, watchEffect as f, onUnmounted as j, renderSlot as Z, inject as J, watch as _, nextTick as $, computed as O } from "vue";
-import { useDevicePixelRatio as V } from "@vueuse/core";
-import { OrthographicCamera as ee, BufferGeometry as te, Float32BufferAttribute as W, Mesh as se, ShaderMaterial as c, UniformsUtils as g, Vector2 as u, WebGLRenderTarget as v, HalfFloatType as x, NoBlending as re, Clock as ae, Color as N, MathUtils as h, DataTexture as ie, RedFormat as oe, FloatType as le, MeshNormalMaterial as ne, NearestFilter as A, DepthTexture as de, Vector4 as ue, RawShaderMaterial as he, ColorManagement as fe, SRGBTransfer as ce, LinearToneMapping as pe, ReinhardToneMapping as me, CineonToneMapping as ge, ACESFilmicToneMapping as ve, AgXToneMapping as xe, NeutralToneMapping as be, Texture as F, LinearFilter as Se, Vector3 as C, AdditiveBlending as Te, MeshBasicMaterial as Ae } from "three";
-import { m as Y } from "./prop-BjrXLDuj.js";
-const Q = {
+import { watch as D, defineComponent as p, shallowRef as N, provide as de, computed as O, onUnmounted as j, renderSlot as ue, inject as ce, watchEffect as m, nextTick as fe } from "vue";
+import { EffectComposer as K, RenderPass as Te, NormalPass as we, DepthDownsamplingPass as Me, EffectPass as ye, BloomEffect as Z, DepthOfFieldEffect as J, GlitchEffect as V, GlitchMode as Ce, BlendFunction as he, NoiseEffect as _, OutlineEffect as $, PixelationEffect as ee, VignetteTechnique as Ee, VignetteEffect as te } from "postprocessing";
+import { useTresContext as S, useLoop as z, normalizeColor as Y } from "@tresjs/core";
+import { HalfFloatType as b, OrthographicCamera as De, BufferGeometry as Le, Float32BufferAttribute as se, Mesh as Pe, ShaderMaterial as x, UniformsUtils as w, Vector2 as h, WebGLRenderTarget as M, NoBlending as Be, Clock as Re, Color as X, MathUtils as v, DataTexture as Ne, RedFormat as Oe, FloatType as ze, MeshNormalMaterial as Fe, NearestFilter as E, DepthTexture as We, Vector4 as Ue, RawShaderMaterial as He, ColorManagement as Ge, SRGBTransfer as Xe, LinearToneMapping as je, ReinhardToneMapping as Ie, CineonToneMapping as Ve, ACESFilmicToneMapping as Ye, AgXToneMapping as Qe, NeutralToneMapping as qe, Texture as ae, LinearFilter as ke, Vector3 as R, AdditiveBlending as Ke, MeshBasicMaterial as Ze } from "three";
+import { useDevicePixelRatio as me } from "@vueuse/core";
+const pe = /([^[.\]])+/g, Je = (i, e) => {
+  if (!e)
+    return;
+  const t = Array.isArray(e) ? e : e.match(pe);
+  return t == null ? void 0 : t.reduce((s, a) => s && s[a], i);
+}, re = (i, e, t) => {
+  const s = Array.isArray(e) ? e : e.match(pe);
+  s && s.reduce((a, r, o) => (a[r] === void 0 && (a[r] = {}), o === s.length - 1 && (a[r] = t), a[r]), i);
+}, q = (i, e) => {
+  const t = { ...i };
+  return e.forEach((s) => delete t[s]), t;
+}, ge = (i, e, t, s, a = {}) => D(i, (r) => {
+  var o;
+  if (e.value)
+    if (r === void 0) {
+      const n = s();
+      re(e.value, t, Je(n, t)), (o = n.dispose) == null || o.call(n);
+    } else
+      re(e.value, t, i());
+}, a), F = (i, e, t) => i.map(([s, a]) => ge(
+  s,
+  e,
+  a,
+  t
+)), I = (i, e, t) => Object.keys(i).map((s) => ge(
+  () => i[s],
+  e,
+  s,
+  t
+));
+class oe {
+  static isWebGL2Available() {
+    try {
+      const e = document.createElement("canvas");
+      return !!(window.WebGL2RenderingContext && e.getContext("webgl2"));
+    } catch {
+      return !1;
+    }
+  }
+  static isColorSpaceAvailable(e) {
+    try {
+      const t = document.createElement("canvas"), s = window.WebGL2RenderingContext && t.getContext("webgl2");
+      return s.drawingBufferColorSpace = e, s.drawingBufferColorSpace === e;
+    } catch {
+      return !1;
+    }
+  }
+  static getWebGL2ErrorMessage() {
+    return this.getErrorMessage(2);
+  }
+  static getErrorMessage(e) {
+    const t = {
+      1: "WebGL",
+      2: "WebGL 2"
+    }, s = {
+      1: window.WebGLRenderingContext,
+      2: window.WebGL2RenderingContext
+    };
+    let a = 'Your $0 does not seem to support <a href="http://khronos.org/webgl/wiki/Getting_a_WebGL_Implementation" style="color:#000">$1</a>';
+    const r = document.createElement("div");
+    return r.id = "webglmessage", r.style.fontFamily = "monospace", r.style.fontSize = "13px", r.style.fontWeight = "normal", r.style.textAlign = "center", r.style.background = "#fff", r.style.color = "#000", r.style.padding = "1.5em", r.style.width = "400px", r.style.margin = "5em auto 0", s[e] ? a = a.replace("$0", "graphics card") : a = a.replace("$0", "browser"), a = a.replace("$1", t[e]), r.innerHTML = a, r;
+  }
+  // @deprecated, r168
+  static isWebGLAvailable() {
+    console.warn("isWebGLAvailable() has been deprecated and will be removed in r178. Use isWebGL2Available() instead.");
+    try {
+      const e = document.createElement("canvas");
+      return !!(window.WebGLRenderingContext && (e.getContext("webgl") || e.getContext("experimental-webgl")));
+    } catch {
+      return !1;
+    }
+  }
+  static getWebGLErrorMessage() {
+    return console.warn("getWebGLErrorMessage() has been deprecated and will be removed in r178. Use getWebGL2ErrorMessage() instead."), this.getErrorMessage(1);
+  }
+}
+const ve = Symbol("effectComposerPmndrs"), pt = /* @__PURE__ */ p({
+  __name: "EffectComposerPmndrs",
+  props: {
+    enabled: { type: Boolean, default: !0 },
+    depthBuffer: { type: Boolean, default: void 0 },
+    disableNormalPass: { type: Boolean, default: !1 },
+    stencilBuffer: { type: Boolean, default: void 0 },
+    resolutionScale: {},
+    autoClear: { type: Boolean, default: !0 },
+    multisampling: { default: 0 },
+    frameBufferType: { default: b }
+  },
+  emits: ["render"],
+  setup(i, { expose: e, emit: t }) {
+    const s = i, a = t, { scene: r, camera: o, renderer: n, sizes: l, render: g } = S(), d = N(null);
+    let c = null, u = null;
+    de(ve, d), e({ composer: d });
+    const T = () => {
+      d.value && (u = new we(r.value, o.value), u.enabled = !1, d.value.addPass(u), s.resolutionScale !== void 0 && oe.isWebGL2Available() && (c = new Me({
+        normalBuffer: u.texture,
+        resolutionScale: s.resolutionScale
+      }), c.enabled = !1, d.value.addPass(c)));
+    }, W = O(() => {
+      const f = new K(), B = {
+        depthBuffer: s.depthBuffer !== void 0 ? s.depthBuffer : f.inputBuffer.depthBuffer,
+        stencilBuffer: s.stencilBuffer !== void 0 ? s.stencilBuffer : f.inputBuffer.stencilBuffer,
+        multisampling: oe.isWebGL2Available() ? s.multisampling !== void 0 ? s.multisampling : f.multisampling : 0,
+        frameBufferType: s.frameBufferType !== void 0 ? s.frameBufferType : b
+      };
+      return f.dispose(), B;
+    }), k = () => {
+      var f;
+      !n.value && !r.value && !o.value || ((f = d.value) == null || f.dispose(), d.value = new K(n.value, W.value), d.value.addPass(new Te(r.value, o.value)), s.disableNormalPass || T());
+    };
+    D([n, r, o, () => s.disableNormalPass], () => {
+      !l.width.value || !l.height.value || k();
+    }), D(() => [l.width.value, l.height.value], ([f, B]) => {
+      !f && !B || (d.value ? d.value.setSize(f, B) : k());
+    }, {
+      immediate: !0
+    });
+    const { render: Ae } = z();
+    return Ae(() => {
+      if (s.enabled && n.value && d.value && l.width.value && l.height.value && g.frames.value > 0) {
+        const f = n.value.autoClear;
+        n.value.autoClear = s.autoClear, s.stencilBuffer && !s.autoClear && n.value.clearStencil(), d.value.render(), a("render", d.value), n.value.autoClear = f;
+      }
+      g.frames.value = g.mode.value === "always" ? 1 : Math.max(0, g.frames.value - 1);
+    }), j(() => {
+      var f;
+      (f = d.value) == null || f.dispose();
+    }), (f, B) => ue(f.$slots, "default");
+  }
+}), y = (i, e) => {
+  const t = ce(ve), s = N(null), a = N(null), { scene: r, camera: o, invalidate: n } = S();
+  e && D(e, () => n()), m(() => {
+    !o.value || !(a != null && a.value) || (a.value.mainCamera = o.value);
+  });
+  const l = m(() => {
+    !o.value || !(t != null && t.value) || !r.value || (fe(() => l()), !a.value && (a.value = i(), s.value = new ye(o.value, a.value), t.value.addPass(s.value)));
+  });
+  return j(() => {
+    var g, d, c;
+    s.value && ((g = t == null ? void 0 : t.value) == null || g.removePass(s.value)), (d = a.value) == null || d.dispose(), (c = s.value) == null || c.dispose();
+  }), {
+    pass: s,
+    effect: a
+  };
+}, gt = /* @__PURE__ */ p({
+  __name: "BloomPmndrs",
+  props: {
+    blendFunction: {},
+    intensity: {},
+    kernelSize: {},
+    luminanceThreshold: {},
+    luminanceSmoothing: {},
+    mipmapBlur: { type: Boolean, default: void 0 }
+  },
+  setup(i, { expose: e }) {
+    const t = i, { pass: s, effect: a } = y(() => new Z(t), t);
+    return e({ pass: s, effect: a }), F(
+      [
+        // blendFunction is not updated, because it has no setter in BloomEffect
+        [() => t.intensity, "intensity"],
+        [() => t.kernelSize, "kernelSize"],
+        [() => t.luminanceSmoothing, "luminanceMaterial.smoothing"],
+        [() => t.luminanceThreshold, "luminanceMaterial.threshold"]
+      ],
+      a,
+      () => new Z()
+    ), () => {
+    };
+  }
+}), vt = /* @__PURE__ */ p({
+  __name: "DepthOfFieldPmndrs",
+  props: {
+    blendFunction: {},
+    worldFocusDistance: {},
+    worldFocusRange: {},
+    focusDistance: {},
+    focusRange: {},
+    bokehScale: {},
+    resolutionScale: {},
+    resolutionX: {},
+    resolutionY: {}
+  },
+  setup(i, { expose: e }) {
+    const t = i, { camera: s } = S(), { pass: a, effect: r } = y(() => new J(s.value, t), t);
+    return e({ pass: a, effect: r }), F(
+      [
+        // blendFunction is not updated, because it has no setter in BloomEffect
+        [() => t.worldFocusDistance, "circleOfConfusionMaterial.worldFocusDistance"],
+        [() => t.focusDistance, "circleOfConfusionMaterial.focusDistance"],
+        [() => t.worldFocusRange, "circleOfConfusionMaterial.worldFocusRange"],
+        [() => t.focusRange, "circleOfConfusionMaterial.focusRange"],
+        [() => t.bokehScale, "bokehScale"],
+        [() => t.resolutionScale, "blurPass.resolution.scale"],
+        [() => t.resolutionX, "resolution.width"],
+        [() => t.resolutionY, "resolution.height"]
+      ],
+      r,
+      () => new J()
+    ), () => {
+    };
+  }
+}), xt = /* @__PURE__ */ p({
+  __name: "GlitchPmndrs",
+  props: {
+    blendFunction: {},
+    delay: {},
+    duration: {},
+    strength: {},
+    mode: {},
+    active: { type: Boolean },
+    ratio: {},
+    columns: {},
+    chromaticAberrationOffset: {},
+    perturbationMap: {},
+    dtSize: {}
+  },
+  setup(i, { expose: e }) {
+    const t = i, { pass: s, effect: a } = y(() => new V(t), t);
+    e({ pass: s, effect: a });
+    const { onBeforeRender: r } = z();
+    return r(({ invalidate: o }) => o()), m(() => {
+      const o = () => {
+        if (t.mode !== void 0)
+          return t.active === !1 ? Ce.DISABLED : t.mode;
+        const n = new V(), l = n.mode;
+        return n.dispose(), l;
+      };
+      a.value && (a.value.mode = o());
+    }), I(
+      q(t, ["active", "mode", "blendFunction"]),
+      a,
+      () => new V()
+    ), () => {
+    };
+  }
+}), bt = /* @__PURE__ */ p({
+  __name: "NoisePmndrs",
+  props: {
+    premultiply: { type: Boolean, default: !1 },
+    blendFunction: { default: he.SCREEN }
+  },
+  setup(i, { expose: e }) {
+    const t = i, { pass: s, effect: a } = y(() => new _(t), t);
+    e({ pass: s, effect: a });
+    const { onBeforeRender: r } = z();
+    return r(({ invalidate: o }) => o()), I(
+      q(t, ["blendFunction"]),
+      a,
+      () => new _()
+    ), () => {
+    };
+  }
+}), St = /* @__PURE__ */ p({
+  __name: "OutlinePmndrs",
+  props: {
+    outlinedObjects: {},
+    blur: { type: Boolean, default: void 0 },
+    xRay: { type: Boolean, default: void 0 },
+    kernelSize: {},
+    pulseSpeed: {},
+    resolutionX: {},
+    resolutionY: {},
+    edgeStrength: {},
+    patternScale: {},
+    multisampling: {},
+    blendFunction: {},
+    patternTexture: {},
+    resolutionScale: {},
+    hiddenEdgeColor: {},
+    visibleEdgeColor: {}
+  },
+  setup(i, { expose: e }) {
+    const t = i, s = (d) => d !== void 0 ? Y(d).getHex() : void 0, { camera: a, scene: r } = S(), o = {
+      blur: t.blur,
+      xRay: t.xRay,
+      kernelSize: t.kernelSize,
+      pulseSpeed: t.pulseSpeed,
+      resolutionX: t.resolutionX,
+      resolutionY: t.resolutionY,
+      patternScale: t.patternScale,
+      edgeStrength: t.edgeStrength,
+      blendFunction: t.blendFunction,
+      multisampling: t.multisampling,
+      patternTexture: t.patternTexture,
+      resolutionScale: t.resolutionScale,
+      hiddenEdgeColor: s(t.hiddenEdgeColor),
+      visibleEdgeColor: s(t.visibleEdgeColor)
+    }, { pass: n, effect: l } = y(() => new $(r.value, a.value, o), t);
+    e({ pass: n, effect: l }), D(
+      [() => t.outlinedObjects, l],
+      // watchEffect is intentionally not used here as it would result in an endless loop
+      () => {
+        var d;
+        (d = l.value) == null || d.selection.set(t.outlinedObjects || []);
+      },
+      {
+        immediate: !0
+      }
+    );
+    const g = O(() => ({
+      hiddenEdgeColor: t.hiddenEdgeColor ? Y(t.hiddenEdgeColor) : void 0,
+      visibleEdgeColor: t.visibleEdgeColor ? Y(t.visibleEdgeColor) : void 0
+    }));
+    return F(
+      [
+        /* some properties are not updated because of different reasons:
+            resolutionX - has no setter in OutlineEffect
+            resolutionY - has no setter in OutlineEffect
+            blendFunction - has no setter in OutlineEffect
+            patternTexture - different type in constructor and in setter
+            resolutionScale - has no setter in OutlineEffect
+          */
+        [() => t.blur, "blur"],
+        [() => t.xRay, "xRay"],
+        [() => t.pulseSpeed, "pulseSpeed"],
+        [() => t.kernelSize, "kernelSize"],
+        [() => t.edgeStrength, "edgeStrength"],
+        [() => t.patternScale, "patternScale"],
+        [() => t.multisampling, "multisampling"],
+        [() => g.value.hiddenEdgeColor, "hiddenEdgeColor"],
+        [() => g.value.visibleEdgeColor, "visibleEdgeColor"]
+      ],
+      l,
+      () => new $()
+    ), () => {
+    };
+  }
+}), At = /* @__PURE__ */ p({
+  __name: "PixelationPmndrs",
+  props: {
+    granularity: {}
+  },
+  setup(i, { expose: e }) {
+    const t = i, { pass: s, effect: a } = y(() => new ee(t.granularity), t);
+    return e({ pass: s, effect: a }), I(
+      t,
+      a,
+      () => new ee()
+    ), () => {
+    };
+  }
+}), Tt = /* @__PURE__ */ p({
+  __name: "VignettePmndrs",
+  props: {
+    technique: { default: Ee.DEFAULT },
+    blendFunction: { default: he.NORMAL },
+    offset: { default: 0.5 },
+    darkness: { default: 0.5 }
+  },
+  setup(i, { expose: e }) {
+    const t = i, { pass: s, effect: a } = y(() => new te(t), t);
+    return e({ pass: s, effect: a }), I(
+      q(t, ["blendFunction"]),
+      a,
+      () => new te()
+    ), () => {
+    };
+  }
+}), xe = {
   name: "CopyShader",
   uniforms: {
     tDiffuse: { value: null },
@@ -48,7 +406,7 @@ const Q = {
 		}`
   )
 };
-class m {
+class A {
   constructor() {
     this.isPass = !0, this.enabled = !0, this.needsSwap = !0, this.clear = !1, this.renderToScreen = !1;
   }
@@ -60,22 +418,22 @@ class m {
   dispose() {
   }
 }
-const Me = new ee(-1, 1, 1, -1, 0, 1);
-class we extends te {
+const _e = new De(-1, 1, 1, -1, 0, 1);
+class $e extends Le {
   constructor() {
-    super(), this.setAttribute("position", new W([-1, 3, 0, -1, -1, 0, 3, -1, 0], 3)), this.setAttribute("uv", new W([0, 2, 0, 0, 2, 0], 2));
+    super(), this.setAttribute("position", new se([-1, 3, 0, -1, -1, 0, 3, -1, 0], 3)), this.setAttribute("uv", new se([0, 2, 0, 0, 2, 0], 2));
   }
 }
-const ye = new we();
-class T {
+const et = new $e();
+class C {
   constructor(e) {
-    this._mesh = new se(ye, e);
+    this._mesh = new Pe(et, e);
   }
   dispose() {
     this._mesh.geometry.dispose();
   }
   render(e) {
-    e.render(this._mesh, Me);
+    e.render(this._mesh, _e);
   }
   get material() {
     return this._mesh.material;
@@ -84,15 +442,15 @@ class T {
     this._mesh.material = e;
   }
 }
-class De extends m {
+class tt extends A {
   constructor(e, t) {
-    super(), this.textureID = t !== void 0 ? t : "tDiffuse", e instanceof c ? (this.uniforms = e.uniforms, this.material = e) : e && (this.uniforms = g.clone(e.uniforms), this.material = new c({
+    super(), this.textureID = t !== void 0 ? t : "tDiffuse", e instanceof x ? (this.uniforms = e.uniforms, this.material = e) : e && (this.uniforms = w.clone(e.uniforms), this.material = new x({
       name: e.name !== void 0 ? e.name : "unspecified",
       defines: Object.assign({}, e.defines),
       uniforms: this.uniforms,
       vertexShader: e.vertexShader,
       fragmentShader: e.fragmentShader
-    })), this.fsQuad = new T(this.material);
+    })), this.fsQuad = new C(this.material);
   }
   render(e, t, s) {
     this.uniforms[this.textureID] && (this.uniforms[this.textureID].value = s.texture), this.fsQuad.material = this.material, this.renderToScreen ? (e.setRenderTarget(null), this.fsQuad.render(e)) : (e.setRenderTarget(t), this.clear && e.clear(e.autoClearColor, e.autoClearDepth, e.autoClearStencil), this.fsQuad.render(e));
@@ -101,18 +459,18 @@ class De extends m {
     this.material.dispose(), this.fsQuad.dispose();
   }
 }
-class U extends m {
+class ie extends A {
   constructor(e, t) {
     super(), this.scene = e, this.camera = t, this.clear = !0, this.needsSwap = !1, this.inverse = !1;
   }
   render(e, t, s) {
     const a = e.getContext(), r = e.state;
     r.buffers.color.setMask(!1), r.buffers.depth.setMask(!1), r.buffers.color.setLocked(!0), r.buffers.depth.setLocked(!0);
-    let i, l;
-    this.inverse ? (i = 0, l = 1) : (i = 1, l = 0), r.buffers.stencil.setTest(!0), r.buffers.stencil.setOp(a.REPLACE, a.REPLACE, a.REPLACE), r.buffers.stencil.setFunc(a.ALWAYS, i, 4294967295), r.buffers.stencil.setClear(l), r.buffers.stencil.setLocked(!0), e.setRenderTarget(s), this.clear && e.clear(), e.render(this.scene, this.camera), e.setRenderTarget(t), this.clear && e.clear(), e.render(this.scene, this.camera), r.buffers.color.setLocked(!1), r.buffers.depth.setLocked(!1), r.buffers.color.setMask(!0), r.buffers.depth.setMask(!0), r.buffers.stencil.setLocked(!1), r.buffers.stencil.setFunc(a.EQUAL, 1, 4294967295), r.buffers.stencil.setOp(a.KEEP, a.KEEP, a.KEEP), r.buffers.stencil.setLocked(!0);
+    let o, n;
+    this.inverse ? (o = 0, n = 1) : (o = 1, n = 0), r.buffers.stencil.setTest(!0), r.buffers.stencil.setOp(a.REPLACE, a.REPLACE, a.REPLACE), r.buffers.stencil.setFunc(a.ALWAYS, o, 4294967295), r.buffers.stencil.setClear(n), r.buffers.stencil.setLocked(!0), e.setRenderTarget(s), this.clear && e.clear(), e.render(this.scene, this.camera), e.setRenderTarget(t), this.clear && e.clear(), e.render(this.scene, this.camera), r.buffers.color.setLocked(!1), r.buffers.depth.setLocked(!1), r.buffers.color.setMask(!0), r.buffers.depth.setMask(!0), r.buffers.stencil.setLocked(!1), r.buffers.stencil.setFunc(a.EQUAL, 1, 4294967295), r.buffers.stencil.setOp(a.KEEP, a.KEEP, a.KEEP), r.buffers.stencil.setLocked(!0);
   }
 }
-class Ce extends m {
+class st extends A {
   constructor() {
     super(), this.needsSwap = !1;
   }
@@ -120,14 +478,14 @@ class Ce extends m {
     e.state.buffers.stencil.setLocked(!1), e.state.buffers.stencil.setTest(!1);
   }
 }
-class Ee {
+class at {
   constructor(e, t) {
     if (this.renderer = e, this._pixelRatio = e.getPixelRatio(), t === void 0) {
-      const s = e.getSize(new u());
-      this._width = s.width, this._height = s.height, t = new v(this._width * this._pixelRatio, this._height * this._pixelRatio, { type: x }), t.texture.name = "EffectComposer.rt1";
+      const s = e.getSize(new h());
+      this._width = s.width, this._height = s.height, t = new M(this._width * this._pixelRatio, this._height * this._pixelRatio, { type: b }), t.texture.name = "EffectComposer.rt1";
     } else
       this._width = t.width, this._height = t.height;
-    this.renderTarget1 = t, this.renderTarget2 = t.clone(), this.renderTarget2.texture.name = "EffectComposer.rt2", this.writeBuffer = this.renderTarget1, this.readBuffer = this.renderTarget2, this.renderToScreen = !0, this.passes = [], this.copyPass = new De(Q), this.copyPass.material.blending = re, this.clock = new ae();
+    this.renderTarget1 = t, this.renderTarget2 = t.clone(), this.renderTarget2.texture.name = "EffectComposer.rt2", this.writeBuffer = this.renderTarget1, this.readBuffer = this.renderTarget2, this.renderToScreen = !0, this.passes = [], this.copyPass = new tt(xe), this.copyPass.material.blending = Be, this.clock = new Re();
   }
   swapBuffers() {
     const e = this.readBuffer;
@@ -154,23 +512,23 @@ class Ee {
     const t = this.renderer.getRenderTarget();
     let s = !1;
     for (let a = 0, r = this.passes.length; a < r; a++) {
-      const i = this.passes[a];
-      if (i.enabled !== !1) {
-        if (i.renderToScreen = this.renderToScreen && this.isLastEnabledPass(a), i.render(this.renderer, this.writeBuffer, this.readBuffer, e, s), i.needsSwap) {
+      const o = this.passes[a];
+      if (o.enabled !== !1) {
+        if (o.renderToScreen = this.renderToScreen && this.isLastEnabledPass(a), o.render(this.renderer, this.writeBuffer, this.readBuffer, e, s), o.needsSwap) {
           if (s) {
-            const l = this.renderer.getContext(), n = this.renderer.state.buffers.stencil;
-            n.setFunc(l.NOTEQUAL, 1, 4294967295), this.copyPass.render(this.renderer, this.writeBuffer, this.readBuffer, e), n.setFunc(l.EQUAL, 1, 4294967295);
+            const n = this.renderer.getContext(), l = this.renderer.state.buffers.stencil;
+            l.setFunc(n.NOTEQUAL, 1, 4294967295), this.copyPass.render(this.renderer, this.writeBuffer, this.readBuffer, e), l.setFunc(n.EQUAL, 1, 4294967295);
           }
           this.swapBuffers();
         }
-        U !== void 0 && (i instanceof U ? s = !0 : i instanceof Ce && (s = !1));
+        ie !== void 0 && (o instanceof ie ? s = !0 : o instanceof st && (s = !1));
       }
     }
     this.renderer.setRenderTarget(t);
   }
   reset(e) {
     if (e === void 0) {
-      const t = this.renderer.getSize(new u());
+      const t = this.renderer.getSize(new h());
       this._pixelRatio = this.renderer.getPixelRatio(), this._width = t.width, this._height = t.height, e = this.renderTarget1.clone(), e.setSize(this._width * this._pixelRatio, this._height * this._pixelRatio);
     }
     this.renderTarget1.dispose(), this.renderTarget2.dispose(), this.renderTarget1 = e, this.renderTarget2 = e.clone(), this.writeBuffer = this.renderTarget1, this.readBuffer = this.renderTarget2;
@@ -189,61 +547,61 @@ class Ee {
     this.renderTarget1.dispose(), this.renderTarget2.dispose(), this.copyPass.dispose();
   }
 }
-class Le extends m {
+class rt extends A {
   constructor(e, t, s = null, a = null, r = null) {
-    super(), this.scene = e, this.camera = t, this.overrideMaterial = s, this.clearColor = a, this.clearAlpha = r, this.clear = !0, this.clearDepth = !1, this.needsSwap = !1, this._oldClearColor = new N();
+    super(), this.scene = e, this.camera = t, this.overrideMaterial = s, this.clearColor = a, this.clearAlpha = r, this.clear = !0, this.clearDepth = !1, this.needsSwap = !1, this._oldClearColor = new X();
   }
   render(e, t, s) {
     const a = e.autoClear;
     e.autoClear = !1;
-    let r, i;
-    this.overrideMaterial !== null && (i = this.scene.overrideMaterial, this.scene.overrideMaterial = this.overrideMaterial), this.clearColor !== null && (e.getClearColor(this._oldClearColor), e.setClearColor(this.clearColor, e.getClearAlpha())), this.clearAlpha !== null && (r = e.getClearAlpha(), e.setClearAlpha(this.clearAlpha)), this.clearDepth == !0 && e.clearDepth(), e.setRenderTarget(this.renderToScreen ? null : s), this.clear === !0 && e.clear(e.autoClearColor, e.autoClearDepth, e.autoClearStencil), e.render(this.scene, this.camera), this.clearColor !== null && e.setClearColor(this._oldClearColor), this.clearAlpha !== null && e.setClearAlpha(r), this.overrideMaterial !== null && (this.scene.overrideMaterial = i), e.autoClear = a;
+    let r, o;
+    this.overrideMaterial !== null && (o = this.scene.overrideMaterial, this.scene.overrideMaterial = this.overrideMaterial), this.clearColor !== null && (e.getClearColor(this._oldClearColor), e.setClearColor(this.clearColor, e.getClearAlpha())), this.clearAlpha !== null && (r = e.getClearAlpha(), e.setClearAlpha(this.clearAlpha)), this.clearDepth == !0 && e.clearDepth(), e.setRenderTarget(this.renderToScreen ? null : s), this.clear === !0 && e.clear(e.autoClearColor, e.autoClearDepth, e.autoClearStencil), e.render(this.scene, this.camera), this.clearColor !== null && e.setClearColor(this._oldClearColor), this.clearAlpha !== null && e.setClearAlpha(r), this.overrideMaterial !== null && (this.scene.overrideMaterial = o), e.autoClear = a;
   }
 }
-const q = Symbol("effectComposerThree"), Xe = /* @__PURE__ */ S({
+const be = Symbol("effectComposerThree"), wt = /* @__PURE__ */ p({
   __name: "EffectComposer",
   props: {
     enabled: { type: Boolean, default: !0 },
     withoutRenderPass: { type: Boolean }
   },
-  setup(o, { expose: e }) {
-    const t = o, s = I(null);
-    k(q, s), e({ composer: s });
-    const { renderer: a, sizes: r, scene: i, camera: l, render: n } = w();
-    f(() => {
-      var d;
-      (d = s.value) == null || d.dispose(), s.value = new Ee(a.value);
-    }), f(() => {
-      var B;
-      const { width: d, height: b } = r;
-      b.value && d.value && ((B = s.value) == null || B.setSize(d.value, b.value));
+  setup(i, { expose: e }) {
+    const t = i, s = N(null);
+    de(be, s), e({ composer: s });
+    const { renderer: a, sizes: r, scene: o, camera: n, render: l } = S();
+    m(() => {
+      var u;
+      (u = s.value) == null || u.dispose(), s.value = new at(a.value);
+    }), m(() => {
+      var W;
+      const { width: u, height: T } = r;
+      T.value && u.value && ((W = s.value) == null || W.setSize(u.value, T.value));
     });
-    const { pixelRatio: D } = V();
-    f(() => {
-      var d;
-      (d = s.value) == null || d.setPixelRatio(D.value);
-    }), t.withoutRenderPass || f(() => {
-      l.value && i.value && s.value && s.value.addPass(new Le(i.value, l.value));
+    const { pixelRatio: d } = me();
+    m(() => {
+      var u;
+      (u = s.value) == null || u.setPixelRatio(d.value);
+    }), t.withoutRenderPass || m(() => {
+      n.value && o.value && s.value && s.value.addPass(new rt(o.value, n.value));
     });
-    const { render: p } = G();
-    return p(() => {
-      n.frames.value > 0 && s.value && t.enabled && s.value.render(), n.frames.value = n.mode.value === "always" ? 1 : Math.max(0, n.frames.value - 1);
+    const { render: c } = z();
+    return c(() => {
+      l.frames.value > 0 && s.value && t.enabled && s.value.render(), l.frames.value = l.mode.value === "always" ? 1 : Math.max(0, l.frames.value - 1);
     }), j(() => {
-      var d;
-      (d = s.value) == null || d.dispose();
-    }), (d, b) => Z(d.$slots, "default");
-  }
-}), y = (o, e) => {
-  const t = J(q), s = I(o()), { sizes: a, invalidate: r } = w();
-  e && _(e, () => r());
-  const i = f(() => {
-    !(t != null && t.value) || !a.height.value || !a.width.value || (t.value.addPass(s.value), $(() => i()));
+      var u;
+      (u = s.value) == null || u.dispose();
+    }), (u, T) => ue(u.$slots, "default");
+  }
+}), P = (i, e) => {
+  const t = ce(be), s = N(i()), { sizes: a, invalidate: r } = S();
+  e && D(e, () => r());
+  const o = m(() => {
+    !(t != null && t.value) || !a.height.value || !a.width.value || (t.value.addPass(s.value), fe(() => o()));
   });
   return j(() => {
-    var l;
-    (l = t == null ? void 0 : t.value) == null || l.removePass(s.value), s.value.dispose();
+    var n;
+    (n = t == null ? void 0 : t.value) == null || n.removePass(s.value), s.value.dispose();
   }), { pass: s };
-}, Pe = {
+}, ot = {
   uniforms: {
     tDiffuse: { value: null },
     //diffuse texture
@@ -338,53 +696,53 @@ const q = Symbol("effectComposerThree"), Xe = /* @__PURE__ */ S({
 		}`
   )
 };
-class H extends m {
+class ne extends A {
   constructor(e = 64) {
     super();
-    const t = Pe;
-    this.uniforms = g.clone(t.uniforms), this.heightMap = this.generateHeightmap(e), this.uniforms.tDisp.value = this.heightMap, this.material = new c({
+    const t = ot;
+    this.uniforms = w.clone(t.uniforms), this.heightMap = this.generateHeightmap(e), this.uniforms.tDisp.value = this.heightMap, this.material = new x({
       uniforms: this.uniforms,
       vertexShader: t.vertexShader,
       fragmentShader: t.fragmentShader
-    }), this.fsQuad = new T(this.material), this.goWild = !1, this.curF = 0, this.generateTrigger();
+    }), this.fsQuad = new C(this.material), this.goWild = !1, this.curF = 0, this.generateTrigger();
   }
   render(e, t, s) {
-    this.uniforms.tDiffuse.value = s.texture, this.uniforms.seed.value = Math.random(), this.uniforms.byp.value = 0, this.curF % this.randX == 0 || this.goWild == !0 ? (this.uniforms.amount.value = Math.random() / 30, this.uniforms.angle.value = h.randFloat(-Math.PI, Math.PI), this.uniforms.seed_x.value = h.randFloat(-1, 1), this.uniforms.seed_y.value = h.randFloat(-1, 1), this.uniforms.distortion_x.value = h.randFloat(0, 1), this.uniforms.distortion_y.value = h.randFloat(0, 1), this.curF = 0, this.generateTrigger()) : this.curF % this.randX < this.randX / 5 ? (this.uniforms.amount.value = Math.random() / 90, this.uniforms.angle.value = h.randFloat(-Math.PI, Math.PI), this.uniforms.distortion_x.value = h.randFloat(0, 1), this.uniforms.distortion_y.value = h.randFloat(0, 1), this.uniforms.seed_x.value = h.randFloat(-0.3, 0.3), this.uniforms.seed_y.value = h.randFloat(-0.3, 0.3)) : this.goWild == !1 && (this.uniforms.byp.value = 1), this.curF++, this.renderToScreen ? (e.setRenderTarget(null), this.fsQuad.render(e)) : (e.setRenderTarget(t), this.clear && e.clear(), this.fsQuad.render(e));
+    this.uniforms.tDiffuse.value = s.texture, this.uniforms.seed.value = Math.random(), this.uniforms.byp.value = 0, this.curF % this.randX == 0 || this.goWild == !0 ? (this.uniforms.amount.value = Math.random() / 30, this.uniforms.angle.value = v.randFloat(-Math.PI, Math.PI), this.uniforms.seed_x.value = v.randFloat(-1, 1), this.uniforms.seed_y.value = v.randFloat(-1, 1), this.uniforms.distortion_x.value = v.randFloat(0, 1), this.uniforms.distortion_y.value = v.randFloat(0, 1), this.curF = 0, this.generateTrigger()) : this.curF % this.randX < this.randX / 5 ? (this.uniforms.amount.value = Math.random() / 90, this.uniforms.angle.value = v.randFloat(-Math.PI, Math.PI), this.uniforms.distortion_x.value = v.randFloat(0, 1), this.uniforms.distortion_y.value = v.randFloat(0, 1), this.uniforms.seed_x.value = v.randFloat(-0.3, 0.3), this.uniforms.seed_y.value = v.randFloat(-0.3, 0.3)) : this.goWild == !1 && (this.uniforms.byp.value = 1), this.curF++, this.renderToScreen ? (e.setRenderTarget(null), this.fsQuad.render(e)) : (e.setRenderTarget(t), this.clear && e.clear(), this.fsQuad.render(e));
   }
   generateTrigger() {
-    this.randX = h.randInt(120, 240);
+    this.randX = v.randInt(120, 240);
   }
   generateHeightmap(e) {
     const t = new Float32Array(e * e), s = e * e;
     for (let r = 0; r < s; r++) {
-      const i = h.randFloat(0, 1);
-      t[r] = i;
+      const o = v.randFloat(0, 1);
+      t[r] = o;
     }
-    const a = new ie(t, e, e, oe, le);
+    const a = new Ne(t, e, e, Oe, ze);
     return a.needsUpdate = !0, a;
   }
   dispose() {
     this.material.dispose(), this.heightMap.dispose(), this.fsQuad.dispose();
   }
 }
-const Ge = /* @__PURE__ */ S({
+const Mt = /* @__PURE__ */ p({
   __name: "Glitch",
   props: {
     dtSize: {},
     goWild: { type: Boolean }
   },
-  setup(o, { expose: e }) {
-    const t = o, { pass: s } = y(() => new H(t.dtSize), t);
+  setup(i, { expose: e }) {
+    const t = i, { pass: s } = P(() => new ne(t.dtSize), t);
     e({ pass: s });
-    const { onBeforeRender: a } = G();
-    return a(({ invalidate: r }) => r()), Y(
+    const { onBeforeRender: a } = z();
+    return a(({ invalidate: r }) => r()), F(
       [[() => t.goWild, "goWild"]],
       s,
-      () => new H()
+      () => new ne()
     ), () => {
     };
   }
-}), P = {
+}), G = {
   name: "HalftoneShader",
   uniforms: {
     tDiffuse: { value: null },
@@ -688,16 +1046,16 @@ const Ge = /* @__PURE__ */ S({
 		}`
   )
 };
-class Ne extends m {
+class it extends A {
   constructor(e, t, s) {
-    super(), this.uniforms = g.clone(P.uniforms), this.material = new c({
+    super(), this.uniforms = w.clone(G.uniforms), this.material = new x({
       uniforms: this.uniforms,
-      fragmentShader: P.fragmentShader,
-      vertexShader: P.vertexShader
+      fragmentShader: G.fragmentShader,
+      vertexShader: G.vertexShader
     }), this.uniforms.width.value = e, this.uniforms.height.value = t;
     for (const a in s)
       s.hasOwnProperty(a) && this.uniforms.hasOwnProperty(a) && (this.uniforms[a].value = s[a]);
-    this.fsQuad = new T(this.material);
+    this.fsQuad = new C(this.material);
   }
   render(e, t, s) {
     this.material.uniforms.tDiffuse.value = s.texture, this.renderToScreen ? (e.setRenderTarget(null), this.fsQuad.render(e)) : (e.setRenderTarget(t), this.clear && e.clear(), this.fsQuad.render(e));
@@ -709,7 +1067,7 @@ class Ne extends m {
     this.material.dispose(), this.fsQuad.dispose();
   }
 }
-const Ie = /* @__PURE__ */ S({
+const yt = /* @__PURE__ */ p({
   __name: "Halftone",
   props: {
     shape: {},
@@ -722,29 +1080,29 @@ const Ie = /* @__PURE__ */ S({
     greyscale: { type: Boolean },
     blendingMode: {}
   },
-  setup(o, { expose: e }) {
-    const t = o, { sizes: s } = w(), a = O(
+  setup(i, { expose: e }) {
+    const t = i, { sizes: s } = S(), a = O(
       () => Object.fromEntries(
-        Object.entries(t).filter(([i, l]) => l !== void 0)
+        Object.entries(t).filter(([o, n]) => n !== void 0)
       )
-    ), { pass: r } = y(() => new Ne(
+    ), { pass: r } = P(() => new it(
       s.width.value,
       s.height.value,
       a.value
     ), t);
-    return e({ pass: r }), f(() => {
+    return e({ pass: r }), m(() => {
       r.value.setSize(s.width.value, s.height.value);
-    }), f(() => {
-      Object.entries(t).forEach(([i, l]) => {
-        i in r.value.uniforms && (r.value.uniforms[i].value = l ?? P.uniforms[i].value);
+    }), m(() => {
+      Object.entries(t).forEach(([o, n]) => {
+        o in r.value.uniforms && (r.value.uniforms[o].value = n ?? G.uniforms[o].value);
       });
     }), () => {
     };
   }
 });
-class X extends m {
+class le extends A {
   constructor(e, t, s, a = {}) {
-    super(), this.pixelSize = e, this.resolution = new u(), this.renderResolution = new u(), this.pixelatedMaterial = this.createPixelatedMaterial(), this.normalMaterial = new ne(), this.fsQuad = new T(this.pixelatedMaterial), this.scene = t, this.camera = s, this.normalEdgeStrength = a.normalEdgeStrength || 0.3, this.depthEdgeStrength = a.depthEdgeStrength || 0.4, this.beautyRenderTarget = new v(), this.beautyRenderTarget.texture.minFilter = A, this.beautyRenderTarget.texture.magFilter = A, this.beautyRenderTarget.texture.type = x, this.beautyRenderTarget.depthTexture = new de(), this.normalRenderTarget = new v(), this.normalRenderTarget.texture.minFilter = A, this.normalRenderTarget.texture.magFilter = A, this.normalRenderTarget.texture.type = x;
+    super(), this.pixelSize = e, this.resolution = new h(), this.renderResolution = new h(), this.pixelatedMaterial = this.createPixelatedMaterial(), this.normalMaterial = new Fe(), this.fsQuad = new C(this.pixelatedMaterial), this.scene = t, this.camera = s, this.normalEdgeStrength = a.normalEdgeStrength || 0.3, this.depthEdgeStrength = a.depthEdgeStrength || 0.4, this.beautyRenderTarget = new M(), this.beautyRenderTarget.texture.minFilter = E, this.beautyRenderTarget.texture.magFilter = E, this.beautyRenderTarget.texture.type = b, this.beautyRenderTarget.depthTexture = new We(), this.normalRenderTarget = new M(), this.normalRenderTarget.texture.minFilter = E, this.normalRenderTarget.texture.magFilter = E, this.normalRenderTarget.texture.type = b;
   }
   dispose() {
     this.beautyRenderTarget.dispose(), this.normalRenderTarget.dispose(), this.pixelatedMaterial.dispose(), this.normalMaterial.dispose(), this.fsQuad.dispose();
@@ -764,13 +1122,13 @@ class X extends m {
     e.setRenderTarget(this.normalRenderTarget), this.scene.overrideMaterial = this.normalMaterial, e.render(this.scene, this.camera), this.scene.overrideMaterial = a, s.tDiffuse.value = this.beautyRenderTarget.texture, s.tDepth.value = this.beautyRenderTarget.depthTexture, s.tNormal.value = this.normalRenderTarget.texture, this.renderToScreen ? e.setRenderTarget(null) : (e.setRenderTarget(t), this.clear && e.clear()), this.fsQuad.render(e);
   }
   createPixelatedMaterial() {
-    return new c({
+    return new x({
       uniforms: {
         tDiffuse: { value: null },
         tDepth: { value: null },
         tNormal: { value: null },
         resolution: {
-          value: new ue(
+          value: new Ue(
             this.renderResolution.x,
             this.renderResolution.y,
             1 / this.renderResolution.x,
@@ -889,28 +1247,28 @@ class X extends m {
     });
   }
 }
-const je = /* @__PURE__ */ S({
+const Ct = /* @__PURE__ */ p({
   __name: "Pixelation",
   props: {
     pixelSize: {},
     depthEdgeStrength: {},
     normalEdgeStrength: {}
   },
-  setup(o, { expose: e }) {
-    const t = o, { scene: s, camera: a } = w(), { pass: r } = y(() => new X(t.pixelSize, s.value, a.value), t);
-    return e({ pass: r }), f(() => {
+  setup(i, { expose: e }) {
+    const t = i, { scene: s, camera: a } = S(), { pass: r } = P(() => new le(t.pixelSize, s.value, a.value), t);
+    return e({ pass: r }), m(() => {
       r.value.setPixelSize(t.pixelSize);
-    }), Y(
+    }), F(
       [
         [() => t.depthEdgeStrength, "depthEdgeStrength"],
         [() => t.normalEdgeStrength, "normalEdgeStrength"]
       ],
       r,
-      () => new X(1, s.value, a.value)
+      () => new le(1, s.value, a.value)
     ), () => {
     };
   }
-}), Re = {
+}), nt = {
   name: "OutputShader",
   uniforms: {
     tDiffuse: { value: null },
@@ -992,39 +1350,39 @@ const je = /* @__PURE__ */ S({
 		}`
   )
 };
-class Oe extends m {
+class lt extends A {
   constructor() {
     super();
-    const e = Re;
-    this.uniforms = g.clone(e.uniforms), this.material = new he({
+    const e = nt;
+    this.uniforms = w.clone(e.uniforms), this.material = new He({
       name: e.name,
       uniforms: this.uniforms,
       vertexShader: e.vertexShader,
       fragmentShader: e.fragmentShader
-    }), this.fsQuad = new T(this.material), this._outputColorSpace = null, this._toneMapping = null;
+    }), this.fsQuad = new C(this.material), this._outputColorSpace = null, this._toneMapping = null;
   }
   render(e, t, s) {
-    this.uniforms.tDiffuse.value = s.texture, this.uniforms.toneMappingExposure.value = e.toneMappingExposure, (this._outputColorSpace !== e.outputColorSpace || this._toneMapping !== e.toneMapping) && (this._outputColorSpace = e.outputColorSpace, this._toneMapping = e.toneMapping, this.material.defines = {}, fe.getTransfer(this._outputColorSpace) === ce && (this.material.defines.SRGB_TRANSFER = ""), this._toneMapping === pe ? this.material.defines.LINEAR_TONE_MAPPING = "" : this._toneMapping === me ? this.material.defines.REINHARD_TONE_MAPPING = "" : this._toneMapping === ge ? this.material.defines.CINEON_TONE_MAPPING = "" : this._toneMapping === ve ? this.material.defines.ACES_FILMIC_TONE_MAPPING = "" : this._toneMapping === xe ? this.material.defines.AGX_TONE_MAPPING = "" : this._toneMapping === be && (this.material.defines.NEUTRAL_TONE_MAPPING = ""), this.material.needsUpdate = !0), this.renderToScreen === !0 ? (e.setRenderTarget(null), this.fsQuad.render(e)) : (e.setRenderTarget(t), this.clear && e.clear(e.autoClearColor, e.autoClearDepth, e.autoClearStencil), this.fsQuad.render(e));
+    this.uniforms.tDiffuse.value = s.texture, this.uniforms.toneMappingExposure.value = e.toneMappingExposure, (this._outputColorSpace !== e.outputColorSpace || this._toneMapping !== e.toneMapping) && (this._outputColorSpace = e.outputColorSpace, this._toneMapping = e.toneMapping, this.material.defines = {}, Ge.getTransfer(this._outputColorSpace) === Xe && (this.material.defines.SRGB_TRANSFER = ""), this._toneMapping === je ? this.material.defines.LINEAR_TONE_MAPPING = "" : this._toneMapping === Ie ? this.material.defines.REINHARD_TONE_MAPPING = "" : this._toneMapping === Ve ? this.material.defines.CINEON_TONE_MAPPING = "" : this._toneMapping === Ye ? this.material.defines.ACES_FILMIC_TONE_MAPPING = "" : this._toneMapping === Qe ? this.material.defines.AGX_TONE_MAPPING = "" : this._toneMapping === qe && (this.material.defines.NEUTRAL_TONE_MAPPING = ""), this.material.needsUpdate = !0), this.renderToScreen === !0 ? (e.setRenderTarget(null), this.fsQuad.render(e)) : (e.setRenderTarget(t), this.clear && e.clear(e.autoClearColor, e.autoClearDepth, e.autoClearStencil), this.fsQuad.render(e));
   }
   dispose() {
     this.material.dispose(), this.fsQuad.dispose();
   }
 }
-const Ve = /* @__PURE__ */ S({
+const Et = /* @__PURE__ */ p({
   __name: "Output",
-  setup(o, { expose: e }) {
-    const { pass: t } = y(() => new Oe());
+  setup(i, { expose: e }) {
+    const { pass: t } = P(() => new lt());
     return e({ pass: t }), () => {
     };
   }
-}), E = {
+}), U = {
   name: "SMAAEdgesShader",
   defines: {
     SMAA_THRESHOLD: "0.1"
   },
   uniforms: {
     tDiffuse: { value: null },
-    resolution: { value: new u(1 / 1024, 1 / 512) }
+    resolution: { value: new h(1 / 1024, 1 / 512) }
   },
   vertexShader: (
     /* glsl */
@@ -1118,7 +1476,7 @@ const Ve = /* @__PURE__ */ S({
 
 		}`
   )
-}, L = {
+}, H = {
   name: "SMAAWeightsShader",
   defines: {
     SMAA_MAX_SEARCH_STEPS: "8",
@@ -1130,7 +1488,7 @@ const Ve = /* @__PURE__ */ S({
     tDiffuse: { value: null },
     tArea: { value: null },
     tSearch: { value: null },
-    resolution: { value: new u(1 / 1024, 1 / 512) }
+    resolution: { value: new h(1 / 1024, 1 / 512) }
   },
   vertexShader: (
     /* glsl */
@@ -1368,12 +1726,12 @@ const Ve = /* @__PURE__ */ S({
 
 		}`
   )
-}, R = {
+}, Q = {
   name: "SMAABlendShader",
   uniforms: {
     tDiffuse: { value: null },
     tColor: { value: null },
-    resolution: { value: new u(1 / 1024, 1 / 512) }
+    resolution: { value: new h(1 / 1024, 1 / 512) }
   },
   vertexShader: (
     /* glsl */
@@ -1458,37 +1816,37 @@ const Ve = /* @__PURE__ */ S({
 		}`
   )
 };
-class ze extends m {
+class dt extends A {
   constructor(e, t) {
-    super(), this.edgesRT = new v(e, t, {
+    super(), this.edgesRT = new M(e, t, {
       depthBuffer: !1,
-      type: x
-    }), this.edgesRT.texture.name = "SMAAPass.edges", this.weightsRT = new v(e, t, {
+      type: b
+    }), this.edgesRT.texture.name = "SMAAPass.edges", this.weightsRT = new M(e, t, {
       depthBuffer: !1,
-      type: x
+      type: b
     }), this.weightsRT.texture.name = "SMAAPass.weights";
     const s = this, a = new Image();
     a.src = this.getAreaTexture(), a.onload = function() {
       s.areaTexture.needsUpdate = !0;
-    }, this.areaTexture = new F(), this.areaTexture.name = "SMAAPass.area", this.areaTexture.image = a, this.areaTexture.minFilter = Se, this.areaTexture.generateMipmaps = !1, this.areaTexture.flipY = !1;
+    }, this.areaTexture = new ae(), this.areaTexture.name = "SMAAPass.area", this.areaTexture.image = a, this.areaTexture.minFilter = ke, this.areaTexture.generateMipmaps = !1, this.areaTexture.flipY = !1;
     const r = new Image();
     r.src = this.getSearchTexture(), r.onload = function() {
       s.searchTexture.needsUpdate = !0;
-    }, this.searchTexture = new F(), this.searchTexture.name = "SMAAPass.search", this.searchTexture.image = r, this.searchTexture.magFilter = A, this.searchTexture.minFilter = A, this.searchTexture.generateMipmaps = !1, this.searchTexture.flipY = !1, this.uniformsEdges = g.clone(E.uniforms), this.uniformsEdges.resolution.value.set(1 / e, 1 / t), this.materialEdges = new c({
-      defines: Object.assign({}, E.defines),
+    }, this.searchTexture = new ae(), this.searchTexture.name = "SMAAPass.search", this.searchTexture.image = r, this.searchTexture.magFilter = E, this.searchTexture.minFilter = E, this.searchTexture.generateMipmaps = !1, this.searchTexture.flipY = !1, this.uniformsEdges = w.clone(U.uniforms), this.uniformsEdges.resolution.value.set(1 / e, 1 / t), this.materialEdges = new x({
+      defines: Object.assign({}, U.defines),
       uniforms: this.uniformsEdges,
-      vertexShader: E.vertexShader,
-      fragmentShader: E.fragmentShader
-    }), this.uniformsWeights = g.clone(L.uniforms), this.uniformsWeights.resolution.value.set(1 / e, 1 / t), this.uniformsWeights.tDiffuse.value = this.edgesRT.texture, this.uniformsWeights.tArea.value = this.areaTexture, this.uniformsWeights.tSearch.value = this.searchTexture, this.materialWeights = new c({
-      defines: Object.assign({}, L.defines),
+      vertexShader: U.vertexShader,
+      fragmentShader: U.fragmentShader
+    }), this.uniformsWeights = w.clone(H.uniforms), this.uniformsWeights.resolution.value.set(1 / e, 1 / t), this.uniformsWeights.tDiffuse.value = this.edgesRT.texture, this.uniformsWeights.tArea.value = this.areaTexture, this.uniformsWeights.tSearch.value = this.searchTexture, this.materialWeights = new x({
+      defines: Object.assign({}, H.defines),
       uniforms: this.uniformsWeights,
-      vertexShader: L.vertexShader,
-      fragmentShader: L.fragmentShader
-    }), this.uniformsBlend = g.clone(R.uniforms), this.uniformsBlend.resolution.value.set(1 / e, 1 / t), this.uniformsBlend.tDiffuse.value = this.weightsRT.texture, this.materialBlend = new c({
+      vertexShader: H.vertexShader,
+      fragmentShader: H.fragmentShader
+    }), this.uniformsBlend = w.clone(Q.uniforms), this.uniformsBlend.resolution.value.set(1 / e, 1 / t), this.uniformsBlend.tDiffuse.value = this.weightsRT.texture, this.materialBlend = new x({
       uniforms: this.uniformsBlend,
-      vertexShader: R.vertexShader,
-      fragmentShader: R.fragmentShader
-    }), this.fsQuad = new T(null);
+      vertexShader: Q.vertexShader,
+      fragmentShader: Q.fragmentShader
+    }), this.fsQuad = new C(null);
   }
   render(e, t, s) {
     this.uniformsEdges.tDiffuse.value = s.texture, this.fsQuad.material = this.materialEdges, e.setRenderTarget(this.edgesRT), this.clear && e.clear(), this.fsQuad.render(e), this.fsQuad.material = this.materialWeights, e.setRenderTarget(this.weightsRT), this.clear && e.clear(), this.fsQuad.render(e), this.uniformsBlend.tColor.value = s.texture, this.fsQuad.material = this.materialBlend, this.renderToScreen ? (e.setRenderTarget(null), this.fsQuad.render(e)) : (e.setRenderTarget(t), this.clear && e.clear(), this.fsQuad.render(e));
@@ -1506,27 +1864,27 @@ class ze extends m {
     this.edgesRT.dispose(), this.weightsRT.dispose(), this.areaTexture.dispose(), this.searchTexture.dispose(), this.materialEdges.dispose(), this.materialWeights.dispose(), this.materialBlend.dispose(), this.fsQuad.dispose();
   }
 }
-const Ye = /* @__PURE__ */ S({
+const Dt = /* @__PURE__ */ p({
   __name: "SMAA",
   props: {
     width: {},
     height: {}
   },
-  setup(o, { expose: e }) {
-    const t = o, { sizes: s } = w(), { pixelRatio: a } = V(), r = O(() => t.width ?? s.width.value * a.value), i = O(() => t.height ?? s.height.value * a.value), { pass: l } = y(() => new ze(r.value, i.value), t);
-    return e({ pass: l }), f(() => {
-      l.value.setSize(r.value, i.value);
+  setup(i, { expose: e }) {
+    const t = i, { sizes: s } = S(), { pixelRatio: a } = me(), r = O(() => t.width ?? s.width.value * a.value), o = O(() => t.height ?? s.height.value * a.value), { pass: n } = P(() => new dt(r.value, o.value), t);
+    return e({ pass: n }), m(() => {
+      n.value.setSize(r.value, o.value);
     }), () => {
     };
   }
-}), K = {
+}), Se = {
   name: "LuminosityHighPassShader",
   shaderID: "luminosityHighPass",
   uniforms: {
     tDiffuse: { value: null },
     luminosityThreshold: { value: 1 },
     smoothWidth: { value: 1 },
-    defaultColor: { value: new N(0) },
+    defaultColor: { value: new X(0) },
     defaultOpacity: { value: 0 }
   },
   vertexShader: (
@@ -1570,40 +1928,40 @@ const Ye = /* @__PURE__ */ S({
 		}`
   )
 };
-class M extends m {
+class L extends A {
   constructor(e, t, s, a) {
-    super(), this.strength = t !== void 0 ? t : 1, this.radius = s, this.threshold = a, this.resolution = e !== void 0 ? new u(e.x, e.y) : new u(256, 256), this.clearColor = new N(0, 0, 0), this.renderTargetsHorizontal = [], this.renderTargetsVertical = [], this.nMips = 5;
-    let r = Math.round(this.resolution.x / 2), i = Math.round(this.resolution.y / 2);
-    this.renderTargetBright = new v(r, i, { type: x }), this.renderTargetBright.texture.name = "UnrealBloomPass.bright", this.renderTargetBright.texture.generateMipmaps = !1;
-    for (let p = 0; p < this.nMips; p++) {
-      const d = new v(r, i, { type: x });
-      d.texture.name = "UnrealBloomPass.h" + p, d.texture.generateMipmaps = !1, this.renderTargetsHorizontal.push(d);
-      const b = new v(r, i, { type: x });
-      b.texture.name = "UnrealBloomPass.v" + p, b.texture.generateMipmaps = !1, this.renderTargetsVertical.push(b), r = Math.round(r / 2), i = Math.round(i / 2);
+    super(), this.strength = t !== void 0 ? t : 1, this.radius = s, this.threshold = a, this.resolution = e !== void 0 ? new h(e.x, e.y) : new h(256, 256), this.clearColor = new X(0, 0, 0), this.renderTargetsHorizontal = [], this.renderTargetsVertical = [], this.nMips = 5;
+    let r = Math.round(this.resolution.x / 2), o = Math.round(this.resolution.y / 2);
+    this.renderTargetBright = new M(r, o, { type: b }), this.renderTargetBright.texture.name = "UnrealBloomPass.bright", this.renderTargetBright.texture.generateMipmaps = !1;
+    for (let c = 0; c < this.nMips; c++) {
+      const u = new M(r, o, { type: b });
+      u.texture.name = "UnrealBloomPass.h" + c, u.texture.generateMipmaps = !1, this.renderTargetsHorizontal.push(u);
+      const T = new M(r, o, { type: b });
+      T.texture.name = "UnrealBloomPass.v" + c, T.texture.generateMipmaps = !1, this.renderTargetsVertical.push(T), r = Math.round(r / 2), o = Math.round(o / 2);
     }
-    const l = K;
-    this.highPassUniforms = g.clone(l.uniforms), this.highPassUniforms.luminosityThreshold.value = a, this.highPassUniforms.smoothWidth.value = 0.01, this.materialHighPassFilter = new c({
+    const n = Se;
+    this.highPassUniforms = w.clone(n.uniforms), this.highPassUniforms.luminosityThreshold.value = a, this.highPassUniforms.smoothWidth.value = 0.01, this.materialHighPassFilter = new x({
       uniforms: this.highPassUniforms,
-      vertexShader: l.vertexShader,
-      fragmentShader: l.fragmentShader
+      vertexShader: n.vertexShader,
+      fragmentShader: n.fragmentShader
     }), this.separableBlurMaterials = [];
-    const n = [3, 5, 7, 9, 11];
-    r = Math.round(this.resolution.x / 2), i = Math.round(this.resolution.y / 2);
-    for (let p = 0; p < this.nMips; p++)
-      this.separableBlurMaterials.push(this.getSeperableBlurMaterial(n[p])), this.separableBlurMaterials[p].uniforms.invSize.value = new u(1 / r, 1 / i), r = Math.round(r / 2), i = Math.round(i / 2);
+    const l = [3, 5, 7, 9, 11];
+    r = Math.round(this.resolution.x / 2), o = Math.round(this.resolution.y / 2);
+    for (let c = 0; c < this.nMips; c++)
+      this.separableBlurMaterials.push(this.getSeparableBlurMaterial(l[c])), this.separableBlurMaterials[c].uniforms.invSize.value = new h(1 / r, 1 / o), r = Math.round(r / 2), o = Math.round(o / 2);
     this.compositeMaterial = this.getCompositeMaterial(this.nMips), this.compositeMaterial.uniforms.blurTexture1.value = this.renderTargetsVertical[0].texture, this.compositeMaterial.uniforms.blurTexture2.value = this.renderTargetsVertical[1].texture, this.compositeMaterial.uniforms.blurTexture3.value = this.renderTargetsVertical[2].texture, this.compositeMaterial.uniforms.blurTexture4.value = this.renderTargetsVertical[3].texture, this.compositeMaterial.uniforms.blurTexture5.value = this.renderTargetsVertical[4].texture, this.compositeMaterial.uniforms.bloomStrength.value = t, this.compositeMaterial.uniforms.bloomRadius.value = 0.1;
-    const z = [1, 0.8, 0.6, 0.4, 0.2];
-    this.compositeMaterial.uniforms.bloomFactors.value = z, this.bloomTintColors = [new C(1, 1, 1), new C(1, 1, 1), new C(1, 1, 1), new C(1, 1, 1), new C(1, 1, 1)], this.compositeMaterial.uniforms.bloomTintColors.value = this.bloomTintColors;
-    const D = Q;
-    this.copyUniforms = g.clone(D.uniforms), this.blendMaterial = new c({
+    const g = [1, 0.8, 0.6, 0.4, 0.2];
+    this.compositeMaterial.uniforms.bloomFactors.value = g, this.bloomTintColors = [new R(1, 1, 1), new R(1, 1, 1), new R(1, 1, 1), new R(1, 1, 1), new R(1, 1, 1)], this.compositeMaterial.uniforms.bloomTintColors.value = this.bloomTintColors;
+    const d = xe;
+    this.copyUniforms = w.clone(d.uniforms), this.blendMaterial = new x({
       uniforms: this.copyUniforms,
-      vertexShader: D.vertexShader,
-      fragmentShader: D.fragmentShader,
-      blending: Te,
+      vertexShader: d.vertexShader,
+      fragmentShader: d.fragmentShader,
+      blending: Ke,
       depthTest: !1,
       depthWrite: !1,
       transparent: !0
-    }), this.enabled = !0, this.needsSwap = !1, this._oldClearColor = new N(), this.oldClearAlpha = 1, this.basic = new Ae(), this.fsQuad = new T(null);
+    }), this.enabled = !0, this.needsSwap = !1, this._oldClearColor = new X(), this.oldClearAlpha = 1, this.basic = new Ze(), this.fsQuad = new C(null);
   }
   dispose() {
     for (let e = 0; e < this.renderTargetsHorizontal.length; e++)
@@ -1619,30 +1977,30 @@ class M extends m {
     let s = Math.round(e / 2), a = Math.round(t / 2);
     this.renderTargetBright.setSize(s, a);
     for (let r = 0; r < this.nMips; r++)
-      this.renderTargetsHorizontal[r].setSize(s, a), this.renderTargetsVertical[r].setSize(s, a), this.separableBlurMaterials[r].uniforms.invSize.value = new u(1 / s, 1 / a), s = Math.round(s / 2), a = Math.round(a / 2);
+      this.renderTargetsHorizontal[r].setSize(s, a), this.renderTargetsVertical[r].setSize(s, a), this.separableBlurMaterials[r].uniforms.invSize.value = new h(1 / s, 1 / a), s = Math.round(s / 2), a = Math.round(a / 2);
   }
   render(e, t, s, a, r) {
     e.getClearColor(this._oldClearColor), this.oldClearAlpha = e.getClearAlpha();
-    const i = e.autoClear;
+    const o = e.autoClear;
     e.autoClear = !1, e.setClearColor(this.clearColor, 0), r && e.state.buffers.stencil.setTest(!1), this.renderToScreen && (this.fsQuad.material = this.basic, this.basic.map = s.texture, e.setRenderTarget(null), e.clear(), this.fsQuad.render(e)), this.highPassUniforms.tDiffuse.value = s.texture, this.highPassUniforms.luminosityThreshold.value = this.threshold, this.fsQuad.material = this.materialHighPassFilter, e.setRenderTarget(this.renderTargetBright), e.clear(), this.fsQuad.render(e);
-    let l = this.renderTargetBright;
-    for (let n = 0; n < this.nMips; n++)
-      this.fsQuad.material = this.separableBlurMaterials[n], this.separableBlurMaterials[n].uniforms.colorTexture.value = l.texture, this.separableBlurMaterials[n].uniforms.direction.value = M.BlurDirectionX, e.setRenderTarget(this.renderTargetsHorizontal[n]), e.clear(), this.fsQuad.render(e), this.separableBlurMaterials[n].uniforms.colorTexture.value = this.renderTargetsHorizontal[n].texture, this.separableBlurMaterials[n].uniforms.direction.value = M.BlurDirectionY, e.setRenderTarget(this.renderTargetsVertical[n]), e.clear(), this.fsQuad.render(e), l = this.renderTargetsVertical[n];
-    this.fsQuad.material = this.compositeMaterial, this.compositeMaterial.uniforms.bloomStrength.value = this.strength, this.compositeMaterial.uniforms.bloomRadius.value = this.radius, this.compositeMaterial.uniforms.bloomTintColors.value = this.bloomTintColors, e.setRenderTarget(this.renderTargetsHorizontal[0]), e.clear(), this.fsQuad.render(e), this.fsQuad.material = this.blendMaterial, this.copyUniforms.tDiffuse.value = this.renderTargetsHorizontal[0].texture, r && e.state.buffers.stencil.setTest(!0), this.renderToScreen ? (e.setRenderTarget(null), this.fsQuad.render(e)) : (e.setRenderTarget(s), this.fsQuad.render(e)), e.setClearColor(this._oldClearColor, this.oldClearAlpha), e.autoClear = i;
+    let n = this.renderTargetBright;
+    for (let l = 0; l < this.nMips; l++)
+      this.fsQuad.material = this.separableBlurMaterials[l], this.separableBlurMaterials[l].uniforms.colorTexture.value = n.texture, this.separableBlurMaterials[l].uniforms.direction.value = L.BlurDirectionX, e.setRenderTarget(this.renderTargetsHorizontal[l]), e.clear(), this.fsQuad.render(e), this.separableBlurMaterials[l].uniforms.colorTexture.value = this.renderTargetsHorizontal[l].texture, this.separableBlurMaterials[l].uniforms.direction.value = L.BlurDirectionY, e.setRenderTarget(this.renderTargetsVertical[l]), e.clear(), this.fsQuad.render(e), n = this.renderTargetsVertical[l];
+    this.fsQuad.material = this.compositeMaterial, this.compositeMaterial.uniforms.bloomStrength.value = this.strength, this.compositeMaterial.uniforms.bloomRadius.value = this.radius, this.compositeMaterial.uniforms.bloomTintColors.value = this.bloomTintColors, e.setRenderTarget(this.renderTargetsHorizontal[0]), e.clear(), this.fsQuad.render(e), this.fsQuad.material = this.blendMaterial, this.copyUniforms.tDiffuse.value = this.renderTargetsHorizontal[0].texture, r && e.state.buffers.stencil.setTest(!0), this.renderToScreen ? (e.setRenderTarget(null), this.fsQuad.render(e)) : (e.setRenderTarget(s), this.fsQuad.render(e)), e.setClearColor(this._oldClearColor, this.oldClearAlpha), e.autoClear = o;
   }
-  getSeperableBlurMaterial(e) {
+  getSeparableBlurMaterial(e) {
     const t = [];
     for (let s = 0; s < e; s++)
       t.push(0.39894 * Math.exp(-0.5 * s * s / (e * e)) / e);
-    return new c({
+    return new x({
       defines: {
         KERNEL_RADIUS: e
       },
       uniforms: {
         colorTexture: { value: null },
-        invSize: { value: new u(0.5, 0.5) },
+        invSize: { value: new h(0.5, 0.5) },
         // inverse texture size
-        direction: { value: new u(0.5, 0.5) },
+        direction: { value: new h(0.5, 0.5) },
         gaussianCoefficients: { value: t }
         // precomputed Gaussian coefficients
       },
@@ -1675,7 +2033,7 @@ class M extends m {
     });
   }
   getCompositeMaterial(e) {
-    return new c({
+    return new x({
       defines: {
         NUM_MIPS: e
       },
@@ -1721,42 +2079,51 @@ class M extends m {
     });
   }
 }
-M.BlurDirectionX = new u(1, 0);
-M.BlurDirectionY = new u(0, 1);
-const Qe = /* @__PURE__ */ S({
+L.BlurDirectionX = new h(1, 0);
+L.BlurDirectionY = new h(0, 1);
+const Lt = /* @__PURE__ */ p({
   __name: "UnrealBloom",
   props: {
     radius: { default: 0 },
     strength: { default: 1 },
     threshold: { default: 0 }
   },
-  setup(o, { expose: e }) {
-    const t = o, { sizes: s } = w(), { pass: a } = y(() => new M(
-      new u(s.width.value, s.height.value),
+  setup(i, { expose: e }) {
+    const t = i, { sizes: s } = S(), { pass: a } = P(() => new L(
+      new h(s.width.value, s.height.value),
       t.radius,
       t.strength,
       t.threshold
     ), t);
-    return e({ pass: a }), f(() => {
+    return e({ pass: a }), m(() => {
       var r;
       a.value.radius = t.radius ?? ((r = a.value.getCompositeMaterial().uniforms.bloomRadius) == null ? void 0 : r.value) ?? 0.1;
-    }), f(() => {
+    }), m(() => {
       var r;
       a.value.strength = t.strength ?? ((r = a.value.getCompositeMaterial().uniforms.bloomStrength) == null ? void 0 : r.value) ?? 1;
-    }), f(() => {
+    }), m(() => {
       var r;
-      a.value.threshold = t.threshold ?? ((r = K.uniforms.luminosityThreshold) == null ? void 0 : r.value) ?? 1;
+      a.value.threshold = t.threshold ?? ((r = Se.uniforms.luminosityThreshold) == null ? void 0 : r.value) ?? 1;
     }), () => {
     };
   }
 });
 export {
-  Xe as EffectComposer,
-  Ge as Glitch,
-  Ie as Halftone,
-  Ve as Output,
-  je as Pixelation,
-  Ye as SMAA,
-  Qe as UnrealBloom,
-  y as useEffect
+  gt as BloomPmndrs,
+  vt as DepthOfFieldPmndrs,
+  wt as EffectComposer,
+  pt as EffectComposerPmndrs,
+  Mt as Glitch,
+  xt as GlitchPmndrs,
+  yt as Halftone,
+  bt as NoisePmndrs,
+  St as OutlinePmndrs,
+  Et as Output,
+  Ct as Pixelation,
+  At as PixelationPmndrs,
+  Dt as SMAA,
+  Lt as UnrealBloom,
+  Tt as VignettePmndrs,
+  P as useEffect,
+  y as useEffectPmndrs
 };