@vysmo/transitions 0.1.0

package/dist/transitions/film-grain.js

@@ -0,0 +1,78 @@
+import { defineTransition } from "./define.js";
+/**
+ * Filmic dissolve. Everything that modulates the image is gated by a
+ * 4·p·(1-p) peak envelope so endpoints are pixel-pure from/to.
+ *
+ * At peak, the image picks up:
+ *   - multi-scale animated grain (fine + medium + coarse), reseeded
+ *     in discrete progress frames so scrubbing flickers like a
+ *     projector
+ *   - partial desaturation (content drifts toward luminance)
+ *   - subtle warm tint (R up, B down)
+ *   - a soft corner vignette
+ *   - occasional dark vertical scratches on ~2% of columns, reseeded
+ *     every couple of frames
+ *
+ * Base crossfade is a soft smoothstep(0.25, 0.75) so from and to
+ * overlap through the grainy middle — the grain is what carries the
+ * hand-off, rather than a geometric wipe with film on top.
+ *
+ * One param: grain (master intensity of the whole film character).
+ */
+export const filmGrain = defineTransition({
+    name: "film-grain",
+    defaults: {
+        grain: 1.0,
+    },
+    glsl: `
+uniform float uGrain;
+
+float hash21(vec2 p) {
+  return fract(sin(dot(p, vec2(12.9898, 78.233))) * 43758.5453);
+}
+
+vec4 transition(vec2 uv) {
+  vec3 fromC = getFromColor(uv).rgb;
+  vec3 toC = getToColor(uv).rgb;
+  vec3 base = mix(fromC, toC, smoothstep(0.25, 0.75, uProgress));
+
+  // Peak envelope — zero at both endpoints, 1 at mid.
+  float peak = 4.0 * uProgress * (1.0 - uProgress) * uGrain;
+
+  // Partial desaturation toward luminance (old film is less vivid).
+  float lum = dot(base, vec3(0.299, 0.587, 0.114));
+  base = mix(base, vec3(lum), peak * 0.25);
+
+  // Warm tint: subtle R boost + B drop at peak. Still multiplicative
+  // on content (no synthetic colour introduced from nothing).
+  base *= mix(vec3(1.0), vec3(1.08, 1.00, 0.88), peak * 0.6);
+
+  // Stepped seed → scrubbing reads as projector flicker between
+  // a handful of discrete grain "frames" across the transition.
+  float frame = floor(uProgress * 22.0);
+
+  // Multi-scale grain. Fine texture + medium clumps + occasional
+  // coarse blotches — reads as film-stock rather than digital noise.
+  float g = 0.0;
+  g += (hash21(uv * 520.0 + vec2(frame, 0.0)) - 0.5) * 0.6;
+  g += (hash21(uv * 130.0 + vec2(0.0, frame)) - 0.5) * 0.3;
+  g += (hash21(uv * 32.0 + vec2(frame, frame)) - 0.5) * 0.18;
+  base += vec3(g) * peak * 0.55;
+
+  // Vertical scratches on ~2% of columns, reseeded every two frames.
+  float scratchCol = floor(uv.x * 220.0);
+  float scratchSeed = floor(frame * 0.5);
+  float scratchHash = hash21(vec2(scratchCol, scratchSeed));
+  float isScratch = step(0.98, scratchHash);
+  base *= mix(1.0, 0.32, isScratch * peak);
+
+  // Soft corner vignette at peak only — old projector look.
+  float d = distance(uv, vec2(0.5));
+  float vignette = 1.0 - smoothstep(0.35, 0.9, d);
+  base *= mix(1.0, 0.65 + 0.35 * vignette, peak * 0.8);
+
+  return vec4(base, 1.0);
+}
+`,
+});
+//# sourceMappingURL=film-grain.js.map

package/dist/transitions/film-grain.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"film-grain.js","sourceRoot":"","sources":["../../src/transitions/film-grain.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAE/C;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,CAAC,MAAM,SAAS,GAAG,gBAAgB,CAAC;IACxC,IAAI,EAAE,YAAY;IAClB,QAAQ,EAAE;QACR,KAAK,EAAE,GAAG;KACX;IACD,IAAI,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiDP;CACA,CAAC,CAAC"}

package/dist/transitions/flow-warp.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Faithful port of akella demo6 (the "planetary" transition). Reads a
+ * displacement-map texture supplied via `RenderArgs.displacement` to drive
+ * a per-pixel UV offset vector. From-image is displaced in the direction
+ * `rotate(angle1) * dispVec * progress`; to-image is displaced in the
+ * direction `rotate(angle2) * dispVec * (1-progress)`. The two opposing
+ * angles produce the signature dual-flow akella aesthetic.
+ *
+ * The displacement is interpreted as centered: mid-gray (0.5) maps to
+ * zero offset; channel-r drives the x-component, channel-g the y. This
+ * differs from akella's raw [0,1] convention so the runner's default
+ * mid-gray fallback degrades to a clean crossfade when no displacement
+ * is supplied.
+ */
+export declare const flowWarp: import("../types.js").Transition<import("@vysmo/gl-core").Widen<{
+    readonly intensity: 0.4;
+    readonly angle1: 0.7853982;
+    readonly angle2: -2.3561945;
+}>>;
+//# sourceMappingURL=flow-warp.d.ts.map

package/dist/transitions/flow-warp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"flow-warp.d.ts","sourceRoot":"","sources":["../../src/transitions/flow-warp.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,QAAQ;;;;GAkCnB,CAAC"}

package/dist/transitions/flow-warp.js

@@ -0,0 +1,51 @@
+import { defineTransition } from "./define.js";
+/**
+ * Faithful port of akella demo6 (the "planetary" transition). Reads a
+ * displacement-map texture supplied via `RenderArgs.displacement` to drive
+ * a per-pixel UV offset vector. From-image is displaced in the direction
+ * `rotate(angle1) * dispVec * progress`; to-image is displaced in the
+ * direction `rotate(angle2) * dispVec * (1-progress)`. The two opposing
+ * angles produce the signature dual-flow akella aesthetic.
+ *
+ * The displacement is interpreted as centered: mid-gray (0.5) maps to
+ * zero offset; channel-r drives the x-component, channel-g the y. This
+ * differs from akella's raw [0,1] convention so the runner's default
+ * mid-gray fallback degrades to a clean crossfade when no displacement
+ * is supplied.
+ */
+export const flowWarp = defineTransition({
+    name: "flow-warp",
+    defaults: {
+        intensity: 0.4,
+        angle1: 0.7853982,
+        angle2: -2.3561945,
+    },
+    glsl: `
+uniform float uIntensity;
+uniform float uAngle1;
+uniform float uAngle2;
+
+mat2 rotate2d(float a) {
+  float s = sin(a);
+  float c = cos(a);
+  return mat2(c, -s, s, c);
+}
+
+// Out-of-range UVs use the runner-prologue mirrorUv() so displacement
+// reads as mirrored continuation rather than streaked edge texels.
+vec4 transition(vec2 uv) {
+  vec4 disp = getDisplacement(uv);
+  // Centered convention: mid-gray = no displacement, range [-1, 1].
+  vec2 dispVec = (disp.rg - 0.5) * 2.0;
+
+  vec2 distorted1 = uv + rotate2d(uAngle1) * dispVec * uIntensity * uProgress;
+  vec2 distorted2 = uv + rotate2d(uAngle2) * dispVec * uIntensity * (1.0 - uProgress);
+
+  vec4 t1 = getFromColor(mirrorUv(distorted1));
+  vec4 t2 = getToColor(mirrorUv(distorted2));
+
+  return mix(t1, t2, uProgress);
+}
+`,
+});
+//# sourceMappingURL=flow-warp.js.map

package/dist/transitions/flow-warp.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"flow-warp.js","sourceRoot":"","sources":["../../src/transitions/flow-warp.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAE/C;;;;;;;;;;;;;GAaG;AACH,MAAM,CAAC,MAAM,QAAQ,GAAG,gBAAgB,CAAC;IACvC,IAAI,EAAE,WAAW;IACjB,QAAQ,EAAE;QACR,SAAS,EAAE,GAAG;QACd,MAAM,EAAE,SAAS;QACjB,MAAM,EAAE,CAAC,SAAS;KACnB;IACD,IAAI,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;CA0BP;CACA,CAAC,CAAC"}

package/dist/transitions/fluid-flow.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Multi-pass pixel advection. The from-image is progressively carried
+ * along a swirly vector field, then blended toward to. Each pass
+ * samples uPrevious at a displaced position — pixels genuinely move
+ * (follow flow lines across iterations) rather than fading in place,
+ * so the character is closer to ink-stirring-into-water than any
+ * crossfade. Impossible single-pass: resolving a multi-step flow
+ * trajectory requires reading previous pass output.
+ *
+ *   pass 0              — seed: sample from.
+ *   pass 1..passCount-2 — advection: sample uPrevious at uv - flow·step,
+ *                         and blend toward to by a per-pass amount
+ *                         chosen so the compounded blend reaches
+ *                         progress after all advection passes.
+ *   final pass          — pass-through (output previous).
+ *
+ * Endpoints: at progress 0, step = 0 and per-pass blend = 0, so the
+ * chain preserves from. At progress 1, the per-pass blend = 1 so the
+ * first advection pass already writes to, and every subsequent pass
+ * preserves it (advecting a uniform field is a fixed point).
+ */
+export declare const fluidFlow: import("../types.js").Transition<import("@vysmo/gl-core").Widen<{
+    readonly strength: 0.12;
+    readonly scale: 3;
+}>>;
+//# sourceMappingURL=fluid-flow.d.ts.map

package/dist/transitions/fluid-flow.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fluid-flow.d.ts","sourceRoot":"","sources":["../../src/transitions/fluid-flow.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,SAAS;;;GAsEpB,CAAC"}

package/dist/transitions/fluid-flow.js

@@ -0,0 +1,94 @@
+import { defineTransition } from "./define.js";
+/**
+ * Multi-pass pixel advection. The from-image is progressively carried
+ * along a swirly vector field, then blended toward to. Each pass
+ * samples uPrevious at a displaced position — pixels genuinely move
+ * (follow flow lines across iterations) rather than fading in place,
+ * so the character is closer to ink-stirring-into-water than any
+ * crossfade. Impossible single-pass: resolving a multi-step flow
+ * trajectory requires reading previous pass output.
+ *
+ *   pass 0              — seed: sample from.
+ *   pass 1..passCount-2 — advection: sample uPrevious at uv - flow·step,
+ *                         and blend toward to by a per-pass amount
+ *                         chosen so the compounded blend reaches
+ *                         progress after all advection passes.
+ *   final pass          — pass-through (output previous).
+ *
+ * Endpoints: at progress 0, step = 0 and per-pass blend = 0, so the
+ * chain preserves from. At progress 1, the per-pass blend = 1 so the
+ * first advection pass already writes to, and every subsequent pass
+ * preserves it (advecting a uniform field is a fixed point).
+ */
+export const fluidFlow = defineTransition({
+    name: "fluid-flow",
+    passes: 6,
+    defaults: {
+        strength: 0.12,
+        scale: 3,
+    },
+    glsl: `
+uniform float uStrength;
+uniform float uScale;
+
+float hash21(vec2 p) {
+  return fract(sin(dot(p, vec2(12.9898, 78.233))) * 43758.5453);
+}
+
+float valNoise(vec2 p) {
+  vec2 i = floor(p);
+  vec2 f = fract(p);
+  f = f * f * (3.0 - 2.0 * f);
+  float a = hash21(i);
+  float b = hash21(i + vec2(1.0, 0.0));
+  float c = hash21(i + vec2(0.0, 1.0));
+  float d = hash21(i + vec2(1.0, 1.0));
+  return mix(mix(a, b, f.x), mix(c, d, f.x), f.y);
+}
+
+float fbm(vec2 p) {
+  return valNoise(p) * 0.55 +
+         valNoise(p * 2.1) * 0.28 +
+         valNoise(p * 4.3) * 0.17;
+}
+
+// Swirly 2D vector field in [-1,1]² per axis. Two offset fbm fields
+// give a non-divergence-free flow that still reads as fluid swirl.
+vec2 flowField(vec2 p) {
+  return vec2(
+    fbm(p) * 2.0 - 1.0,
+    fbm(p + vec2(17.3, 23.7)) * 2.0 - 1.0
+  );
+}
+
+vec4 transition(vec2 uv) {
+  // Final pass: pass through the accumulated result.
+  if (uPass == uPassCount - 1) {
+    return getPrevious(uv);
+  }
+
+  // Seed pass: carry the from image in untouched.
+  if (uPass == 0) {
+    return vec4(getFromColor(uv).rgb, 1.0);
+  }
+
+  float nAdvect = float(uPassCount - 2);
+  vec2 flow = flowField(uv * uScale);
+  float stepAmount = uStrength * uProgress / nAdvect;
+
+  // Sample previous at the advected position — pixels flow along the
+  // field. Clamp keeps samples in-bounds when the flow pushes near
+  // the frame edge.
+  vec2 advectedUv = clamp(uv - flow * stepAmount, 0.0, 1.0);
+  vec3 advected = getPrevious(advectedUv).rgb;
+
+  // Per-pass blend chosen so (1 - blend)^N = 1 - progress, i.e. after
+  // nAdvect passes the compounded blend exactly equals progress.
+  float perPassBlend = 1.0 - pow(1.0 - uProgress, 1.0 / nAdvect);
+
+  vec3 blended = mix(advected, getToColor(uv).rgb, perPassBlend);
+  return vec4(blended, 1.0);
+}
+`,
+});
+//# sourceMappingURL=fluid-flow.js.map

package/dist/transitions/fluid-flow.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fluid-flow.js","sourceRoot":"","sources":["../../src/transitions/fluid-flow.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAE/C;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,CAAC,MAAM,SAAS,GAAG,gBAAgB,CAAC;IACxC,IAAI,EAAE,YAAY;IAClB,MAAM,EAAE,CAAC;IACT,QAAQ,EAAE;QACR,QAAQ,EAAE,IAAI;QACd,KAAK,EAAE,CAAC;KACT;IACD,IAAI,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8DP;CACA,CAAC,CAAC"}

package/dist/transitions/fly-eye.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fly-eye.d.ts","sourceRoot":"","sources":["../../src/transitions/fly-eye.ts"],"names":[],"mappings":"AAEA;;;;;;;GAOG;AACH,eAAO,MAAM,MAAM;;;;GA+CjB,CAAC"}

package/dist/transitions/fly-eye.js

@@ -0,0 +1,58 @@
+import { defineTransition } from "./define.js";
+/**
+ * Compound-eye lens effect: the frame fragments into tiles that grow from
+ * pixel-sized (endpoints) to large (midpoint) where each tile shows a
+ * centered sample. Per-tile staggered transitions avoid the freeze that a
+ * symmetric tile envelope + centered crossfade would otherwise produce —
+ * at any progress the image has tiles at every transition stage. A soft
+ * per-tile vignette gives it a lens feel without ever going fully dark.
+ */
+export const flyEye = defineTransition({
+    name: "fly-eye",
+    defaults: {
+        size: 22,
+        vignette: 0.35,
+        stagger: 0.5,
+    },
+    glsl: `
+uniform float uSize;
+uniform float uVignette;
+uniform float uStagger;
+
+float hash21(vec2 p) {
+  return fract(sin(dot(p, vec2(12.9898, 78.233))) * 43758.5453);
+}
+
+vec4 transition(vec2 uv) {
+  float env = 4.0 * uProgress * (1.0 - uProgress);
+
+  // Cell count slides between per-pixel (no quantization at endpoints) and
+  // uSize tiles (large lenses at midpoint).
+  float maxRes = max(uResolution.x, uResolution.y);
+  float cellCount = mix(maxRes, max(uSize, 2.0), env);
+
+  vec2 pixel = uv * uResolution;
+  vec2 tileSize = uResolution / cellCount;
+  vec2 tileIdx = floor(pixel / tileSize);
+  vec2 tileCenter = (tileIdx + 0.5) * tileSize / uResolution;
+  vec2 sampleUv = mix(uv, tileCenter, env);
+
+  // Per-tile transition start times — breaks the freeze that a symmetric
+  // tile envelope + centered crossfade would create. At any given moment
+  // some tiles are mid-fade, some are fully from, some fully to.
+  float priority = hash21(tileIdx);
+  float start = priority * uStagger;
+  float localP = clamp((uProgress - start) / max(1.0 - uStagger, 0.0001), 0.0, 1.0);
+
+  // Per-tile vignette bounded away from zero so corners never go black.
+  vec2 withinTile = fract(pixel / tileSize) - 0.5;
+  float tileDist = length(withinTile);
+  float vignette = mix(1.0 - uVignette, 1.0, 1.0 - smoothstep(0.25, 0.5, tileDist));
+  float vEff = mix(1.0, vignette, env);
+
+  vec4 color = mix(getFromColor(sampleUv), getToColor(sampleUv), localP);
+  return vec4(color.rgb * vEff, color.a);
+}
+`,
+});
+//# sourceMappingURL=fly-eye.js.map

package/dist/transitions/fly-eye.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fly-eye.js","sourceRoot":"","sources":["../../src/transitions/fly-eye.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAE/C;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,MAAM,GAAG,gBAAgB,CAAC;IACrC,IAAI,EAAE,SAAS;IACf,QAAQ,EAAE;QACR,IAAI,EAAE,EAAE;QACR,QAAQ,EAAE,IAAI;QACd,OAAO,EAAE,GAAG;KACb;IACD,IAAI,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuCP;CACA,CAAC,CAAC"}

package/dist/transitions/glass-shatter.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Voronoi tessellation where each cell flips from from to to at its own
+ * randomised moment, with a soft temporal window so the flip isn't an
+ * instant step. Every pixel samples both source images at its own uv —
+ * no per-shard displacement — so adjacent cells never diverge into
+ * different sample positions and the Voronoi edges resolve cleanly
+ * without halos or ghost outlines.
+ *
+ * Optional env-map glint (reflection > 0): each shard gets a random
+ * "facet direction" which picks a different patch of the env map, and
+ * that reflection blends in strongest at the shard's own mid-flip
+ * moment — reads as broken mirror catching the light as each piece
+ * rotates through, not a coloured tile. Defaults to 0 (no reflection)
+ * so the transition is unchanged without an env map.
+ *
+ * Endpoints: each cell's flip moment is constrained to [flipWindow/2,
+ * 1 - flipWindow/2] with a small safety margin, so at progress 0/1 the
+ * smoothstep is saturated off/on for every cell AND the mid-flip
+ * glint envelope is zero for every cell.
+ */
+export declare const glassShatter: import("../types.js").Transition<import("@vysmo/gl-core").Widen<{
+    readonly cells: 14;
+    readonly reflection: 0;
+}>>;
+//# sourceMappingURL=glass-shatter.d.ts.map

package/dist/transitions/glass-shatter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"glass-shatter.d.ts","sourceRoot":"","sources":["../../src/transitions/glass-shatter.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,YAAY;;;GA+DvB,CAAC"}

package/dist/transitions/glass-shatter.js

@@ -0,0 +1,86 @@
+import { defineTransition } from "./define.js";
+/**
+ * Voronoi tessellation where each cell flips from from to to at its own
+ * randomised moment, with a soft temporal window so the flip isn't an
+ * instant step. Every pixel samples both source images at its own uv —
+ * no per-shard displacement — so adjacent cells never diverge into
+ * different sample positions and the Voronoi edges resolve cleanly
+ * without halos or ghost outlines.
+ *
+ * Optional env-map glint (reflection > 0): each shard gets a random
+ * "facet direction" which picks a different patch of the env map, and
+ * that reflection blends in strongest at the shard's own mid-flip
+ * moment — reads as broken mirror catching the light as each piece
+ * rotates through, not a coloured tile. Defaults to 0 (no reflection)
+ * so the transition is unchanged without an env map.
+ *
+ * Endpoints: each cell's flip moment is constrained to [flipWindow/2,
+ * 1 - flipWindow/2] with a small safety margin, so at progress 0/1 the
+ * smoothstep is saturated off/on for every cell AND the mid-flip
+ * glint envelope is zero for every cell.
+ */
+export const glassShatter = defineTransition({
+    name: "glass-shatter",
+    defaults: {
+        cells: 14,
+        reflection: 0.0,
+    },
+    glsl: `
+uniform float uCells;
+uniform float uReflection;
+const float uFlipWindow = 0.12;
+
+float hash21(vec2 p) {
+  return fract(sin(dot(p, vec2(12.9898, 78.233))) * 43758.5453);
+}
+vec2 hash22(vec2 p) {
+  return vec2(hash21(p), hash21(p + vec2(17.5, 31.3)));
+}
+
+vec4 transition(vec2 uv) {
+  float aspect = uResolution.x / uResolution.y;
+  vec2 freq = vec2(uCells * aspect, uCells);
+  vec2 p = uv * freq;
+  vec2 cellBase = floor(p);
+  vec2 local = fract(p);
+
+  // 3x3 neighbourhood search for the closest cell (Voronoi).
+  float dist1 = 999.0;
+  vec2 id1 = cellBase;
+  for (int j = -1; j <= 1; j++) {
+    for (int i = -1; i <= 1; i++) {
+      vec2 nId = cellBase + vec2(float(i), float(j));
+      vec2 jitter = hash22(nId);
+      vec2 nPos = vec2(float(i), float(j)) + jitter;
+      float d = length(nPos - local);
+      if (d < dist1) {
+        dist1 = d;
+        id1 = nId;
+      }
+    }
+  }
+
+  // Keep cell flip moments away from 0 and 1 with enough headroom for
+  // the window, plus a tiny safety margin so endpoints saturate cleanly.
+  float halfWin = uFlipWindow * 0.5;
+  float cellFlip = mix(halfWin + 0.02, 1.0 - halfWin - 0.02, hash21(id1 + vec2(0.31)));
+
+  float reveal = smoothstep(cellFlip - halfWin, cellFlip + halfWin, uProgress);
+  vec4 baseColor = mix(getFromColor(uv), getToColor(uv), reveal);
+
+  // Per-shard mirror glint: each shard has its own facet direction, and
+  // its reflection of the env map peaks at reveal=0.5 (the moment the
+  // shard flips). Reveal=0 or 1 → glintEnv=0, so endpoints stay clean.
+  if (uReflection > 0.0) {
+    vec2 facetDir = normalize(hash22(id1 + vec2(0.83)) * 2.0 - 1.0);
+    vec2 envUv = vec2(0.5 + 0.5 * facetDir.x, 0.5 - 0.5 * facetDir.y);
+    vec3 envColor = getEnvironment(envUv).rgb;
+    float glintEnv = 4.0 * reveal * (1.0 - reveal);
+    baseColor.rgb = mix(baseColor.rgb, envColor, glintEnv * uReflection);
+  }
+
+  return baseColor;
+}
+`,
+});
+//# sourceMappingURL=glass-shatter.js.map

package/dist/transitions/glass-shatter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"glass-shatter.js","sourceRoot":"","sources":["../../src/transitions/glass-shatter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAE/C;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,CAAC,MAAM,YAAY,GAAG,gBAAgB,CAAC;IAC3C,IAAI,EAAE,eAAe;IACrB,QAAQ,EAAE;QACR,KAAK,EAAE,EAAE;QACT,UAAU,EAAE,GAAG;KAChB;IACD,IAAI,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwDP;CACA,CAAC,CAAC"}

package/dist/transitions/glitch.d.ts

@@ -0,0 +1,6 @@
+export declare const glitch: import("../types.js").Transition<import("@vysmo/gl-core").Widen<{
+    readonly intensity: 0.6;
+    readonly chroma: 0.02;
+    readonly blocks: 30;
+}>>;
+//# sourceMappingURL=glitch.d.ts.map

package/dist/transitions/glitch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"glitch.d.ts","sourceRoot":"","sources":["../../src/transitions/glitch.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,MAAM;;;;GAwDjB,CAAC"}

package/dist/transitions/glitch.js

@@ -0,0 +1,59 @@
+import { defineTransition } from "./define.js";
+export const glitch = defineTransition({
+    name: "glitch",
+    defaults: {
+        intensity: 0.6,
+        chroma: 0.02,
+        blocks: 30,
+    },
+    glsl: `
+uniform float uIntensity;
+uniform float uChroma;
+uniform float uBlocks;
+
+float hash11(float n) { return fract(sin(n * 12.9898) * 43758.5453); }
+float hash21(vec2 p) { return fract(sin(dot(p, vec2(12.9898, 78.233))) * 43758.5453); }
+
+vec4 transition(vec2 uv) {
+  // Envelope: ramps up to max at midpoint, zero at endpoints.
+  float envelope = 4.0 * uProgress * (1.0 - uProgress);
+  float glitchAmt = uIntensity * envelope;
+
+  // Per-stripe horizontal displacement; stripe layout evolves over time.
+  float stripeId = floor(uv.y * uBlocks);
+  float timeStep = floor(uProgress * 24.0);
+  float stripeSeed = hash21(vec2(stripeId, timeStep));
+  float displaceActive = step(0.6, stripeSeed);
+  float displaceAmount = (hash11(stripeSeed + 1.0) - 0.5) * 0.12 * glitchAmt * displaceActive;
+
+  vec2 displacedUv = vec2(uv.x + displaceAmount, uv.y);
+  vec2 clamped = clamp(displacedUv, 0.0, 1.0);
+
+  // RGB channel split scales with glitch amount. chroma is the per-channel
+  // UV offset multiplier — capped at 0.05; past that, R/B samples come from
+  // unrelated parts of the scene and edge-clamping creates color stripes
+  // instead of reading as glitch chromatic aberration.
+  float chromaOffset = glitchAmt * min(uChroma, 0.05);
+  vec2 offR = clamp(displacedUv + vec2(chromaOffset, 0.0), 0.0, 1.0);
+  vec2 offB = clamp(displacedUv - vec2(chromaOffset, 0.0), 0.0, 1.0);
+
+  vec3 fromRgb = vec3(
+    getFromColor(offR).r,
+    getFromColor(clamped).g,
+    getFromColor(offB).b
+  );
+  vec3 toRgb = vec3(
+    getToColor(offR).r,
+    getToColor(clamped).g,
+    getToColor(offB).b
+  );
+
+  // Hard-ish crossover concentrated in the middle 20% for a "cut" feel.
+  float mixW = smoothstep(0.45, 0.55, uProgress);
+  vec3 rgb = mix(fromRgb, toRgb, mixW);
+
+  return vec4(rgb, 1.0);
+}
+`,
+});
+//# sourceMappingURL=glitch.js.map

package/dist/transitions/glitch.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"glitch.js","sourceRoot":"","sources":["../../src/transitions/glitch.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAE/C,MAAM,CAAC,MAAM,MAAM,GAAG,gBAAgB,CAAC;IACrC,IAAI,EAAE,QAAQ;IACd,QAAQ,EAAE;QACR,SAAS,EAAE,GAAG;QACd,MAAM,EAAE,IAAI;QACZ,MAAM,EAAE,EAAE;KACX;IACD,IAAI,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgDP;CACA,CAAC,CAAC"}

package/dist/transitions/god-rays-reveal.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Multi-pass transition. As to reveals through a noise mask, its
+ * bright highlights emit volumetric-looking light shafts toward a
+ * source point, built up by iterative radial blur — each pass samples
+ * from the previous pass's output at progressively finer steps along
+ * the ray from every pixel to the source. Impossible single-pass: a
+ * full-length radial streak would need ~30 samples across the ray,
+ * and after five iterations of 6 samples each, the shafts have
+ * progressively-refined spatial frequencies that a one-pass sampling
+ * of the source texture cannot produce.
+ *
+ *   pass 0               — seed: to-highlights gated by the reveal
+ *                          mask AND a 4·p·(1-p) envelope.
+ *   pass 1..passCount-2  — iterative radial blur. Pass i samples 6
+ *                          points along uv→source at step = 1/(5 · 2^(i-1)),
+ *                          reading from uPrevious so the shafts
+ *                          accumulate across passes.
+ *   final pass           — composite = mix(from, to, mask) +
+ *                          rays * intensity.
+ *
+ * Endpoints: seed envelope is 0 at progress 0 and 1, so the blur
+ * chain carries zeros and the composite resolves to pure from/to.
+ */
+export declare const godRaysReveal: import("../types.js").Transition<import("@vysmo/gl-core").Widen<{
+    readonly scale: 5;
+    readonly softness: 0.08;
+    readonly threshold: 0.45;
+    readonly intensity: 1.6;
+    readonly decay: 0.92;
+    readonly source: readonly [0.5, 0.5];
+}>>;
+//# sourceMappingURL=god-rays-reveal.d.ts.map

package/dist/transitions/god-rays-reveal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"god-rays-reveal.d.ts","sourceRoot":"","sources":["../../src/transitions/god-rays-reveal.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,eAAO,MAAM,aAAa;;;;;;;GAoFxB,CAAC"}