@flare-engine/postfx 0.1.0

package/dist/index.mjs

@@ -0,0 +1,1037 @@
+// src/effect.ts
+function createVignette(id = "vignette", uniforms = {}) {
+  return {
+    id,
+    enabled: true,
+    uniforms: {
+      kind: "vignette",
+      intensity: uniforms.intensity ?? 0.4,
+      radius: uniforms.radius ?? 0.8,
+      color: uniforms.color ?? [0, 0, 0]
+    }
+  };
+}
+function createGrayscaleFlash(id = "grayscale-flash", uniforms = {}) {
+  return {
+    id,
+    enabled: true,
+    uniforms: { kind: "grayscale-flash", intensity: uniforms.intensity ?? 0 }
+  };
+}
+function createChromaticAberration(id = "chromatic-aberration", uniforms = {}) {
+  return {
+    id,
+    enabled: true,
+    uniforms: { kind: "chromatic-aberration", amount: uniforms.amount ?? 5e-3 }
+  };
+}
+function createCrt(id = "crt", uniforms = {}) {
+  return {
+    id,
+    enabled: true,
+    uniforms: {
+      kind: "crt",
+      scanlineIntensity: uniforms.scanlineIntensity ?? 0.25,
+      curvature: uniforms.curvature ?? 0.12
+    }
+  };
+}
+function createBloom(id = "bloom", uniforms = {}) {
+  return {
+    id,
+    enabled: true,
+    uniforms: {
+      kind: "bloom",
+      threshold: uniforms.threshold ?? 0.7,
+      intensity: uniforms.intensity ?? 0.6
+    }
+  };
+}
+function createGodRays(id = "god-rays", uniforms = {}) {
+  return {
+    id,
+    enabled: true,
+    uniforms: {
+      kind: "god-rays",
+      lightX: uniforms.lightX ?? 0.5,
+      lightY: uniforms.lightY ?? 0.1,
+      color: uniforms.color ?? [1, 0.95, 0.8],
+      intensity: uniforms.intensity ?? 0.6,
+      decay: uniforms.decay ?? 0.96,
+      density: uniforms.density ?? 0.5,
+      weight: uniforms.weight ?? 0.4,
+      samples: uniforms.samples ?? 48
+    }
+  };
+}
+function createColorGradingLut(uniforms, id = "color-grading-lut") {
+  return {
+    id,
+    enabled: true,
+    uniforms: {
+      kind: "color-grading-lut",
+      lut: uniforms.lut,
+      intensity: uniforms.intensity ?? 1
+    }
+  };
+}
+function createWeatherRain(id = "weather-rain", uniforms = {}) {
+  return {
+    id,
+    enabled: true,
+    uniforms: {
+      kind: "weather-rain",
+      intensity: uniforms.intensity ?? 0.5,
+      direction: uniforms.direction ?? 0,
+      speed: uniforms.speed ?? 0,
+      scrollOffsetY: uniforms.scrollOffsetY ?? 0,
+      color: uniforms.color ?? [1, 1, 1],
+      density: uniforms.density ?? 0.5,
+      streakLen: uniforms.streakLen ?? 0.15
+    }
+  };
+}
+function createWeatherSunShaft(id = "weather-sun-shaft", uniforms = {}) {
+  return {
+    id,
+    enabled: true,
+    uniforms: {
+      kind: "weather-sun-shaft",
+      intensity: uniforms.intensity ?? 0.5,
+      direction: uniforms.direction ?? 0
+    }
+  };
+}
+function createWeatherDarkVignette(id = "weather-dark-vignette", uniforms = {}) {
+  return {
+    id,
+    enabled: true,
+    uniforms: {
+      kind: "weather-dark-vignette",
+      intensity: uniforms.intensity ?? 0.5
+    }
+  };
+}
+function createWeatherClouds(id = "weather-clouds", uniforms = {}) {
+  return {
+    id,
+    enabled: true,
+    uniforms: {
+      kind: "weather-clouds",
+      intensity: uniforms.intensity ?? 0.5,
+      direction: uniforms.direction ?? 0,
+      speed: uniforms.speed ?? 0,
+      scrollOffsetX: uniforms.scrollOffsetX ?? 0
+    }
+  };
+}
+function createPostFxComposite(id = "composite", uniforms = {}) {
+  return {
+    id,
+    enabled: true,
+    uniforms: {
+      kind: "composite",
+      vignetteIntensity: uniforms.vignetteIntensity ?? 0,
+      vignetteRadius: uniforms.vignetteRadius ?? 0.8,
+      vignetteColor: uniforms.vignetteColor ?? [0, 0, 0],
+      bloomThreshold: uniforms.bloomThreshold ?? 0.7,
+      bloomIntensity: uniforms.bloomIntensity ?? 0,
+      flashIntensity: uniforms.flashIntensity ?? 0,
+      chromaAmount: uniforms.chromaAmount ?? 0,
+      crtScanlineIntensity: uniforms.crtScanlineIntensity ?? 0.25,
+      crtCurvature: uniforms.crtCurvature ?? 0.12,
+      crtEnabled: uniforms.crtEnabled ?? false,
+      weatherKind: uniforms.weatherKind ?? 0,
+      weatherIntensity: uniforms.weatherIntensity ?? 0,
+      weatherDirection: uniforms.weatherDirection ?? 0,
+      weatherScrollX: uniforms.weatherScrollX ?? 0,
+      weatherScrollY: uniforms.weatherScrollY ?? 0,
+      weatherColor: uniforms.weatherColor ?? [1, 1, 1],
+      weatherDensity: uniforms.weatherDensity ?? 0.5,
+      weatherStreakLen: uniforms.weatherStreakLen ?? 0.15
+    }
+  };
+}
+
+// src/chain.ts
+var EffectChain = class {
+  _effects = [];
+  _globalIntensity = 1;
+  get length() {
+    return this._effects.length;
+  }
+  /**
+   * Global intensity multiplier applied to every enabled effect's
+   * "strength" uniform when the pass is built. Default 1 (no-op).
+   *
+   * Scales the following uniform fields at pass-build time:
+   *  - vignette.intensity
+   *  - grayscale-flash.intensity
+   *  - chromatic-aberration.amount
+   *  - crt.scanlineIntensity
+   *  - bloom.intensity
+   *
+   * Geometry-like uniforms (radius, curvature, threshold) are not scaled.
+   * Intended for a11y reduced-motion (set to 0 to null all dampen-able
+   * effects in one call) without touching per-effect state.
+   *
+   * Clamped to `>= 0`. Negative values are clamped to 0.
+   */
+  get globalIntensity() {
+    return this._globalIntensity;
+  }
+  set globalIntensity(value) {
+    this._globalIntensity = value < 0 ? 0 : value;
+  }
+  /** Convenience setter — mirrors the getter/setter. */
+  setGlobalIntensity(value) {
+    this.globalIntensity = value;
+  }
+  /** Snapshot view of the chain. Do not mutate. */
+  all() {
+    return this._effects;
+  }
+  /** Append an effect to the end of the chain. */
+  add(effect) {
+    if (this._effects.some((e) => e.id === effect.id)) {
+      throw new Error(`EffectChain: duplicate id "${effect.id}"`);
+    }
+    this._effects.push(effect);
+  }
+  /** Insert an effect at a specific index (clamped to [0, length]). */
+  insert(index, effect) {
+    if (this._effects.some((e) => e.id === effect.id)) {
+      throw new Error(`EffectChain: duplicate id "${effect.id}"`);
+    }
+    const i = Math.max(0, Math.min(this._effects.length, index));
+    this._effects.splice(i, 0, effect);
+  }
+  remove(id) {
+    const i = this._effects.findIndex((e) => e.id === id);
+    if (i === -1) return false;
+    this._effects.splice(i, 1);
+    return true;
+  }
+  get(id) {
+    return this._effects.find((e) => e.id === id) ?? null;
+  }
+  setEnabled(id, enabled) {
+    const e = this.get(id);
+    if (e) e.enabled = enabled;
+  }
+  /** Update uniforms in place. Kind must match the existing effect's kind. */
+  setUniforms(id, uniforms) {
+    const e = this.get(id);
+    if (!e) return;
+    if (e.uniforms.kind !== uniforms.kind) {
+      throw new Error(
+        `EffectChain: cannot change kind of "${id}" from "${e.uniforms.kind}" to "${uniforms.kind}"`
+      );
+    }
+    e.uniforms = uniforms;
+  }
+  move(id, newIndex) {
+    const i = this._effects.findIndex((e) => e.id === id);
+    if (i === -1) return;
+    const [removed] = this._effects.splice(i, 1);
+    if (!removed) return;
+    const clamped = Math.max(0, Math.min(this._effects.length, newIndex));
+    this._effects.splice(clamped, 0, removed);
+  }
+  clear() {
+    this._effects.length = 0;
+  }
+  /** Iterate only over enabled effects, in order. */
+  *enabled() {
+    for (const e of this._effects) {
+      if (e.enabled) yield e;
+    }
+  }
+};
+
+// src/shaders.ts
+var VIGNETTE_SKSL = (
+  /* sksl */
+  `
+uniform shader src;
+uniform float2 resolution;
+uniform float intensity;
+uniform float radius;
+uniform float3 color;
+
+half4 main(float2 coord) {
+  half4 c = src.eval(coord);
+  float2 uv = coord / resolution;
+  float2 centered = uv - 0.5;
+  float d = length(centered);
+  float v = smoothstep(radius, radius * 0.5, d);
+  return half4(mix(half3(color), c.rgb, mix(1.0 - intensity, 1.0, v)), c.a);
+}
+`
+);
+var GRAYSCALE_FLASH_SKSL = (
+  /* sksl */
+  `
+uniform shader src;
+uniform float intensity;
+
+half4 main(float2 coord) {
+  half4 c = src.eval(coord);
+  float luma = dot(c.rgb, half3(0.299, 0.587, 0.114));
+  half3 gray = half3(luma);
+  half3 mixed = mix(c.rgb, gray, half(intensity));
+  return half4(mixed, c.a);
+}
+`
+);
+var CHROMATIC_ABERRATION_SKSL = (
+  /* sksl */
+  `
+uniform shader src;
+uniform float2 resolution;
+uniform float amount;
+
+half4 main(float2 coord) {
+  float2 uv = coord / resolution;
+  float2 offset = (uv - 0.5) * amount;
+  half r = src.eval((uv - offset) * resolution).r;
+  half g = src.eval(coord).g;
+  half b = src.eval((uv + offset) * resolution).b;
+  half a = src.eval(coord).a;
+  return half4(r, g, b, a);
+}
+`
+);
+var CRT_SKSL = (
+  /* sksl */
+  `
+uniform shader src;
+uniform float2 resolution;
+uniform float scanlineIntensity;
+uniform float curvature;
+
+half4 main(float2 coord) {
+  float2 uv = coord / resolution;
+  float2 centered = uv - 0.5;
+  float2 warp = centered * (1.0 + dot(centered, centered) * curvature);
+  float2 warpedUv = warp + 0.5;
+  if (warpedUv.x < 0.0 || warpedUv.x > 1.0 || warpedUv.y < 0.0 || warpedUv.y > 1.0) {
+    return half4(0.0, 0.0, 0.0, 1.0);
+  }
+  half4 c = src.eval(warpedUv * resolution);
+  float scan = 0.5 + 0.5 * sin(warpedUv.y * resolution.y * 3.14159);
+  float dim = mix(1.0, scan, scanlineIntensity);
+  return half4(c.rgb * dim, c.a);
+}
+`
+);
+var BLOOM_SKSL = (
+  /* sksl */
+  `
+uniform shader src;
+uniform float2 resolution;
+uniform float threshold;
+uniform float intensity;
+
+half4 main(float2 coord) {
+  half4 c = src.eval(coord);
+  float luma = dot(c.rgb, half3(0.299, 0.587, 0.114));
+  float mask = smoothstep(threshold, 1.0, luma);
+  half3 boost = c.rgb * mask * intensity;
+  return half4(c.rgb + boost, c.a);
+}
+`
+);
+var COLOR_GRADING_LUT_SKSL = (
+  /* sksl */
+  `
+uniform shader src;
+uniform shader lut;
+uniform float intensity;
+
+half4 main(float2 coord) {
+  half4 scene = src.eval(coord);
+
+  float r = float(scene.r) * 63.0;
+  float g = float(scene.g) * 63.0;
+  float b = float(scene.b) * 63.0;
+
+  float bFloor = floor(b);
+  float bCeil  = min(bFloor + 1.0, 63.0);
+  float bFrac  = b - bFloor;
+
+  float2 uvFloor = float2((bFloor * 64.0 + r + 0.5) / 4096.0,
+                          (g + 0.5) / 64.0);
+  float2 uvCeil  = float2((bCeil  * 64.0 + r + 0.5) / 4096.0,
+                          (g + 0.5) / 64.0);
+
+  half3 lutFloor = lut.eval(uvFloor * float2(4096.0, 64.0)).rgb;
+  half3 lutCeil  = lut.eval(uvCeil  * float2(4096.0, 64.0)).rgb;
+
+  half3 graded = mix(lutFloor, lutCeil, half(bFrac));
+  half3 result = mix(scene.rgb, graded, half(intensity));
+
+  return half4(result, scene.a);
+}
+`
+);
+var WEATHER_RAIN_SKSL = (
+  /* sksl */
+  `
+uniform shader src;
+uniform float2 resolution;
+uniform float intensity;
+uniform float direction;
+uniform float scrollOffsetY;
+uniform float3 color;
+uniform float density;
+uniform float streakLen;
+
+// scrollOffsetY is a normalized fall phase in [0,1). Increase it each tick
+// by (speed * dt / screenHeight) and wrap with fract() on the game side.
+
+float hash(float2 p) { return fract(sin(dot(p, float2(127.1, 311.7))) * 43758.5453); }
+
+half4 main(float2 coord) {
+  half4 scene = src.eval(coord);
+  float2 uv = coord / resolution;
+  float aspect = resolution.x / resolution.y;
+  float rad = direction * 3.14159 / 180.0;
+  float sinA = sin(rad);
+  float cosA = cos(rad);
+  // aspect-corrected rotated axes: fallAxis along drop travel, perpAxis across
+  float perpAxis = (cosA * uv.x - sinA * uv.y) * aspect;
+  float fallAxis = sinA * uv.x + cosA * uv.y;
+
+  float coverage = 0.0;
+
+  // near layer \u2014 COLS=45, tiling=6, brightness=1.0
+  {
+    float COLS = 45.0;
+    float tiling = 6.0;
+    float brightness = 1.0;
+    float cid = floor(perpAxis * COLS);
+    float colHash = hash(float2(cid, 0.0));
+    if (colHash < density) {
+      float phase = hash(float2(cid, 1.0));
+      float colBright = brightness * (0.6 + hash(float2(cid, 2.0)) * 0.4);
+      float center = 0.5 + (hash(float2(cid, 3.0)) - 0.5) * 0.4;
+      float seg = fract(fallAxis * tiling - scrollOffsetY + phase);
+      float coverageY = smoothstep(streakLen, 0.0, seg);
+      float width = 0.04;
+      float xMask = smoothstep(width, 0.0, abs(fract(perpAxis * COLS) - center));
+      coverage = max(coverage, coverageY * xMask * colBright);
+    }
+  }
+
+  // far layer \u2014 COLS=85, tiling=11, brightness=0.5
+  {
+    float COLS = 85.0;
+    float tiling = 11.0;
+    float brightness = 0.5;
+    float cid = floor(perpAxis * COLS);
+    float colHash = hash(float2(cid, 10.0));
+    if (colHash < density) {
+      float phase = hash(float2(cid, 11.0));
+      float colBright = brightness * (0.6 + hash(float2(cid, 12.0)) * 0.4);
+      float center = 0.5 + (hash(float2(cid, 13.0)) - 0.5) * 0.4;
+      float seg = fract(fallAxis * tiling - scrollOffsetY + phase);
+      float coverageY = smoothstep(streakLen, 0.0, seg);
+      float width = 0.03;
+      float xMask = smoothstep(width, 0.0, abs(fract(perpAxis * COLS) - center));
+      coverage = max(coverage, coverageY * xMask * colBright);
+    }
+  }
+
+  half3 mixed = mix(scene.rgb, half3(color), half(coverage * intensity));
+  return half4(mixed, scene.a);
+}
+`
+);
+var WEATHER_SUN_SHAFT_SKSL = (
+  /* sksl */
+  `
+uniform shader src;
+uniform float2 resolution;
+uniform float intensity;
+uniform float direction;
+
+half4 main(float2 coord) {
+  half4 scene = src.eval(coord);
+  float2 uv = coord / resolution;
+  float rad = direction * 3.14159 / 180.0;
+  float2 src_point = float2(0.5 + sin(rad) * 0.3, -0.05);
+  float2 toFrag = uv - src_point;
+  float angle = atan(toFrag.x, toFrag.y);
+  float shafts = 0.5 + 0.5 * sin(angle * 8.0);
+  float dist = length(toFrag);
+  float falloff = 1.0 - smoothstep(0.0, 1.2, dist);
+  half shaft = half(shafts * falloff * intensity * 0.35);
+  return half4(scene.rgb + half3(shaft * 0.95, shaft * 0.9, shaft * 0.6), scene.a);
+}
+`
+);
+var WEATHER_DARK_VIGNETTE_SKSL = (
+  /* sksl */
+  `
+uniform shader src;
+uniform float2 resolution;
+uniform float intensity;
+
+half4 main(float2 coord) {
+  half4 scene = src.eval(coord);
+  float2 uv = coord / resolution - 0.5;
+  float d = length(uv);
+  float v = smoothstep(0.3, 0.85, d);
+  half dark = half(v * intensity);
+  return half4(scene.rgb * (1.0 - dark), scene.a);
+}
+`
+);
+var WEATHER_CLOUDS_SKSL = (
+  /* sksl */
+  `
+uniform shader src;
+uniform float2 resolution;
+uniform float intensity;
+uniform float scrollOffsetX;
+
+float hash(float2 p) { return fract(sin(dot(p, float2(127.1, 311.7))) * 43758.5453); }
+float vnoise(float2 p) {
+  float2 i = floor(p); float2 f = fract(p);
+  float2 u = f * f * (3.0 - 2.0 * f);
+  return mix(mix(hash(i), hash(i + float2(1.0, 0.0)), u.x),
+             mix(hash(i + float2(0.0, 1.0)), hash(i + float2(1.0, 1.0)), u.x), u.y);
+}
+float fbm(float2 p) { return vnoise(p) * 0.6 + vnoise(p * 2.3) * 0.4; }
+
+half4 main(float2 coord) {
+  half4 scene = src.eval(coord);
+  float2 uv = coord / resolution;
+  float2 cloudUv = float2(uv.x + scrollOffsetX / resolution.x, uv.y * 0.5);
+  float cloud = fbm(cloudUv * 3.0);
+  float heightFade = smoothstep(0.6, 0.2, uv.y);
+  float alpha = cloud * heightFade * intensity * 0.5;
+  half3 cloudColor = half3(0.9, 0.9, 0.95);
+  return half4(mix(scene.rgb, cloudColor, half(alpha)), scene.a);
+}
+`
+);
+var COMPOSITE_SKSL = (
+  /* sksl */
+  `
+uniform shader src;
+
+uniform float2 resolution;
+uniform float vignetteIntensity;
+uniform float vignetteRadius;
+uniform float3 vignetteColor;
+uniform float bloomThreshold;
+uniform float bloomIntensity;
+uniform float flashIntensity;
+uniform float chromaAmount;
+uniform float crtScanlineIntensity;
+uniform float crtCurvature;
+uniform float crtEnabled;
+uniform float weatherKind;
+uniform float weatherIntensity;
+uniform float weatherDirection;
+uniform float weatherScrollX;
+uniform float weatherScrollY;
+uniform float3 weatherColor;
+uniform float weatherDensity;
+uniform float weatherStreakLen;
+
+float hash(float2 p) { return fract(sin(dot(p, float2(127.1, 311.7))) * 43758.5453); }
+float vnoise(float2 p) {
+  float2 i = floor(p); float2 f = fract(p);
+  float2 u = f * f * (3.0 - 2.0 * f);
+  return mix(mix(hash(i), hash(i + float2(1.0, 0.0)), u.x),
+             mix(hash(i + float2(0.0, 1.0)), hash(i + float2(1.0, 1.0)), u.x), u.y);
+}
+float fbm(float2 p) { return vnoise(p) * 0.6 + vnoise(p * 2.3) * 0.4; }
+
+half4 main(float2 coord) {
+  // --- chromatic aberration ---
+  float2 uv = coord / resolution;
+  float2 chromaOffset = (uv - 0.5) * chromaAmount;
+  half r = src.eval((uv - chromaOffset) * resolution).r;
+  half g = src.eval(coord).g;
+  half b = src.eval((uv + chromaOffset) * resolution).b;
+  half3 c = half3(r, g, b);
+
+  // --- CRT ---
+  float2 crtCentered = uv - 0.5;
+  float2 crtWarp = crtCentered * (1.0 + dot(crtCentered, crtCentered) * crtCurvature);
+  float2 crtUv = crtWarp + 0.5;
+  float crtMask = float(crtUv.x >= 0.0 && crtUv.x <= 1.0 && crtUv.y >= 0.0 && crtUv.y <= 1.0);
+  {
+    float2 chromaOffsetCrt = (crtUv - 0.5) * chromaAmount;
+    half rCrt = src.eval((crtUv - chromaOffsetCrt) * resolution).r;
+    half gCrt = src.eval(crtUv * resolution).g;
+    half bCrt = src.eval((crtUv + chromaOffsetCrt) * resolution).b;
+    half3 crtColor = half3(rCrt, gCrt, bCrt);
+    float scan = 0.5 + 0.5 * sin(crtUv.y * resolution.y * 3.14159);
+    float dim = mix(1.0, scan, crtScanlineIntensity);
+    half3 crtResult = crtColor * half(dim);
+    c = mix(c, mix(half3(0.0), crtResult, half(crtMask)), half(crtEnabled));
+  }
+
+  // --- bloom ---
+  float luma = dot(c, half3(0.299, 0.587, 0.114));
+  float bloomMask = smoothstep(bloomThreshold, 1.0, luma);
+  c = c + c * half(bloomMask * bloomIntensity);
+
+  // --- weather ---
+  {
+    float wk = weatherKind;
+    if (wk >= 0.5 && wk < 1.5) {
+      // rain \u2014 falling sawtooth streaks, 2 parallax layers, alpha-over blend
+      // weatherScrollY is normalized [0,1) fall phase (increment speed*dt/screenH each tick)
+      float rad = weatherDirection * 3.14159 / 180.0;
+      float sinA = sin(rad);
+      float cosA = cos(rad);
+      float aspect = resolution.x / resolution.y;
+      float perpAxis = (cosA * uv.x - sinA * uv.y) * aspect;
+      float fallAxis = sinA * uv.x + cosA * uv.y;
+
+      float coverage = 0.0;
+
+      // near layer \u2014 COLS=45, tiling=6, brightness=1.0
+      {
+        float COLS = 45.0;
+        float tiling = 6.0;
+        float brightness = 1.0;
+        float cid = floor(perpAxis * COLS);
+        float colHash = hash(float2(cid, 0.0));
+        if (colHash < weatherDensity) {
+          float phase = hash(float2(cid, 1.0));
+          float colBright = brightness * (0.6 + hash(float2(cid, 2.0)) * 0.4);
+          float center = 0.5 + (hash(float2(cid, 3.0)) - 0.5) * 0.4;
+          float seg = fract(fallAxis * tiling - weatherScrollY + phase);
+          float coverageY = smoothstep(weatherStreakLen, 0.0, seg);
+          float width = 0.04;
+          float xMask = smoothstep(width, 0.0, abs(fract(perpAxis * COLS) - center));
+          coverage = max(coverage, coverageY * xMask * colBright);
+        }
+      }
+
+      // far layer \u2014 COLS=85, tiling=11, brightness=0.5
+      {
+        float COLS = 85.0;
+        float tiling = 11.0;
+        float brightness = 0.5;
+        float cid = floor(perpAxis * COLS);
+        float colHash = hash(float2(cid, 10.0));
+        if (colHash < weatherDensity) {
+          float phase = hash(float2(cid, 11.0));
+          float colBright = brightness * (0.6 + hash(float2(cid, 12.0)) * 0.4);
+          float center = 0.5 + (hash(float2(cid, 13.0)) - 0.5) * 0.4;
+          float seg = fract(fallAxis * tiling - weatherScrollY + phase);
+          float coverageY = smoothstep(weatherStreakLen, 0.0, seg);
+          float width = 0.03;
+          float xMask = smoothstep(width, 0.0, abs(fract(perpAxis * COLS) - center));
+          coverage = max(coverage, coverageY * xMask * colBright);
+        }
+      }
+
+      c = mix(c, half3(weatherColor), half(coverage * weatherIntensity));
+    } else if (wk >= 1.5 && wk < 2.5) {
+      // sun-shaft
+      float rad = weatherDirection * 3.14159 / 180.0;
+      float2 srcPoint = float2(0.5 + sin(rad) * 0.3, -0.05);
+      float2 toFrag = uv - srcPoint;
+      float angle = atan(toFrag.x, toFrag.y);
+      float shafts = 0.5 + 0.5 * sin(angle * 8.0);
+      float dist = length(toFrag);
+      float falloff = 1.0 - smoothstep(0.0, 1.2, dist);
+      half shaft = half(shafts * falloff * weatherIntensity * 0.35);
+      c = c + half3(shaft * 0.95, shaft * 0.9, shaft * 0.6);
+    } else if (wk >= 2.5 && wk < 3.5) {
+      // dark-vignette
+      float2 uvShift = uv - 0.5;
+      float d2 = length(uvShift);
+      float vd = smoothstep(0.3, 0.85, d2);
+      half dark = half(vd * weatherIntensity);
+      c = c * (1.0 - dark);
+    } else if (wk >= 3.5) {
+      // clouds
+      float2 cloudUv = float2(uv.x + weatherScrollX / resolution.x, uv.y * 0.5);
+      float cloud = fbm(cloudUv * 3.0);
+      float heightFade = smoothstep(0.6, 0.2, uv.y);
+      float alpha = cloud * heightFade * weatherIntensity * 0.5;
+      half3 cloudColor = half3(0.9, 0.9, 0.95);
+      c = mix(c, cloudColor, half(alpha));
+    }
+  }
+
+  // --- grayscale flash ---
+  float lumaFlash = dot(c, half3(0.299, 0.587, 0.114));
+  half3 gray = half3(lumaFlash);
+  c = mix(c, gray, half(flashIntensity));
+
+  // --- vignette ---
+  float2 vigCentered = uv - 0.5;
+  float vigD = length(vigCentered);
+  float vigV = smoothstep(vignetteRadius, vignetteRadius * 0.5, vigD);
+  c = mix(half3(vignetteColor), c, half(mix(1.0 - vignetteIntensity, 1.0, vigV)));
+
+  return half4(c, 1.0);
+}
+`
+);
+var GOD_RAYS_SKSL = (
+  /* sksl */
+  `
+uniform shader src;
+uniform float2 resolution;
+uniform float2 u_lightPos;
+uniform float3 u_color;
+uniform float u_intensity;
+uniform float u_decay;
+uniform float u_density;
+uniform float u_weight;
+uniform float u_samples;
+
+const int MAX_SAMPLES = 64;
+
+half4 main(float2 coord) {
+  float2 uv = coord / resolution;
+  float2 delta = (u_lightPos - uv) * u_density / float(MAX_SAMPLES);
+  float2 sampleUv = uv;
+  float illuminationDecay = 1.0;
+  half3 accumulated = half3(0.0);
+
+  for (int i = 0; i < MAX_SAMPLES; i++) {
+    if (float(i) >= u_samples) break;
+    sampleUv += delta;
+    half3 s = src.eval(sampleUv * resolution).rgb;
+    accumulated += s * half(illuminationDecay) * half(u_weight);
+    illuminationDecay *= u_decay;
+  }
+
+  half4 orig = src.eval(coord);
+  half3 rays = accumulated * half3(u_color) * half(u_weight) * half(u_intensity);
+  return half4(orig.rgb + rays, orig.a);
+}
+`
+);
+
+// src/runtime.ts
+var EMPTY_CHILDREN = Object.freeze([]);
+var SKSL_SOURCE = {
+  vignette: VIGNETTE_SKSL,
+  "grayscale-flash": GRAYSCALE_FLASH_SKSL,
+  "chromatic-aberration": CHROMATIC_ABERRATION_SKSL,
+  crt: CRT_SKSL,
+  bloom: BLOOM_SKSL,
+  "god-rays": GOD_RAYS_SKSL,
+  "color-grading-lut": COLOR_GRADING_LUT_SKSL,
+  "weather-rain": WEATHER_RAIN_SKSL,
+  "weather-sun-shaft": WEATHER_SUN_SHAFT_SKSL,
+  "weather-dark-vignette": WEATHER_DARK_VIGNETTE_SKSL,
+  "weather-clouds": WEATHER_CLOUDS_SKSL,
+  composite: COMPOSITE_SKSL
+};
+function createPostFxRuntime(skia) {
+  const cache = /* @__PURE__ */ new Map();
+  const _loggedCompileFailures = /* @__PURE__ */ new Set();
+  const _loggedCompileSuccesses = /* @__PURE__ */ new Set();
+  const supported = skia !== null && typeof skia.RuntimeEffect?.Make === "function";
+  return {
+    supported,
+    compile(kind) {
+      if (!supported || !skia) return null;
+      const cached = cache.get(kind);
+      if (cached) return cached;
+      const effect = skia.RuntimeEffect.Make(SKSL_SOURCE[kind]);
+      if (!effect) {
+        if (!_loggedCompileFailures.has(kind)) {
+          _loggedCompileFailures.add(kind);
+          console.warn(
+            `[postfx] RuntimeEffect.Make returned null for "${kind}" \u2014 shader failed to compile. Pass will be silently skipped.`
+          );
+        }
+        return null;
+      }
+      if (!_loggedCompileSuccesses.has(kind)) {
+        _loggedCompileSuccesses.add(kind);
+        if (typeof effect.getUniformFloatCount === "function") {
+          console.info(
+            `[postfx] compiled "${kind}" \u2014 getUniformFloatCount=${effect.getUniformFloatCount()}`
+          );
+        }
+      }
+      const compiled = { kind, effect };
+      cache.set(kind, compiled);
+      return compiled;
+    },
+    packUniforms(effect, width, height) {
+      return packUniforms(effect.uniforms, width, height);
+    },
+    buildPass(chain, width, height) {
+      const out = [];
+      if (!supported) return out;
+      const scale = chain.globalIntensity;
+      for (const effect of chain.enabled()) {
+        const compiled = this.compile(effect.uniforms.kind);
+        if (!compiled) continue;
+        const uniforms = packUniforms(effect.uniforms, width, height);
+        if (scale !== 1) scaleIntensity(effect.uniforms.kind, uniforms, scale);
+        const children = effect.uniforms.kind === "color-grading-lut" ? [effect.uniforms.lut] : EMPTY_CHILDREN;
+        out.push({
+          id: effect.id,
+          kind: effect.uniforms.kind,
+          shader: compiled.effect,
+          uniforms,
+          children
+        });
+      }
+      return out;
+    },
+    reset() {
+      cache.clear();
+    }
+  };
+}
+function packUniforms(u, width, height) {
+  switch (u.kind) {
+    case "vignette": {
+      const col = u.color ?? [0, 0, 0];
+      return new Float32Array([width, height, u.intensity, u.radius, col[0], col[1], col[2]]);
+    }
+    case "grayscale-flash":
+      return new Float32Array([u.intensity]);
+    case "chromatic-aberration":
+      return new Float32Array([width, height, u.amount]);
+    case "crt":
+      return new Float32Array([width, height, u.scanlineIntensity, u.curvature]);
+    case "bloom":
+      return new Float32Array([width, height, u.threshold, u.intensity]);
+    case "god-rays": {
+      const samples = Math.max(1, Math.min(64, Math.round(u.samples)));
+      return new Float32Array([
+        width,
+        height,
+        u.lightX,
+        u.lightY,
+        u.color[0],
+        u.color[1],
+        u.color[2],
+        u.intensity,
+        u.decay,
+        u.density,
+        u.weight,
+        samples
+      ]);
+    }
+    case "color-grading-lut":
+      return new Float32Array([u.intensity]);
+    // Weather kinds: TS interfaces are wider than the packed SkSL inputs (speed/direction
+    // for clouds, speed for rain are B5-passthrough fields; the shader doesn't consume them).
+    case "weather-rain": {
+      const col = u.color ?? [1, 1, 1];
+      return new Float32Array([
+        width,
+        height,
+        u.intensity,
+        u.direction,
+        u.scrollOffsetY,
+        col[0],
+        col[1],
+        col[2],
+        u.density ?? 0.5,
+        u.streakLen ?? 0.15
+      ]);
+    }
+    case "weather-sun-shaft":
+      return new Float32Array([width, height, u.intensity, u.direction]);
+    case "weather-dark-vignette":
+      return new Float32Array([width, height, u.intensity]);
+    case "weather-clouds":
+      return new Float32Array([width, height, u.intensity, u.scrollOffsetX]);
+    case "composite":
+      return new Float32Array([
+        width,
+        height,
+        u.vignetteIntensity,
+        u.vignetteRadius,
+        u.vignetteColor[0],
+        u.vignetteColor[1],
+        u.vignetteColor[2],
+        u.bloomThreshold,
+        u.bloomIntensity,
+        u.flashIntensity,
+        u.chromaAmount,
+        u.crtScanlineIntensity,
+        u.crtCurvature,
+        u.crtEnabled ? 1 : 0,
+        u.weatherKind,
+        u.weatherIntensity,
+        u.weatherDirection,
+        u.weatherScrollX,
+        u.weatherScrollY,
+        u.weatherColor[0],
+        u.weatherColor[1],
+        u.weatherColor[2],
+        u.weatherDensity,
+        u.weatherStreakLen
+      ]);
+  }
+}
+function scaleIntensity(kind, packed, scale) {
+  switch (kind) {
+    case "vignette":
+      packed[2] = (packed[2] ?? 0) * scale;
+      return;
+    case "grayscale-flash":
+      packed[0] = (packed[0] ?? 0) * scale;
+      return;
+    case "chromatic-aberration":
+      packed[2] = (packed[2] ?? 0) * scale;
+      return;
+    case "crt":
+      packed[2] = (packed[2] ?? 0) * scale;
+      return;
+    case "bloom":
+      packed[3] = (packed[3] ?? 0) * scale;
+      return;
+    case "god-rays":
+      packed[7] = (packed[7] ?? 0) * scale;
+      return;
+    case "color-grading-lut":
+      packed[0] = (packed[0] ?? 0) * scale;
+      return;
+    case "weather-rain":
+    case "weather-sun-shaft":
+    case "weather-dark-vignette":
+    case "weather-clouds":
+      packed[2] = (packed[2] ?? 0) * scale;
+      return;
+    case "composite":
+      packed[2] = (packed[2] ?? 0) * scale;
+      packed[8] = (packed[8] ?? 0) * scale;
+      packed[9] = (packed[9] ?? 0) * scale;
+      packed[10] = (packed[10] ?? 0) * scale;
+      packed[15] = (packed[15] ?? 0) * scale;
+      return;
+  }
+}
+
+// src/lut.ts
+function createNeutralLutBytes() {
+  const buf = new Uint8Array(4096 * 64 * 4);
+  for (let b = 0; b < 64; b++) {
+    for (let g = 0; g < 64; g++) {
+      for (let r = 0; r < 64; r++) {
+        const x = b * 64 + r;
+        const y = g;
+        const off = (y * 4096 + x) * 4;
+        buf[off] = Math.round(r / 63 * 255);
+        buf[off + 1] = Math.round(g / 63 * 255);
+        buf[off + 2] = Math.round(b / 63 * 255);
+        buf[off + 3] = 255;
+      }
+    }
+  }
+  return buf;
+}
+
+// src/controller.ts
+var DEFAULT_FLASH_DECAY = 4.2;
+function createPostFxController(options) {
+  const chain = new EffectChain();
+  for (let i = 0; i < options.effects.length; i++) {
+    const e = options.effects[i];
+    if (e) chain.add(e);
+  }
+  const runtime = createPostFxRuntime(options.skia ?? null);
+  const flashCfg = options.flash;
+  const flashDecay = flashCfg?.decay ?? DEFAULT_FLASH_DECAY;
+  let flashIntensity = 0;
+  const timedRemaining = /* @__PURE__ */ new Map();
+  const timedRestore = /* @__PURE__ */ new Map();
+  return {
+    chain,
+    runtime,
+    triggerHitFlash() {
+      if (!flashCfg) return;
+      flashIntensity = 1;
+      chain.setUniforms(flashCfg.id, { kind: "grayscale-flash", intensity: 1 });
+    },
+    triggerTimed(effectId, decayMs) {
+      const effect = chain.get(effectId);
+      if (!effect) return;
+      timedRestore.set(effectId, { ...effect.uniforms });
+      chain.setEnabled(effectId, true);
+      timedRemaining.set(effectId, decayMs);
+    },
+    update(dt) {
+      if (flashCfg && flashIntensity > 0) {
+        flashIntensity = Math.max(0, flashIntensity - dt * flashDecay);
+        chain.setUniforms(flashCfg.id, {
+          kind: "grayscale-flash",
+          intensity: flashIntensity
+        });
+      }
+      if (timedRemaining.size > 0) {
+        const dtMs = dt * 1e3;
+        const expired = [];
+        for (const [id, rem] of timedRemaining) {
+          const next = rem - dtMs;
+          if (next <= 0) {
+            expired.push(id);
+          } else {
+            timedRemaining.set(id, next);
+          }
+        }
+        if (expired.length > 0) {
+          for (const id of expired) {
+            const snapshot = timedRestore.get(id);
+            if (snapshot !== void 0) chain.setUniforms(id, snapshot);
+            chain.setEnabled(id, false);
+            timedRemaining.delete(id);
+            timedRestore.delete(id);
+          }
+        }
+      }
+    },
+    buildPass(width, height) {
+      return runtime.buildPass(chain, width, height);
+    },
+    setMotionScale(k) {
+      chain.setGlobalIntensity(k);
+    }
+  };
+}
+export {
+  BLOOM_SKSL,
+  CHROMATIC_ABERRATION_SKSL,
+  COLOR_GRADING_LUT_SKSL,
+  COMPOSITE_SKSL,
+  CRT_SKSL,
+  EffectChain,
+  GOD_RAYS_SKSL,
+  GRAYSCALE_FLASH_SKSL,
+  VIGNETTE_SKSL,
+  WEATHER_CLOUDS_SKSL,
+  WEATHER_DARK_VIGNETTE_SKSL,
+  WEATHER_RAIN_SKSL,
+  WEATHER_SUN_SHAFT_SKSL,
+  createBloom,
+  createChromaticAberration,
+  createColorGradingLut,
+  createCrt,
+  createGodRays,
+  createGrayscaleFlash,
+  createNeutralLutBytes,
+  createPostFxComposite,
+  createPostFxController,
+  createPostFxRuntime,
+  createVignette,
+  createWeatherClouds,
+  createWeatherDarkVignette,
+  createWeatherRain,
+  createWeatherSunShaft
+};
+//# sourceMappingURL=index.mjs.map