1681-engine 0.0.0-stage → 0.5.8

package/dist/platform/touch.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"touch.js","sources":["../../src/platform/touch.ts"],"sourcesContent":["import { detectTouch, type TouchEnv } from '../input/touchDetect';\n\nlet cached: boolean | null = null;\nlet nativeShell = false;\nlet overrideKey = 'engine.touch';\n\n/** A native shell (Capacitor, Electron touch kiosk…) tells the engine it is one; browsers leave it false. */\nexport function setNativeShell(native: boolean): void {\n  nativeShell = native;\n  cached = null;\n}\n\n/**\n * The `localStorage` key that forces the touch controls on or off (`'1'`/`'0'`, beside `?touch=1|0` in the URL), for\n * trying them on a desktop browser. A game names its own so its players' saved choice carries over.\n */\nexport function setTouchOverrideKey(key: string): void {\n  overrideKey = key;\n  cached = null;\n}\n\nfunction readOverride(): string | null {\n  try {\n    const fromUrl = new URLSearchParams(window.location.search).get('touch');\n    if (fromUrl !== null) return fromUrl;\n    return localStorage.getItem(overrideKey);\n  } catch {\n    return null;\n  }\n}\n\nfunction readEnv(): TouchEnv {\n  return {\n    native: nativeShell,\n    coarse: typeof matchMedia === 'function' && matchMedia('(pointer: coarse)').matches,\n    touchPoints: typeof navigator !== 'undefined' ? navigator.maxTouchPoints ?? 0 : 0,\n    override: readOverride(),\n  };\n}\n\n/** True when the game is played with fingers (decided once per launch, `detectTouch`). */\nexport function isTouchUi(): boolean {\n  if (cached === null) cached = typeof window !== 'undefined' && detectTouch(readEnv());\n  return cached;\n}\n"],"names":["cached","nativeShell","overrideKey","setNativeShell","native","setTouchOverrideKey","key","readOverride","fromUrl","readEnv","isTouchUi","detectTouch"],"mappings":";AAEA,IAAIA,IAAyB,MACzBC,IAAc,IACdC,IAAc;AAGX,SAASC,EAAeC,GAAuB;AACpD,EAAAH,IAAcG,GACdJ,IAAS;AACX;AAMO,SAASK,EAAoBC,GAAmB;AACrD,EAAAJ,IAAcI,GACdN,IAAS;AACX;AAEA,SAASO,IAA8B;AACrC,MAAI;AACF,UAAMC,IAAU,IAAI,gBAAgB,OAAO,SAAS,MAAM,EAAE,IAAI,OAAO;AACvE,WAAIA,MAAY,OAAaA,IACtB,aAAa,QAAQN,CAAW;AAAA,EACzC,QAAQ;AACN,WAAO;AAAA,EACT;AACF;AAEA,SAASO,IAAoB;AAC3B,SAAO;AAAA,IACL,QAAQR;AAAA,IACR,QAAQ,OAAO,cAAe,cAAc,WAAW,mBAAmB,EAAE;AAAA,IAC5E,aAAa,OAAO,YAAc,MAAc,UAAU,kBAAkB,IAAI;AAAA,IAChF,UAAUM,EAAA;AAAA,EAAa;AAE3B;AAGO,SAASG,IAAqB;AACnC,SAAIV,MAAW,SAAMA,IAAS,OAAO,SAAW,OAAeW,EAAYF,GAAS,IAC7ET;AACT;"}

package/dist/postfx/BloomFilter.js

@@ -0,0 +1,65 @@
+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
+};
+//# sourceMappingURL=BloomFilter.js.map

package/dist/postfx/BloomFilter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"BloomFilter.js","sources":["../../src/postfx/BloomFilter.ts"],"sourcesContent":["import { BlurFilter, TexturePool, type FilterSystem, type RenderSurface, type Texture } from 'pixi.js';\nimport { FxFilter } from './fxShader';\n\nexport interface BloomOptions {\n  /** Brightness (0–1, the brightest channel) from which a pixel glows (default 0.7). */\n  threshold?: number;\n  /** How gradually the glow comes in above the threshold (default 0.2). */\n  knee?: number;\n  /** How strongly the glow is added back (default 1). */\n  intensity?: number;\n  /** Blur strength of the glow, pixels (default 8). */\n  blur?: number;\n  /** Blur quality: passes (default 4). */\n  quality?: number;\n}\n\n/** The bright pass: what is above the threshold, the rest black. */\nclass BrightPass extends FxFilter {\n  constructor(threshold: number, knee: number) {\n    super({\n      name: 'bloom-bright',\n      uniforms: { uThreshold: { type: 'f32', value: threshold }, uKnee: { type: 'f32', value: knee } },\n      glsl: `\n  vec3 c = src.a > 0.0 ? src.rgb / src.a : src.rgb;\n  float l = max(c.r, max(c.g, c.b));\n  float k = smoothstep(uThreshold, uThreshold + max(uKnee, 0.0001), l);\n  result = src * k;`,\n      wgsl: `\n  var c = src.rgb;\n  if (src.a > 0.0) { c = src.rgb / src.a; }\n  let l = max(c.r, max(c.g, c.b));\n  let k = smoothstep(fx.uThreshold, fx.uThreshold + max(fx.uKnee, 0.0001), l);\n  result = src * k;`,\n    });\n  }\n}\n\n/**\n * Bright things glow: the pixels above a threshold are blurred and added back over the picture. Three passes (bright,\n * blur, combine) on textures from Pixi's pool; costlier than the one-pass effects, so give it a `filterArea` or put it\n * on the world layer only.\n */\nexport class BloomFilter extends FxFilter {\n  private readonly bright: BrightPass;\n  private readonly blurPass: BlurFilter;\n\n  constructor(options: BloomOptions = {}) {\n    super({\n      name: 'bloom',\n      map: true,\n      uniforms: { uIntensity: { type: 'f32', value: options.intensity ?? 1 } },\n      glsl: `\n  result = src + sampleMap(coord) * uIntensity;`,\n      wgsl: `\n  result = src + sampleMap(coord) * fx.uIntensity;`,\n    });\n    this.bright = new BrightPass(options.threshold ?? 0.7, options.knee ?? 0.2);\n    this.blurPass = new BlurFilter({ strength: options.blur ?? 8, quality: options.quality ?? 4 });\n  }\n\n  get intensity(): number {\n    return this.num('uIntensity');\n  }\n  set intensity(v: number) {\n    this.set('uIntensity', v);\n  }\n  get threshold(): number {\n    return this.bright.get('uThreshold') as number;\n  }\n  set threshold(v: number) {\n    this.bright.set('uThreshold', v);\n  }\n  get blur(): number {\n    return this.blurPass.strength;\n  }\n  set blur(v: number) {\n    this.blurPass.strength = v;\n  }\n\n  override apply(filterManager: FilterSystem, input: Texture, output: RenderSurface, clearMode: boolean): void {\n    const light = TexturePool.getSameSizeTexture(input);\n    const glow = TexturePool.getSameSizeTexture(input);\n    this.bright.apply(filterManager, input, light, true);\n    this.blurPass.apply(filterManager, light, glow, true);\n    this.resources.uMap = glow.source;\n    filterManager.applyFilter(this, input, output, clearMode);\n    TexturePool.returnTexture(glow);\n    TexturePool.returnTexture(light);\n  }\n\n  override destroy(): void {\n    this.bright.destroy();\n    this.blurPass.destroy();\n    super.destroy();\n  }\n}\n"],"names":["BrightPass","FxFilter","threshold","knee","BloomFilter","options","BlurFilter","v","filterManager","input","output","clearMode","light","TexturePool","glow"],"mappings":";;AAiBA,MAAMA,UAAmBC,EAAS;AAAA,EAChC,YAAYC,GAAmBC,GAAc;AAC3C,UAAM;AAAA,MACJ,MAAM;AAAA,MACN,UAAU,EAAE,YAAY,EAAE,MAAM,OAAO,OAAOD,KAAa,OAAO,EAAE,MAAM,OAAO,OAAOC,IAAK;AAAA,MAC7F,MAAM;AAAA;AAAA;AAAA;AAAA;AAAA,MAKN,MAAM;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,IAAA,CAMP;AAAA,EACH;AACF;AAOO,MAAMC,UAAoBH,EAAS;AAAA,EACvB;AAAA,EACA;AAAA,EAEjB,YAAYI,IAAwB,IAAI;AACtC,UAAM;AAAA,MACJ,MAAM;AAAA,MACN,KAAK;AAAA,MACL,UAAU,EAAE,YAAY,EAAE,MAAM,OAAO,OAAOA,EAAQ,aAAa,IAAE;AAAA,MACrE,MAAM;AAAA;AAAA,MAEN,MAAM;AAAA;AAAA,IAAA,CAEP,GACD,KAAK,SAAS,IAAIL,EAAWK,EAAQ,aAAa,KAAKA,EAAQ,QAAQ,GAAG,GAC1E,KAAK,WAAW,IAAIC,EAAW,EAAE,UAAUD,EAAQ,QAAQ,GAAG,SAASA,EAAQ,WAAW,EAAA,CAAG;AAAA,EAC/F;AAAA,EAEA,IAAI,YAAoB;AACtB,WAAO,KAAK,IAAI,YAAY;AAAA,EAC9B;AAAA,EACA,IAAI,UAAUE,GAAW;AACvB,SAAK,IAAI,cAAcA,CAAC;AAAA,EAC1B;AAAA,EACA,IAAI,YAAoB;AACtB,WAAO,KAAK,OAAO,IAAI,YAAY;AAAA,EACrC;AAAA,EACA,IAAI,UAAUA,GAAW;AACvB,SAAK,OAAO,IAAI,cAAcA,CAAC;AAAA,EACjC;AAAA,EACA,IAAI,OAAe;AACjB,WAAO,KAAK,SAAS;AAAA,EACvB;AAAA,EACA,IAAI,KAAKA,GAAW;AAClB,SAAK,SAAS,WAAWA;AAAA,EAC3B;AAAA,EAES,MAAMC,GAA6BC,GAAgBC,GAAuBC,GAA0B;AAC3G,UAAMC,IAAQC,EAAY,mBAAmBJ,CAAK,GAC5CK,IAAOD,EAAY,mBAAmBJ,CAAK;AACjD,SAAK,OAAO,MAAMD,GAAeC,GAAOG,GAAO,EAAI,GACnD,KAAK,SAAS,MAAMJ,GAAeI,GAAOE,GAAM,EAAI,GACpD,KAAK,UAAU,OAAOA,EAAK,QAC3BN,EAAc,YAAY,MAAMC,GAAOC,GAAQC,CAAS,GACxDE,EAAY,cAAcC,CAAI,GAC9BD,EAAY,cAAcD,CAAK;AAAA,EACjC;AAAA,EAES,UAAgB;AACvB,SAAK,OAAO,QAAA,GACZ,KAAK,SAAS,QAAA,GACd,MAAM,QAAA;AAAA,EACR;AACF;"}

package/dist/postfx/ChromaticAberrationFilter.js

@@ -0,0 +1,25 @@
+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
+};
+//# sourceMappingURL=ChromaticAberrationFilter.js.map

package/dist/postfx/ChromaticAberrationFilter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ChromaticAberrationFilter.js","sources":["../../src/postfx/ChromaticAberrationFilter.ts"],"sourcesContent":["import { FxFilter } from './fxShader';\n\n/**\n * Splits red and blue apart towards the edges, `offset` pixels at a corner: a hit's jolt, a dream, a cheap lens.\n * Nothing at the centre of the screen moves.\n */\nexport class ChromaticAberrationFilter extends FxFilter {\n  constructor(offset = 2) {\n    super({\n      name: 'chromatic-aberration',\n      uniforms: { uOffset: { type: 'f32', value: offset } },\n      glsl: `\n  vec2 off = (frameUv - 0.5) * 2.0 * uOffset * texel;\n  result = vec4(sampleAt(coord + off).r, src.g, sampleAt(coord - off).b, src.a);`,\n      wgsl: `\n  let off = (frameUv - 0.5) * 2.0 * fx.uOffset * texel;\n  result = vec4<f32>(sampleAt(coord + off).r, src.g, sampleAt(coord - off).b, src.a);`,\n    });\n  }\n\n  get offset(): number {\n    return this.num('uOffset');\n  }\n  set offset(v: number) {\n    this.set('uOffset', v);\n  }\n}\n"],"names":["ChromaticAberrationFilter","FxFilter","offset","v"],"mappings":";AAMO,MAAMA,UAAkCC,EAAS;AAAA,EACtD,YAAYC,IAAS,GAAG;AACtB,UAAM;AAAA,MACJ,MAAM;AAAA,MACN,UAAU,EAAE,SAAS,EAAE,MAAM,OAAO,OAAOA,IAAO;AAAA,MAClD,MAAM;AAAA;AAAA;AAAA,MAGN,MAAM;AAAA;AAAA;AAAA,IAAA,CAGP;AAAA,EACH;AAAA,EAEA,IAAI,SAAiB;AACnB,WAAO,KAAK,IAAI,SAAS;AAAA,EAC3B;AAAA,EACA,IAAI,OAAOC,GAAW;AACpB,SAAK,IAAI,WAAWA,CAAC;AAAA,EACvB;AACF;"}

package/dist/postfx/ColorAdjustFilter.js

@@ -0,0 +1,76 @@
+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
+};
+//# sourceMappingURL=ColorAdjustFilter.js.map

package/dist/postfx/ColorAdjustFilter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ColorAdjustFilter.js","sources":["../../src/postfx/ColorAdjustFilter.ts"],"sourcesContent":["import { FxFilter, rgb } from './fxShader';\n\nexport interface ColorAdjustOptions {\n  /** Multiplies every channel (default 1). */\n  brightness?: number;\n  /** 1 unchanged, 0 flat grey, above 1 punchier (default 1). */\n  contrast?: number;\n  /** 1 unchanged, 0 greyscale (default 1). */\n  saturation?: number;\n  /** A colour multiplied in by `tintAmount` (default white, 0). */\n  tint?: number;\n  tintAmount?: number;\n}\n\n/**\n * Brightness, contrast, saturation and a tint, all animatable, plus a flash: the whole screen washed towards a colour\n * (`flash` 0–1, `flashColor`), for a hit, a pickup or lightning. `PostFx.flash` drives it.\n */\nexport class ColorAdjustFilter extends FxFilter {\n  constructor(options: ColorAdjustOptions = {}) {\n    super({\n      name: 'color-adjust',\n      uniforms: {\n        uBrightness: { type: 'f32', value: options.brightness ?? 1 },\n        uContrast: { type: 'f32', value: options.contrast ?? 1 },\n        uSaturation: { type: 'f32', value: options.saturation ?? 1 },\n        uTintAmount: { type: 'f32', value: options.tintAmount ?? 0 },\n        uTint: { type: 'vec3<f32>', value: new Float32Array(rgb(options.tint ?? 0xffffff)) },\n        uFlash: { type: 'f32', value: 0 },\n        uFlashColor: { type: 'vec3<f32>', value: new Float32Array([1, 1, 1]) },\n      },\n      glsl: `\n  vec3 c = src.a > 0.0 ? src.rgb / src.a : src.rgb;\n  c *= uBrightness;\n  c = (c - 0.5) * uContrast + 0.5;\n  float l = dot(c, vec3(0.299, 0.587, 0.114));\n  c = mix(vec3(l), c, uSaturation);\n  c = mix(c, c * uTint, uTintAmount);\n  c = mix(c, uFlashColor, uFlash);\n  result = vec4(clamp(c, 0.0, 1.0) * src.a, src.a);`,\n      wgsl: `\n  var c = src.rgb;\n  if (src.a > 0.0) { c = src.rgb / src.a; }\n  c = c * fx.uBrightness;\n  c = (c - 0.5) * fx.uContrast + 0.5;\n  let l = dot(c, vec3<f32>(0.299, 0.587, 0.114));\n  c = mix(vec3<f32>(l), c, fx.uSaturation);\n  c = mix(c, c * fx.uTint, fx.uTintAmount);\n  c = mix(c, fx.uFlashColor, fx.uFlash);\n  result = vec4<f32>(clamp(c, vec3<f32>(0.0), vec3<f32>(1.0)) * src.a, src.a);`,\n    });\n  }\n\n  get brightness(): number {\n    return this.num('uBrightness');\n  }\n  set brightness(v: number) {\n    this.set('uBrightness', v);\n  }\n  get contrast(): number {\n    return this.num('uContrast');\n  }\n  set contrast(v: number) {\n    this.set('uContrast', v);\n  }\n  get saturation(): number {\n    return this.num('uSaturation');\n  }\n  set saturation(v: number) {\n    this.set('uSaturation', v);\n  }\n  get flash(): number {\n    return this.num('uFlash');\n  }\n  set flash(v: number) {\n    this.set('uFlash', v);\n  }\n  set flashColor(c: number) {\n    this.set('uFlashColor', ...rgb(c));\n  }\n  set tint(c: number) {\n    this.set('uTint', ...rgb(c));\n  }\n  get tintAmount(): number {\n    return this.num('uTintAmount');\n  }\n  set tintAmount(v: number) {\n    this.set('uTintAmount', v);\n  }\n}\n"],"names":["ColorAdjustFilter","FxFilter","options","rgb","v","c"],"mappings":";AAkBO,MAAMA,UAA0BC,EAAS;AAAA,EAC9C,YAAYC,IAA8B,IAAI;AAC5C,UAAM;AAAA,MACJ,MAAM;AAAA,MACN,UAAU;AAAA,QACR,aAAa,EAAE,MAAM,OAAO,OAAOA,EAAQ,cAAc,EAAA;AAAA,QACzD,WAAW,EAAE,MAAM,OAAO,OAAOA,EAAQ,YAAY,EAAA;AAAA,QACrD,aAAa,EAAE,MAAM,OAAO,OAAOA,EAAQ,cAAc,EAAA;AAAA,QACzD,aAAa,EAAE,MAAM,OAAO,OAAOA,EAAQ,cAAc,EAAA;AAAA,QACzD,OAAO,EAAE,MAAM,aAAa,OAAO,IAAI,aAAaC,EAAID,EAAQ,QAAQ,QAAQ,CAAC,EAAA;AAAA,QACjF,QAAQ,EAAE,MAAM,OAAO,OAAO,EAAA;AAAA,QAC9B,aAAa,EAAE,MAAM,aAAa,OAAO,IAAI,aAAa,CAAC,GAAG,GAAG,CAAC,CAAC,EAAA;AAAA,MAAE;AAAA,MAEvE,MAAM;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,MASN,MAAM;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,IAAA,CAUP;AAAA,EACH;AAAA,EAEA,IAAI,aAAqB;AACvB,WAAO,KAAK,IAAI,aAAa;AAAA,EAC/B;AAAA,EACA,IAAI,WAAWE,GAAW;AACxB,SAAK,IAAI,eAAeA,CAAC;AAAA,EAC3B;AAAA,EACA,IAAI,WAAmB;AACrB,WAAO,KAAK,IAAI,WAAW;AAAA,EAC7B;AAAA,EACA,IAAI,SAASA,GAAW;AACtB,SAAK,IAAI,aAAaA,CAAC;AAAA,EACzB;AAAA,EACA,IAAI,aAAqB;AACvB,WAAO,KAAK,IAAI,aAAa;AAAA,EAC/B;AAAA,EACA,IAAI,WAAWA,GAAW;AACxB,SAAK,IAAI,eAAeA,CAAC;AAAA,EAC3B;AAAA,EACA,IAAI,QAAgB;AAClB,WAAO,KAAK,IAAI,QAAQ;AAAA,EAC1B;AAAA,EACA,IAAI,MAAMA,GAAW;AACnB,SAAK,IAAI,UAAUA,CAAC;AAAA,EACtB;AAAA,EACA,IAAI,WAAWC,GAAW;AACxB,SAAK,IAAI,eAAe,GAAGF,EAAIE,CAAC,CAAC;AAAA,EACnC;AAAA,EACA,IAAI,KAAKA,GAAW;AAClB,SAAK,IAAI,SAAS,GAAGF,EAAIE,CAAC,CAAC;AAAA,EAC7B;AAAA,EACA,IAAI,aAAqB;AACvB,WAAO,KAAK,IAAI,aAAa;AAAA,EAC/B;AAAA,EACA,IAAI,WAAWD,GAAW;AACxB,SAAK,IAAI,eAAeA,CAAC;AAAA,EAC3B;AACF;"}

package/dist/postfx/CrtFilter.js

@@ -0,0 +1,42 @@
+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
+};
+//# sourceMappingURL=CrtFilter.js.map

package/dist/postfx/CrtFilter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"CrtFilter.js","sources":["../../src/postfx/CrtFilter.ts"],"sourcesContent":["import { FxFilter } from './fxShader';\n\nexport interface CrtOptions {\n  /** 0–1, how dark the gaps between scanlines are (default 0.3). */\n  scanlines?: number;\n  /** Screen pixels per scanline (default 3). */\n  lineHeight?: number;\n  /** How much the glass bulges, 0 flat (default 0.08). */\n  curvature?: number;\n  /** 0–1, how much darker the bulged corners are (default 0.25). */\n  cornerShade?: number;\n}\n\n/** An old television: scanlines, a bulging glass with black beyond its edge, darker corners. */\nexport class CrtFilter extends FxFilter {\n  constructor(options: CrtOptions = {}) {\n    super({\n      name: 'crt',\n      uniforms: {\n        uScanlines: { type: 'f32', value: options.scanlines ?? 0.3 },\n        uLineHeight: { type: 'f32', value: options.lineHeight ?? 3 },\n        uCurvature: { type: 'f32', value: options.curvature ?? 0.08 },\n        uCornerShade: { type: 'f32', value: options.cornerShade ?? 0.25 },\n      },\n      glsl: `\n  vec2 c = frameUv * 2.0 - 1.0;\n  c = c * (1.0 + uCurvature * (c.yx * c.yx));\n  vec2 uv = c * 0.5 + 0.5;\n  if (uv.x < 0.0 || uv.y < 0.0 || uv.x > 1.0 || uv.y > 1.0) {\n    result = vec4(0.0, 0.0, 0.0, 1.0);\n  } else {\n    result = sampleAt(toCoord(uv));\n    float line = 0.5 + 0.5 * cos(uv.y * framePx.y / max(uLineHeight, 1.0) * 6.2831853);\n    float shade = 1.0 - uCornerShade * dot(c, c) * 0.5;\n    result = vec4(result.rgb * mix(1.0, line, uScanlines) * shade, result.a);\n  }`,\n      wgsl: `\n  var c = frameUv * 2.0 - 1.0;\n  c = c * (1.0 + fx.uCurvature * (c.yx * c.yx));\n  let uv2 = c * 0.5 + 0.5;\n  if (uv2.x < 0.0 || uv2.y < 0.0 || uv2.x > 1.0 || uv2.y > 1.0) {\n    result = vec4<f32>(0.0, 0.0, 0.0, 1.0);\n  } else {\n    result = sampleAt(toCoord(uv2));\n    let line = 0.5 + 0.5 * cos(uv2.y * framePx.y / max(fx.uLineHeight, 1.0) * 6.2831853);\n    let shade = 1.0 - fx.uCornerShade * dot(c, c) * 0.5;\n    result = vec4<f32>(result.rgb * mix(1.0, line, fx.uScanlines) * shade, result.a);\n  }`,\n    });\n  }\n}\n"],"names":["CrtFilter","FxFilter","options"],"mappings":";AAcO,MAAMA,UAAkBC,EAAS;AAAA,EACtC,YAAYC,IAAsB,IAAI;AACpC,UAAM;AAAA,MACJ,MAAM;AAAA,MACN,UAAU;AAAA,QACR,YAAY,EAAE,MAAM,OAAO,OAAOA,EAAQ,aAAa,IAAA;AAAA,QACvD,aAAa,EAAE,MAAM,OAAO,OAAOA,EAAQ,cAAc,EAAA;AAAA,QACzD,YAAY,EAAE,MAAM,OAAO,OAAOA,EAAQ,aAAa,KAAA;AAAA,QACvD,cAAc,EAAE,MAAM,OAAO,OAAOA,EAAQ,eAAe,KAAA;AAAA,MAAK;AAAA,MAElE,MAAM;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,MAYN,MAAM;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,IAAA,CAYP;AAAA,EACH;AACF;"}

package/dist/postfx/PixelateFilter.js

@@ -0,0 +1,27 @@
+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
+};
+//# sourceMappingURL=PixelateFilter.js.map

package/dist/postfx/PixelateFilter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"PixelateFilter.js","sources":["../../src/postfx/PixelateFilter.ts"],"sourcesContent":["import { FxFilter } from './fxShader';\n\n/** Shows the screen in blocks of `size` pixels: a transition's dissolve, a retro mode, a censor box. 1 is off. */\nexport class PixelateFilter extends FxFilter {\n  constructor(size = 4) {\n    super({\n      name: 'pixelate',\n      uniforms: { uSize: { type: 'f32', value: size } },\n      glsl: `\n  float s = max(uSize, 1.0);\n  vec2 px = coord / texel;\n  result = sampleAt((floor(px / s) + 0.5) * s * texel);`,\n      wgsl: `\n  let s = max(fx.uSize, 1.0);\n  let px = coord / texel;\n  result = sampleAt((floor(px / s) + 0.5) * s * texel);`,\n    });\n  }\n\n  get size(): number {\n    return this.num('uSize');\n  }\n  set size(v: number) {\n    this.set('uSize', v);\n  }\n}\n"],"names":["PixelateFilter","FxFilter","size","v"],"mappings":";AAGO,MAAMA,UAAuBC,EAAS;AAAA,EAC3C,YAAYC,IAAO,GAAG;AACpB,UAAM;AAAA,MACJ,MAAM;AAAA,MACN,UAAU,EAAE,OAAO,EAAE,MAAM,OAAO,OAAOA,IAAK;AAAA,MAC9C,MAAM;AAAA;AAAA;AAAA;AAAA,MAIN,MAAM;AAAA;AAAA;AAAA;AAAA,IAAA,CAIP;AAAA,EACH;AAAA,EAEA,IAAI,OAAe;AACjB,WAAO,KAAK,IAAI,OAAO;AAAA,EACzB;AAAA,EACA,IAAI,KAAKC,GAAW;AAClB,SAAK,IAAI,SAASA,CAAC;AAAA,EACrB;AACF;"}

package/dist/postfx/PostFx.js

@@ -0,0 +1,123 @@
+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
+};
+//# sourceMappingURL=PostFx.js.map

package/dist/postfx/PostFx.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"PostFx.js","sources":["../../src/postfx/PostFx.ts"],"sourcesContent":["import { Container, Rectangle, Sprite, Texture, type Filter } from 'pixi.js';\nimport { easeByName, type EaseFn } from '../core/eases';\nimport type { Engine } from '../engine/Engine';\nimport { engineSettings } from '../settings';\nimport { ColorAdjustFilter } from './ColorAdjustFilter';\nimport { FxAnimator } from './fxAnimator';\nimport { ShockwaveFilter, type ShockwaveOptions } from './ShockwaveFilter';\n\nexport interface PostFxOptions {\n  /**\n   * What the effects lie over: 'all' (default) the whole picture, HUD included; 'world' the camera's layer only, so\n   * the HUD stays sharp; or any container.\n   */\n  layer?: 'all' | 'world' | Container;\n  /**\n   * Fills the screen behind the picture with this colour (default the renderer's background when `layer` is 'all').\n   * Effects only see what is drawn: without a backdrop the empty background stays untouched by a vignette or a flash.\n   * `false` for none.\n   */\n  backdrop?: number | false;\n  /** Skip flashes and shockwaves while the player asked for reduced effects (default true). */\n  honourReducedFx?: boolean;\n}\n\nexport interface FlashOptions {\n  color?: number;\n  /** Peak strength, 0–1 (default 0.6). */\n  strength?: number;\n  ms?: number;\n}\n\nexport interface ShockwaveRun extends ShockwaveOptions {\n  /** How far the ring travels, as a share of the screen's height (default 0.6). */\n  reach?: number;\n  ms?: number;\n}\n\n/**\n * Full-screen effects over a game: a chain of filters (vignette, bloom, a colour grade, CRT, pixelate…) laid over the\n * picture in the order added, switched on and off one by one, and short effects that come and go — a flash, a\n * shockwave, any uniform animated over time. One per engine is plenty; give it to the scenes that want it.\n *\n * ```ts\n * const post = PostFx.forEngine(engine);\n * const vignette = post.add(new VignetteFilter({ strength: 0.4 }));\n * post.add(new BloomFilter({ threshold: 0.75 }));\n * post.flash({ color: 0xffffff, ms: 120 }); // a hit\n * post.shockwave(x, y); // screen pixels: an explosion\n * post.animate((v) => (vignette.strength = v), 0.4, 0.8, 300, 'Sine.InOut'); // a heartbeat\n * ```\n */\nexport class PostFx {\n  readonly animator = new FxAnimator();\n  private readonly chain: { filter: Filter; on: boolean }[] = [];\n  private transient: Filter[] = [];\n  private colorFx: ColorAdjustFilter | null = null;\n  private backdropSprite: Sprite | null = null;\n  private offFrame: (() => void) | null = null;\n  /** The screen in the target's own coordinates: the filtered area, refreshed every frame as a camera moves. */\n  private readonly area = new Rectangle();\n\n  constructor(\n    readonly target: Container,\n    /** The screen rectangle, live (the renderer's `screen`): what is filtered, and how screen points map to it. */\n    private readonly screen: Rectangle,\n    private readonly options: PostFxOptions = {},\n  ) {\n    this.fitArea();\n    target.filterArea = this.area;\n    // the backdrop is laid in screen space: only over a target that is not moved by a camera\n    if (options.backdrop !== false && options.backdrop !== undefined) this.setBackdrop(options.backdrop);\n  }\n\n  /** A `PostFx` over an engine's picture, stepped on its frames. */\n  static forEngine(engine: Engine, options: PostFxOptions = {}): PostFx {\n    const layer = options.layer ?? 'all';\n    const target = layer === 'all' ? engine.app.stage : layer === 'world' ? engine.stage.world : layer;\n    const backdrop = options.backdrop ?? (layer === 'all' ? engine.app.renderer.background.color.toNumber() : false);\n    const fx = new PostFx(target, engine.app.screen, { ...options, backdrop });\n    fx.offFrame = engine.events.on('frame', ({ dt }) => fx.update(dt * 1000));\n    return fx;\n  }\n\n  /** Adds an effect at the end of the chain (or at `index`) and returns it. */\n  add<T extends Filter>(filter: T, index = this.chain.length): T {\n    this.chain.splice(index, 0, { filter, on: true });\n    this.apply();\n    return filter;\n  }\n\n  /** Takes an effect out (it is not destroyed: add it back later, or destroy it yourself). */\n  remove(filter: Filter): void {\n    const i = this.chain.findIndex((e) => e.filter === filter);\n    if (i < 0) return;\n    this.chain.splice(i, 1);\n    this.apply();\n  }\n\n  /** Turns an effect on or off without taking it out of its place. */\n  setEnabled(filter: Filter, on: boolean): void {\n    const e = this.chain.find((x) => x.filter === filter);\n    if (!e || e.on === on) return;\n    e.on = on;\n    this.apply();\n  }\n\n  isEnabled(filter: Filter): boolean {\n    return this.chain.find((x) => x.filter === filter)?.on ?? false;\n  }\n\n  /** Every effect in the chain, in order. */\n  get filters(): readonly Filter[] {\n    return this.chain.map((e) => e.filter);\n  }\n\n  /** Animates any number (a uniform, an effect's property) from `from` to `to` over `ms`. */\n  animate(set: (v: number) => void, from: number, to: number, ms: number, ease?: EaseFn | string, done?: () => void): void {\n    this.animator.run({ set, from, to, ms, ease: typeof ease === 'string' ? easeByName(ease) : ease, done });\n  }\n\n  /** The whole picture washed towards a colour, fading out over `ms`. Skipped under reduced effects. */\n  flash(options: FlashOptions = {}): void {\n    if (this.reduced) return;\n    const fx = this.ensureColor();\n    fx.flashColor = options.color ?? 0xffffff;\n    this.animator.run({ key: 'flash', set: (v) => (fx.flash = v), from: options.strength ?? 0.6, to: 0, ms: options.ms ?? 160, ease: easeByName('Quad.Out') });\n  }\n\n  /** A ring of bent picture spreading from a screen point (screen pixels). Skipped under reduced effects. */\n  shockwave(x: number, y: number, options: ShockwaveRun = {}): void {\n    if (this.reduced) return;\n    const wave = new ShockwaveFilter(options);\n    wave.setCenter((x - this.screen.x) / this.screen.width, (y - this.screen.y) / this.screen.height);\n    const amplitude = wave.amplitude;\n    this.transient.push(wave);\n    this.apply();\n    this.animator.run({\n      set: (t) => {\n        wave.radius = t * (options.reach ?? 0.6);\n        wave.amplitude = amplitude * (1 - t);\n      },\n      from: 0,\n      to: 1,\n      ms: options.ms ?? 600,\n      ease: easeByName('Quad.Out'),\n      done: () => {\n        this.transient = this.transient.filter((f) => f !== wave);\n        this.apply();\n        wave.destroy();\n      },\n    });\n  }\n\n  /** The colour adjustment `flash` uses, made and put first in the chain the first time: brightness, saturation, a tint. */\n  get color(): ColorAdjustFilter {\n    return this.ensureColor();\n  }\n\n  /** Steps the animations; `forEngine` calls it on every frame. */\n  update(ms: number): void {\n    if (this.animator.size > 0) this.animator.step(ms);\n    this.fitArea();\n  }\n\n  destroy(): void {\n    this.offFrame?.();\n    this.offFrame = null;\n    this.animator.finishAll();\n    this.target.filters = [];\n    for (const e of this.chain) e.filter.destroy();\n    this.chain.length = 0;\n    this.backdropSprite?.destroy();\n    this.backdropSprite = null;\n  }\n\n  /** The screen rectangle mapped into the target's local space (a camera's layer is scaled and moved). */\n  private fitArea(): void {\n    const m = this.target.worldTransform;\n    const det = m.a * m.d - m.b * m.c;\n    if (det === 0) return;\n    const inv = (x: number, y: number): [number, number] => {\n      const dx = x - m.tx;\n      const dy = y - m.ty;\n      return [(m.d * dx - m.c * dy) / det, (m.a * dy - m.b * dx) / det];\n    };\n    const [x0, y0] = inv(this.screen.x, this.screen.y);\n    const [x1, y1] = inv(this.screen.x + this.screen.width, this.screen.y + this.screen.height);\n    this.area.x = Math.min(x0, x1);\n    this.area.y = Math.min(y0, y1);\n    this.area.width = Math.abs(x1 - x0);\n    this.area.height = Math.abs(y1 - y0);\n  }\n\n  private get reduced(): boolean {\n    return (this.options.honourReducedFx ?? true) && engineSettings.getState().reducedFx;\n  }\n\n  private ensureColor(): ColorAdjustFilter {\n    if (!this.colorFx) this.colorFx = this.add(new ColorAdjustFilter(), 0);\n    return this.colorFx;\n  }\n\n  private setBackdrop(color: number): void {\n    const s = new Sprite(Texture.WHITE);\n    s.tint = color;\n    s.label = 'postfx-backdrop';\n    this.backdropSprite = s;\n    this.target.addChildAt(s, 0);\n    const fit = () => {\n      s.position.set(this.screen.x, this.screen.y);\n      s.width = this.screen.width;\n      s.height = this.screen.height;\n    };\n    fit();\n    s.onRender = fit;\n  }\n\n  private apply(): void {\n    const list: Filter[] = [];\n    for (const e of this.chain) if (e.on) list.push(e.filter);\n    // transient waves go under the lasting effects, so a CRT's curve bends the wave too\n    this.target.filters = list.length + this.transient.length > 0 ? [...this.transient, ...list] : [];\n  }\n}\n"],"names":["PostFx","target","screen","options","FxAnimator","Rectangle","engine","layer","backdrop","fx","dt","filter","index","i","e","on","x","set","from","to","ms","ease","done","easeByName","v","y","wave","ShockwaveFilter","amplitude","t","f","m","det","inv","dx","dy","x0","y0","x1","y1","engineSettings","ColorAdjustFilter","color","s","Sprite","Texture","fit","list"],"mappings":";;;;;;AAmDO,MAAMA,EAAO;AAAA,EAUlB,YACWC,GAEQC,GACAC,IAAyB,CAAA,GAC1C;AAJS,SAAA,SAAAF,GAEQ,KAAA,SAAAC,GACA,KAAA,UAAAC,GAEjB,KAAK,QAAA,GACLF,EAAO,aAAa,KAAK,MAErBE,EAAQ,aAAa,MAASA,EAAQ,aAAa,UAAW,KAAK,YAAYA,EAAQ,QAAQ;AAAA,EACrG;AAAA,EATW;AAAA,EAEQ;AAAA,EACA;AAAA,EAbV,WAAW,IAAIC,EAAA;AAAA,EACP,QAA2C,CAAA;AAAA,EACpD,YAAsB,CAAA;AAAA,EACtB,UAAoC;AAAA,EACpC,iBAAgC;AAAA,EAChC,WAAgC;AAAA;AAAA,EAEvB,OAAO,IAAIC,EAAA;AAAA;AAAA,EAe5B,OAAO,UAAUC,GAAgBH,IAAyB,IAAY;AACpE,UAAMI,IAAQJ,EAAQ,SAAS,OACzBF,IAASM,MAAU,QAAQD,EAAO,IAAI,QAAQC,MAAU,UAAUD,EAAO,MAAM,QAAQC,GACvFC,IAAWL,EAAQ,aAAaI,MAAU,QAAQD,EAAO,IAAI,SAAS,WAAW,MAAM,SAAA,IAAa,KACpGG,IAAK,IAAIT,EAAOC,GAAQK,EAAO,IAAI,QAAQ,EAAE,GAAGH,GAAS,UAAAK,GAAU;AACzE,WAAAC,EAAG,WAAWH,EAAO,OAAO,GAAG,SAAS,CAAC,EAAE,IAAAI,EAAA,MAASD,EAAG,OAAOC,IAAK,GAAI,CAAC,GACjED;AAAA,EACT;AAAA;AAAA,EAGA,IAAsBE,GAAWC,IAAQ,KAAK,MAAM,QAAW;AAC7D,gBAAK,MAAM,OAAOA,GAAO,GAAG,EAAE,QAAAD,GAAQ,IAAI,IAAM,GAChD,KAAK,MAAA,GACEA;AAAA,EACT;AAAA;AAAA,EAGA,OAAOA,GAAsB;AAC3B,UAAME,IAAI,KAAK,MAAM,UAAU,CAACC,MAAMA,EAAE,WAAWH,CAAM;AACzD,IAAIE,IAAI,MACR,KAAK,MAAM,OAAOA,GAAG,CAAC,GACtB,KAAK,MAAA;AAAA,EACP;AAAA;AAAA,EAGA,WAAWF,GAAgBI,GAAmB;AAC5C,UAAMD,IAAI,KAAK,MAAM,KAAK,CAACE,MAAMA,EAAE,WAAWL,CAAM;AACpD,IAAI,CAACG,KAAKA,EAAE,OAAOC,MACnBD,EAAE,KAAKC,GACP,KAAK,MAAA;AAAA,EACP;AAAA,EAEA,UAAUJ,GAAyB;AACjC,WAAO,KAAK,MAAM,KAAK,CAACK,MAAMA,EAAE,WAAWL,CAAM,GAAG,MAAM;AAAA,EAC5D;AAAA;AAAA,EAGA,IAAI,UAA6B;AAC/B,WAAO,KAAK,MAAM,IAAI,CAACG,MAAMA,EAAE,MAAM;AAAA,EACvC;AAAA;AAAA,EAGA,QAAQG,GAA0BC,GAAcC,GAAYC,GAAYC,GAAwBC,GAAyB;AACvH,SAAK,SAAS,IAAI,EAAE,KAAAL,GAAK,MAAAC,GAAM,IAAAC,GAAI,IAAAC,GAAI,MAAM,OAAOC,KAAS,WAAWE,EAAWF,CAAI,IAAIA,GAAM,MAAAC,GAAM;AAAA,EACzG;AAAA;AAAA,EAGA,MAAMnB,IAAwB,IAAU;AACtC,QAAI,KAAK,QAAS;AAClB,UAAMM,IAAK,KAAK,YAAA;AAChB,IAAAA,EAAG,aAAaN,EAAQ,SAAS,UACjC,KAAK,SAAS,IAAI,EAAE,KAAK,SAAS,KAAK,CAACqB,MAAOf,EAAG,QAAQe,GAAI,MAAMrB,EAAQ,YAAY,KAAK,IAAI,GAAG,IAAIA,EAAQ,MAAM,KAAK,MAAMoB,EAAW,UAAU,EAAA,CAAG;AAAA,EAC3J;AAAA;AAAA,EAGA,UAAUP,GAAWS,GAAWtB,IAAwB,CAAA,GAAU;AAChE,QAAI,KAAK,QAAS;AAClB,UAAMuB,IAAO,IAAIC,EAAgBxB,CAAO;AACxC,IAAAuB,EAAK,WAAWV,IAAI,KAAK,OAAO,KAAK,KAAK,OAAO,QAAQS,IAAI,KAAK,OAAO,KAAK,KAAK,OAAO,MAAM;AAChG,UAAMG,IAAYF,EAAK;AACvB,SAAK,UAAU,KAAKA,CAAI,GACxB,KAAK,MAAA,GACL,KAAK,SAAS,IAAI;AAAA,MAChB,KAAK,CAACG,MAAM;AACV,QAAAH,EAAK,SAASG,KAAK1B,EAAQ,SAAS,MACpCuB,EAAK,YAAYE,KAAa,IAAIC;AAAA,MACpC;AAAA,MACA,MAAM;AAAA,MACN,IAAI;AAAA,MACJ,IAAI1B,EAAQ,MAAM;AAAA,MAClB,MAAMoB,EAAW,UAAU;AAAA,MAC3B,MAAM,MAAM;AACV,aAAK,YAAY,KAAK,UAAU,OAAO,CAACO,MAAMA,MAAMJ,CAAI,GACxD,KAAK,MAAA,GACLA,EAAK,QAAA;AAAA,MACP;AAAA,IAAA,CACD;AAAA,EACH;AAAA;AAAA,EAGA,IAAI,QAA2B;AAC7B,WAAO,KAAK,YAAA;AAAA,EACd;AAAA;AAAA,EAGA,OAAON,GAAkB;AACvB,IAAI,KAAK,SAAS,OAAO,KAAG,KAAK,SAAS,KAAKA,CAAE,GACjD,KAAK,QAAA;AAAA,EACP;AAAA,EAEA,UAAgB;AACd,SAAK,WAAA,GACL,KAAK,WAAW,MAChB,KAAK,SAAS,UAAA,GACd,KAAK,OAAO,UAAU,CAAA;AACtB,eAAWN,KAAK,KAAK,MAAO,CAAAA,EAAE,OAAO,QAAA;AACrC,SAAK,MAAM,SAAS,GACpB,KAAK,gBAAgB,QAAA,GACrB,KAAK,iBAAiB;AAAA,EACxB;AAAA;AAAA,EAGQ,UAAgB;AACtB,UAAMiB,IAAI,KAAK,OAAO,gBAChBC,IAAMD,EAAE,IAAIA,EAAE,IAAIA,EAAE,IAAIA,EAAE;AAChC,QAAIC,MAAQ,EAAG;AACf,UAAMC,IAAM,CAACjB,GAAWS,MAAgC;AACtD,YAAMS,IAAKlB,IAAIe,EAAE,IACXI,IAAKV,IAAIM,EAAE;AACjB,aAAO,EAAEA,EAAE,IAAIG,IAAKH,EAAE,IAAII,KAAMH,IAAMD,EAAE,IAAII,IAAKJ,EAAE,IAAIG,KAAMF,CAAG;AAAA,IAClE,GACM,CAACI,GAAIC,CAAE,IAAIJ,EAAI,KAAK,OAAO,GAAG,KAAK,OAAO,CAAC,GAC3C,CAACK,GAAIC,CAAE,IAAIN,EAAI,KAAK,OAAO,IAAI,KAAK,OAAO,OAAO,KAAK,OAAO,IAAI,KAAK,OAAO,MAAM;AAC1F,SAAK,KAAK,IAAI,KAAK,IAAIG,GAAIE,CAAE,GAC7B,KAAK,KAAK,IAAI,KAAK,IAAID,GAAIE,CAAE,GAC7B,KAAK,KAAK,QAAQ,KAAK,IAAID,IAAKF,CAAE,GAClC,KAAK,KAAK,SAAS,KAAK,IAAIG,IAAKF,CAAE;AAAA,EACrC;AAAA,EAEA,IAAY,UAAmB;AAC7B,YAAQ,KAAK,QAAQ,mBAAmB,OAASG,EAAe,WAAW;AAAA,EAC7E;AAAA,EAEQ,cAAiC;AACvC,WAAK,KAAK,YAAS,KAAK,UAAU,KAAK,IAAI,IAAIC,EAAA,GAAqB,CAAC,IAC9D,KAAK;AAAA,EACd;AAAA,EAEQ,YAAYC,GAAqB;AACvC,UAAMC,IAAI,IAAIC,EAAOC,EAAQ,KAAK;AAClC,IAAAF,EAAE,OAAOD,GACTC,EAAE,QAAQ,mBACV,KAAK,iBAAiBA,GACtB,KAAK,OAAO,WAAWA,GAAG,CAAC;AAC3B,UAAMG,IAAM,MAAM;AAChB,MAAAH,EAAE,SAAS,IAAI,KAAK,OAAO,GAAG,KAAK,OAAO,CAAC,GAC3CA,EAAE,QAAQ,KAAK,OAAO,OACtBA,EAAE,SAAS,KAAK,OAAO;AAAA,IACzB;AACA,IAAAG,EAAA,GACAH,EAAE,WAAWG;AAAA,EACf;AAAA,EAEQ,QAAc;AACpB,UAAMC,IAAiB,CAAA;AACvB,eAAW,KAAK,KAAK,MAAO,CAAI,EAAE,MAAIA,EAAK,KAAK,EAAE,MAAM;AAExD,SAAK,OAAO,UAAUA,EAAK,SAAS,KAAK,UAAU,SAAS,IAAI,CAAC,GAAG,KAAK,WAAW,GAAGA,CAAI,IAAI,CAAA;AAAA,EACjG;AACF;"}

package/dist/postfx/ShockwaveFilter.js

@@ -0,0 +1,49 @@
+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
+};
+//# sourceMappingURL=ShockwaveFilter.js.map

package/dist/postfx/ShockwaveFilter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ShockwaveFilter.js","sources":["../../src/postfx/ShockwaveFilter.ts"],"sourcesContent":["import { FxFilter } from './fxShader';\n\nexport interface ShockwaveOptions {\n  /** Ring's width as a share of the screen's height (default 0.06). */\n  width?: number;\n  /** How far the ring pushes the picture, screen pixels (default 12). */\n  amplitude?: number;\n}\n\n/**\n * A ring that bends the picture as it passes: an explosion's blast, a landing's thump. Set `centerX/Y` (0–1 across the\n * filtered area) and grow `radius` (a share of its height) over time; `PostFx.shockwave` does both and removes it.\n */\nexport class ShockwaveFilter extends FxFilter {\n  constructor(options: ShockwaveOptions = {}) {\n    super({\n      name: 'shockwave',\n      uniforms: {\n        uCenter: { type: 'vec2<f32>', value: new Float32Array([0.5, 0.5]) },\n        uRadius: { type: 'f32', value: 0 },\n        uWidth: { type: 'f32', value: options.width ?? 0.06 },\n        uAmplitude: { type: 'f32', value: options.amplitude ?? 12 },\n      },\n      glsl: `\n  vec2 d = (frameUv - uCenter) * vec2(framePx.x / framePx.y, 1.0);\n  float dist = length(d);\n  float x = (dist - uRadius) / max(uWidth, 0.0001);\n  if (abs(x) < 1.0 && dist > 0.0) {\n    float wave = sin(x * 3.14159265) * (1.0 - abs(x));\n    result = sampleAt(coord - (d / dist) * wave * uAmplitude * texel);\n  }`,\n      wgsl: `\n  let d = (frameUv - fx.uCenter) * vec2<f32>(framePx.x / framePx.y, 1.0);\n  let dist = length(d);\n  let x = (dist - fx.uRadius) / max(fx.uWidth, 0.0001);\n  if (abs(x) < 1.0 && dist > 0.0) {\n    let wave = sin(x * 3.14159265) * (1.0 - abs(x));\n    result = sampleAt(coord - (d / dist) * wave * fx.uAmplitude * texel);\n  }`,\n    });\n  }\n\n  setCenter(x: number, y: number): void {\n    this.set('uCenter', x, y);\n  }\n  get radius(): number {\n    return this.num('uRadius');\n  }\n  set radius(v: number) {\n    this.set('uRadius', v);\n  }\n  get amplitude(): number {\n    return this.num('uAmplitude');\n  }\n  set amplitude(v: number) {\n    this.set('uAmplitude', v);\n  }\n}\n"],"names":["ShockwaveFilter","FxFilter","options","x","y","v"],"mappings":";AAaO,MAAMA,UAAwBC,EAAS;AAAA,EAC5C,YAAYC,IAA4B,IAAI;AAC1C,UAAM;AAAA,MACJ,MAAM;AAAA,MACN,UAAU;AAAA,QACR,SAAS,EAAE,MAAM,aAAa,OAAO,IAAI,aAAa,CAAC,KAAK,GAAG,CAAC,EAAA;AAAA,QAChE,SAAS,EAAE,MAAM,OAAO,OAAO,EAAA;AAAA,QAC/B,QAAQ,EAAE,MAAM,OAAO,OAAOA,EAAQ,SAAS,KAAA;AAAA,QAC/C,YAAY,EAAE,MAAM,OAAO,OAAOA,EAAQ,aAAa,GAAA;AAAA,MAAG;AAAA,MAE5D,MAAM;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,MAQN,MAAM;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,IAAA,CAQP;AAAA,EACH;AAAA,EAEA,UAAUC,GAAWC,GAAiB;AACpC,SAAK,IAAI,WAAWD,GAAGC,CAAC;AAAA,EAC1B;AAAA,EACA,IAAI,SAAiB;AACnB,WAAO,KAAK,IAAI,SAAS;AAAA,EAC3B;AAAA,EACA,IAAI,OAAOC,GAAW;AACpB,SAAK,IAAI,WAAWA,CAAC;AAAA,EACvB;AAAA,EACA,IAAI,YAAoB;AACtB,WAAO,KAAK,IAAI,YAAY;AAAA,EAC9B;AAAA,EACA,IAAI,UAAUA,GAAW;AACvB,SAAK,IAAI,cAAcA,CAAC;AAAA,EAC1B;AACF;"}

package/dist/postfx/VignetteFilter.js

@@ -0,0 +1,37 @@
+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
+};
+//# sourceMappingURL=VignetteFilter.js.map

package/dist/postfx/VignetteFilter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"VignetteFilter.js","sources":["../../src/postfx/VignetteFilter.ts"],"sourcesContent":["import { FxFilter, rgb } from './fxShader';\n\nexport interface VignetteOptions {\n  /** 0–1, how dark the corners go (default 0.5). */\n  strength?: number;\n  /** Where the darkening starts, as a share of the way from the centre to a corner (default 0.55). */\n  radius?: number;\n  /** How far beyond `radius` it reaches full strength (default 0.45). */\n  softness?: number;\n  /** What the edges fade to (default black); a red one is a classic low-health warning. */\n  color?: number;\n}\n\n/** Darkens the edges of the screen towards a colour, round whatever its shape. */\nexport class VignetteFilter extends FxFilter {\n  constructor(options: VignetteOptions = {}) {\n    super({\n      name: 'vignette',\n      uniforms: {\n        uStrength: { type: 'f32', value: options.strength ?? 0.5 },\n        uRadius: { type: 'f32', value: options.radius ?? 0.55 },\n        uSoftness: { type: 'f32', value: options.softness ?? 0.45 },\n        uColor: { type: 'vec3<f32>', value: new Float32Array(rgb(options.color ?? 0)) },\n      },\n      glsl: `\n  vec2 aspect = vec2(framePx.x / framePx.y, 1.0);\n  float dist = length((frameUv - 0.5) * aspect) / length(aspect * 0.5);\n  float v = smoothstep(uRadius, uRadius + max(uSoftness, 0.0001), dist) * uStrength;\n  result = vec4(mix(src.rgb, uColor * src.a, v), src.a);`,\n      wgsl: `\n  let aspect = vec2<f32>(framePx.x / framePx.y, 1.0);\n  let dist = length((frameUv - 0.5) * aspect) / length(aspect * 0.5);\n  let v = smoothstep(fx.uRadius, fx.uRadius + max(fx.uSoftness, 0.0001), dist) * fx.uStrength;\n  result = vec4<f32>(mix(src.rgb, fx.uColor * src.a, v), src.a);`,\n    });\n  }\n\n  get strength(): number {\n    return this.num('uStrength');\n  }\n  set strength(v: number) {\n    this.set('uStrength', v);\n  }\n\n  set color(c: number) {\n    this.set('uColor', ...rgb(c));\n  }\n}\n"],"names":["VignetteFilter","FxFilter","options","rgb","v","c"],"mappings":";AAcO,MAAMA,UAAuBC,EAAS;AAAA,EAC3C,YAAYC,IAA2B,IAAI;AACzC,UAAM;AAAA,MACJ,MAAM;AAAA,MACN,UAAU;AAAA,QACR,WAAW,EAAE,MAAM,OAAO,OAAOA,EAAQ,YAAY,IAAA;AAAA,QACrD,SAAS,EAAE,MAAM,OAAO,OAAOA,EAAQ,UAAU,KAAA;AAAA,QACjD,WAAW,EAAE,MAAM,OAAO,OAAOA,EAAQ,YAAY,KAAA;AAAA,QACrD,QAAQ,EAAE,MAAM,aAAa,OAAO,IAAI,aAAaC,EAAID,EAAQ,SAAS,CAAC,CAAC,EAAA;AAAA,MAAE;AAAA,MAEhF,MAAM;AAAA;AAAA;AAAA;AAAA;AAAA,MAKN,MAAM;AAAA;AAAA;AAAA;AAAA;AAAA,IAAA,CAKP;AAAA,EACH;AAAA,EAEA,IAAI,WAAmB;AACrB,WAAO,KAAK,IAAI,WAAW;AAAA,EAC7B;AAAA,EACA,IAAI,SAASE,GAAW;AACtB,SAAK,IAAI,aAAaA,CAAC;AAAA,EACzB;AAAA,EAEA,IAAI,MAAMC,GAAW;AACnB,SAAK,IAAI,UAAU,GAAGF,EAAIE,CAAC,CAAC;AAAA,EAC9B;AACF;"}

package/dist/postfx/fxAnimator.js

@@ -0,0 +1,38 @@
+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
+};
+//# sourceMappingURL=fxAnimator.js.map

package/dist/postfx/fxAnimator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fxAnimator.js","sources":["../../src/postfx/fxAnimator.ts"],"sourcesContent":["import type { EaseFn } from '../core/eases';\n\n/** One running change of a number over time. */\nexport interface FxAnimation {\n  /** Called with the eased value every frame, and with `to` at the end. */\n  set: (value: number) => void;\n  from: number;\n  to: number;\n  ms: number;\n  ease: EaseFn;\n  /** Runs once after the last `set`. */\n  done?: () => void;\n  elapsed: number;\n  /** A key that cancels whatever animation already holds it (one flash at a time, say). */\n  key?: string;\n}\n\nconst linear: EaseFn = (t) => t;\n\n/**\n * Advances numbers over time for the post effects: a flash fading, a shockwave growing, a vignette breathing. Pure,\n * so it is tested without a renderer; `PostFx` steps it on every frame.\n */\nexport class FxAnimator {\n  private readonly list: FxAnimation[] = [];\n\n  get size(): number {\n    return this.list.length;\n  }\n\n  /** Starts an animation; one with the same `key` as a running one replaces it (the old one's `done` still runs). */\n  run(a: Omit<FxAnimation, 'elapsed' | 'ease'> & { ease?: EaseFn }): void {\n    if (a.key !== undefined) {\n      const i = this.list.findIndex((x) => x.key === a.key);\n      if (i >= 0) this.list.splice(i, 1)[0]!.done?.();\n    }\n    const anim: FxAnimation = { ...a, ease: a.ease ?? linear, elapsed: 0 };\n    anim.set(anim.from);\n    if (anim.ms <= 0) {\n      anim.set(anim.to);\n      anim.done?.();\n      return;\n    }\n    this.list.push(anim);\n  }\n\n  /** Moves every animation on by `ms`; finished ones set their last value, call `done` and are dropped. */\n  step(ms: number): void {\n    for (let i = 0; i < this.list.length; ) {\n      const a = this.list[i]!;\n      a.elapsed += ms;\n      const t = Math.min(1, a.elapsed / a.ms);\n      a.set(a.from + (a.to - a.from) * a.ease(t));\n      if (t >= 1) {\n        this.list.splice(i, 1);\n        a.done?.();\n      } else i++;\n    }\n  }\n\n  /** Ends everything at once, each at its last value. */\n  finishAll(): void {\n    for (const a of this.list.splice(0)) {\n      a.set(a.to);\n      a.done?.();\n    }\n  }\n}\n"],"names":["linear","t","FxAnimator","a","i","x","anim","ms"],"mappings":"AAiBA,MAAMA,IAAiB,CAACC,MAAMA;AAMvB,MAAMC,EAAW;AAAA,EACL,OAAsB,CAAA;AAAA,EAEvC,IAAI,OAAe;AACjB,WAAO,KAAK,KAAK;AAAA,EACnB;AAAA;AAAA,EAGA,IAAIC,GAAoE;AACtE,QAAIA,EAAE,QAAQ,QAAW;AACvB,YAAMC,IAAI,KAAK,KAAK,UAAU,CAACC,MAAMA,EAAE,QAAQF,EAAE,GAAG;AACpD,MAAIC,KAAK,KAAG,KAAK,KAAK,OAAOA,GAAG,CAAC,EAAE,CAAC,EAAG,OAAA;AAAA,IACzC;AACA,UAAME,IAAoB,EAAE,GAAGH,GAAG,MAAMA,EAAE,QAAQH,GAAQ,SAAS,EAAA;AAEnE,QADAM,EAAK,IAAIA,EAAK,IAAI,GACdA,EAAK,MAAM,GAAG;AAChB,MAAAA,EAAK,IAAIA,EAAK,EAAE,GAChBA,EAAK,OAAA;AACL;AAAA,IACF;AACA,SAAK,KAAK,KAAKA,CAAI;AAAA,EACrB;AAAA;AAAA,EAGA,KAAKC,GAAkB;AACrB,aAASH,IAAI,GAAGA,IAAI,KAAK,KAAK,UAAU;AACtC,YAAMD,IAAI,KAAK,KAAKC,CAAC;AACrB,MAAAD,EAAE,WAAWI;AACb,YAAMN,IAAI,KAAK,IAAI,GAAGE,EAAE,UAAUA,EAAE,EAAE;AACtC,MAAAA,EAAE,IAAIA,EAAE,QAAQA,EAAE,KAAKA,EAAE,QAAQA,EAAE,KAAKF,CAAC,CAAC,GACtCA,KAAK,KACP,KAAK,KAAK,OAAOG,GAAG,CAAC,GACrBD,EAAE,OAAA,KACGC;AAAA,IACT;AAAA,EACF;AAAA;AAAA,EAGA,YAAkB;AAChB,eAAWD,KAAK,KAAK,KAAK,OAAO,CAAC;AAChC,MAAAA,EAAE,IAAIA,EAAE,EAAE,GACVA,EAAE,OAAA;AAAA,EAEN;AACF;"}