@dopaminefx/effect-lightning 0.1.0

package/src/lightning-logic.ts

@@ -0,0 +1,221 @@
+/**
+ * Lightning bolt geometry precompute — the SINGLE cross-platform source.
+ *
+ * The bolt polyline is fragment-INDEPENDENT, so it is computed ONCE per frame
+ * here (a faithful port of the shared fbm/hash + the original shader
+ * `boltPoint`) and fed to the shader as the `uVerts` / `uBoltMeta` arrays. The
+ * shader keeps the exact original inverse-distance plasma glow; only the cost
+ * moved off the per-pixel path.
+ *
+ * THIS FILE IS TRANSPILED to Swift (`LightningRenderer.swift`) and Kotlin
+ * (`LightningRenderer.kt`) by `tools/dopamine/src/logic.mjs` (declared by the
+ * `.dope` `x-build.logic` block) — the per-frame-geometry analog of the scoped
+ * GLSL→MSL shader transpiler. Keep it inside the supported subset:
+ *
+ *   • no imports — the module is self-contained (pure math, no DOM/GL);
+ *   • function declarations with `number` / `Float32Array` / interface-typed
+ *     params; `const`/`let`; `if`/`else`; canonical `for (let i = A; i < B; i++)`
+ *     loops; `break`/`continue`/`return`; ternaries; arithmetic + comparisons;
+ *   • Math.{floor,min,max,abs,sqrt,exp,hypot,sin,cos,pow,round} and Math.PI;
+ *   • `new Float32Array(n)`, element writes, `{ x, y }` vector literals, and a
+ *     `{ verts, meta }` bundle return (declared via an exported interface).
+ *
+ * The transpiler THROWS on anything outside that subset. Numeric semantics are
+ * JS's: every number is a double (loop counters transpile to ints), `/` is
+ * always double division, and array writes narrow to float32 exactly like the
+ * Float32Array stores here do.
+ *
+ * Output (gl_FragCoord space — device px, y-UP, to match the shader):
+ *   verts: Float32Array(MAX_BOLTS * VERTS_PER_BOLT * 2) — vertex i of bolt b at
+ *          [(b*VPB + i) * 2].
+ *   meta:  Float32Array(MAX_BOLTS * 4) — per bolt (segCount, radFrac, fadeMul, isMain).
+ */
+
+/** Max secondary forks — shared by the shader + the `.dope` clamp. */
+export const MAX_FORKS = 7;
+/** Polyline segment count of the main bolt (and forks). More = jaggier arc. */
+export const BOLT_SEGS = 14;
+/** Main trunk + forks. */
+export const MAX_BOLTS = MAX_FORKS + 1;
+/** Vertices stored per bolt (BOLT_SEGS + 1). */
+export const VERTS_PER_BOLT = BOLT_SEGS + 1;
+/** Window (ms) over which the bolt cracks in to the strike point. Hard + fast. */
+export const STRIKE_MS = 130;
+
+interface Vec2 {
+  x: number;
+  y: number;
+}
+
+/** verts: MAX_BOLTS*VPB*2 ; meta: MAX_BOLTS*4 = (segCount, radFrac, fadeMul, isMain). */
+export interface LightningArrays {
+  verts: Float32Array;
+  meta: Float32Array;
+}
+
+function clamp(x: number, lo: number, hi: number): number {
+  return x < lo ? lo : x > hi ? hi : x;
+}
+
+function clamp01(x: number): number {
+  return x < 0 ? 0 : x > 1 ? 1 : x;
+}
+
+function smoothstep(e0: number, e1: number, x: number): number {
+  const t = clamp01((x - e0) / (e1 - e0));
+  return t * t * (3 - 2 * t);
+}
+
+function fract(x: number): number {
+  return x - Math.floor(x);
+}
+
+function mix(a: number, b: number, t: number): number {
+  return a + (b - a) * t;
+}
+
+/**
+ * Bolt strike progress (0..1) over elapsed ms — the jagged arc racing from the
+ * source to the action point. Ease-out quint: a near-instant crack-in that
+ * settles abruptly, so the bolt reads as a strike, not a slow draw.
+ */
+export function strikeProgress(elapsedMs: number): number {
+  const x = clamp01(elapsedMs / STRIKE_MS);
+  return 1 - Math.pow(1 - x, 5);
+}
+
+// --- Faithful port of the shared look/glsl hash + value-noise fbm -----------
+
+function hash11(p: number): number {
+  p = fract(p * 0.1031);
+  p *= p + 33.33;
+  p *= p + p;
+  return fract(p);
+}
+
+/** Just the .x channel of the shared hash21 (used for the start jog). */
+function hash21x(p: number): number {
+  let x = fract(p * 0.1031), y = fract(p * 0.103), z = fract(p * 0.0973);
+  const d = x * (y + 33.33) + y * (z + 33.33) + z * (x + 33.33);
+  x += d; y += d; z += d;
+  return fract((x + y) * z);
+}
+
+function hash21(p: number): Vec2 {
+  let x = fract(p * 0.1031), y = fract(p * 0.103), z = fract(p * 0.0973);
+  const d = x * (y + 33.33) + y * (z + 33.33) + z * (x + 33.33);
+  x += d; y += d; z += d;
+  return { x: fract((x + y) * z), y: fract((x + z) * y) };
+}
+
+function vnoise(x: number, y: number): number {
+  const ix = Math.floor(x), iy = Math.floor(y);
+  const fx = x - ix, fy = y - iy;
+  const ux = fx * fx * (3 - 2 * fx), uy = fy * fy * (3 - 2 * fy);
+  const a = hash11(ix * 1 + iy * 57);
+  const b = hash11((ix + 1) * 1 + iy * 57);
+  const c = hash11(ix * 1 + (iy + 1) * 57);
+  const d = hash11((ix + 1) * 1 + (iy + 1) * 57);
+  return mix(mix(a, b, ux), mix(c, d, ux), uy);
+}
+
+function fbm(x: number, y: number): number {
+  let s = 0, a = 0.5;
+  for (let i = 0; i < 4; i++) {
+    s += a * vnoise(x, y);
+    const nx = (0.8 * x + 0.6 * y) * 2.03;
+    const ny = (-0.6 * x + 0.8 * y) * 2.03;
+    x = nx; y = ny; a *= 0.5;
+  }
+  return s;
+}
+
+/** Port of the shader boltPoint: a jagged vertex at t along A→B. */
+function boltPoint(A: Vec2, B: Vec2, t: number, seedOff: number, seed: number, jagged: number, beat: number): Vec2 {
+  const dx = B.x - A.x, dy = B.y - A.y;
+  const len = Math.max(Math.hypot(dx, dy), 1);
+  const dirx = dx / len, diry = dy / len;
+  const nrmx = -diry, nrmy = dirx;
+  const n = fbm(t * 6 + seedOff + seed, beat * 0.5) - 0.5;
+  const fine = fbm(t * 22 + seedOff * 3.1 + seed, beat) - 0.5;
+  const taper = Math.sin(t * Math.PI);
+  const off = (n * 1.6 + fine * 0.5) * jagged * len * 0.16 * taper;
+  return { x: A.x + dirx * (t * len) + nrmx * off, y: A.y + diry * (t * len) + nrmy * off };
+}
+
+/** Write up to BOLT_SEGS+1 vertices of the drawn (0..drawn) polyline A→B into
+ *  `verts` at bolt slot `b`; returns the segment count (points-1). */
+function writeBolt(
+  verts: Float32Array, b: number, A: Vec2, B: Vec2, drawn: number,
+  seedOff: number, seed: number, jagged: number, beat: number,
+): number {
+  const base = b * VERTS_PER_BOLT;
+  let last = 0;
+  const v0 = boltPoint(A, B, 0, seedOff, seed, jagged, beat);
+  verts[(base + 0) * 2] = v0.x;
+  verts[(base + 0) * 2 + 1] = v0.y;
+  for (let i = 1; i <= BOLT_SEGS; i++) {
+    const t = i / BOLT_SEGS;
+    if (t - 1 / BOLT_SEGS > drawn) break;
+    const tc = Math.min(t, drawn);
+    const v = boltPoint(A, B, tc, seedOff, seed, jagged, beat);
+    verts[(base + i) * 2] = v.x;
+    verts[(base + i) * 2 + 1] = v.y;
+    last = i;
+  }
+  return last;
+}
+
+/**
+ * Compute the bolt polyline (trunk + forks) for this frame, in gl_FragCoord
+ * space (device px, y-up). `originX`/`originY` is the strike point (gl coords);
+ * `width`/`height` the canvas device px; `elapsedMs`/`life` the timing.
+ */
+export function computeLightningArrays(
+  style: number, thickness: number, jagged: number, branches: number, boltSeed: number,
+  width: number, height: number, originX: number, originY: number,
+  elapsedMs: number, life: number,
+): LightningArrays {
+  const verts = new Float32Array(MAX_BOLTS * VERTS_PER_BOLT * 2);
+  const meta = new Float32Array(MAX_BOLTS * 4);
+  const strike = strikeProgress(elapsedMs);
+  if (strike <= 0) return { verts, meta };
+
+  const seed = boltSeed;
+  const beat = Math.floor((elapsedMs / 1000) * 12) * style;
+
+  // Strike geometry: from near the top edge (biased toward the strike x) down to
+  // the strike point. gl coords y-up: top edge is y ≈ height.
+  const jx = (hash21x(seed * 1.7) - 0.5) * width * 0.5;
+  const A: Vec2 = { x: clamp(originX + jx, width * 0.12, width * 0.88), y: height * 1.02 };
+  const B: Vec2 = { x: originX, y: originY };
+
+  // MAIN BOLT (slot 0).
+  const mainSegs = writeBolt(verts, 0, A, B, strike, 0, seed, jagged, beat);
+  meta[0] = mainSegs; meta[1] = thickness; meta[2] = 1.0; meta[3] = 1.0;
+
+  // FORKS (slots 1..).
+  const forks = Math.max(0, Math.min(MAX_FORKS, Math.round(branches)));
+  const dlenRaw = Math.hypot(B.x - A.x, B.y - A.y);
+  const dlen = dlenRaw === 0 ? 1 : dlenRaw;
+  const dirx = (B.x - A.x) / dlen, diry = (B.y - A.y) / dlen;
+  const nrmx = -diry, nrmy = dirx;
+  const forkFade = 0.6 + 0.4 * (1 - smoothstep(0.5, 1.0, life));
+  for (let i = 0; i < forks; i++) {
+    const b = 1 + i;
+    const hh = hash21(i * 9.7 + seed + 3);
+    const launchT = 0.18 + hh.x * 0.62;
+    if (strike < launchT) { meta[b * 4] = 0; continue; }
+    const forkA = boltPoint(A, B, launchT, 0, seed, jagged, beat);
+    const ang = (hh.y - 0.5) * 2.2;
+    const reach = (0.18 + hh.x * 0.22) * dlen;
+    const ex = dirx * (0.5 + hh.y) + nrmx * ang;
+    const ey = diry * (0.5 + hh.y) + nrmy * ang;
+    const forkB: Vec2 = { x: forkA.x + ex * reach, y: forkA.y + ey * reach };
+    const forkDrawn = clamp((strike - launchT) / Math.max(1 - launchT, 0.05), 0, 1);
+    const segs = writeBolt(verts, b, forkA, forkB, forkDrawn, i * 17 + 5, seed, jagged, beat);
+    meta[b * 4] = segs; meta[b * 4 + 1] = thickness * 0.6; meta[b * 4 + 2] = forkFade; meta[b * 4 + 3] = 0;
+  }
+
+  return { verts, meta };
+}

package/src/lightning-shader.ts

@@ -0,0 +1,220 @@
+/**
+ * GLSL ES 3.00 source for Lightning (web, PRECOMPUTED-VERTEX glow).
+ *
+ * This keeps the ORIGINAL look — a per-pixel inverse-distance (`1/d`) plasma glow
+ * with a hot white core, branching forks, impact burst, strobe flash and cel
+ * comic mode — but removes the cost that made it crawl under software/ANGLE
+ * WebGL: the old shader re-derived every bolt vertex with TWO 4-octave `fbm`
+ * calls per segment AT EVERY PIXEL (~220 fbm/pixel). The bolt polyline is
+ * fragment-INDEPENDENT, so it's now computed ONCE per frame on the CPU (see
+ * lightning-logic.ts — a faithful JS port of the same fbm/boltPoint) and fed
+ * in as the `uVerts` / `uBoltMeta` uniform arrays. The fragment shader just walks
+ * those segments with cheap `sdSeg` + the same glow accumulation, so the look is
+ * unchanged while the per-pixel cost drops from ~220 fbm to a single fbm (the
+ * halo's living variation).
+ *
+ * All three platforms use this precomputed-vertex approach, and THIS GLSL is
+ * the single shader source (`x-build.shader`): the MSL `Lightning.metal` and
+ * the Kotlin `LightningShader.kt` are GENERATED from it by the toolchain. The
+ * `uVerts`/`uBoltMeta` uniform arrays ride the `.dope` `binding.arrays`
+ * contract — web and Android bind them by name through the runners'
+ * `frameArrays` seam; the GLSL→MSL transpiler turns each declared uniform
+ * array into a `constant floatN *` fragment buffer at its declared index, and
+ * the generated native factories feed them from the transpiled
+ * `LightningRenderer` (the same lightning-logic.ts source as here).
+ */
+
+import {
+  GLSL_CONSTANTS,
+  GLSL_DITHER,
+  GLSL_FBM,
+  GLSL_HASH,
+  GLSL_SD_SEG,
+  GLSL_TONEMAP_ACES,
+} from "@dopaminefx/core";
+// The bolt-geometry constants live with the CPU precompute (the single
+// transpiled source, lightning-logic.ts); re-exported here for consumers.
+import { MAX_FORKS, BOLT_SEGS, MAX_BOLTS, VERTS_PER_BOLT } from "./lightning-logic.js";
+
+export { MAX_FORKS, BOLT_SEGS, MAX_BOLTS, VERTS_PER_BOLT };
+
+/**
+ * Total uVerts entries (exported so the toolchain's Android emitter can resolve
+ * the `${TOTAL_VERTS}` interpolation — it resolves single identifiers only).
+ */
+export const TOTAL_VERTS = MAX_BOLTS * VERTS_PER_BOLT;
+
+export const LIGHTNING_VERTEX_SRC = /* glsl */ `#version 300 es
+void main() {
+  vec2 pos = vec2(float((gl_VertexID << 1) & 2), float(gl_VertexID & 2));
+  gl_Position = vec4(pos * 2.0 - 1.0, 0.0, 1.0);
+}`;
+
+export const LIGHTNING_FRAGMENT_SRC = /* glsl */ `#version 300 es
+precision highp float;
+out vec4 fragColor;
+
+uniform vec2  uResolution;    // device pixels
+uniform vec2  uOrigin;        // strike point (gl coords, y-up)
+uniform float uStrike;        // bolt strike progress 0..1 (impact timing)
+uniform float uFlash;         // strobe/flash amplitude
+uniform float uLife;          // whole-effect progress 0..1
+uniform float uTimeS;         // elapsed seconds
+uniform float uAmp;           // impact envelope amplitude (peaks > 1)
+uniform float uThickness;     // bolt half-width as fraction of min dim (impact sizing)
+uniform float uFlashBright;   // peak flash brightness multiplier
+uniform float uExposure;      // overall light gain
+uniform float uSeed;          // per-fire hash offset (halo variation)
+uniform float uStyle;         // 0..1 photoreal plasma -> cel comic bolt (whimsy)
+uniform float uShadow;        // 0 = light pass (screen), 1 = shadow pass (multiply)
+uniform vec2  uShadowOffset;  // device-px offset of the cast silhouette
+uniform float uShadowSoft;    // penumbra softness in device px
+uniform float uShadowStrength;// 0..1 max darkening of the multiply layer
+uniform vec3  uC0;            // electric core hue
+// CPU-precomputed bolt polyline: uVerts[b*VPB + i] is vertex i of bolt b
+// (device px, gl coords); uBoltMeta[b] = (segCount, radFrac, fadeMul, isMain).
+uniform vec2  uVerts[${TOTAL_VERTS}];
+uniform vec4  uBoltMeta[${MAX_BOLTS}];
+
+#define MAX_FORKS ${MAX_FORKS}
+#define BOLT_SEGS ${BOLT_SEGS}
+#define MAX_BOLTS ${MAX_BOLTS}
+#define VPB ${VERTS_PER_BOLT}
+${GLSL_CONSTANTS}
+${GLSL_HASH}
+${GLSL_FBM}
+${GLSL_TONEMAP_ACES}
+${GLSL_DITHER}
+${GLSL_SD_SEG}
+
+// Electric channel colour ramp: a tight blue/violet -> hot white anchored on uC0
+// (so the bolt stays monochromatic electric, not the roaming golden-angle palette).
+vec3 elecRamp(float t){
+  t = clamp(t, 0.0, 1.0);
+  vec3 rim = mix(uC0, vec3(0.45, 0.6, 1.0), 0.35);
+  vec3 mid = mix(uC0, vec3(0.8, 0.85, 1.0), 0.5);
+  vec3 hot = vec3(1.0);
+  return t < 0.5 ? mix(rim, mid, t * 2.0) : mix(mid, hot, (t - 0.5) * 2.0);
+}
+
+// Glow of bolt \`b\` at frag: walk its precomputed segments, accumulate the same
+// inverse-distance plasma glow + hot core the original boltGlow used. radFrac is
+// the bolt half-width as a frac of minDim. Returns vec2(core, glow).
+vec2 boltGlowV(vec2 frag, int b, int segCount, float radFrac){
+  float minDim = min(uResolution.x, uResolution.y);
+  float rad = minDim * radFrac;
+  float glow = 0.0;
+  float core = 0.0;
+  int base = b * VPB;
+  vec2 prev = uVerts[base];
+  for (int i = 1; i <= BOLT_SEGS; i++) {
+    if (i > segCount) break;
+    vec2 cur = uVerts[base + i];
+    float dist = sdSeg(frag, prev, cur);
+    glow += rad / (dist + rad * 0.35);
+    core = max(core, 1.0 - smoothstep(rad * 0.25, rad * 0.6, dist));
+    prev = cur;
+  }
+  glow = clamp(glow / float(BOLT_SEGS) * 2.2, 0.0, 1.4);
+  return vec2(core, glow);
+}
+
+// SHADOW: the main bolt's silhouette only (matches the original), 9-tap ring blur.
+vec4 lightningShadowColor(vec2 frag){
+  float minDim = min(uResolution.x, uResolution.y);
+  float rad = minDim * uThickness * 1.6;
+  int segCount = int(uBoltMeta[0].x + 0.5);
+  vec2 sp = frag - uShadowOffset;
+  float soft = uShadowSoft;
+  float s2 = soft * 0.7071;
+  vec2 taps[9];
+  taps[0] = sp;
+  taps[1] = sp + vec2( soft, 0.0);
+  taps[2] = sp + vec2(-soft, 0.0);
+  taps[3] = sp + vec2(0.0,  soft);
+  taps[4] = sp + vec2(0.0, -soft);
+  taps[5] = sp + vec2( s2,  s2);
+  taps[6] = sp + vec2(-s2,  s2);
+  taps[7] = sp + vec2( s2, -s2);
+  taps[8] = sp + vec2(-s2, -s2);
+  float occSum = 0.0;
+  for (int k = 0; k < 9; k++) {
+    float occ = 0.0;
+    vec2 prev = uVerts[0];
+    for (int i = 1; i <= BOLT_SEGS; i++) {
+      if (i > segCount) break;
+      vec2 cur = uVerts[i];
+      occ = max(occ, 1.0 - smoothstep(rad * 0.6, rad, sdSeg(taps[k], prev, cur)));
+      prev = cur;
+    }
+    occSum += clamp(occ * uAmp, 0.0, 1.0);
+  }
+  occSum /= 9.0;
+  float dark = clamp(occSum, 0.0, 1.0) * uShadowStrength;
+  vec3 tint = mix(vec3(1.0), 0.55 + 0.45 * normalize(elecRamp(0.2) + 1e-3), 0.25);
+  return vec4(mix(vec3(1.0), tint, dark), 1.0);
+}
+
+void main(){
+  vec2 frag = gl_FragCoord.xy;
+  float minDim = min(uResolution.x, uResolution.y);
+
+  if (uShadow > 0.5) {
+    fragColor = lightningShadowColor(frag);
+    return;
+  }
+
+  vec3 col = vec3(0.0);
+  float gain = uExposure * uAmp;
+  float boltCore = 0.0;
+  float boltGlowAcc = 0.0;
+
+  // A touch of living fbm variation on the halo — ONE fbm/pixel (was the only
+  // per-pixel noise we keep; the bolt geometry is precomputed on the CPU).
+  float haloVar = 0.1 * (fbm(frag / minDim * 4.0 + uSeed) - 0.5);
+
+  // Trunk + forks: same glow/colour accumulation as the original, reading the
+  // precomputed polyline. uBoltMeta[b] = (segCount, radFrac, fadeMul, isMain).
+  for (int b = 0; b < MAX_BOLTS; b++) {
+    vec4 meta = uBoltMeta[b];
+    int segCount = int(meta.x + 0.5);
+    if (segCount < 1) continue;
+    float fadeMul = meta.z;
+    bool isMain = meta.w > 0.5;
+    vec2 g = boltGlowV(frag, b, segCount, meta.y);
+    float core = g.x * fadeMul;
+    float glow = g.y * fadeMul;
+    float haloT = clamp(glow * 0.7 + (isMain ? haloVar : 0.15), 0.0, 1.0);
+    col += elecRamp(haloT) * glow * gain * (isMain ? 1.3 : 0.8);
+    col += vec3(1.0) * core * gain * (isMain ? 2.4 : 1.5);
+    boltCore = max(boltCore, core);
+    boltGlowAcc = max(boltGlowAcc, glow);
+  }
+
+  // ---- IMPACT GLOW ---- bright radial burst at the strike point, easing off.
+  float landed = smoothstep(0.7, 1.0, uStrike) * (0.4 + 0.6 * (1.0 - smoothstep(0.1, 0.5, uLife)));
+  float dB = length(frag - uOrigin);
+  float impact = (minDim * uThickness * 2.0) / (dB + minDim * uThickness * 1.4);
+  impact *= impact;
+  col += elecRamp(0.7) * impact * landed * gain * 0.8;
+
+  // ---- FLASH / STROBE ---- hard near-white wash, hottest at the strike point.
+  float flashRadial = 0.28 + 0.72 * exp(-dB / (minDim * 0.5));
+  vec3 flashCol = mix(vec3(1.0), elecRamp(0.6), 0.25);
+  col += flashCol * uFlash * uFlashBright * flashRadial;
+
+  col = tonemapACES(col * 0.9);
+
+  // ---- Cel / comic-book bolt (whimsy) ---- flatten ONLY the bolt forms.
+  if (uStyle > 0.001) {
+    float coreMask = smoothstep(0.45, 0.65, boltCore);
+    float bandMask = smoothstep(0.45, 0.8, boltGlowAcc) * (1.0 - coreMask);
+    vec3 boltColor = clamp(elecRamp(0.35) * 1.5 + 0.05, 0.0, 1.3);
+    vec3 cel = vec3(1.0) * coreMask + boltColor * bandMask;
+    float boltMask = clamp(coreMask + bandMask, 0.0, 1.0);
+    col = mix(col, mix(col, cel, boltMask), uStyle);
+  }
+
+  col = ditherAdd(col, frag, uTimeS, 1.0 - uStyle);
+  fragColor = vec4(max(col, 0.0), 1.0);
+}`;