@tresjs/post-processing 1.0.0 → 2.1.0

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

@@ -1,16 +1,1060 @@
 /**
  * name: @tresjs/post-processing
- * version: v1.0.0
- * (c) 2024
+ * version: v2.1.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 C, defineComponent as c, shallowRef as z, provide as Ce, computed as F, onUnmounted as V, renderSlot as Ee, inject as De, watchEffect as v, nextTick as Pe } from "vue";
+import { EffectComposer as oe, RenderPass as We, NormalPass as Ue, DepthDownsamplingPass as He, EffectPass as Ge, BloomEffect as ae, DepthOfFieldEffect as se, GlitchEffect as Y, GlitchMode as Xe, NoiseEffect as re, OutlineEffect as ie, PixelationEffect as ne, VignetteEffect as le, Effect as Z, BlendFunction as _, ToneMappingEffect as ue, ChromaticAberrationEffect as q, HueSaturationEffect as ce, ScanlineEffect as k, ColorAverageEffect as Q, LensDistortionEffect as de, ShockWaveEffect as fe, TiltShiftEffect as he, DotScreenEffect as pe, SepiaEffect as me } from "postprocessing";
+import { useTresContext as A, useLoop as W, normalizeColor as K } from "@tresjs/core";
+import { HalfFloatType as w, Uniform as E, Vector2 as d, Vector3 as P, OrthographicCamera as Ie, BufferGeometry as je, Float32BufferAttribute as ge, Mesh as Ve, ShaderMaterial as S, UniformsUtils as M, WebGLRenderTarget as D, NoBlending as Ye, Clock as qe, Color as j, MathUtils as b, DataTexture as ke, RedFormat as Qe, FloatType as Ke, MeshNormalMaterial as Je, NearestFilter as O, DepthTexture as Ze, Vector4 as _e, RawShaderMaterial as $e, ColorManagement as et, SRGBTransfer as tt, LinearToneMapping as ot, ReinhardToneMapping as at, CineonToneMapping as st, ACESFilmicToneMapping as rt, AgXToneMapping as it, NeutralToneMapping as nt, Texture as ve, LinearFilter as lt, AdditiveBlending as ut, MeshBasicMaterial as ct } from "three";
+import { useDevicePixelRatio as Le } from "@vueuse/core";
+const Oe = /([^[.\]])+/g, dt = (r, e) => {
+  if (!e)
+    return;
+  const t = Array.isArray(e) ? e : e.match(Oe);
+  return t == null ? void 0 : t.reduce((o, a) => o && o[a], r);
+}, xe = (r, e, t) => {
+  const o = Array.isArray(e) ? e : e.match(Oe);
+  o && o.reduce((a, s, i) => (a[s] === void 0 && (a[s] = {}), i === o.length - 1 && (a[s] = t), a[s]), r);
+}, $ = (r, e) => {
+  const t = { ...r };
+  return e.forEach((o) => delete t[o]), t;
+}, ee = (r, e, t, o, a = {}) => C(r, (s) => {
+  var i;
+  if (e.value)
+    if (s === void 0) {
+      const n = o();
+      xe(e.value, t, dt(n, t)), (i = n.dispose) == null || i.call(n);
+    } else
+      xe(e.value, t, r());
+}, a), g = (r, e, t) => r.map(([o, a]) => ee(
+  o,
+  e,
+  a,
+  t
+)), U = (r, e, t) => Object.keys(r).map((o) => ee(
+  () => r[o],
+  e,
+  o,
+  t
+));
+class be {
+  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"), o = window.WebGL2RenderingContext && t.getContext("webgl2");
+      return o.drawingBufferColorSpace = e, o.drawingBufferColorSpace === e;
+    } catch {
+      return !1;
+    }
+  }
+  static getWebGL2ErrorMessage() {
+    return this.getErrorMessage(2);
+  }
+  static getErrorMessage(e) {
+    const t = {
+      1: "WebGL",
+      2: "WebGL 2"
+    }, o = {
+      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 s = document.createElement("div");
+    return s.id = "webglmessage", s.style.fontFamily = "monospace", s.style.fontSize = "13px", s.style.fontWeight = "normal", s.style.textAlign = "center", s.style.background = "#fff", s.style.color = "#000", s.style.padding = "1.5em", s.style.width = "400px", s.style.margin = "5em auto 0", o[e] ? a = a.replace("$0", "graphics card") : a = a.replace("$0", "browser"), a = a.replace("$1", t[e]), s.innerHTML = a, s;
+  }
+  // @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 Re = Symbol("effectComposerPmndrs"), Lt = /* @__PURE__ */ c({
+  __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: w }
+  },
+  emits: ["render"],
+  setup(r, { expose: e, emit: t }) {
+    const o = r, a = t, { scene: s, camera: i, renderer: n, sizes: l, render: x } = A(), u = z(null);
+    let p = null, f = null;
+    Ce(Re, u), e({ composer: u });
+    const y = () => {
+      u.value && (f = new Ue(s.value, i.value), f.enabled = !1, u.value.addPass(f), o.resolutionScale !== void 0 && be.isWebGL2Available() && (p = new He({
+        normalBuffer: f.texture,
+        resolutionScale: o.resolutionScale
+      }), p.enabled = !1, u.value.addPass(p)));
+    }, H = F(() => {
+      const m = new oe(), N = {
+        depthBuffer: o.depthBuffer !== void 0 ? o.depthBuffer : m.inputBuffer.depthBuffer,
+        stencilBuffer: o.stencilBuffer !== void 0 ? o.stencilBuffer : m.inputBuffer.stencilBuffer,
+        multisampling: be.isWebGL2Available() ? o.multisampling !== void 0 ? o.multisampling : m.multisampling : 0,
+        frameBufferType: o.frameBufferType !== void 0 ? o.frameBufferType : w
+      };
+      return m.dispose(), N;
+    }), te = () => {
+      var m;
+      !n.value && !s.value && !i.value || ((m = u.value) == null || m.dispose(), u.value = new oe(n.value, H.value), u.value.addPass(new We(s.value, i.value)), o.disableNormalPass || y());
+    };
+    C([n, s, i, () => o.disableNormalPass], () => {
+      !l.width.value || !l.height.value || te();
+    }), C(() => [l.width.value, l.height.value], ([m, N]) => {
+      !m && !N || (u.value ? u.value.setSize(m, N) : te());
+    }, {
+      immediate: !0
+    });
+    const { render: Fe } = W();
+    return Fe(() => {
+      if (o.enabled && n.value && u.value && l.width.value && l.height.value && x.frames.value > 0) {
+        const m = n.value.autoClear;
+        n.value.autoClear = o.autoClear, o.stencilBuffer && !o.autoClear && n.value.clearStencil(), u.value.render(), a("render", u.value), n.value.autoClear = m;
+      }
+      x.frames.value = x.mode.value === "always" ? 1 : Math.max(0, x.frames.value - 1);
+    }), V(() => {
+      var m;
+      (m = u.value) == null || m.dispose();
+    }), (m, N) => Ee(m.$slots, "default");
+  }
+}), h = (r, e) => {
+  const t = De(Re), o = z(null), a = z(null), { scene: s, camera: i, invalidate: n } = A();
+  e && C(e, () => n()), v(() => {
+    !i.value || !(a != null && a.value) || (a.value.mainCamera = i.value);
+  });
+  const l = v(() => {
+    !i.value || !(t != null && t.value) || !s.value || (Pe(() => l()), !a.value && (a.value = r(), o.value = new Ge(i.value, a.value), t.value.addPass(o.value)));
+  });
+  return V(() => {
+    var x, u, p;
+    o.value && ((x = t == null ? void 0 : t.value) == null || x.removePass(o.value)), (u = a.value) == null || u.dispose(), (p = o.value) == null || p.dispose();
+  }), {
+    pass: o,
+    effect: a
+  };
+}, Ot = /* @__PURE__ */ c({
+  __name: "BloomPmndrs",
+  props: {
+    blendFunction: {},
+    intensity: {},
+    kernelSize: {},
+    luminanceThreshold: {},
+    luminanceSmoothing: {},
+    mipmapBlur: { type: Boolean, default: void 0 }
+  },
+  setup(r, { expose: e }) {
+    const t = r, { pass: o, effect: a } = h(() => new ae(t), t);
+    return e({ pass: o, effect: a }), g(
+      [
+        // 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 ae()
+    ), () => {
+    };
+  }
+}), Rt = /* @__PURE__ */ c({
+  __name: "DepthOfFieldPmndrs",
+  props: {
+    blendFunction: {},
+    worldFocusDistance: {},
+    worldFocusRange: {},
+    focusDistance: {},
+    focusRange: {},
+    bokehScale: {},
+    resolutionScale: {},
+    resolutionX: {},
+    resolutionY: {}
+  },
+  setup(r, { expose: e }) {
+    const t = r, { camera: o } = A(), { pass: a, effect: s } = h(() => new se(o.value, t), t);
+    return e({ pass: a, effect: s }), g(
+      [
+        // 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"]
+      ],
+      s,
+      () => new se()
+    ), () => {
+    };
+  }
+}), Bt = /* @__PURE__ */ c({
+  __name: "GlitchPmndrs",
+  props: {
+    blendFunction: {},
+    delay: {},
+    duration: {},
+    strength: {},
+    mode: {},
+    active: { type: Boolean },
+    ratio: {},
+    columns: {},
+    chromaticAberrationOffset: {},
+    perturbationMap: {},
+    dtSize: {}
+  },
+  setup(r, { expose: e }) {
+    const t = r, { pass: o, effect: a } = h(() => new Y(t), t);
+    e({ pass: o, effect: a });
+    const { onBeforeRender: s } = W();
+    return s(({ invalidate: i }) => i()), v(() => {
+      const i = () => {
+        if (t.mode !== void 0)
+          return t.active === !1 ? Xe.DISABLED : t.mode;
+        const n = new Y(), l = n.mode;
+        return n.dispose(), l;
+      };
+      a.value && (a.value.mode = i());
+    }), U(
+      $(t, ["active", "mode", "blendFunction"]),
+      a,
+      () => new Y()
+    ), () => {
+    };
+  }
+}), Nt = /* @__PURE__ */ c({
+  __name: "NoisePmndrs",
+  props: {
+    premultiply: { type: Boolean, default: void 0 },
+    blendFunction: {}
+  },
+  setup(r, { expose: e }) {
+    const t = r, { pass: o, effect: a } = h(() => new re(t), t);
+    e({ pass: o, effect: a });
+    const { onBeforeRender: s } = W();
+    return s(({ invalidate: i }) => i()), U(
+      $(t, ["blendFunction"]),
+      a,
+      () => new re()
+    ), () => {
+    };
+  }
+}), zt = /* @__PURE__ */ c({
+  __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(r, { expose: e }) {
+    const t = r, o = (u) => u !== void 0 ? K(u).getHex() : void 0, { camera: a, scene: s } = A(), i = {
+      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: o(t.hiddenEdgeColor),
+      visibleEdgeColor: o(t.visibleEdgeColor)
+    }, { pass: n, effect: l } = h(() => new ie(s.value, a.value, i), t);
+    e({ pass: n, effect: l }), C(
+      [() => t.outlinedObjects, l],
+      // watchEffect is intentionally not used here as it would result in an endless loop
+      () => {
+        var u;
+        (u = l.value) == null || u.selection.set(t.outlinedObjects || []);
+      },
+      {
+        immediate: !0
+      }
+    );
+    const x = F(() => ({
+      hiddenEdgeColor: t.hiddenEdgeColor ? K(t.hiddenEdgeColor) : void 0,
+      visibleEdgeColor: t.visibleEdgeColor ? K(t.visibleEdgeColor) : void 0
+    }));
+    return g(
+      [
+        /* 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"],
+        [() => x.value.hiddenEdgeColor, "hiddenEdgeColor"],
+        [() => x.value.visibleEdgeColor, "visibleEdgeColor"]
+      ],
+      l,
+      () => new ie()
+    ), () => {
+    };
+  }
+}), Ft = /* @__PURE__ */ c({
+  __name: "PixelationPmndrs",
+  props: {
+    granularity: {}
+  },
+  setup(r, { expose: e }) {
+    const t = r, { pass: o, effect: a } = h(() => new ne(t.granularity), t);
+    return e({ pass: o, effect: a }), U(
+      t,
+      a,
+      () => new ne()
+    ), () => {
+    };
+  }
+}), Wt = /* @__PURE__ */ c({
+  __name: "VignettePmndrs",
+  props: {
+    technique: {},
+    blendFunction: {},
+    offset: {},
+    darkness: {}
+  },
+  setup(r, { expose: e }) {
+    const t = r, { pass: o, effect: a } = h(() => new le(t), t);
+    return e({ pass: o, effect: a }), U(
+      $(t, ["blendFunction"]),
+      a,
+      () => new le()
+    ), () => {
+    };
+  }
+});
+class Se extends Z {
+  /**
+   * Creates a new BarrelBlurEffect instance.
+   *
+   * @param {object} [options] - Configuration options for the effect.
+   * @param {BlendFunction} [options.blendFunction] - Blend mode.
+   * @param {number} [options.amount] - Intensity of the barrel distortion (0 to 1).
+   * @param {Vector2} [options.offset] - Offset of the barrel distortion center (0 to 1 for both x and y). This allows you to change the position of the distortion effect.
+   *
+   */
+  constructor({ blendFunction: e = _.NORMAL, amount: t = 0.15, offset: o = new d(0.5, 0.5) } = {}) {
+    super("BarrelBlurEffect", `
+    uniform float amount;
+    uniform vec2 offset;
+
+    #define NUM_ITER 16
+    #define RECIP_NUM_ITER 0.0625
+    #define GAMMA 1.0
+
+    vec3 spectrum_offset(float t) {
+        float lo = step(t, 0.5);
+        float hi = 1.0 - lo;
+        float w = 1.0 - abs(2.0 * t - 1.0);
+        return pow(vec3(lo, 1.0, hi) * vec3(1.0 - w, w, 1.0 - w), vec3(1.0 / GAMMA));
+    }
+
+    vec2 barrelDistortion(vec2 p, float amt) {
+        p = p - offset;
+        float theta = atan(p.y, p.x);
+        float radius = pow(length(p), 1.0 + 3.0 * amt);
+        return vec2(cos(theta), sin(theta)) * radius + offset;
+    }
+
+    void mainUv(inout vec2 uv) {
+        uv = barrelDistortion(uv, amount * 0.5);
+    }
+
+    void mainImage(const in vec4 inputColor, const in vec2 uv, out vec4 outputColor) {
+        vec3 sumcol = vec3(0.0);
+        vec3 sumw = vec3(0.0);
+
+        for (int i = 0; i < NUM_ITER; ++i) {
+            float t = float(i) * RECIP_NUM_ITER;
+            vec3 w = spectrum_offset(t);
+            vec2 distortedUV = barrelDistortion(uv, amount * t);
+            sumcol += w * texture(inputBuffer, distortedUV).rgb;
+            sumw += w;
+        }
+
+        vec3 outcol = pow(sumcol / sumw, vec3(1.0 / GAMMA));
+
+        outcol = clamp(outcol, 0.0, 1.0); // Ensures normalized color values
+
+        outputColor = vec4(outcol, inputColor.a); // Preserves original alpha
+    }
+      `, {
+      blendFunction: e,
+      uniforms: /* @__PURE__ */ new Map([
+        ["amount", new E(t)],
+        // Uniform controlling the intensity of distortion
+        ["offset", new E(o)]
+        // Uniform controlling the offset of distortion
+      ])
+    });
+  }
+  /**
+   * The amount.
+   *
+   * @type {number}
+   */
+  get amount() {
+    var e;
+    return (e = this.uniforms.get("amount")) == null ? void 0 : e.value;
+  }
+  set amount(e) {
+    this.uniforms.get("amount").value = e;
+  }
+  /**
+   * The offset.
+   *
+   * @type {Vector2}
+   */
+  get offset() {
+    var e;
+    return (e = this.uniforms.get("offset")) == null ? void 0 : e.value;
+  }
+  set offset(e) {
+    this.uniforms.get("offset").value = e;
+  }
+}
+const Ut = /* @__PURE__ */ c({
+  __name: "BarrelBlurPmndrs",
+  props: {
+    blendFunction: {},
+    amount: {},
+    offset: {}
+  },
+  setup(r, { expose: e }) {
+    const t = r, { pass: o, effect: a } = h(
+      () => new Se({
+        ...t,
+        offset: Array.isArray(t.offset) ? new d(...t.offset) : t.offset
+      }),
+      t
+    );
+    return e({ pass: o, effect: a }), g(
+      [
+        [() => t.blendFunction, "blendMode.blendFunction"],
+        [() => t.amount, "amount"],
+        [() => t.offset, "offset"]
+      ],
+      a,
+      () => new Se()
+    ), () => {
+    };
+  }
+}), Ht = /* @__PURE__ */ c({
+  __name: "ToneMappingPmndrs",
+  props: {
+    mode: {},
+    blendFunction: {},
+    resolution: {},
+    averageLuminance: {},
+    middleGrey: {},
+    minLuminance: {},
+    whitePoint: {}
+  },
+  setup(r, { expose: e }) {
+    const t = r, { pass: o, effect: a } = h(() => new ue(t), t);
+    return e({ pass: o, effect: a }), g(
+      [
+        [() => t.mode, "mode"],
+        [() => t.blendFunction, "blendMode.blendFunction"],
+        [() => t.resolution, "resolution"],
+        [() => t.averageLuminance, "averageLuminance"],
+        [() => t.middleGrey, "middleGrey"],
+        [() => t.minLuminance, "adaptiveLuminanceMaterial.minLuminance"],
+        [() => t.whitePoint, "whitePoint"]
+      ],
+      a,
+      () => new ue()
+    ), () => {
+    };
+  }
+}), Gt = /* @__PURE__ */ c({
+  __name: "ChromaticAberrationPmndrs",
+  props: {
+    blendFunction: {},
+    offset: {},
+    radialModulation: { type: Boolean, default: void 0 },
+    modulationOffset: {}
+  },
+  setup(r, { expose: e }) {
+    const t = r, o = new q(), { pass: a, effect: s } = h(() => new q({
+      ...t,
+      // Unfortunately, these defaults must be set this way as the type in postprocessing is not correct.
+      // The arguments are optional in the actual constructor, but not in the type.
+      radialModulation: t.radialModulation ?? o.radialModulation,
+      modulationOffset: t.modulationOffset ?? o.modulationOffset
+    }), t);
+    return o.dispose(), e({ pass: a, effect: s }), g(
+      [
+        [() => t.blendFunction, "blendMode.blendFunction"],
+        [() => t.offset, "offset"],
+        [() => t.radialModulation, "radialModulation"],
+        [() => t.modulationOffset, "modulationOffset"]
+      ],
+      s,
+      () => new q()
+    ), () => {
+    };
+  }
+}), Xt = /* @__PURE__ */ c({
+  __name: "HueSaturationPmndrs",
+  props: {
+    saturation: {},
+    hue: {},
+    blendFunction: {}
+  },
+  setup(r, { expose: e }) {
+    const t = r, { pass: o, effect: a } = h(() => new ce(t), t);
+    return e({ pass: o, effect: a }), g(
+      [
+        [() => t.blendFunction, "blendMode.blendFunction"],
+        [() => t.hue, "hue"],
+        [() => t.saturation, "saturation"]
+      ],
+      a,
+      () => new ce()
+    ), () => {
+    };
+  }
+}), It = /* @__PURE__ */ c({
+  __name: "ScanlinePmndrs",
+  props: {
+    blendFunction: {},
+    density: {},
+    scrollSpeed: {},
+    opacity: {}
+  },
+  setup(r, { expose: e }) {
+    const t = r, { pass: o, effect: a } = h(() => new k(t), t);
+    return e({ pass: o, effect: a }), g(
+      [
+        [() => t.blendFunction, "blendMode.blendFunction"],
+        [() => t.density, "density"],
+        [() => t.scrollSpeed, "scrollSpeed"]
+      ],
+      a,
+      () => new k()
+    ), C(
+      [() => t.opacity],
+      () => {
+        var s, i;
+        if (t.opacity !== void 0)
+          (s = a.value) == null || s.blendMode.setOpacity(t.opacity);
+        else {
+          const n = new k();
+          (i = a.value) == null || i.blendMode.setOpacity(n.blendMode.getOpacity()), n.dispose();
+        }
+      },
+      {
+        immediate: !0
+      }
+    ), () => {
+    };
+  }
+}), ft = `
+uniform float radius;
+uniform int sectorCount;
+
+const int MAX_SECTOR_COUNT = 8;
+
+float polynomialWeight(float x, float y, float eta, float lambda) {
+    float polyValue = (x + eta) - lambda * (y * y);
+    return max(0.0, polyValue * polyValue);
+}
+
+void getSectorVarianceAndAverageColor(mat2 anisotropyMat, float angle, float radius, out vec3 avgColor, out float variance) {
+    vec3 weightedColorSum = vec3(0.0);
+    vec3 weightedSquaredColorSum = vec3(0.0);
+    float totalWeight = 0.0;
+
+    float eta = 0.1;
+    float lambda = 0.5;
+    float angleStep = 0.196349; // Precompute angle step
+    float halfAngleRange = 0.392699; // Precompute half angle range
+
+    float cosAngle = cos(angle);
+    float sinAngle = sin(angle);
+
+    for (float r = 1.0; r <= radius; r += 1.0) {
+        float rCosAngle = r * cosAngle;
+        float rSinAngle = r * sinAngle;
+        for (float a = -halfAngleRange; a <= halfAngleRange; a += angleStep) {
+            float cosA = cos(a);
+            float sinA = sin(a);
+            vec2 sampleOffset = vec2(rCosAngle * cosA - rSinAngle * sinA, rCosAngle * sinA + rSinAngle * cosA) / resolution;
+            sampleOffset *= anisotropyMat;
+
+            vec3 color = texture2D(inputBuffer, vUv + sampleOffset).rgb;
+            float weight = polynomialWeight(sampleOffset.x, sampleOffset.y, eta, lambda);
+            
+            weightedColorSum += color * weight;
+            weightedSquaredColorSum += color * color * weight;
+            totalWeight += weight;
+        }
+    }
+
+    // Calculate average color and variance
+    avgColor = weightedColorSum / totalWeight;
+    vec3 varianceRes = (weightedSquaredColorSum / totalWeight) - (avgColor * avgColor);
+    variance = dot(varianceRes, vec3(0.299, 0.587, 0.114)); // Convert to luminance
+}
+
+vec4 getDominantOrientation(vec4 structureTensor) {
+    float Jxx = structureTensor.r; 
+    float Jyy = structureTensor.g; 
+    float Jxy = structureTensor.b; 
+
+    float trace = Jxx + Jyy;
+    float det = Jxx * Jyy - Jxy * Jxy;
+    float lambda1 = 0.5 * (trace + sqrt(trace * trace - 4.0 * det));
+    float lambda2 = 0.5 * (trace - sqrt(trace * trace - 4.0 * det));
+
+    float dominantOrientation = atan(2.0 * Jxy, Jxx - Jyy) / 2.0;
+    return vec4(dominantOrientation, lambda1, lambda2, 0.0);
+}
+
+void mainImage(const in vec4 inputColor, const in vec2 uv, out vec4 outputColor) {
+    vec4 structureTensor = texture2D(inputBuffer, uv);
+
+    vec3 sectorAvgColors[MAX_SECTOR_COUNT];
+    float sectorVariances[MAX_SECTOR_COUNT];
+
+    vec4 orientationAndAnisotropy = getDominantOrientation(structureTensor);
+    vec2 orientation = orientationAndAnisotropy.xy;
+
+    float anisotropy = (orientationAndAnisotropy.z - orientationAndAnisotropy.w) / (orientationAndAnisotropy.z + orientationAndAnisotropy.w + 1e-7);
+
+    float alpha = 25.0;
+    float scaleX = alpha / (anisotropy + alpha);
+    float scaleY = (anisotropy + alpha) / alpha;
+
+    mat2 anisotropyMat = mat2(orientation.x, -orientation.y, orientation.y, orientation.x) * mat2(scaleX, 0.0, 0.0, scaleY);
+
+    for (int i = 0; i < sectorCount; i++) {
+      float angle = float(i) * 6.28318 / float(sectorCount); // 2π / sectorCount
+      getSectorVarianceAndAverageColor(anisotropyMat, angle, float(radius), sectorAvgColors[i], sectorVariances[i]);
+    }
+
+    float minVariance = sectorVariances[0];
+    vec3 finalColor = sectorAvgColors[0];
+
+    for (int i = 1; i < sectorCount; i++) {
+        if (sectorVariances[i] < minVariance) {
+            minVariance = sectorVariances[i];
+            finalColor = sectorAvgColors[i];
+        }
+    }
+
+    outputColor = vec4(finalColor, inputColor.a);
+}
+`;
+class Ae extends Z {
+  /**
+   * Creates a new KuwaharaEffect instance.
+   *
+   * @param {object} [options] - Configuration options for the effect.
+   * @param {BlendFunction} [options.blendFunction] - Blend mode.
+   * @param {number} [options.radius] - Intensity of the effect.
+   * @param {number} [options.sectorCount] - Number of sectors.
+   *
+   */
+  constructor({ blendFunction: e = _.NORMAL, radius: t = 1, sectorCount: o = 4 } = {}) {
+    super("KuwaharaEffect", ft, {
+      blendFunction: e,
+      uniforms: /* @__PURE__ */ new Map([
+        ["radius", new E(t)],
+        ["sectorCount", new E(o)]
+      ])
+    });
+  }
+  /**
+   * The radius.
+   *
+   * @type {number}
+   */
+  get radius() {
+    var e;
+    return (e = this.uniforms.get("radius")) == null ? void 0 : e.value;
+  }
+  set radius(e) {
+    this.uniforms.get("radius").value = e;
+  }
+  /**
+   * The sector count.
+   *
+   * @type {number}
+   */
+  get sectorCount() {
+    var e;
+    return (e = this.uniforms.get("sectorCount")) == null ? void 0 : e.value;
+  }
+  set sectorCount(e) {
+    this.uniforms.get("sectorCount").value = e;
+  }
+}
+const jt = /* @__PURE__ */ c({
+  __name: "KuwaharaPmndrs",
+  props: {
+    blendFunction: {},
+    radius: {},
+    sectorCount: {}
+  },
+  setup(r, { expose: e }) {
+    const t = r, { pass: o, effect: a } = h(
+      () => new Ae(t),
+      t
+    );
+    return e({ pass: o, effect: a }), g(
+      [
+        [() => t.blendFunction, "blendMode.blendFunction"],
+        [() => t.radius, "radius"],
+        [() => t.sectorCount, "sectorCount"]
+      ],
+      a,
+      () => new Ae()
+    ), () => {
+    };
+  }
+}), Vt = /* @__PURE__ */ c({
+  __name: "ColorAveragePmndrs",
+  props: {
+    blendFunction: {},
+    opacity: {}
+  },
+  setup(r, { expose: e }) {
+    const t = r, { pass: o, effect: a } = h(() => new Q(t.blendFunction), t);
+    return e({ pass: o, effect: a }), ee(
+      () => t.blendFunction,
+      a,
+      "blendMode.blendFunction",
+      () => new Q()
+    ), C(
+      [a, () => t.opacity],
+      () => {
+        var s, i;
+        if (a.value)
+          if (t.opacity !== void 0)
+            (s = a.value) == null || s.blendMode.setOpacity(t.opacity);
+          else {
+            const n = new Q();
+            (i = a.value) == null || i.blendMode.setOpacity(n.blendMode.getOpacity()), n.dispose();
+          }
+      }
+    ), () => {
+    };
+  }
+}), Yt = /* @__PURE__ */ c({
+  __name: "LensDistortionPmndrs",
+  props: {
+    distortion: {},
+    principalPoint: {},
+    focalLength: {},
+    skew: {}
+  },
+  setup(r, { expose: e }) {
+    const t = r, { pass: o, effect: a } = h(
+      () => new de({
+        ...t,
+        distortion: t.distortion ? Array.isArray(t.distortion) ? new d(...t.distortion) : t.distortion : new d(),
+        principalPoint: t.principalPoint ? Array.isArray(t.principalPoint) ? new d(...t.principalPoint) : t.principalPoint : new d(),
+        focalLength: t.focalLength ? Array.isArray(t.focalLength) ? new d(...t.focalLength) : t.focalLength : new d()
+      }),
+      t
+    );
+    return e({ pass: o, effect: a }), U(
+      t,
+      a,
+      () => new de()
+    ), () => {
+    };
+  }
+}), qt = /* @__PURE__ */ c({
+  __name: "ShockWavePmndrs",
+  props: {
+    position: {},
+    amplitude: {},
+    speed: {},
+    maxRadius: {},
+    waveSize: {}
+  },
+  setup(r, { expose: e }) {
+    const t = r, { camera: o } = A(), { pass: a, effect: s } = h(
+      () => new fe(o.value, Array.isArray(t.position) ? new P(...t.position) : t.position, t),
+      t
+    );
+    return e({ pass: a, effect: s }), C(
+      () => t.position,
+      (i) => {
+        s.value && (Array.isArray(i) ? s.value.position.set(...i) : i instanceof P && s.value.position.copy(i));
+      },
+      { immediate: !0 }
+    ), g(
+      [
+        [() => t.amplitude, "amplitude"],
+        [() => t.waveSize, "waveSize"],
+        [() => t.maxRadius, "maxRadius"],
+        [() => t.speed, "speed"]
+      ],
+      s,
+      () => new fe()
+    ), () => {
+    };
+  }
+}), kt = /* @__PURE__ */ c({
+  __name: "TiltShiftPmndrs",
+  props: {
+    blendFunction: {},
+    offset: {},
+    rotation: {},
+    focusArea: {},
+    feather: {},
+    kernelSize: {},
+    resolutionScale: {},
+    resolutionX: {},
+    resolutionY: {}
+  },
+  setup(r, { expose: e }) {
+    const t = r, { pass: o, effect: a } = h(() => new he(t), t);
+    return e({ pass: o, effect: a }), g(
+      [
+        [() => t.blendFunction, "blendMode.blendFunction"],
+        [() => t.offset, "offset"],
+        [() => t.rotation, "rotation"],
+        [() => t.focusArea, "focusArea"],
+        [() => t.feather, "feather"],
+        [() => t.kernelSize, "kernelSize"],
+        [() => t.resolutionScale, "resolution.scale"],
+        [() => t.resolutionX, "resolution.width"],
+        [() => t.resolutionY, "resolution.height"]
+      ],
+      a,
+      () => new he()
+    ), () => {
+    };
+  }
+}), Qt = /* @__PURE__ */ c({
+  __name: "DotScreenPmndrs",
+  props: {
+    angle: {},
+    scale: {},
+    blendFunction: {}
+  },
+  setup(r, { expose: e }) {
+    const t = r, { pass: o, effect: a } = h(() => new pe(t), t);
+    return e({ pass: o, effect: a }), g(
+      [
+        [() => t.blendFunction, "blendMode.blendFunction"],
+        [() => t.angle, "angle"],
+        [() => t.scale, "scale"]
+      ],
+      a,
+      () => new pe()
+    ), () => {
+    };
+  }
+}), Kt = /* @__PURE__ */ c({
+  __name: "SepiaPmndrs",
+  props: {
+    blendFunction: {},
+    intensity: {}
+  },
+  setup(r, { expose: e }) {
+    const t = r, { pass: o, effect: a } = h(() => new me(t), t);
+    return e({ pass: o, effect: a }), g(
+      [
+        [() => t.blendFunction, "blendMode.blendFunction"],
+        [() => t.intensity, "intensity"]
+      ],
+      a,
+      () => new me()
+    ), () => {
+    };
+  }
+});
+class we extends Z {
+  /**
+   * Creates a new LinocutEffect instance.
+   *
+   * @param {LinocutPmndrsProps} [options] - Configuration options for the effect.
+   *
+   */
+  constructor({ blendFunction: e = _.NORMAL, scale: t = 0.85, noiseScale: o = 0, center: a = [0.5, 0.5], rotation: s = 0 } = {}) {
+    const i = Array.isArray(a) ? new d().fromArray(a) : a;
+    super("LinocutEffect", `
+    uniform float scale;
+    uniform float noiseScale;
+    uniform vec2 center;
+    uniform float rotation;
+
+    float luma(vec3 color) {
+      return dot(color, vec3(0.299, 0.587, 0.114));
+    }
+
+    float luma(vec4 color) {
+      return dot(color.rgb, vec3(0.299, 0.587, 0.114));
+    }
+
+    // Simple pseudo-random noise function
+    float noise(vec2 p) {
+      return fract(sin(dot(p, vec2(12.9898, 78.233))) * 43758.5453123);
+    }
+
+    void mainImage(const in vec4 inputColor, const in vec2 uv, out vec4 outputColor) {
+      // Calculate the center based on center
+      vec2 fragCoord = uv * resolution.xy;
+
+      // Apply rotation to the coordinates
+      vec2 d = fragCoord - center * resolution.xy;
+      mat2 rotMat = mat2(cos(rotation), -sin(rotation), sin(rotation), cos(rotation));
+      vec2 rotatedD = d * rotMat;
+
+      // Calculate radial distance and angle
+      float r = length(rotatedD) / (1000.0 / max(scale, 0.01)); // Normalization to avoid artifacts
+      float a = atan(rotatedD.y, rotatedD.x) + scale * (0.5 - r) / 0.5;
+
+      // Calculate transformed coordinates
+      vec2 uvt = center * resolution.xy + r * vec2(cos(a), sin(a));
+
+      // Normalize UV coordinates
+      vec2 uv2 = fragCoord / resolution.xy;
+
+      // Generate sinusoidal line patterns
+      float c = (0.75 + 0.25 * sin(uvt.x * 1000.0 * max(scale, 0.01))); // Prevent excessive distortions
+
+      // Load the texture and convert to grayscale
+      vec4 color = texture(inputBuffer, uv2);
+      color.rgb = color.rgb * color.rgb; // Convert from sRGB to linear
+      float l = luma(color);
+
+      // Add noise based on noiseScale
+      float n = noise(uv2 * 10.0); // Generate noise
+      l += noiseScale * (n - 0.5); // Apply noise as a perturbation
+
+      // Apply smoothing to achieve the linocut effect
+      float f = smoothstep(0.5 * c, c, l);
+      f = smoothstep(0.0, 0.5, f);
+
+      // Convert the final value back to sRGB
+      f = sqrt(f);
+
+      // Output the final color in black and white
+      outputColor = vec4(vec3(f), 1.0);
+    }
+    `, {
+      blendFunction: e,
+      uniforms: /* @__PURE__ */ new Map([
+        ["scale", new E(t)],
+        ["noiseScale", new E(o)],
+        ["center", new E(i)],
+        ["rotation", new E(s)]
+      ])
+    });
+  }
+  get scale() {
+    var e;
+    return (e = this.uniforms.get("scale")) == null ? void 0 : e.value;
+  }
+  set scale(e) {
+    this.uniforms.get("scale").value = e;
+  }
+  get noiseScale() {
+    var e;
+    return (e = this.uniforms.get("noiseScale")) == null ? void 0 : e.value;
+  }
+  set noiseScale(e) {
+    this.uniforms.get("noiseScale").value = e;
+  }
+  get center() {
+    var e;
+    return (e = this.uniforms.get("center")) == null ? void 0 : e.value;
+  }
+  set center(e) {
+    this.uniforms.get("center").value = Array.isArray(e) ? new d().fromArray(e) : e;
+  }
+  get rotation() {
+    var e;
+    return (e = this.uniforms.get("rotation")) == null ? void 0 : e.value;
+  }
+  set rotation(e) {
+    this.uniforms.get("rotation").value = e;
+  }
+}
+const Jt = /* @__PURE__ */ c({
+  __name: "LinocutPmndrs",
+  props: {
+    blendFunction: {},
+    scale: {},
+    noiseScale: {},
+    center: {},
+    rotation: {}
+  },
+  setup(r, { expose: e }) {
+    const t = r, { pass: o, effect: a } = h(
+      () => new we({
+        ...t,
+        center: t.center instanceof d ? [t.center.x, t.center.y] : t.center
+      }),
+      t
+    );
+    return e({ pass: o, effect: a }), g(
+      [
+        [() => t.blendFunction, "blendMode.blendFunction"],
+        [() => t.scale, "scale"],
+        [() => t.noiseScale, "noiseScale"],
+        [() => t.center, "center"],
+        [() => t.rotation, "rotation"]
+      ],
+      a,
+      () => new we()
+    ), () => {
+    };
+  }
+}), Be = {
   name: "CopyShader",
   uniforms: {
     tDiffuse: { value: null },
@@ -48,7 +1092,7 @@ const Q = {
 		}`
   )
 };
-class m {
+class T {
   constructor() {
     this.isPass = !0, this.enabled = !0, this.needsSwap = !0, this.clear = !1, this.renderToScreen = !1;
   }
@@ -60,22 +1104,22 @@ class m {
   dispose() {
   }
 }
-const Me = new ee(-1, 1, 1, -1, 0, 1);
-class we extends te {
+const ht = new Ie(-1, 1, 1, -1, 0, 1);
+class pt extends je {
   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 ge([-1, 3, 0, -1, -1, 0, 3, -1, 0], 3)), this.setAttribute("uv", new ge([0, 2, 0, 0, 2, 0], 2));
   }
 }
-const ye = new we();
-class T {
+const mt = new pt();
+class L {
   constructor(e) {
-    this._mesh = new se(ye, e);
+    this._mesh = new Ve(mt, e);
   }
   dispose() {
     this._mesh.geometry.dispose();
   }
   render(e) {
-    e.render(this._mesh, Me);
+    e.render(this._mesh, ht);
   }
   get material() {
     return this._mesh.material;
@@ -84,35 +1128,35 @@ class T {
     this._mesh.material = e;
   }
 }
-class De extends m {
+class gt extends T {
   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 S ? (this.uniforms = e.uniforms, this.material = e) : e && (this.uniforms = M.clone(e.uniforms), this.material = new S({
       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 L(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));
+  render(e, t, o) {
+    this.uniforms[this.textureID] && (this.uniforms[this.textureID].value = o.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));
   }
   dispose() {
     this.material.dispose(), this.fsQuad.dispose();
   }
 }
-class U extends m {
+class Te extends T {
   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);
+  render(e, t, o) {
+    const a = e.getContext(), s = e.state;
+    s.buffers.color.setMask(!1), s.buffers.depth.setMask(!1), s.buffers.color.setLocked(!0), s.buffers.depth.setLocked(!0);
+    let i, n;
+    this.inverse ? (i = 0, n = 1) : (i = 1, n = 0), s.buffers.stencil.setTest(!0), s.buffers.stencil.setOp(a.REPLACE, a.REPLACE, a.REPLACE), s.buffers.stencil.setFunc(a.ALWAYS, i, 4294967295), s.buffers.stencil.setClear(n), s.buffers.stencil.setLocked(!0), e.setRenderTarget(o), this.clear && e.clear(), e.render(this.scene, this.camera), e.setRenderTarget(t), this.clear && e.clear(), e.render(this.scene, this.camera), s.buffers.color.setLocked(!1), s.buffers.depth.setLocked(!1), s.buffers.color.setMask(!0), s.buffers.depth.setMask(!0), s.buffers.stencil.setLocked(!1), s.buffers.stencil.setFunc(a.EQUAL, 1, 4294967295), s.buffers.stencil.setOp(a.KEEP, a.KEEP, a.KEEP), s.buffers.stencil.setLocked(!0);
   }
 }
-class Ce extends m {
+class vt extends T {
   constructor() {
     super(), this.needsSwap = !1;
   }
@@ -120,14 +1164,14 @@ class Ce extends m {
     e.state.buffers.stencil.setLocked(!1), e.state.buffers.stencil.setTest(!1);
   }
 }
-class Ee {
+class xt {
   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 o = e.getSize(new d());
+      this._width = o.width, this._height = o.height, t = new D(this._width * this._pixelRatio, this._height * this._pixelRatio, { type: w }), 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 gt(Be), this.copyPass.material.blending = Ye, this.clock = new qe();
   }
   swapBuffers() {
     const e = this.readBuffer;
@@ -152,35 +1196,35 @@ class Ee {
   render(e) {
     e === void 0 && (e = this.clock.getDelta());
     const t = this.renderer.getRenderTarget();
-    let s = !1;
-    for (let a = 0, r = this.passes.length; a < r; a++) {
+    let o = !1;
+    for (let a = 0, s = this.passes.length; a < s; 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) {
-          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);
+        if (i.renderToScreen = this.renderToScreen && this.isLastEnabledPass(a), i.render(this.renderer, this.writeBuffer, this.readBuffer, e, o), i.needsSwap) {
+          if (o) {
+            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));
+        Te !== void 0 && (i instanceof Te ? o = !0 : i instanceof vt && (o = !1));
       }
     }
     this.renderer.setRenderTarget(t);
   }
   reset(e) {
     if (e === void 0) {
-      const t = this.renderer.getSize(new u());
+      const t = this.renderer.getSize(new d());
       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;
   }
   setSize(e, t) {
     this._width = e, this._height = t;
-    const s = this._width * this._pixelRatio, a = this._height * this._pixelRatio;
-    this.renderTarget1.setSize(s, a), this.renderTarget2.setSize(s, a);
-    for (let r = 0; r < this.passes.length; r++)
-      this.passes[r].setSize(s, a);
+    const o = this._width * this._pixelRatio, a = this._height * this._pixelRatio;
+    this.renderTarget1.setSize(o, a), this.renderTarget2.setSize(o, a);
+    for (let s = 0; s < this.passes.length; s++)
+      this.passes[s].setSize(o, a);
   }
   setPixelRatio(e) {
     this._pixelRatio = e, this.setSize(this._width, this._height);
@@ -189,61 +1233,61 @@ class Ee {
     this.renderTarget1.dispose(), this.renderTarget2.dispose(), this.copyPass.dispose();
   }
 }
-class Le extends m {
-  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();
+class bt extends T {
+  constructor(e, t, o = null, a = null, s = null) {
+    super(), this.scene = e, this.camera = t, this.overrideMaterial = o, this.clearColor = a, this.clearAlpha = s, this.clear = !0, this.clearDepth = !1, this.needsSwap = !1, this._oldClearColor = new j();
   }
-  render(e, t, s) {
+  render(e, t, o) {
     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 s, 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 && (s = e.getClearAlpha(), e.setClearAlpha(this.clearAlpha)), this.clearDepth == !0 && e.clearDepth(), e.setRenderTarget(this.renderToScreen ? null : o), 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(s), this.overrideMaterial !== null && (this.scene.overrideMaterial = i), e.autoClear = a;
   }
 }
-const q = Symbol("effectComposerThree"), Xe = /* @__PURE__ */ S({
+const Ne = Symbol("effectComposerThree"), Zt = /* @__PURE__ */ c({
   __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(r, { expose: e }) {
+    const t = r, o = z(null);
+    Ce(Ne, o), e({ composer: o });
+    const { renderer: a, sizes: s, scene: i, camera: n, render: l } = A();
+    v(() => {
+      var f;
+      (f = o.value) == null || f.dispose(), o.value = new xt(a.value);
+    }), v(() => {
+      var H;
+      const { width: f, height: y } = s;
+      y.value && f.value && ((H = o.value) == null || H.setSize(f.value, y.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: u } = Le();
+    v(() => {
+      var f;
+      (f = o.value) == null || f.setPixelRatio(u.value);
+    }), t.withoutRenderPass || v(() => {
+      n.value && i.value && o.value && o.value.addPass(new bt(i.value, n.value));
     });
-    const { render: p } = G();
+    const { render: p } = W();
     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);
-    }), 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()));
+      l.frames.value > 0 && o.value && t.enabled && o.value.render(), l.frames.value = l.mode.value === "always" ? 1 : Math.max(0, l.frames.value - 1);
+    }), V(() => {
+      var f;
+      (f = o.value) == null || f.dispose();
+    }), (f, y) => Ee(f.$slots, "default");
+  }
+}), B = (r, e) => {
+  const t = De(Ne), o = z(r()), { sizes: a, invalidate: s } = A();
+  e && C(e, () => s());
+  const i = v(() => {
+    !(t != null && t.value) || !a.height.value || !a.width.value || (t.value.addPass(o.value), Pe(() => i()));
   });
-  return j(() => {
-    var l;
-    (l = t == null ? void 0 : t.value) == null || l.removePass(s.value), s.value.dispose();
-  }), { pass: s };
-}, Pe = {
+  return V(() => {
+    var n;
+    (n = t == null ? void 0 : t.value) == null || n.removePass(o.value), o.value.dispose();
+  }), { pass: o };
+}, St = {
   uniforms: {
     tDiffuse: { value: null },
     //diffuse texture
@@ -338,53 +1382,53 @@ const q = Symbol("effectComposerThree"), Xe = /* @__PURE__ */ S({
 		}`
   )
 };
-class H extends m {
+class ye extends T {
   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 = St;
+    this.uniforms = M.clone(t.uniforms), this.heightMap = this.generateHeightmap(e), this.uniforms.tDisp.value = this.heightMap, this.material = new S({
       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 L(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));
+  render(e, t, o) {
+    this.uniforms.tDiffuse.value = o.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 = b.randFloat(-Math.PI, Math.PI), this.uniforms.seed_x.value = b.randFloat(-1, 1), this.uniforms.seed_y.value = b.randFloat(-1, 1), this.uniforms.distortion_x.value = b.randFloat(0, 1), this.uniforms.distortion_y.value = b.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 = b.randFloat(-Math.PI, Math.PI), this.uniforms.distortion_x.value = b.randFloat(0, 1), this.uniforms.distortion_y.value = b.randFloat(0, 1), this.uniforms.seed_x.value = b.randFloat(-0.3, 0.3), this.uniforms.seed_y.value = b.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 = b.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 t = new Float32Array(e * e), o = e * e;
+    for (let s = 0; s < o; s++) {
+      const i = b.randFloat(0, 1);
+      t[s] = i;
     }
-    const a = new ie(t, e, e, oe, le);
+    const a = new ke(t, e, e, Qe, Ke);
     return a.needsUpdate = !0, a;
   }
   dispose() {
     this.material.dispose(), this.heightMap.dispose(), this.fsQuad.dispose();
   }
 }
-const Ge = /* @__PURE__ */ S({
+const _t = /* @__PURE__ */ c({
   __name: "Glitch",
   props: {
     dtSize: {},
     goWild: { type: Boolean }
   },
-  setup(o, { expose: e }) {
-    const t = o, { pass: s } = y(() => new H(t.dtSize), t);
-    e({ pass: s });
-    const { onBeforeRender: a } = G();
-    return a(({ invalidate: r }) => r()), Y(
+  setup(r, { expose: e }) {
+    const t = r, { pass: o } = B(() => new ye(t.dtSize), t);
+    e({ pass: o });
+    const { onBeforeRender: a } = W();
+    return a(({ invalidate: s }) => s()), g(
       [[() => t.goWild, "goWild"]],
-      s,
-      () => new H()
+      o,
+      () => new ye()
     ), () => {
     };
   }
-}), P = {
+}), I = {
   name: "HalftoneShader",
   uniforms: {
     tDiffuse: { value: null },
@@ -688,19 +1732,19 @@ const Ge = /* @__PURE__ */ S({
 		}`
   )
 };
-class Ne extends m {
-  constructor(e, t, s) {
-    super(), this.uniforms = g.clone(P.uniforms), this.material = new c({
+class At extends T {
+  constructor(e, t, o) {
+    super(), this.uniforms = M.clone(I.uniforms), this.material = new S({
       uniforms: this.uniforms,
-      fragmentShader: P.fragmentShader,
-      vertexShader: P.vertexShader
+      fragmentShader: I.fragmentShader,
+      vertexShader: I.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);
+    for (const a in o)
+      o.hasOwnProperty(a) && this.uniforms.hasOwnProperty(a) && (this.uniforms[a].value = o[a]);
+    this.fsQuad = new L(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));
+  render(e, t, o) {
+    this.material.uniforms.tDiffuse.value = o.texture, this.renderToScreen ? (e.setRenderTarget(null), this.fsQuad.render(e)) : (e.setRenderTarget(t), this.clear && e.clear(), this.fsQuad.render(e));
   }
   setSize(e, t) {
     this.uniforms.width.value = e, this.uniforms.height.value = t;
@@ -709,7 +1753,7 @@ class Ne extends m {
     this.material.dispose(), this.fsQuad.dispose();
   }
 }
-const Ie = /* @__PURE__ */ S({
+const $t = /* @__PURE__ */ c({
   __name: "Halftone",
   props: {
     shape: {},
@@ -722,55 +1766,55 @@ const Ie = /* @__PURE__ */ S({
     greyscale: { type: Boolean },
     blendingMode: {}
   },
-  setup(o, { expose: e }) {
-    const t = o, { sizes: s } = w(), a = O(
+  setup(r, { expose: e }) {
+    const t = r, { sizes: o } = A(), a = F(
       () => Object.fromEntries(
-        Object.entries(t).filter(([i, l]) => l !== void 0)
+        Object.entries(t).filter(([i, n]) => n !== void 0)
       )
-    ), { pass: r } = y(() => new Ne(
-      s.width.value,
-      s.height.value,
+    ), { pass: s } = B(() => new At(
+      o.width.value,
+      o.height.value,
       a.value
     ), t);
-    return e({ pass: r }), f(() => {
-      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);
+    return e({ pass: s }), v(() => {
+      s.value.setSize(o.width.value, o.height.value);
+    }), v(() => {
+      Object.entries(t).forEach(([i, n]) => {
+        i in s.value.uniforms && (s.value.uniforms[i].value = n ?? I.uniforms[i].value);
       });
     }), () => {
     };
   }
 });
-class X extends m {
-  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;
+class Me extends T {
+  constructor(e, t, o, a = {}) {
+    super(), this.pixelSize = e, this.resolution = new d(), this.renderResolution = new d(), this.pixelatedMaterial = this.createPixelatedMaterial(), this.normalMaterial = new Je(), this.fsQuad = new L(this.pixelatedMaterial), this.scene = t, this.camera = o, this.normalEdgeStrength = a.normalEdgeStrength || 0.3, this.depthEdgeStrength = a.depthEdgeStrength || 0.4, this.beautyRenderTarget = new D(), this.beautyRenderTarget.texture.minFilter = O, this.beautyRenderTarget.texture.magFilter = O, this.beautyRenderTarget.texture.type = w, this.beautyRenderTarget.depthTexture = new Ze(), this.normalRenderTarget = new D(), this.normalRenderTarget.texture.minFilter = O, this.normalRenderTarget.texture.magFilter = O, this.normalRenderTarget.texture.type = w;
   }
   dispose() {
     this.beautyRenderTarget.dispose(), this.normalRenderTarget.dispose(), this.pixelatedMaterial.dispose(), this.normalMaterial.dispose(), this.fsQuad.dispose();
   }
   setSize(e, t) {
     this.resolution.set(e, t), this.renderResolution.set(e / this.pixelSize | 0, t / this.pixelSize | 0);
-    const { x: s, y: a } = this.renderResolution;
-    this.beautyRenderTarget.setSize(s, a), this.normalRenderTarget.setSize(s, a), this.fsQuad.material.uniforms.resolution.value.set(s, a, 1 / s, 1 / a);
+    const { x: o, y: a } = this.renderResolution;
+    this.beautyRenderTarget.setSize(o, a), this.normalRenderTarget.setSize(o, a), this.fsQuad.material.uniforms.resolution.value.set(o, a, 1 / o, 1 / a);
   }
   setPixelSize(e) {
     this.pixelSize = e, this.setSize(this.resolution.x, this.resolution.y);
   }
   render(e, t) {
-    const s = this.fsQuad.material.uniforms;
-    s.normalEdgeStrength.value = this.normalEdgeStrength, s.depthEdgeStrength.value = this.depthEdgeStrength, e.setRenderTarget(this.beautyRenderTarget), e.render(this.scene, this.camera);
+    const o = this.fsQuad.material.uniforms;
+    o.normalEdgeStrength.value = this.normalEdgeStrength, o.depthEdgeStrength.value = this.depthEdgeStrength, e.setRenderTarget(this.beautyRenderTarget), e.render(this.scene, this.camera);
     const a = this.scene.overrideMaterial;
-    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);
+    e.setRenderTarget(this.normalRenderTarget), this.scene.overrideMaterial = this.normalMaterial, e.render(this.scene, this.camera), this.scene.overrideMaterial = a, o.tDiffuse.value = this.beautyRenderTarget.texture, o.tDepth.value = this.beautyRenderTarget.depthTexture, o.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 S({
       uniforms: {
         tDiffuse: { value: null },
         tDepth: { value: null },
         tNormal: { value: null },
         resolution: {
-          value: new ue(
+          value: new _e(
             this.renderResolution.x,
             this.renderResolution.y,
             1 / this.renderResolution.x,
@@ -889,28 +1933,28 @@ class X extends m {
     });
   }
 }
-const je = /* @__PURE__ */ S({
+const eo = /* @__PURE__ */ c({
   __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(() => {
-      r.value.setPixelSize(t.pixelSize);
-    }), Y(
+  setup(r, { expose: e }) {
+    const t = r, { scene: o, camera: a } = A(), { pass: s } = B(() => new Me(t.pixelSize, o.value, a.value), t);
+    return e({ pass: s }), v(() => {
+      s.value.setPixelSize(t.pixelSize);
+    }), g(
       [
         [() => t.depthEdgeStrength, "depthEdgeStrength"],
         [() => t.normalEdgeStrength, "normalEdgeStrength"]
       ],
-      r,
-      () => new X(1, s.value, a.value)
+      s,
+      () => new Me(1, o.value, a.value)
     ), () => {
     };
   }
-}), Re = {
+}), wt = {
   name: "OutputShader",
   uniforms: {
     tDiffuse: { value: null },
@@ -992,39 +2036,39 @@ const je = /* @__PURE__ */ S({
 		}`
   )
 };
-class Oe extends m {
+class Tt extends T {
   constructor() {
     super();
-    const e = Re;
-    this.uniforms = g.clone(e.uniforms), this.material = new he({
+    const e = wt;
+    this.uniforms = M.clone(e.uniforms), this.material = new $e({
       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 L(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));
+  render(e, t, o) {
+    this.uniforms.tDiffuse.value = o.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 = {}, et.getTransfer(this._outputColorSpace) === tt && (this.material.defines.SRGB_TRANSFER = ""), this._toneMapping === ot ? this.material.defines.LINEAR_TONE_MAPPING = "" : this._toneMapping === at ? this.material.defines.REINHARD_TONE_MAPPING = "" : this._toneMapping === st ? this.material.defines.CINEON_TONE_MAPPING = "" : this._toneMapping === rt ? this.material.defines.ACES_FILMIC_TONE_MAPPING = "" : this._toneMapping === it ? this.material.defines.AGX_TONE_MAPPING = "" : this._toneMapping === nt && (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 to = /* @__PURE__ */ c({
   __name: "Output",
-  setup(o, { expose: e }) {
-    const { pass: t } = y(() => new Oe());
+  setup(r, { expose: e }) {
+    const { pass: t } = B(() => new Tt());
     return e({ pass: t }), () => {
     };
   }
-}), E = {
+}), G = {
   name: "SMAAEdgesShader",
   defines: {
     SMAA_THRESHOLD: "0.1"
   },
   uniforms: {
     tDiffuse: { value: null },
-    resolution: { value: new u(1 / 1024, 1 / 512) }
+    resolution: { value: new d(1 / 1024, 1 / 512) }
   },
   vertexShader: (
     /* glsl */
@@ -1118,7 +2162,7 @@ const Ve = /* @__PURE__ */ S({
 
 		}`
   )
-}, L = {
+}, X = {
   name: "SMAAWeightsShader",
   defines: {
     SMAA_MAX_SEARCH_STEPS: "8",
@@ -1130,7 +2174,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 d(1 / 1024, 1 / 512) }
   },
   vertexShader: (
     /* glsl */
@@ -1368,12 +2412,12 @@ const Ve = /* @__PURE__ */ S({
 
 		}`
   )
-}, R = {
+}, J = {
   name: "SMAABlendShader",
   uniforms: {
     tDiffuse: { value: null },
     tColor: { value: null },
-    resolution: { value: new u(1 / 1024, 1 / 512) }
+    resolution: { value: new d(1 / 1024, 1 / 512) }
   },
   vertexShader: (
     /* glsl */
@@ -1458,40 +2502,40 @@ const Ve = /* @__PURE__ */ S({
 		}`
   )
 };
-class ze extends m {
+class yt extends T {
   constructor(e, t) {
-    super(), this.edgesRT = new v(e, t, {
+    super(), this.edgesRT = new D(e, t, {
       depthBuffer: !1,
-      type: x
-    }), this.edgesRT.texture.name = "SMAAPass.edges", this.weightsRT = new v(e, t, {
+      type: w
+    }), this.edgesRT.texture.name = "SMAAPass.edges", this.weightsRT = new D(e, t, {
       depthBuffer: !1,
-      type: x
+      type: w
     }), this.weightsRT.texture.name = "SMAAPass.weights";
-    const s = this, a = new Image();
+    const o = 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;
-    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),
+      o.areaTexture.needsUpdate = !0;
+    }, this.areaTexture = new ve(), this.areaTexture.name = "SMAAPass.area", this.areaTexture.image = a, this.areaTexture.minFilter = lt, this.areaTexture.generateMipmaps = !1, this.areaTexture.flipY = !1;
+    const s = new Image();
+    s.src = this.getSearchTexture(), s.onload = function() {
+      o.searchTexture.needsUpdate = !0;
+    }, this.searchTexture = new ve(), this.searchTexture.name = "SMAAPass.search", this.searchTexture.image = s, this.searchTexture.magFilter = O, this.searchTexture.minFilter = O, this.searchTexture.generateMipmaps = !1, this.searchTexture.flipY = !1, this.uniformsEdges = M.clone(G.uniforms), this.uniformsEdges.resolution.value.set(1 / e, 1 / t), this.materialEdges = new S({
+      defines: Object.assign({}, G.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: G.vertexShader,
+      fragmentShader: G.fragmentShader
+    }), this.uniformsWeights = M.clone(X.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 S({
+      defines: Object.assign({}, X.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: X.vertexShader,
+      fragmentShader: X.fragmentShader
+    }), this.uniformsBlend = M.clone(J.uniforms), this.uniformsBlend.resolution.value.set(1 / e, 1 / t), this.uniformsBlend.tDiffuse.value = this.weightsRT.texture, this.materialBlend = new S({
       uniforms: this.uniformsBlend,
-      vertexShader: R.vertexShader,
-      fragmentShader: R.fragmentShader
-    }), this.fsQuad = new T(null);
+      vertexShader: J.vertexShader,
+      fragmentShader: J.fragmentShader
+    }), this.fsQuad = new L(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));
+  render(e, t, o) {
+    this.uniformsEdges.tDiffuse.value = o.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 = o.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));
   }
   setSize(e, t) {
     this.edgesRT.setSize(e, t), this.weightsRT.setSize(e, t), this.materialEdges.uniforms.resolution.value.set(1 / e, 1 / t), this.materialWeights.uniforms.resolution.value.set(1 / e, 1 / t), this.materialBlend.uniforms.resolution.value.set(1 / e, 1 / t);
@@ -1506,27 +2550,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 oo = /* @__PURE__ */ c({
   __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(r, { expose: e }) {
+    const t = r, { sizes: o } = A(), { pixelRatio: a } = Le(), s = F(() => t.width ?? o.width.value * a.value), i = F(() => t.height ?? o.height.value * a.value), { pass: n } = B(() => new yt(s.value, i.value), t);
+    return e({ pass: n }), v(() => {
+      n.value.setSize(s.value, i.value);
     }), () => {
     };
   }
-}), K = {
+}), ze = {
   name: "LuminosityHighPassShader",
   shaderID: "luminosityHighPass",
   uniforms: {
     tDiffuse: { value: null },
     luminosityThreshold: { value: 1 },
     smoothWidth: { value: 1 },
-    defaultColor: { value: new N(0) },
+    defaultColor: { value: new j(0) },
     defaultOpacity: { value: 0 }
   },
   vertexShader: (
@@ -1570,40 +2614,40 @@ const Ye = /* @__PURE__ */ S({
 		}`
   )
 };
-class M extends m {
-  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;
+class R extends T {
+  constructor(e, t, o, a) {
+    super(), this.strength = t !== void 0 ? t : 1, this.radius = o, this.threshold = a, this.resolution = e !== void 0 ? new d(e.x, e.y) : new d(256, 256), this.clearColor = new j(0, 0, 0), this.renderTargetsHorizontal = [], this.renderTargetsVertical = [], this.nMips = 5;
+    let s = Math.round(this.resolution.x / 2), i = Math.round(this.resolution.y / 2);
+    this.renderTargetBright = new D(s, i, { type: w }), 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);
+      const f = new D(s, i, { type: w });
+      f.texture.name = "UnrealBloomPass.h" + p, f.texture.generateMipmaps = !1, this.renderTargetsHorizontal.push(f);
+      const y = new D(s, i, { type: w });
+      y.texture.name = "UnrealBloomPass.v" + p, y.texture.generateMipmaps = !1, this.renderTargetsVertical.push(y), s = Math.round(s / 2), i = Math.round(i / 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 = ze;
+    this.highPassUniforms = M.clone(n.uniforms), this.highPassUniforms.luminosityThreshold.value = a, this.highPassUniforms.smoothWidth.value = 0.01, this.materialHighPassFilter = new S({
       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);
+    const l = [3, 5, 7, 9, 11];
+    s = 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);
+      this.separableBlurMaterials.push(this.getSeparableBlurMaterial(l[p])), this.separableBlurMaterials[p].uniforms.invSize.value = new d(1 / s, 1 / i), s = Math.round(s / 2), i = Math.round(i / 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 x = [1, 0.8, 0.6, 0.4, 0.2];
+    this.compositeMaterial.uniforms.bloomFactors.value = x, this.bloomTintColors = [new P(1, 1, 1), new P(1, 1, 1), new P(1, 1, 1), new P(1, 1, 1), new P(1, 1, 1)], this.compositeMaterial.uniforms.bloomTintColors.value = this.bloomTintColors;
+    const u = Be;
+    this.copyUniforms = M.clone(u.uniforms), this.blendMaterial = new S({
       uniforms: this.copyUniforms,
-      vertexShader: D.vertexShader,
-      fragmentShader: D.fragmentShader,
-      blending: Te,
+      vertexShader: u.vertexShader,
+      fragmentShader: u.fragmentShader,
+      blending: ut,
       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 j(), this.oldClearAlpha = 1, this.basic = new ct(), this.fsQuad = new L(null);
   }
   dispose() {
     for (let e = 0; e < this.renderTargetsHorizontal.length; e++)
@@ -1616,33 +2660,33 @@ class M extends m {
     this.compositeMaterial.dispose(), this.blendMaterial.dispose(), this.basic.dispose(), this.fsQuad.dispose();
   }
   setSize(e, t) {
-    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);
+    let o = Math.round(e / 2), a = Math.round(t / 2);
+    this.renderTargetBright.setSize(o, a);
+    for (let s = 0; s < this.nMips; s++)
+      this.renderTargetsHorizontal[s].setSize(o, a), this.renderTargetsVertical[s].setSize(o, a), this.separableBlurMaterials[s].uniforms.invSize.value = new d(1 / o, 1 / a), o = Math.round(o / 2), a = Math.round(a / 2);
   }
-  render(e, t, s, a, r) {
+  render(e, t, o, a, s) {
     e.getClearColor(this._oldClearColor), this.oldClearAlpha = e.getClearAlpha();
     const i = 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;
+    e.autoClear = !1, e.setClearColor(this.clearColor, 0), s && e.state.buffers.stencil.setTest(!1), this.renderToScreen && (this.fsQuad.material = this.basic, this.basic.map = o.texture, e.setRenderTarget(null), e.clear(), this.fsQuad.render(e)), this.highPassUniforms.tDiffuse.value = o.texture, this.highPassUniforms.luminosityThreshold.value = this.threshold, this.fsQuad.material = this.materialHighPassFilter, e.setRenderTarget(this.renderTargetBright), e.clear(), this.fsQuad.render(e);
+    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 = R.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 = R.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, s && e.state.buffers.stencil.setTest(!0), this.renderToScreen ? (e.setRenderTarget(null), this.fsQuad.render(e)) : (e.setRenderTarget(o), this.fsQuad.render(e)), e.setClearColor(this._oldClearColor, this.oldClearAlpha), e.autoClear = i;
   }
-  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({
+    for (let o = 0; o < e; o++)
+      t.push(0.39894 * Math.exp(-0.5 * o * o / (e * e)) / e);
+    return new S({
       defines: {
         KERNEL_RADIUS: e
       },
       uniforms: {
         colorTexture: { value: null },
-        invSize: { value: new u(0.5, 0.5) },
+        invSize: { value: new d(0.5, 0.5) },
         // inverse texture size
-        direction: { value: new u(0.5, 0.5) },
+        direction: { value: new d(0.5, 0.5) },
         gaussianCoefficients: { value: t }
         // precomputed Gaussian coefficients
       },
@@ -1675,7 +2719,7 @@ class M extends m {
     });
   }
   getCompositeMaterial(e) {
-    return new c({
+    return new S({
       defines: {
         NUM_MIPS: e
       },
@@ -1721,42 +2765,64 @@ class M extends m {
     });
   }
 }
-M.BlurDirectionX = new u(1, 0);
-M.BlurDirectionY = new u(0, 1);
-const Qe = /* @__PURE__ */ S({
+R.BlurDirectionX = new d(1, 0);
+R.BlurDirectionY = new d(0, 1);
+const ao = /* @__PURE__ */ c({
   __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(r, { expose: e }) {
+    const t = r, { sizes: o } = A(), { pass: a } = B(() => new R(
+      new d(o.width.value, o.height.value),
       t.radius,
       t.strength,
       t.threshold
     ), t);
-    return e({ pass: a }), f(() => {
-      var r;
-      a.value.radius = t.radius ?? ((r = a.value.getCompositeMaterial().uniforms.bloomRadius) == null ? void 0 : r.value) ?? 0.1;
-    }), f(() => {
-      var r;
-      a.value.strength = t.strength ?? ((r = a.value.getCompositeMaterial().uniforms.bloomStrength) == null ? void 0 : r.value) ?? 1;
-    }), f(() => {
-      var r;
-      a.value.threshold = t.threshold ?? ((r = K.uniforms.luminosityThreshold) == null ? void 0 : r.value) ?? 1;
+    return e({ pass: a }), v(() => {
+      var s;
+      a.value.radius = t.radius ?? ((s = a.value.getCompositeMaterial().uniforms.bloomRadius) == null ? void 0 : s.value) ?? 0.1;
+    }), v(() => {
+      var s;
+      a.value.strength = t.strength ?? ((s = a.value.getCompositeMaterial().uniforms.bloomStrength) == null ? void 0 : s.value) ?? 1;
+    }), v(() => {
+      var s;
+      a.value.threshold = t.threshold ?? ((s = ze.uniforms.luminosityThreshold) == null ? void 0 : s.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
+  Ut as BarrelBlurPmndrs,
+  Ot as BloomPmndrs,
+  Gt as ChromaticAberrationPmndrs,
+  Vt as ColorAveragePmndrs,
+  Rt as DepthOfFieldPmndrs,
+  Qt as DotScreenPmndrs,
+  Zt as EffectComposer,
+  Lt as EffectComposerPmndrs,
+  _t as Glitch,
+  Bt as GlitchPmndrs,
+  $t as Halftone,
+  Xt as HueSaturationPmndrs,
+  jt as KuwaharaPmndrs,
+  Yt as LensDistortionPmndrs,
+  Jt as LinocutPmndrs,
+  Nt as NoisePmndrs,
+  zt as OutlinePmndrs,
+  to as Output,
+  eo as Pixelation,
+  Ft as PixelationPmndrs,
+  oo as SMAA,
+  It as ScanlinePmndrs,
+  Kt as SepiaPmndrs,
+  qt as ShockWavePmndrs,
+  kt as TiltShiftPmndrs,
+  Ht as ToneMappingPmndrs,
+  ao as UnrealBloom,
+  Wt as VignettePmndrs,
+  B as useEffect,
+  h as useEffectPmndrs
 };