@hyperframes/engine 0.4.6 → 0.4.8

package/dist/utils/shaderTransitions.js

@@ -0,0 +1,894 @@
+/**
+ * Shader Transition Math Utilities
+ *
+ * Sampling helpers and math primitives for rgb48le shader transitions.
+ * Functions are ported from GLSL to operate on 16-bit little-endian pixel
+ * buffers (6 bytes per pixel: R, G, B each stored as UInt16LE).
+ */
+// ── PQ linearization ─────────────────────────────────────────────────────────
+// Shader transitions were ported from sRGB GLSL where pixel values distribute
+// linearly across the visible range. In PQ space, dark content clusters near
+// zero, causing UV-warping shaders to produce black artifacts. Converting to
+// linear light before the shader and back to PQ after gives correct results.
+const PQ_M1 = 0.1593017578125;
+const PQ_M2 = 78.84375;
+const PQ_C1 = 0.8359375;
+const PQ_C2 = 18.8515625;
+const PQ_C3 = 18.6875;
+/** PQ EOTF: decode PQ signal (0-1) → linear light (0-1, normalized to 10000 nits). */
+function pqEotf(signal) {
+    const sp = Math.pow(Math.max(0, signal), 1 / PQ_M2);
+    const num = Math.max(sp - PQ_C1, 0);
+    const den = PQ_C2 - PQ_C3 * sp;
+    return den > 0 ? Math.pow(num / den, 1 / PQ_M1) : 0;
+}
+/** PQ OETF: encode linear light (0-1) → PQ signal (0-1). */
+function pqOetf(linear) {
+    const lp = Math.pow(Math.max(0, linear), PQ_M1);
+    return Math.pow((PQ_C1 + PQ_C2 * lp) / (1 + PQ_C3 * lp), PQ_M2);
+}
+/** HLG OETF inverse: decode HLG signal (0-1) → linear scene light (0-1). */
+function hlgEotf(signal) {
+    const a = 0.17883277;
+    const b = 1 - 4 * a;
+    const c = 0.5 - a * Math.log(4 * a);
+    if (signal <= 0.5) {
+        return (signal * signal) / 3;
+    }
+    return (Math.exp((signal - c) / a) + b) / 12;
+}
+/** HLG OETF: encode linear scene light (0-1) → HLG signal (0-1). */
+function hlgOetf(linear) {
+    const a = 0.17883277;
+    const b = 1 - 4 * a;
+    const c = 0.5 - a * Math.log(4 * a);
+    if (linear <= 1 / 12) {
+        return Math.sqrt(3 * linear);
+    }
+    return a * Math.log(12 * linear - b) + c;
+}
+// ── Precomputed LUTs for fast HDR↔linear conversion ─────────────────────────
+// 65536-entry lookup tables eliminate per-pixel Math.pow calls. Built once on
+// first use, then reused for all subsequent conversions. At 4K (8.3M pixels ×
+// 3 channels × 3 buffers), this turns ~75M Math.pow calls per transition frame
+// into 75M array lookups — ~100× faster.
+function buildLut(fn) {
+    const lut = new Uint16Array(65536);
+    for (let i = 0; i < 65536; i++) {
+        lut[i] = Math.round(fn(i / 65535) * 65535);
+    }
+    return lut;
+}
+let pqToLinearLut = null;
+let linearToPqLut = null;
+let hlgToLinearLut = null;
+let linearToHlgLut = null;
+function getPqToLinearLut() {
+    if (!pqToLinearLut)
+        pqToLinearLut = buildLut(pqEotf);
+    return pqToLinearLut;
+}
+function getLinearToPqLut() {
+    if (!linearToPqLut)
+        linearToPqLut = buildLut(pqOetf);
+    return linearToPqLut;
+}
+function getHlgToLinearLut() {
+    if (!hlgToLinearLut)
+        hlgToLinearLut = buildLut(hlgEotf);
+    return hlgToLinearLut;
+}
+function getLinearToHlgLut() {
+    if (!linearToHlgLut)
+        linearToHlgLut = buildLut(hlgOetf);
+    return linearToHlgLut;
+}
+/**
+ * Convert an rgb48le buffer from HDR signal space to linear light, in-place.
+ * Uses precomputed 65536-entry LUT for O(1) per-sample conversion.
+ * @param transfer "pq" or "hlg"
+ */
+export function hdrToLinear(buf, transfer) {
+    const lut = transfer === "pq" ? getPqToLinearLut() : getHlgToLinearLut();
+    const len = buf.length / 2;
+    for (let i = 0; i < len; i++) {
+        const off = i * 2;
+        buf.writeUInt16LE(lut[buf.readUInt16LE(off)] ?? 0, off);
+    }
+}
+/**
+ * Convert an rgb48le buffer from linear light back to HDR signal space, in-place.
+ * Uses precomputed 65536-entry LUT for O(1) per-sample conversion.
+ * @param transfer "pq" or "hlg"
+ */
+export function linearToHdr(buf, transfer) {
+    const lut = transfer === "pq" ? getLinearToPqLut() : getLinearToHlgLut();
+    const len = buf.length / 2;
+    for (let i = 0; i < len; i++) {
+        const off = i * 2;
+        buf.writeUInt16LE(lut[buf.readUInt16LE(off)] ?? 0, off);
+    }
+}
+// ── Cross-transfer conversion (HLG↔PQ) ──────────────────────────────────────
+// HLG is scene-referred, PQ is display-referred. Converting between them
+// requires the OOTF (Optical-Optical Transfer Function) which maps scene
+// light to display light. Per BT.2100, the HLG OOTF for a reference
+// display at Lw nits is: Y_display = Lw * Y_scene^gamma, where
+// gamma = 1.2 * 1.111^(log2(Lw/1000)). At 1000 nits: gamma = 1.2.
+//
+// The per-channel approximation (applying gamma per-channel rather than
+// on luminance Y) introduces slight color shifts but avoids a full
+// colorimetric conversion with BT.2020 luma coefficients.
+const HLG_OOTF_LW = 1000; // reference display peak luminance (nits)
+const HLG_OOTF_GAMMA = 1.2 * Math.pow(1.111, Math.log2(HLG_OOTF_LW / 1000));
+/** HLG scene light → PQ display light (per-channel, normalized to 10000 nits) */
+function hlgSceneToPqDisplay(sceneLinear) {
+    const displayNits = HLG_OOTF_LW * Math.pow(Math.max(0, sceneLinear), HLG_OOTF_GAMMA);
+    return displayNits / 10000; // PQ is normalized to 10000 nits
+}
+/** PQ display light → HLG scene light (inverse OOTF) */
+function pqDisplayToHlgScene(displayNormalized) {
+    const displayNits = displayNormalized * 10000;
+    return Math.pow(Math.max(0, displayNits / HLG_OOTF_LW), 1 / HLG_OOTF_GAMMA);
+}
+let hlgToPqLut = null;
+let pqToHlgLut = null;
+function getHlgToPqLut() {
+    // HLG signal → scene linear (EOTF) → display linear (OOTF) → PQ signal (OETF)
+    if (!hlgToPqLut)
+        hlgToPqLut = buildLut((v) => pqOetf(hlgSceneToPqDisplay(hlgEotf(v))));
+    return hlgToPqLut;
+}
+function getPqToHlgLut() {
+    // PQ signal → display linear (EOTF) → scene linear (inverse OOTF) → HLG signal (OETF)
+    if (!pqToHlgLut)
+        pqToHlgLut = buildLut((v) => hlgOetf(pqDisplayToHlgScene(pqEotf(v))));
+    return pqToHlgLut;
+}
+/**
+ * Convert an rgb48le buffer between HDR transfer functions, in-place.
+ * Uses a composite 65536-entry LUT (source EOTF → linear → target OETF)
+ * for O(1) per-sample conversion. No-op if from === to.
+ */
+export function convertTransfer(buf, from, to) {
+    if (from === to)
+        return;
+    const lut = from === "hlg" ? getHlgToPqLut() : getPqToHlgLut();
+    const len = buf.length / 2;
+    for (let i = 0; i < len; i++) {
+        const off = i * 2;
+        buf.writeUInt16LE(lut[buf.readUInt16LE(off)] ?? 0, off);
+    }
+}
+// ── Buffer sampling ───────────────────────────────────────────────────────────
+/**
+ * Sample an rgb48le buffer at floating-point UV coordinates (0–1 range, clamped).
+ * Uses bilinear interpolation between the 4 nearest pixels, equivalent to
+ * GLSL `texture2D` with clamp-to-edge wrapping.
+ *
+ * @param buf  rgb48le buffer — w * h * 6 bytes
+ * @param u    Horizontal coordinate in [0, 1]
+ * @param v    Vertical coordinate in [0, 1]
+ * @param w    Image width in pixels
+ * @param h    Image height in pixels
+ * @returns    [r, g, b] as 16-bit values (0–65535)
+ */
+export function sampleRgb48le(buf, u, v, w, h) {
+    // Clamp UV to [0, 1] then map to pixel coordinates
+    const uc = Math.max(0, Math.min(1, u));
+    const vc = Math.max(0, Math.min(1, v));
+    const sx = uc * (w - 1);
+    const sy = vc * (h - 1);
+    const x0 = Math.floor(sx);
+    const y0 = Math.floor(sy);
+    const x1 = Math.min(x0 + 1, w - 1);
+    const y1 = Math.min(y0 + 1, h - 1);
+    const fx = sx - x0;
+    const fy = sy - y0;
+    const w00 = (1 - fx) * (1 - fy);
+    const w10 = fx * (1 - fy);
+    const w01 = (1 - fx) * fy;
+    const w11 = fx * fy;
+    const off00 = (y0 * w + x0) * 6;
+    const off10 = (y0 * w + x1) * 6;
+    const off01 = (y1 * w + x0) * 6;
+    const off11 = (y1 * w + x1) * 6;
+    const r = Math.round(buf.readUInt16LE(off00) * w00 +
+        buf.readUInt16LE(off10) * w10 +
+        buf.readUInt16LE(off01) * w01 +
+        buf.readUInt16LE(off11) * w11);
+    const g = Math.round(buf.readUInt16LE(off00 + 2) * w00 +
+        buf.readUInt16LE(off10 + 2) * w10 +
+        buf.readUInt16LE(off01 + 2) * w01 +
+        buf.readUInt16LE(off11 + 2) * w11);
+    const b = Math.round(buf.readUInt16LE(off00 + 4) * w00 +
+        buf.readUInt16LE(off10 + 4) * w10 +
+        buf.readUInt16LE(off01 + 4) * w01 +
+        buf.readUInt16LE(off11 + 4) * w11);
+    return [r, g, b];
+}
+// ── 16-bit math primitives ────────────────────────────────────────────────────
+/**
+ * Linear interpolate two 16-bit values. Equivalent to GLSL `mix(a, b, t)`.
+ */
+export function mix16(a, b, t) {
+    return Math.round(a * (1 - t) + b * t);
+}
+/**
+ * Clamp a value to the 16-bit unsigned range [0, 65535].
+ */
+export function clamp16(v) {
+    return Math.max(0, Math.min(65535, v));
+}
+// ── GLSL math ports ───────────────────────────────────────────────────────────
+/**
+ * Hermite interpolation from GLSL `smoothstep(edge0, edge1, x)`.
+ * Returns 0 for x ≤ edge0, 1 for x ≥ edge1, and a smooth S-curve between.
+ */
+export function smoothstep(edge0, edge1, x) {
+    const t = Math.max(0, Math.min(1, (x - edge0) / (edge1 - edge0)));
+    return t * t * (3 - 2 * t);
+}
+/**
+ * Deterministic pseudo-random value in [0, 1).
+ * Port of the GLSL idiom: `fract(sin(dot(p, vec2(127.1, 311.7))) * 43758.5453)`.
+ */
+export function hash(x, y) {
+    return (((Math.sin(x * 127.1 + y * 311.7) * 43758.5453) % 1) + 1) % 1;
+}
+/**
+ * Value noise with C2-continuous quintic interpolation.
+ * Samples `hash()` at the 4 surrounding integer grid corners and blends
+ * using the quintic fade f = f³(f(6f − 15) + 10).
+ *
+ * Returns a value in [0, 1].
+ */
+export function vnoise(px, py) {
+    const ix = Math.floor(px);
+    const iy = Math.floor(py);
+    // Fractional part
+    let fx = px - ix;
+    let fy = py - iy;
+    // Quintic C2 interpolation weights
+    fx = fx * fx * fx * (fx * (fx * 6 - 15) + 10);
+    fy = fy * fy * fy * (fy * (fy * 6 - 15) + 10);
+    const h00 = hash(ix, iy);
+    const h10 = hash(ix + 1, iy);
+    const h01 = hash(ix, iy + 1);
+    const h11 = hash(ix + 1, iy + 1);
+    // Bilinear blend
+    return h00 * (1 - fx) * (1 - fy) + h10 * fx * (1 - fy) + h01 * (1 - fx) * fy + h11 * fx * fy;
+}
+// Rotation matrix constants from GLSL: mat2(0.8, 0.6, -0.6, 0.8)
+// Applies to [px, py]: px' = 0.8*px - 0.6*py, py' = 0.6*px + 0.8*py
+const ROT_A = 0.8;
+const ROT_B = 0.6;
+/**
+ * Fractal Brownian motion — 5-octave accumulation of value noise.
+ *
+ * Each octave: accumulate `amplitude * vnoise(p)`, rotate p by 36.87°,
+ * scale by 2.02, halve the amplitude. Matching the GLSL convention of
+ * `mat2(0.8, 0.6, -0.6, 0.8)` for the rotation.
+ */
+export function fbm(px, py) {
+    let value = 0;
+    let amplitude = 0.5;
+    let x = px;
+    let y = py;
+    for (let i = 0; i < 5; i++) {
+        value += amplitude * vnoise(x, y);
+        // Rotate by mat2(0.8, 0.6, -0.6, 0.8)
+        const nx = ROT_A * x - ROT_B * y;
+        const ny = ROT_B * x + ROT_A * y;
+        x = nx * 2.02;
+        y = ny * 2.02;
+        amplitude *= 0.5;
+    }
+    return value;
+}
+/** Registry of all available transitions by name. */
+export const TRANSITIONS = {};
+// ── crossfade ─────────────────────────────────────────────────────────────────
+/**
+ * Simple linear blend between two frames. Equivalent to GLSL `mix(from, to, progress)`.
+ */
+export const crossfade = (from, to, out, w, h, p) => {
+    const inv = 1 - p;
+    for (let i = 0; i < w * h; i++) {
+        const o = i * 6;
+        out.writeUInt16LE(Math.round(from.readUInt16LE(o) * inv + to.readUInt16LE(o) * p), o);
+        out.writeUInt16LE(Math.round(from.readUInt16LE(o + 2) * inv + to.readUInt16LE(o + 2) * p), o + 2);
+        out.writeUInt16LE(Math.round(from.readUInt16LE(o + 4) * inv + to.readUInt16LE(o + 4) * p), o + 4);
+    }
+};
+TRANSITIONS["crossfade"] = crossfade;
+// ── flashThroughWhite ─────────────────────────────────────────────────────────
+/**
+ * Flash-through-white transition: the outgoing scene brightens to white while
+ * the incoming scene emerges from white, creating a bright flash at the midpoint.
+ *
+ * Port of the GLSL flash-through-white shader.
+ */
+export const flashThroughWhite = (from, to, out, w, h, p) => {
+    const toWhite = smoothstep(0, 0.45, p); // outgoing brightens toward white
+    const fromWhite = 1 - smoothstep(0.5, 1, p); // incoming starts from white
+    const blend = smoothstep(0.35, 0.65, p); // crossfade between the two
+    for (let i = 0; i < w * h; i++) {
+        const o = i * 6;
+        const fromR = mix16(from.readUInt16LE(o), 65535, toWhite);
+        const fromG = mix16(from.readUInt16LE(o + 2), 65535, toWhite);
+        const fromB = mix16(from.readUInt16LE(o + 4), 65535, toWhite);
+        const toR = mix16(to.readUInt16LE(o), 65535, fromWhite);
+        const toG = mix16(to.readUInt16LE(o + 2), 65535, fromWhite);
+        const toB = mix16(to.readUInt16LE(o + 4), 65535, fromWhite);
+        out.writeUInt16LE(mix16(fromR, toR, blend), o);
+        out.writeUInt16LE(mix16(fromG, toG, blend), o + 2);
+        out.writeUInt16LE(mix16(fromB, toB, blend), o + 4);
+    }
+};
+TRANSITIONS["flash-through-white"] = flashThroughWhite;
+// ── chromatic-split ───────────────────────────────────────────────────────────
+/**
+ * RGB channel offset transition. Each channel is sampled at a different UV
+ * offset, spreading apart as progress increases (outgoing) and converging
+ * as progress approaches 1 (incoming). Port of the GLSL chromatic-split shader.
+ */
+export const chromaticSplit = (from, to, out, w, h, p) => {
+    for (let i = 0; i < w * h; i++) {
+        const ux = (i % w) / w;
+        const uy = Math.floor(i / w) / h;
+        const o = i * 6;
+        // Center-relative UV for offset direction
+        const cx = ux - 0.5;
+        const cy = uy - 0.5;
+        const fromShift = p * 0.06;
+        const fr = sampleRgb48le(from, ux + cx * fromShift, uy + cy * fromShift, w, h)[0];
+        const fg = sampleRgb48le(from, ux, uy, w, h)[1];
+        const fb = sampleRgb48le(from, ux - cx * fromShift, uy - cy * fromShift, w, h)[2];
+        const toShift = (1 - p) * 0.06;
+        const tr = sampleRgb48le(to, ux - cx * toShift, uy - cy * toShift, w, h)[0];
+        const tg = sampleRgb48le(to, ux, uy, w, h)[1];
+        const tb = sampleRgb48le(to, ux + cx * toShift, uy + cy * toShift, w, h)[2];
+        out.writeUInt16LE(clamp16(mix16(fr, tr, p)), o);
+        out.writeUInt16LE(clamp16(mix16(fg, tg, p)), o + 2);
+        out.writeUInt16LE(clamp16(mix16(fb, tb, p)), o + 4);
+    }
+};
+TRANSITIONS["chromatic-split"] = chromaticSplit;
+// ── sdf-iris ──────────────────────────────────────────────────────────────────
+/**
+ * Circular iris reveal. A sharp edge expands from the center while golden
+ * glow rings ripple outward at the boundary. Port of the GLSL sdf-iris shader.
+ */
+export const sdfIris = (from, to, out, w, h, p) => {
+    // Accent colors for glow rings (16-bit scale)
+    const accentBright = [65535, 55000, 35000];
+    for (let i = 0; i < w * h; i++) {
+        const ux = (i % w) / w;
+        const uy = Math.floor(i / w) / h;
+        const o = i * 6;
+        // Aspect-corrected distance from center
+        const ax = (ux - 0.5) * (w / h);
+        const ay = uy - 0.5;
+        const d = Math.sqrt(ax * ax + ay * ay);
+        const radius = p * 1.2;
+        const fw = 0.003;
+        const edge = smoothstep(radius + fw, radius - fw, d);
+        // Three glow rings at different radii and falloff speeds
+        const ring1 = Math.exp(-Math.abs(d - radius) * 25);
+        const ring2 = Math.exp(-Math.abs(d - radius + 0.04) * 20) * 0.5;
+        const ring3 = Math.exp(-Math.abs(d - radius + 0.08) * 15) * 0.25;
+        const glow = (ring1 + ring2 + ring3) * p * (1 - p) * 4;
+        const [fromR, fromG, fromB] = sampleRgb48le(from, ux, uy, w, h);
+        const [toR, toG, toB] = sampleRgb48le(to, ux, uy, w, h);
+        out.writeUInt16LE(clamp16(mix16(fromR, toR, edge) + accentBright[0] * glow * 0.6), o);
+        out.writeUInt16LE(clamp16(mix16(fromG, toG, edge) + accentBright[1] * glow * 0.6), o + 2);
+        out.writeUInt16LE(clamp16(mix16(fromB, toB, edge) + accentBright[2] * glow * 0.6), o + 4);
+    }
+};
+TRANSITIONS["sdf-iris"] = sdfIris;
+// ── glitch ────────────────────────────────────────────────────────────────────
+/**
+ * Deterministic PRNG matching the GLSL `rand` in the glitch shader.
+ * Uses different constants than `hash` — do NOT substitute.
+ */
+function glitchRand(x, y) {
+    return (((Math.sin(x * 12.9898 + y * 78.233) * 43758.5453) % 1) + 1) % 1;
+}
+/**
+ * Block displacement + scanlines + RGB channel split. Intensity peaks at the
+ * midpoint (p=0.5) and decays at both ends. Port of the GLSL glitch shader.
+ */
+export const glitch = (from, to, out, w, h, p) => {
+    const intensity = p * (1 - p) * 4;
+    for (let i = 0; i < w * h; i++) {
+        const ux = (i % w) / w;
+        const uy = Math.floor(i / w) / h;
+        const o = i * 6;
+        // Horizontal line displacement
+        const lineY = Math.floor(uy * 60) / 60;
+        const lineDisp = (glitchRand(lineY, Math.floor(p * 17)) - 0.5) * 0.18 * intensity;
+        // Block displacement
+        const blockX = Math.floor(ux * 12);
+        const blockY = Math.floor(uy * 8);
+        const progressStep = Math.floor(p * 11);
+        const br = glitchRand(blockX + progressStep, blockY + progressStep);
+        const ba = (br >= 0.83 ? 1 : 0) * intensity;
+        const bdx = (glitchRand(blockX * 2.1, blockY * 2.1) - 0.5) * 0.35 * ba;
+        const bdy = (glitchRand(blockX * 3.7, blockY * 3.7) - 0.5) * 0.35 * ba;
+        const uvx = Math.max(0, Math.min(1, ux + lineDisp + bdx));
+        const uvy = Math.max(0, Math.min(1, uy + bdy));
+        // RGB channel split on displaced UV
+        const shift = intensity * 0.035;
+        const r = sampleRgb48le(from, uvx + shift, uvy, w, h)[0];
+        const g = sampleRgb48le(from, uvx, uvy, w, h)[1];
+        const b = sampleRgb48le(from, uvx - shift, uvy, w, h)[2];
+        // Normalize to 0-1 for scanline, flicker, and crush operations
+        let cr = r / 65535;
+        let cg = g / 65535;
+        let cb = b / 65535;
+        // Scanline darkening: darken rows where fract(uy * h * 0.5) > 0.5
+        const scanline = (((uy * h * 0.5) % 1) + 1) % 1 >= 0.5 ? 0.05 * intensity : 0;
+        cr -= scanline;
+        cg -= scanline;
+        cb -= scanline;
+        // Brightness flicker
+        const flicker = 1 + (glitchRand(Math.floor(p * 23), 0) - 0.5) * 0.3 * intensity;
+        cr *= flicker;
+        cg *= flicker;
+        cb *= flicker;
+        // Color crush (posterize)
+        const levels = 256 - (256 - 8) * (intensity * 0.5);
+        cr = Math.floor(cr * levels) / levels;
+        cg = Math.floor(cg * levels) / levels;
+        cb = Math.floor(cb * levels) / levels;
+        // Scale back to 16-bit and mix with `to` by progress
+        const [toR, toG, toB] = sampleRgb48le(to, ux, uy, w, h);
+        out.writeUInt16LE(clamp16(mix16(Math.round(cr * 65535), toR, p)), o);
+        out.writeUInt16LE(clamp16(mix16(Math.round(cg * 65535), toG, p)), o + 2);
+        out.writeUInt16LE(clamp16(mix16(Math.round(cb * 65535), toB, p)), o + 4);
+    }
+};
+TRANSITIONS["glitch"] = glitch;
+// ── light-leak ────────────────────────────────────────────────────────────────
+/**
+ * ACES filmic tonemap. Input and output in 0-1 normalized range.
+ * Formula: (x * (2.51x + 0.03)) / (x * (2.43x + 0.59) + 0.14)
+ */
+function aces(x) {
+    return Math.max(0, Math.min(1, (x * (2.51 * x + 0.03)) / (x * (2.43 * x + 0.59) + 0.14)));
+}
+/**
+ * Warm lens-flare from the upper-right corner. The incoming scene burns through
+ * an overexposed flash, tonemapped with ACES and crossfaded with the outgoing
+ * scene. Port of the GLSL light-leak shader.
+ */
+export const lightLeak = (from, to, out, w, h, p) => {
+    // Normalized accent colors (0-1 range for ACES pipeline)
+    const accent = [50000 / 65535, 25000 / 65535, 5000 / 65535];
+    const accentBright = [65535 / 65535, 55000 / 65535, 35000 / 65535];
+    // Light source position
+    const lpx = 1.3;
+    const lpy = -0.2;
+    for (let i = 0; i < w * h; i++) {
+        const ux = (i % w) / w;
+        const uy = Math.floor(i / w) / h;
+        const o = i * 6;
+        const dx = ux - lpx;
+        const dy = uy - lpy;
+        const dist = Math.sqrt(dx * dx + dy * dy);
+        const leak = Math.max(0, Math.min(1, Math.exp(-dist * 1.8) * p * 4));
+        // Warm color: mix accent with accent_bright based on distance
+        const warmR = accent[0] + (accentBright[0] - accent[0]) * dist * 0.7;
+        const warmG = accent[1] + (accentBright[1] - accent[1]) * dist * 0.7;
+        const warmB = accent[2] + (accentBright[2] - accent[2]) * dist * 0.7;
+        // Lens flare streak
+        const flare = Math.exp(-Math.abs(uy - (-0.2 + ux * 0.3)) * 15) * leak * 0.3;
+        const [fr, fg, fb] = sampleRgb48le(from, ux, uy, w, h);
+        const fromR = fr / 65535;
+        const fromG = fg / 65535;
+        const fromB = fb / 65535;
+        // Overexpose and tonemap
+        const overR = aces(fromR + warmR * leak * 3 + accentBright[0] * flare);
+        const overG = aces(fromG + warmG * leak * 3 + accentBright[1] * flare);
+        const overB = aces(fromB + warmB * leak * 3 + accentBright[2] * flare);
+        // Mix overexposed → to by smoothstepped progress
+        const [toR, toG, toB] = sampleRgb48le(to, ux, uy, w, h);
+        const blend = smoothstep(0.15, 0.85, p);
+        out.writeUInt16LE(clamp16(mix16(Math.round(overR * 65535), toR, blend)), o);
+        out.writeUInt16LE(clamp16(mix16(Math.round(overG * 65535), toG, blend)), o + 2);
+        out.writeUInt16LE(clamp16(mix16(Math.round(overB * 65535), toB, blend)), o + 4);
+    }
+};
+TRANSITIONS["light-leak"] = lightLeak;
+// ── cross-warp-morph ──────────────────────────────────────────────────────────
+/**
+ * FBM displacement warp. Both frames are warped in opposite directions by a
+ * fractal noise field, then blended by a noise-threshold mask that sweeps
+ * across the screen as progress advances. Port of the GLSL cross-warp-morph shader.
+ */
+export const crossWarpMorph = (from, to, out, w, h, p) => {
+    for (let i = 0; i < w * h; i++) {
+        const ux = (i % w) / w;
+        const uy = Math.floor(i / w) / h;
+        const o = i * 6;
+        const dispX = fbm(ux * 3, uy * 3) - 0.5;
+        const dispY = fbm(ux * 3 + 7.3, uy * 3 + 3.7) - 0.5;
+        const fromUx = Math.max(0, Math.min(1, ux + dispX * p * 0.5));
+        const fromUy = Math.max(0, Math.min(1, uy + dispY * p * 0.5));
+        const toUx = Math.max(0, Math.min(1, ux - dispX * (1 - p) * 0.5));
+        const toUy = Math.max(0, Math.min(1, uy - dispY * (1 - p) * 0.5));
+        const [fromR, fromG, fromB] = sampleRgb48le(from, fromUx, fromUy, w, h);
+        const [toR, toG, toB] = sampleRgb48le(to, toUx, toUy, w, h);
+        const n = fbm(ux * 4 + 3.1, uy * 4 + 1.7);
+        const blend = smoothstep(0.4, 0.6, n + p * 1.2 - 0.6);
+        out.writeUInt16LE(clamp16(mix16(fromR, toR, blend)), o);
+        out.writeUInt16LE(clamp16(mix16(fromG, toG, blend)), o + 2);
+        out.writeUInt16LE(clamp16(mix16(fromB, toB, blend)), o + 4);
+    }
+};
+TRANSITIONS["cross-warp-morph"] = crossWarpMorph;
+// ── whip-pan ──────────────────────────────────────────────────────────────────
+/**
+ * Horizontal motion blur. The outgoing frame is sampled with offsets shifted
+ * right (by progress*1.5) and the incoming frame is sampled with offsets shifted
+ * left (by (1-progress)*1.5). Each direction uses 10 samples averaged together.
+ * Port of the GLSL whip-pan shader.
+ */
+export const whipPan = (from, to, out, w, h, p) => {
+    const fromOff = p * 1.5;
+    const toOff = (1 - p) * 1.5;
+    for (let i = 0; i < w * h; i++) {
+        const ux = (i % w) / w;
+        const uy = Math.floor(i / w) / h;
+        const o = i * 6;
+        let fromR = 0, fromG = 0, fromB = 0;
+        for (let s = 0; s < 10; s++) {
+            const f = s / 10;
+            const fuv = Math.max(0, Math.min(1, ux + fromOff + p * 0.08 * f));
+            const [r, g, b] = sampleRgb48le(from, fuv, uy, w, h);
+            fromR += r;
+            fromG += g;
+            fromB += b;
+        }
+        fromR /= 10;
+        fromG /= 10;
+        fromB /= 10;
+        let toR = 0, toG = 0, toB = 0;
+        for (let s = 0; s < 10; s++) {
+            const f = s / 10;
+            const tuv = Math.max(0, Math.min(1, ux - toOff - (1 - p) * 0.08 * f));
+            const [r, g, b] = sampleRgb48le(to, tuv, uy, w, h);
+            toR += r;
+            toG += g;
+            toB += b;
+        }
+        toR /= 10;
+        toG /= 10;
+        toB /= 10;
+        out.writeUInt16LE(clamp16(mix16(Math.round(fromR), Math.round(toR), p)), o);
+        out.writeUInt16LE(clamp16(mix16(Math.round(fromG), Math.round(toG), p)), o + 2);
+        out.writeUInt16LE(clamp16(mix16(Math.round(fromB), Math.round(toB), p)), o + 4);
+    }
+};
+TRANSITIONS["whip-pan"] = whipPan;
+// ── cinematic-zoom ────────────────────────────────────────────────────────────
+/**
+ * Radial zoom blur with chromatic aberration. Both frames are blurred along a
+ * radial direction from center using 12 samples. R/G/B channels use slightly
+ * different zoom factors (1.06, 1.0, 0.94) for chromatic aberration. The
+ * outgoing frame zooms inward while the incoming zooms outward.
+ * Port of the GLSL cinematic-zoom shader.
+ */
+export const cinematicZoom = (from, to, out, w, h, p) => {
+    const fromS = p * 0.08;
+    const toS = (1 - p) * 0.06;
+    for (let i = 0; i < w * h; i++) {
+        const ux = (i % w) / w;
+        const uy = Math.floor(i / w) / h;
+        const o = i * 6;
+        const dx = ux - 0.5;
+        const dy = uy - 0.5;
+        let fr = 0, fg = 0, fb = 0;
+        for (let s = 0; s < 12; s++) {
+            const f = s / 12;
+            const rr = sampleRgb48le(from, ux - dx * fromS * 1.06 * f, uy - dy * fromS * 1.06 * f, w, h)[0];
+            const gg = sampleRgb48le(from, ux - dx * fromS * f, uy - dy * fromS * f, w, h)[1];
+            const bb = sampleRgb48le(from, ux - dx * fromS * 0.94 * f, uy - dy * fromS * 0.94 * f, w, h)[2];
+            fr += rr;
+            fg += gg;
+            fb += bb;
+        }
+        fr /= 12;
+        fg /= 12;
+        fb /= 12;
+        let tr = 0, tg = 0, tb = 0;
+        for (let s = 0; s < 12; s++) {
+            const f = s / 12;
+            const rr = sampleRgb48le(to, ux + dx * toS * 1.06 * f, uy + dy * toS * 1.06 * f, w, h)[0];
+            const gg = sampleRgb48le(to, ux + dx * toS * f, uy + dy * toS * f, w, h)[1];
+            const bb = sampleRgb48le(to, ux + dx * toS * 0.94 * f, uy + dy * toS * 0.94 * f, w, h)[2];
+            tr += rr;
+            tg += gg;
+            tb += bb;
+        }
+        tr /= 12;
+        tg /= 12;
+        tb /= 12;
+        out.writeUInt16LE(clamp16(mix16(Math.round(fr), Math.round(tr), p)), o);
+        out.writeUInt16LE(clamp16(mix16(Math.round(fg), Math.round(tg), p)), o + 2);
+        out.writeUInt16LE(clamp16(mix16(Math.round(fb), Math.round(tb), p)), o + 4);
+    }
+};
+TRANSITIONS["cinematic-zoom"] = cinematicZoom;
+// ── gravitational-lens ────────────────────────────────────────────────────────
+/**
+ * Radial warp toward center simulating a gravitational lens effect. The
+ * outgoing frame is warped with chromatic separation, masked by a horizon
+ * that depends on distance from center. Mixed to the incoming frame using
+ * smoothstep(0.3, 0.9, progress). Port of the GLSL gravitational-lens shader.
+ */
+export const gravitationalLens = (from, to, out, w, h, p) => {
+    for (let i = 0; i < w * h; i++) {
+        const ux = (i % w) / w;
+        const uy = Math.floor(i / w) / h;
+        const o = i * 6;
+        const uvx = ux - 0.5;
+        const uvy = uy - 0.5;
+        const dist = Math.sqrt(uvx * uvx + uvy * uvy);
+        const pull = p * 2;
+        const warpStr = (pull * 0.3) / (dist + 0.1);
+        const warpedX = Math.max(0, Math.min(1, ux - uvx * warpStr));
+        const warpedY = Math.max(0, Math.min(1, uy - uvy * warpStr));
+        const [, ag] = sampleRgb48le(from, warpedX, warpedY, w, h);
+        const horizon = smoothstep(0, 0.3, dist / (1 - p * 0.85 + 0.001));
+        const shift = (pull * 0.02) / (dist + 0.2);
+        const rSampX = Math.max(0, Math.min(1, ux - uvx * (warpStr + shift)));
+        const rSampY = Math.max(0, Math.min(1, uy - uvy * (warpStr + shift)));
+        const bSampX = Math.max(0, Math.min(1, ux - uvx * (warpStr - shift)));
+        const bSampY = Math.max(0, Math.min(1, uy - uvy * (warpStr - shift)));
+        const ar = sampleRgb48le(from, rSampX, rSampY, w, h)[0];
+        const ab = sampleRgb48le(from, bSampX, bSampY, w, h)[2];
+        const lensedR = Math.round(ar * horizon);
+        const lensedG = Math.round(ag * horizon);
+        const lensedB = Math.round(ab * horizon);
+        const [toR, toG, toB] = sampleRgb48le(to, ux, uy, w, h);
+        const blend = smoothstep(0.3, 0.9, p);
+        out.writeUInt16LE(clamp16(mix16(lensedR, toR, blend)), o);
+        out.writeUInt16LE(clamp16(mix16(lensedG, toG, blend)), o + 2);
+        out.writeUInt16LE(clamp16(mix16(lensedB, toB, blend)), o + 4);
+    }
+};
+TRANSITIONS["gravitational-lens"] = gravitationalLens;
+// ── ripple-waves ──────────────────────────────────────────────────────────────
+/**
+ * Concentric wave distortion. Exponential wave functions create rings radiating
+ * outward from center. Both frames are distorted — the outgoing with progress-
+ * scaled amplitude, the incoming with (1-progress)-scaled amplitude. A warm
+ * accent tint highlights wave peaks. Port of the GLSL ripple-waves shader.
+ */
+export const rippleWaves = (from, to, out, w, h, p) => {
+    // Accent bright color (16-bit)
+    const accentBright = [65535, 55000, 35000];
+    for (let i = 0; i < w * h; i++) {
+        const ux = (i % w) / w;
+        const uy = Math.floor(i / w) / h;
+        const o = i * 6;
+        const uvx = ux - 0.5;
+        const uvy = uy - 0.5;
+        const dist = Math.sqrt(uvx * uvx + uvy * uvy);
+        // Normalize direction from center, offset by small amount to avoid div-by-zero
+        const nux = uvx + 0.001;
+        const nuy = uvy + 0.001;
+        const nlen = Math.sqrt(nux * nux + nuy * nuy);
+        const dirx = nux / nlen;
+        const diry = nuy / nlen;
+        // From frame: waves moving outward (positive phase)
+        const fromAmp = p * 0.04;
+        const fw1 = Math.exp(Math.sin(dist * 25 - p * 12) - 1);
+        const fw2 = Math.exp(Math.sin(dist * 50 - p * 18) - 1) * 0.5;
+        const fromUx = Math.max(0, Math.min(1, ux + dirx * (fw1 + fw2) * fromAmp));
+        const fromUy = Math.max(0, Math.min(1, uy + diry * (fw1 + fw2) * fromAmp));
+        // To frame: waves moving inward (reversed phase)
+        const toAmp = (1 - p) * 0.04;
+        const tw1 = Math.exp(Math.sin(dist * 25 + p * 12) - 1);
+        const tw2 = Math.exp(Math.sin(dist * 50 + p * 18) - 1) * 0.5;
+        const toUx = Math.max(0, Math.min(1, ux - dirx * (tw1 + tw2) * toAmp));
+        const toUy = Math.max(0, Math.min(1, uy - diry * (tw1 + tw2) * toAmp));
+        const [fromR, fromG, fromB] = sampleRgb48le(from, fromUx, fromUy, w, h);
+        const [toR, toG, toB] = sampleRgb48le(to, toUx, toUy, w, h);
+        const peak = fw1 * p;
+        const tintR = accentBright[0] * peak * 0.1;
+        const tintG = accentBright[1] * peak * 0.1;
+        const tintB = accentBright[2] * peak * 0.1;
+        out.writeUInt16LE(clamp16(mix16(Math.round(fromR + tintR), toR, p)), o);
+        out.writeUInt16LE(clamp16(mix16(Math.round(fromG + tintG), toG, p)), o + 2);
+        out.writeUInt16LE(clamp16(mix16(Math.round(fromB + tintB), toB, p)), o + 4);
+    }
+};
+TRANSITIONS["ripple-waves"] = rippleWaves;
+// ── swirl-vortex ──────────────────────────────────────────────────────────────
+/**
+ * Rotational UV warp. The outgoing frame is rotated clockwise and the incoming
+ * counter-clockwise. Rotation angle depends on distance from center and FBM
+ * warp noise. Port of the GLSL swirl-vortex shader.
+ */
+export const swirlVortex = (from, to, out, w, h, p) => {
+    for (let i = 0; i < w * h; i++) {
+        const ux = (i % w) / w;
+        const uy = Math.floor(i / w) / h;
+        const o = i * 6;
+        const uvx = ux - 0.5;
+        const uvy = uy - 0.5;
+        const dist = Math.sqrt(uvx * uvx + uvy * uvy);
+        const warp = fbm(ux * 4, uy * 4) * 0.5;
+        const fromAng = p * (1 - dist) * 10 + warp * p * 3;
+        const fs = Math.sin(fromAng);
+        const fc = Math.cos(fromAng);
+        const fromUx = Math.max(0, Math.min(1, uvx * fc - uvy * fs + 0.5));
+        const fromUy = Math.max(0, Math.min(1, uvx * fs + uvy * fc + 0.5));
+        const toAng = -(1 - p) * (1 - dist) * 10 - warp * (1 - p) * 3;
+        const ts = Math.sin(toAng);
+        const tc = Math.cos(toAng);
+        const toUx = Math.max(0, Math.min(1, uvx * tc - uvy * ts + 0.5));
+        const toUy = Math.max(0, Math.min(1, uvx * ts + uvy * tc + 0.5));
+        const [fromR, fromG, fromB] = sampleRgb48le(from, fromUx, fromUy, w, h);
+        const [toR, toG, toB] = sampleRgb48le(to, toUx, toUy, w, h);
+        out.writeUInt16LE(clamp16(mix16(fromR, toR, p)), o);
+        out.writeUInt16LE(clamp16(mix16(fromG, toG, p)), o + 2);
+        out.writeUInt16LE(clamp16(mix16(fromB, toB, p)), o + 4);
+    }
+};
+TRANSITIONS["swirl-vortex"] = swirlVortex;
+// ── thermal-distortion ────────────────────────────────────────────────────────
+/**
+ * Heat shimmer effect. Horizontal displacement based on a sin wave modulated by
+ * FBM noise, fading toward the top of the screen. Both frames are displaced
+ * independently, and a warm haze overlay fades as progress advances.
+ * Port of the GLSL thermal-distortion shader.
+ */
+export const thermalDistortion = (from, to, out, w, h, p) => {
+    // Accent bright color (16-bit)
+    const accentBright = [65535, 55000, 35000];
+    for (let i = 0; i < w * h; i++) {
+        const ux = (i % w) / w;
+        const uy = Math.floor(i / w) / h;
+        const o = i * 6;
+        const heat = p * 1.5;
+        const yFade = smoothstep(1, 0, uy);
+        // From frame shimmer: fbm(uv*6) modulates sin wave
+        const shimmer = Math.sin(uy * 40 + fbm(ux * 6, uy * 6) * 8) * fbm(ux * 3 + 0, uy * 3 + p * 2);
+        const dispX = shimmer * heat * 0.03 * yFade;
+        const fromUx = Math.max(0, Math.min(1, ux + dispX));
+        const [fromR, fromG, fromB] = sampleRgb48le(from, fromUx, uy, w, h);
+        // To frame shimmer: different FBM seed (offset by 3)
+        const invShimmer = Math.sin(uy * 40 + fbm(ux * 6 + 3, uy * 6 + 3) * 8) * fbm(ux * 3 + 3, uy * 3 + p * 2);
+        const dispX2 = invShimmer * (1 - p) * 0.03 * yFade;
+        const toUx = Math.max(0, Math.min(1, ux + dispX2));
+        const [toR, toG, toB] = sampleRgb48le(to, toUx, uy, w, h);
+        const haze = heat * yFade * 0.15 * (1 - p);
+        out.writeUInt16LE(clamp16(mix16(fromR, toR, p) + Math.round(accentBright[0] * haze)), o);
+        out.writeUInt16LE(clamp16(mix16(fromG, toG, p) + Math.round(accentBright[1] * haze)), o + 2);
+        out.writeUInt16LE(clamp16(mix16(fromB, toB, p) + Math.round(accentBright[2] * haze)), o + 4);
+    }
+};
+TRANSITIONS["thermal-distortion"] = thermalDistortion;
+// ── domain-warp ───────────────────────────────────────────────────────────────
+/**
+ * FBM-driven UV warp with edge glow. Computes two layers of FBM (q and r) to
+ * derive a warp direction. Both frames are displaced in opposite directions.
+ * An edge-detection glow appears at the transition boundary.
+ * Port of the GLSL domain-warp shader. Note: mix(B, A, e) ordering — e=1 shows A (from).
+ */
+export const domainWarp = (from, to, out, w, h, p) => {
+    // Accent colors (16-bit)
+    const accentDark = [25000, 8000, 2000];
+    const accentBright = [65535, 55000, 35000];
+    for (let i = 0; i < w * h; i++) {
+        const ux = (i % w) / w;
+        const uy = Math.floor(i / w) / h;
+        const o = i * 6;
+        // Two-layer domain warp: q, then r
+        const qx = fbm(ux * 3, uy * 3);
+        const qy = fbm(ux * 3 + 5.2, uy * 3 + 1.3);
+        const rx = fbm(ux * 3 + qx * 4 + 1.7, uy * 3 + qy * 4 + 9.2);
+        const ry = fbm(ux * 3 + qx * 4 + 8.3, uy * 3 + qy * 4 + 2.8);
+        const n = fbm(ux * 3 + rx * 2, uy * 3 + ry * 2);
+        const warpDirX = (qx - 0.5) * 0.4;
+        const warpDirY = (qy - 0.5) * 0.4;
+        const aUx = Math.max(0, Math.min(1, ux + warpDirX * p));
+        const aUy = Math.max(0, Math.min(1, uy + warpDirY * p));
+        const bUx = Math.max(0, Math.min(1, ux - warpDirX * (1 - p)));
+        const bUy = Math.max(0, Math.min(1, uy - warpDirY * (1 - p)));
+        const [aR, aG, aB] = sampleRgb48le(from, aUx, aUy, w, h);
+        const [bR, bG, bB] = sampleRgb48le(to, bUx, bUy, w, h);
+        // e=1 → show A (from), e=0 → show B (to): mix(B, A, e)
+        const e = smoothstep(p - 0.08, p + 0.08, n);
+        const ed = Math.abs(n - p);
+        // step(1, p) = p >= 1 ? 1 : 0 → suppress glow at p=1
+        const pStep = p >= 1 ? 1 : 0;
+        const em = smoothstep(0.1, 0, ed) * (1 - pStep);
+        // Edge color: mix accent_dark → accent_bright based on edge proximity
+        const ecBlend = smoothstep(0, 0.1, ed);
+        const ecR = accentDark[0] + (accentBright[0] - accentDark[0]) * (1 - ecBlend);
+        const ecG = accentDark[1] + (accentBright[1] - accentDark[1]) * (1 - ecBlend);
+        const ecB = accentDark[2] + (accentBright[2] - accentDark[2]) * (1 - ecBlend);
+        // mix(B, A, e) + edge glow
+        out.writeUInt16LE(clamp16(mix16(bR, aR, e) + Math.round(ecR * em * 2)), o);
+        out.writeUInt16LE(clamp16(mix16(bG, aG, e) + Math.round(ecG * em * 2)), o + 2);
+        out.writeUInt16LE(clamp16(mix16(bB, aB, e) + Math.round(ecB * em * 2)), o + 4);
+    }
+};
+TRANSITIONS["domain-warp"] = domainWarp;
+// ── ridged-burn ───────────────────────────────────────────────────────────────
+/**
+ * Ridged noise threshold transition with heat glow and sparks. Uses a custom
+ * ridged noise function (5 octaves of abs(vnoise*2 - 1)) to create a
+ * burning-paper effect. Accent colors glow at the burn boundary. Sparks
+ * appear from high-frequency noise.
+ * Port of the GLSL ridged-burn shader. Note: mix(B, A, e) ordering — e=1 shows A (from).
+ */
+/**
+ * Ridged noise: 5 octaves of abs(vnoise*2 - 1) with the same rotation and
+ * scaling as fbm. Returns values in [0, ~0.97].
+ */
+function ridged(px, py) {
+    let value = 0;
+    let amplitude = 0.5;
+    let x = px;
+    let y = py;
+    for (let i = 0; i < 5; i++) {
+        value += amplitude * Math.abs(vnoise(x, y) * 2 - 1);
+        const nx = ROT_A * x - ROT_B * y;
+        const ny = ROT_B * x + ROT_A * y;
+        x = nx * 2.02;
+        y = ny * 2.02;
+        amplitude *= 0.5;
+    }
+    return value;
+}
+export const ridgedBurn = (from, to, out, w, h, p) => {
+    // Accent colors (16-bit)
+    const accent = [50000, 25000, 5000];
+    const accentDark = [25000, 8000, 2000];
+    const accentBright = [65535, 55000, 35000];
+    for (let i = 0; i < w * h; i++) {
+        const ux = (i % w) / w;
+        const uy = Math.floor(i / w) / h;
+        const o = i * 6;
+        const [aR, aG, aB] = sampleRgb48le(from, ux, uy, w, h);
+        const [bR, bG, bB] = sampleRgb48le(to, ux, uy, w, h);
+        const n = ridged(ux * 4, uy * 4);
+        // e=1 → show A (from), e=0 → show B (to): mix(B, A, e)
+        const e = smoothstep(p - 0.04, p + 0.04, n);
+        const heat = smoothstep(0.12, 0, Math.abs(n - p));
+        // step(1, p) = p >= 1 ? 1 : 0 → suppress glow at p=1
+        const pStep = p >= 1 ? 1 : 0;
+        const heatMasked = heat * (1 - pStep);
+        // Burn color gradient: dark → accent → accent_bright → white
+        let burnR = accentDark[0] + (accent[0] - accentDark[0]) * smoothstep(0, 0.25, heatMasked);
+        let burnG = accentDark[1] + (accent[1] - accentDark[1]) * smoothstep(0, 0.25, heatMasked);
+        let burnB = accentDark[2] + (accent[2] - accentDark[2]) * smoothstep(0, 0.25, heatMasked);
+        const blend2 = smoothstep(0.25, 0.5, heatMasked);
+        burnR = burnR + (accentBright[0] - burnR) * blend2;
+        burnG = burnG + (accentBright[1] - burnG) * blend2;
+        burnB = burnB + (accentBright[2] - burnB) * blend2;
+        const blend3 = smoothstep(0.5, 1, heatMasked);
+        burnR = burnR + (65535 - burnR) * blend3;
+        burnG = burnG + (65535 - burnG) * blend3;
+        burnB = burnB + (65535 - burnB) * blend3;
+        // Sparks: high-frequency noise above threshold
+        const sparks = (vnoise(ux * 80, uy * 80) >= 0.92 ? 1 : 0) * heatMasked * 3;
+        out.writeUInt16LE(clamp16(mix16(bR, aR, e) +
+            Math.round(burnR * heatMasked * 3.5) +
+            Math.round(accentBright[0] * sparks)), o);
+        out.writeUInt16LE(clamp16(mix16(bG, aG, e) +
+            Math.round(burnG * heatMasked * 3.5) +
+            Math.round(accentBright[1] * sparks)), o + 2);
+        out.writeUInt16LE(clamp16(mix16(bB, aB, e) +
+            Math.round(burnB * heatMasked * 3.5) +
+            Math.round(accentBright[2] * sparks)), o + 4);
+    }
+};
+TRANSITIONS["ridged-burn"] = ridgedBurn;
+//# sourceMappingURL=shaderTransitions.js.map