1681-engine 0.0.0-stage → 0.5.9

package/dist/platform/fullscreen.js

@@ -0,0 +1,52 @@
+function r() {
+  return typeof document > "u" ? null : document;
+}
+function i(e = r()) {
+  return e !== null && (e.fullscreenEnabled === !0 || e.webkitFullscreenEnabled === !0);
+}
+function l(e = r()) {
+  return e ? (e.fullscreenElement ?? e.webkitFullscreenElement ?? null) !== null : !1;
+}
+async function u(e, n = r()) {
+  if (!n) return !1;
+  const t = e ?? n.documentElement;
+  if (!t) return !1;
+  try {
+    if (typeof t.requestFullscreen == "function") await t.requestFullscreen({ navigationUI: "hide" });
+    else if (typeof t.webkitRequestFullscreen == "function") t.webkitRequestFullscreen();
+    else return !1;
+  } catch {
+    return !1;
+  }
+  return l(n) || typeof t.requestFullscreen != "function";
+}
+async function s(e = r()) {
+  if (!e || !l(e)) return !1;
+  try {
+    if (typeof e.exitFullscreen == "function") await e.exitFullscreen();
+    else if (typeof e.webkitExitFullscreen == "function") e.webkitExitFullscreen();
+    else return !1;
+  } catch {
+    return !1;
+  }
+  return !0;
+}
+async function f(e, n = r()) {
+  return l(n) ? !await s(n) : u(e, n);
+}
+function c(e, n = r()) {
+  if (!n) return () => {
+  };
+  const t = () => e(l(n));
+  return n.addEventListener("fullscreenchange", t), n.addEventListener("webkitfullscreenchange", t), () => {
+    n.removeEventListener("fullscreenchange", t), n.removeEventListener("webkitfullscreenchange", t);
+  };
+}
+export {
+  u as enterFullscreen,
+  s as exitFullscreen,
+  i as fullscreenSupported,
+  l as isFullscreen,
+  c as onFullscreenChange,
+  f as toggleFullscreen
+};

package/dist/platform/orientation.js

@@ -0,0 +1,26 @@
+function r() {
+  return typeof screen > "u" || !screen.orientation ? null : screen.orientation;
+}
+async function e(t, n = r()) {
+  if (!n || typeof n.lock != "function") return !1;
+  try {
+    return await n.lock(t), !0;
+  } catch {
+    return !1;
+  }
+}
+function i(t = r()) {
+  try {
+    t?.unlock?.();
+  } catch {
+  }
+}
+function o(t = r()) {
+  const n = t?.type ?? "";
+  return n.startsWith("landscape") ? "landscape" : n.startsWith("portrait") ? "portrait" : null;
+}
+export {
+  o as currentOrientationKind,
+  e as lockOrientation,
+  i as unlockOrientation
+};

package/dist/platform/pointerLock.js

@@ -0,0 +1,37 @@
+function r() {
+  return typeof document > "u" ? null : document;
+}
+function i(e, t = r()) {
+  const n = t?.pointerLockElement ?? null;
+  return e === void 0 ? n !== null : n === e;
+}
+async function u(e, t = {}, n = r()) {
+  const o = e;
+  if (!n || typeof o.requestPointerLock != "function") return !1;
+  try {
+    await o.requestPointerLock(t.raw ? { unadjustedMovement: !0 } : void 0);
+  } catch {
+    if (!t.raw) return !1;
+    try {
+      await o.requestPointerLock();
+    } catch {
+      return !1;
+    }
+  }
+  return i(e, n);
+}
+function c(e = r()) {
+  e?.pointerLockElement && e.exitPointerLock?.();
+}
+function a(e, t = r()) {
+  if (!t) return () => {
+  };
+  const n = () => e(i(void 0, t));
+  return t.addEventListener("pointerlockchange", n), () => t.removeEventListener("pointerlockchange", n);
+}
+export {
+  c as exitPointerLock,
+  i as isPointerLocked,
+  a as onPointerLockChange,
+  u as requestPointerLock
+};

package/dist/platform/reducedMotion.js

@@ -0,0 +1,23 @@
+import { engineSettings as o } from "../settings.js";
+const c = "(prefers-reduced-motion: reduce)";
+function r() {
+  return typeof matchMedia == "function" ? matchMedia(c) : null;
+}
+function u(n = r()) {
+  return n?.matches === !0;
+}
+function i(n, e = r()) {
+  if (!e) return () => {
+  };
+  const t = () => n(e.matches);
+  return typeof e.addEventListener == "function" ? (e.addEventListener("change", t), () => e.removeEventListener?.("change", t)) : (e.addListener?.(t), () => e.removeListener?.(t));
+}
+function f(n = r()) {
+  return n ? (o.set({ reducedFx: n.matches }), i((e) => o.set({ reducedFx: e }), n)) : () => {
+  };
+}
+export {
+  f as followReducedMotion,
+  i as onReducedMotionChange,
+  u as prefersReducedMotion
+};

package/dist/platform/timeoutSignal.js

@@ -0,0 +1,14 @@
+function i(t) {
+  const o = AbortSignal.timeout;
+  if (typeof o == "function") return o.call(AbortSignal, t);
+  const r = new AbortController();
+  return setTimeout(() => r.abort(e()), t).unref?.(), r.signal;
+}
+function e() {
+  if (typeof DOMException == "function") return new DOMException("The operation timed out.", "TimeoutError");
+  const t = new Error("The operation timed out.");
+  return t.name = "TimeoutError", t;
+}
+export {
+  i as timeoutSignal
+};

package/dist/platform/touch.js

@@ -0,0 +1,32 @@
+import { detectTouch as r } from "../input/touchDetect.js";
+let t = null, n = !1, o = "engine.touch";
+function u(e) {
+  n = e, t = null;
+}
+function l(e) {
+  o = e, t = null;
+}
+function i() {
+  try {
+    const e = new URLSearchParams(window.location.search).get("touch");
+    return e !== null ? e : localStorage.getItem(o);
+  } catch {
+    return null;
+  }
+}
+function c() {
+  return {
+    native: n,
+    coarse: typeof matchMedia == "function" && matchMedia("(pointer: coarse)").matches,
+    touchPoints: typeof navigator < "u" ? navigator.maxTouchPoints ?? 0 : 0,
+    override: i()
+  };
+}
+function d() {
+  return t === null && (t = typeof window < "u" && r(c())), t;
+}
+export {
+  d as isTouchUi,
+  u as setNativeShell,
+  l as setTouchOverrideKey
+};

package/dist/postfx/BloomFilter.js

@@ -0,0 +1,64 @@
+import { BlurFilter as a, TexturePool as s } from "pixi.js";
+import { FxFilter as u } from "./fxShader.js";
+class c extends u {
+  constructor(t, e) {
+    super({
+      name: "bloom-bright",
+      uniforms: { uThreshold: { type: "f32", value: t }, uKnee: { type: "f32", value: e } },
+      glsl: `
+  vec3 c = src.a > 0.0 ? src.rgb / src.a : src.rgb;
+  float l = max(c.r, max(c.g, c.b));
+  float k = smoothstep(uThreshold, uThreshold + max(uKnee, 0.0001), l);
+  result = src * k;`,
+      wgsl: `
+  var c = src.rgb;
+  if (src.a > 0.0) { c = src.rgb / src.a; }
+  let l = max(c.r, max(c.g, c.b));
+  let k = smoothstep(fx.uThreshold, fx.uThreshold + max(fx.uKnee, 0.0001), l);
+  result = src * k;`
+    });
+  }
+}
+class m extends u {
+  bright;
+  blurPass;
+  constructor(t = {}) {
+    super({
+      name: "bloom",
+      map: !0,
+      uniforms: { uIntensity: { type: "f32", value: t.intensity ?? 1 } },
+      glsl: `
+  result = src + sampleMap(coord) * uIntensity;`,
+      wgsl: `
+  result = src + sampleMap(coord) * fx.uIntensity;`
+    }), this.bright = new c(t.threshold ?? 0.7, t.knee ?? 0.2), this.blurPass = new a({ strength: t.blur ?? 8, quality: t.quality ?? 4 });
+  }
+  get intensity() {
+    return this.num("uIntensity");
+  }
+  set intensity(t) {
+    this.set("uIntensity", t);
+  }
+  get threshold() {
+    return this.bright.get("uThreshold");
+  }
+  set threshold(t) {
+    this.bright.set("uThreshold", t);
+  }
+  get blur() {
+    return this.blurPass.strength;
+  }
+  set blur(t) {
+    this.blurPass.strength = t;
+  }
+  apply(t, e, o, i) {
+    const r = s.getSameSizeTexture(e), l = s.getSameSizeTexture(e);
+    this.bright.apply(t, e, r, !0), this.blurPass.apply(t, r, l, !0), this.resources.uMap = l.source, t.applyFilter(this, e, o, i), s.returnTexture(l), s.returnTexture(r);
+  }
+  destroy() {
+    this.bright.destroy(), this.blurPass.destroy(), super.destroy();
+  }
+}
+export {
+  m as BloomFilter
+};

package/dist/postfx/ChromaticAberrationFilter.js

@@ -0,0 +1,24 @@
+import { FxFilter as t } from "./fxShader.js";
+class s extends t {
+  constructor(e = 2) {
+    super({
+      name: "chromatic-aberration",
+      uniforms: { uOffset: { type: "f32", value: e } },
+      glsl: `
+  vec2 off = (frameUv - 0.5) * 2.0 * uOffset * texel;
+  result = vec4(sampleAt(coord + off).r, src.g, sampleAt(coord - off).b, src.a);`,
+      wgsl: `
+  let off = (frameUv - 0.5) * 2.0 * fx.uOffset * texel;
+  result = vec4<f32>(sampleAt(coord + off).r, src.g, sampleAt(coord - off).b, src.a);`
+    });
+  }
+  get offset() {
+    return this.num("uOffset");
+  }
+  set offset(e) {
+    this.set("uOffset", e);
+  }
+}
+export {
+  s as ChromaticAberrationFilter
+};

package/dist/postfx/ColorAdjustFilter.js

@@ -0,0 +1,75 @@
+import { FxFilter as r, rgb as s } from "./fxShader.js";
+class a extends r {
+  constructor(t = {}) {
+    super({
+      name: "color-adjust",
+      uniforms: {
+        uBrightness: { type: "f32", value: t.brightness ?? 1 },
+        uContrast: { type: "f32", value: t.contrast ?? 1 },
+        uSaturation: { type: "f32", value: t.saturation ?? 1 },
+        uTintAmount: { type: "f32", value: t.tintAmount ?? 0 },
+        uTint: { type: "vec3<f32>", value: new Float32Array(s(t.tint ?? 16777215)) },
+        uFlash: { type: "f32", value: 0 },
+        uFlashColor: { type: "vec3<f32>", value: new Float32Array([1, 1, 1]) }
+      },
+      glsl: `
+  vec3 c = src.a > 0.0 ? src.rgb / src.a : src.rgb;
+  c *= uBrightness;
+  c = (c - 0.5) * uContrast + 0.5;
+  float l = dot(c, vec3(0.299, 0.587, 0.114));
+  c = mix(vec3(l), c, uSaturation);
+  c = mix(c, c * uTint, uTintAmount);
+  c = mix(c, uFlashColor, uFlash);
+  result = vec4(clamp(c, 0.0, 1.0) * src.a, src.a);`,
+      wgsl: `
+  var c = src.rgb;
+  if (src.a > 0.0) { c = src.rgb / src.a; }
+  c = c * fx.uBrightness;
+  c = (c - 0.5) * fx.uContrast + 0.5;
+  let l = dot(c, vec3<f32>(0.299, 0.587, 0.114));
+  c = mix(vec3<f32>(l), c, fx.uSaturation);
+  c = mix(c, c * fx.uTint, fx.uTintAmount);
+  c = mix(c, fx.uFlashColor, fx.uFlash);
+  result = vec4<f32>(clamp(c, vec3<f32>(0.0), vec3<f32>(1.0)) * src.a, src.a);`
+    });
+  }
+  get brightness() {
+    return this.num("uBrightness");
+  }
+  set brightness(t) {
+    this.set("uBrightness", t);
+  }
+  get contrast() {
+    return this.num("uContrast");
+  }
+  set contrast(t) {
+    this.set("uContrast", t);
+  }
+  get saturation() {
+    return this.num("uSaturation");
+  }
+  set saturation(t) {
+    this.set("uSaturation", t);
+  }
+  get flash() {
+    return this.num("uFlash");
+  }
+  set flash(t) {
+    this.set("uFlash", t);
+  }
+  set flashColor(t) {
+    this.set("uFlashColor", ...s(t));
+  }
+  set tint(t) {
+    this.set("uTint", ...s(t));
+  }
+  get tintAmount() {
+    return this.num("uTintAmount");
+  }
+  set tintAmount(t) {
+    this.set("uTintAmount", t);
+  }
+}
+export {
+  a as ColorAdjustFilter
+};

package/dist/postfx/CrtFilter.js

@@ -0,0 +1,41 @@
+import { FxFilter as u } from "./fxShader.js";
+class l extends u {
+  constructor(e = {}) {
+    super({
+      name: "crt",
+      uniforms: {
+        uScanlines: { type: "f32", value: e.scanlines ?? 0.3 },
+        uLineHeight: { type: "f32", value: e.lineHeight ?? 3 },
+        uCurvature: { type: "f32", value: e.curvature ?? 0.08 },
+        uCornerShade: { type: "f32", value: e.cornerShade ?? 0.25 }
+      },
+      glsl: `
+  vec2 c = frameUv * 2.0 - 1.0;
+  c = c * (1.0 + uCurvature * (c.yx * c.yx));
+  vec2 uv = c * 0.5 + 0.5;
+  if (uv.x < 0.0 || uv.y < 0.0 || uv.x > 1.0 || uv.y > 1.0) {
+    result = vec4(0.0, 0.0, 0.0, 1.0);
+  } else {
+    result = sampleAt(toCoord(uv));
+    float line = 0.5 + 0.5 * cos(uv.y * framePx.y / max(uLineHeight, 1.0) * 6.2831853);
+    float shade = 1.0 - uCornerShade * dot(c, c) * 0.5;
+    result = vec4(result.rgb * mix(1.0, line, uScanlines) * shade, result.a);
+  }`,
+      wgsl: `
+  var c = frameUv * 2.0 - 1.0;
+  c = c * (1.0 + fx.uCurvature * (c.yx * c.yx));
+  let uv2 = c * 0.5 + 0.5;
+  if (uv2.x < 0.0 || uv2.y < 0.0 || uv2.x > 1.0 || uv2.y > 1.0) {
+    result = vec4<f32>(0.0, 0.0, 0.0, 1.0);
+  } else {
+    result = sampleAt(toCoord(uv2));
+    let line = 0.5 + 0.5 * cos(uv2.y * framePx.y / max(fx.uLineHeight, 1.0) * 6.2831853);
+    let shade = 1.0 - fx.uCornerShade * dot(c, c) * 0.5;
+    result = vec4<f32>(result.rgb * mix(1.0, line, fx.uScanlines) * shade, result.a);
+  }`
+    });
+  }
+}
+export {
+  l as CrtFilter
+};

package/dist/postfx/PixelateFilter.js

@@ -0,0 +1,26 @@
+import { FxFilter as t } from "./fxShader.js";
+class r extends t {
+  constructor(e = 4) {
+    super({
+      name: "pixelate",
+      uniforms: { uSize: { type: "f32", value: e } },
+      glsl: `
+  float s = max(uSize, 1.0);
+  vec2 px = coord / texel;
+  result = sampleAt((floor(px / s) + 0.5) * s * texel);`,
+      wgsl: `
+  let s = max(fx.uSize, 1.0);
+  let px = coord / texel;
+  result = sampleAt((floor(px / s) + 0.5) * s * texel);`
+    });
+  }
+  get size() {
+    return this.num("uSize");
+  }
+  set size(e) {
+    this.set("uSize", e);
+  }
+}
+export {
+  r as PixelateFilter
+};

package/dist/postfx/PostFx.js

@@ -0,0 +1,122 @@
+import { Rectangle as p, Sprite as u, Texture as m } from "pixi.js";
+import { easeByName as h } from "../core/eases.js";
+import { engineSettings as g } from "../settings.js";
+import { ColorAdjustFilter as y } from "./ColorAdjustFilter.js";
+import { FxAnimator as x } from "./fxAnimator.js";
+import { ShockwaveFilter as b } from "./ShockwaveFilter.js";
+class l {
+  constructor(t, e, r = {}) {
+    this.target = t, this.screen = e, this.options = r, this.fitArea(), t.filterArea = this.area, r.backdrop !== !1 && r.backdrop !== void 0 && this.setBackdrop(r.backdrop);
+  }
+  target;
+  screen;
+  options;
+  animator = new x();
+  chain = [];
+  transient = [];
+  colorFx = null;
+  backdropSprite = null;
+  offFrame = null;
+  /** The screen in the target's own coordinates: the filtered area, refreshed every frame as a camera moves. */
+  area = new p();
+  /** A `PostFx` over an engine's picture, stepped on its frames. */
+  static forEngine(t, e = {}) {
+    const r = e.layer ?? "all", s = r === "all" ? t.app.stage : r === "world" ? t.stage.world : r, a = e.backdrop ?? (r === "all" ? t.app.renderer.background.color.toNumber() : !1), i = new l(s, t.app.screen, { ...e, backdrop: a });
+    return i.offFrame = t.events.on("frame", ({ dt: n }) => i.update(n * 1e3)), i;
+  }
+  /** Adds an effect at the end of the chain (or at `index`) and returns it. */
+  add(t, e = this.chain.length) {
+    return this.chain.splice(e, 0, { filter: t, on: !0 }), this.apply(), t;
+  }
+  /** Takes an effect out (it is not destroyed: add it back later, or destroy it yourself). */
+  remove(t) {
+    const e = this.chain.findIndex((r) => r.filter === t);
+    e < 0 || (this.chain.splice(e, 1), this.apply());
+  }
+  /** Turns an effect on or off without taking it out of its place. */
+  setEnabled(t, e) {
+    const r = this.chain.find((s) => s.filter === t);
+    !r || r.on === e || (r.on = e, this.apply());
+  }
+  isEnabled(t) {
+    return this.chain.find((e) => e.filter === t)?.on ?? !1;
+  }
+  /** Every effect in the chain, in order. */
+  get filters() {
+    return this.chain.map((t) => t.filter);
+  }
+  /** Animates any number (a uniform, an effect's property) from `from` to `to` over `ms`. */
+  animate(t, e, r, s, a, i) {
+    this.animator.run({ set: t, from: e, to: r, ms: s, ease: typeof a == "string" ? h(a) : a, done: i });
+  }
+  /** The whole picture washed towards a colour, fading out over `ms`. Skipped under reduced effects. */
+  flash(t = {}) {
+    if (this.reduced) return;
+    const e = this.ensureColor();
+    e.flashColor = t.color ?? 16777215, this.animator.run({ key: "flash", set: (r) => e.flash = r, from: t.strength ?? 0.6, to: 0, ms: t.ms ?? 160, ease: h("Quad.Out") });
+  }
+  /** A ring of bent picture spreading from a screen point (screen pixels). Skipped under reduced effects. */
+  shockwave(t, e, r = {}) {
+    if (this.reduced) return;
+    const s = new b(r);
+    s.setCenter((t - this.screen.x) / this.screen.width, (e - this.screen.y) / this.screen.height);
+    const a = s.amplitude;
+    this.transient.push(s), this.apply(), this.animator.run({
+      set: (i) => {
+        s.radius = i * (r.reach ?? 0.6), s.amplitude = a * (1 - i);
+      },
+      from: 0,
+      to: 1,
+      ms: r.ms ?? 600,
+      ease: h("Quad.Out"),
+      done: () => {
+        this.transient = this.transient.filter((i) => i !== s), this.apply(), s.destroy();
+      }
+    });
+  }
+  /** The colour adjustment `flash` uses, made and put first in the chain the first time: brightness, saturation, a tint. */
+  get color() {
+    return this.ensureColor();
+  }
+  /** Steps the animations; `forEngine` calls it on every frame. */
+  update(t) {
+    this.animator.size > 0 && this.animator.step(t), this.fitArea();
+  }
+  destroy() {
+    this.offFrame?.(), this.offFrame = null, this.animator.finishAll(), this.target.filters = [];
+    for (const t of this.chain) t.filter.destroy();
+    this.chain.length = 0, this.backdropSprite?.destroy(), this.backdropSprite = null;
+  }
+  /** The screen rectangle mapped into the target's local space (a camera's layer is scaled and moved). */
+  fitArea() {
+    const t = this.target.worldTransform, e = t.a * t.d - t.b * t.c;
+    if (e === 0) return;
+    const r = (d, f) => {
+      const o = d - t.tx, c = f - t.ty;
+      return [(t.d * o - t.c * c) / e, (t.a * c - t.b * o) / e];
+    }, [s, a] = r(this.screen.x, this.screen.y), [i, n] = r(this.screen.x + this.screen.width, this.screen.y + this.screen.height);
+    this.area.x = Math.min(s, i), this.area.y = Math.min(a, n), this.area.width = Math.abs(i - s), this.area.height = Math.abs(n - a);
+  }
+  get reduced() {
+    return (this.options.honourReducedFx ?? !0) && g.getState().reducedFx;
+  }
+  ensureColor() {
+    return this.colorFx || (this.colorFx = this.add(new y(), 0)), this.colorFx;
+  }
+  setBackdrop(t) {
+    const e = new u(m.WHITE);
+    e.tint = t, e.label = "postfx-backdrop", this.backdropSprite = e, this.target.addChildAt(e, 0);
+    const r = () => {
+      e.position.set(this.screen.x, this.screen.y), e.width = this.screen.width, e.height = this.screen.height;
+    };
+    r(), e.onRender = r;
+  }
+  apply() {
+    const t = [];
+    for (const e of this.chain) e.on && t.push(e.filter);
+    this.target.filters = t.length + this.transient.length > 0 ? [...this.transient, ...t] : [];
+  }
+}
+export {
+  l as PostFx
+};

package/dist/postfx/ShockwaveFilter.js

@@ -0,0 +1,48 @@
+import { FxFilter as u } from "./fxShader.js";
+class i extends u {
+  constructor(e = {}) {
+    super({
+      name: "shockwave",
+      uniforms: {
+        uCenter: { type: "vec2<f32>", value: new Float32Array([0.5, 0.5]) },
+        uRadius: { type: "f32", value: 0 },
+        uWidth: { type: "f32", value: e.width ?? 0.06 },
+        uAmplitude: { type: "f32", value: e.amplitude ?? 12 }
+      },
+      glsl: `
+  vec2 d = (frameUv - uCenter) * vec2(framePx.x / framePx.y, 1.0);
+  float dist = length(d);
+  float x = (dist - uRadius) / max(uWidth, 0.0001);
+  if (abs(x) < 1.0 && dist > 0.0) {
+    float wave = sin(x * 3.14159265) * (1.0 - abs(x));
+    result = sampleAt(coord - (d / dist) * wave * uAmplitude * texel);
+  }`,
+      wgsl: `
+  let d = (frameUv - fx.uCenter) * vec2<f32>(framePx.x / framePx.y, 1.0);
+  let dist = length(d);
+  let x = (dist - fx.uRadius) / max(fx.uWidth, 0.0001);
+  if (abs(x) < 1.0 && dist > 0.0) {
+    let wave = sin(x * 3.14159265) * (1.0 - abs(x));
+    result = sampleAt(coord - (d / dist) * wave * fx.uAmplitude * texel);
+  }`
+    });
+  }
+  setCenter(e, t) {
+    this.set("uCenter", e, t);
+  }
+  get radius() {
+    return this.num("uRadius");
+  }
+  set radius(e) {
+    this.set("uRadius", e);
+  }
+  get amplitude() {
+    return this.num("uAmplitude");
+  }
+  set amplitude(e) {
+    this.set("uAmplitude", e);
+  }
+}
+export {
+  i as ShockwaveFilter
+};

package/dist/postfx/VignetteFilter.js

@@ -0,0 +1,36 @@
+import { FxFilter as s, rgb as t } from "./fxShader.js";
+class u extends s {
+  constructor(e = {}) {
+    super({
+      name: "vignette",
+      uniforms: {
+        uStrength: { type: "f32", value: e.strength ?? 0.5 },
+        uRadius: { type: "f32", value: e.radius ?? 0.55 },
+        uSoftness: { type: "f32", value: e.softness ?? 0.45 },
+        uColor: { type: "vec3<f32>", value: new Float32Array(t(e.color ?? 0)) }
+      },
+      glsl: `
+  vec2 aspect = vec2(framePx.x / framePx.y, 1.0);
+  float dist = length((frameUv - 0.5) * aspect) / length(aspect * 0.5);
+  float v = smoothstep(uRadius, uRadius + max(uSoftness, 0.0001), dist) * uStrength;
+  result = vec4(mix(src.rgb, uColor * src.a, v), src.a);`,
+      wgsl: `
+  let aspect = vec2<f32>(framePx.x / framePx.y, 1.0);
+  let dist = length((frameUv - 0.5) * aspect) / length(aspect * 0.5);
+  let v = smoothstep(fx.uRadius, fx.uRadius + max(fx.uSoftness, 0.0001), dist) * fx.uStrength;
+  result = vec4<f32>(mix(src.rgb, fx.uColor * src.a, v), src.a);`
+    });
+  }
+  get strength() {
+    return this.num("uStrength");
+  }
+  set strength(e) {
+    this.set("uStrength", e);
+  }
+  set color(e) {
+    this.set("uColor", ...t(e));
+  }
+}
+export {
+  u as VignetteFilter
+};

package/dist/postfx/fxAnimator.js

@@ -0,0 +1,37 @@
+const n = (l) => l;
+class o {
+  list = [];
+  get size() {
+    return this.list.length;
+  }
+  /** Starts an animation; one with the same `key` as a running one replaces it (the old one's `done` still runs). */
+  run(e) {
+    if (e.key !== void 0) {
+      const t = this.list.findIndex((i) => i.key === e.key);
+      t >= 0 && this.list.splice(t, 1)[0].done?.();
+    }
+    const s = { ...e, ease: e.ease ?? n, elapsed: 0 };
+    if (s.set(s.from), s.ms <= 0) {
+      s.set(s.to), s.done?.();
+      return;
+    }
+    this.list.push(s);
+  }
+  /** Moves every animation on by `ms`; finished ones set their last value, call `done` and are dropped. */
+  step(e) {
+    for (let s = 0; s < this.list.length; ) {
+      const t = this.list[s];
+      t.elapsed += e;
+      const i = Math.min(1, t.elapsed / t.ms);
+      t.set(t.from + (t.to - t.from) * t.ease(i)), i >= 1 ? (this.list.splice(s, 1), t.done?.()) : s++;
+    }
+  }
+  /** Ends everything at once, each at its last value. */
+  finishAll() {
+    for (const e of this.list.splice(0))
+      e.set(e.to), e.done?.();
+  }
+}
+export {
+  o as FxAnimator
+};