gl-transitions 1.74.0 → 1.76.0

package/glsl3/RotateScaleVanish.glsl

@@ -0,0 +1,42 @@
+// RotateScaleVanish — GLSL ES 3.00, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/RotateScaleVanish.glsl
+// Author: Mark Craig
+// mrmcsoftware on github and youtube ( http://www.youtube.com/MrMcSoftware )
+// License: MIT
+// Description: The outgoing image spins and shrinks away over the incoming one
+// Tags: rotate, zoom, spin
+
+// RotateScaleVanish Transition by Mark Craig (Copyright © 2022)
+
+// @param Fade in the incoming image
+uniform bool FadeInSecond; // = true
+// @param Run the effect in reverse
+uniform bool ReverseEffect; // = false
+// @param Rotate the other way
+uniform bool ReverseRotation; // = false
+
+#define M_PI 3.14159265358979323846
+#define _TWOPI 6.283185307179586476925286766559
+
+vec4 transition(vec2 uv)
+{
+vec2 iResolution = vec2(ratio, 1.0);
+float t = ReverseEffect ? 1.0 - progress : progress;
+float theta = ReverseRotation ? _TWOPI * t : -_TWOPI * t;
+float c1 = cos(theta);
+float s1 = sin(theta);
+float rad = max(0.00001, 1.0 - t);
+float xc1 = (uv.x - 0.5) * iResolution.x;
+float yc1 = (uv.y - 0.5) * iResolution.y;
+float xc2 = (xc1 * c1 - yc1 * s1) / rad;
+float yc2 = (xc1 * s1 + yc1 * c1) / rad;
+vec2 uv2 = vec2(xc2 + iResolution.x / 2.0, yc2 + iResolution.y / 2.0);
+vec4 col3;
+vec4 ColorTo = ReverseEffect ? getFromColor(uv) : getToColor(uv);
+if ((uv2.x >= 0.0) && (uv2.x <= iResolution.x) && (uv2.y >= 0.0) && (uv2.y <= iResolution.y))
+	{
+	uv2 /= iResolution;
+	col3 = ReverseEffect ? getToColor(uv2) : getFromColor(uv2);
+	}
+else { col3 = FadeInSecond ? vec4(0.0, 0.0, 0.0, 1.0) : ColorTo; }
+return((1.0 - t) * col3 + t * ColorTo); // could have used mix
+}

package/glsl3/SimpleFlip.glsl

@@ -0,0 +1,14 @@
+// SimpleFlip — GLSL ES 3.00, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/SimpleFlip.glsl
+// Author: nwoeanhinnogaehr
+// License: MIT
+// Description: The outgoing image flips around the vertical axis into the incoming one
+// Tags: flip, horizontal
+// Ported from https://gist.github.com/nwoeanhinnogaehr/408045772d255df97520
+
+vec4 transition(vec2 uv) {
+  vec2 q = uv;
+  uv.x = (uv.x - 0.5) / abs(progress - 0.5) * 0.5 + 0.5;
+  vec4 a = getFromColor(uv);
+  vec4 b = getToColor(uv);
+  return vec4(mix(a, b, step(0.5, progress)).rgb * step(abs(q.x - 0.5), abs(progress - 0.5)), 1.0);
+}

package/glsl3/SimpleZoom.glsl

@@ -0,0 +1,20 @@
+// SimpleZoom — GLSL ES 3.00, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/SimpleZoom.glsl
+// Author: 0gust1
+// License: MIT
+// Description: Zooms into the outgoing image, then fades to the incoming one
+// Tags: zoom, fade
+
+// @range(0.2, 1) Part of the transition spent zooming
+uniform float zoom_quickness; // = 0.8
+vec2 zoom(vec2 uv, float amount) {
+  return 0.5 + ((uv - 0.5) * (1.0-amount));	
+}
+
+vec4 transition (vec2 uv) {
+  float nQuick = clamp(zoom_quickness,0.2,1.0);
+  return mix(
+    getFromColor(zoom(uv, smoothstep(0.0, nQuick, progress))),
+    getToColor(uv),
+   smoothstep(nQuick-0.2, 1.0, progress)
+  );
+}

package/glsl3/SimpleZoomOut.glsl

@@ -0,0 +1,23 @@
+// SimpleZoomOut — GLSL ES 3.00, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/SimpleZoomOut.glsl
+// Author: Tianshuo
+// License: MIT
+// Description: The incoming image zooms out into place while fading in
+// Tags: zoom, fade
+
+
+// @range(0.2, 1) Part of the transition spent zooming
+uniform float zoom_quickness; // = 0.8
+// @param Fade instead of cutting to the incoming image
+uniform bool fade; // = true
+vec2 zoom(vec2 uv, float amount) {
+  return 0.5 + ((uv - 0.5) * (1.0-amount));	
+}
+
+vec4 transition (vec2 uv) {
+  float nQuick = clamp(zoom_quickness,0.2,1.0);
+  return mix(
+    getFromColor(uv),
+    getToColor(zoom(uv,1.-smoothstep(1.-nQuick, 1., progress))),
+   fade?smoothstep(1.0-nQuick, 1., progress):(progress<1.0-nQuick?0.0:1.0)
+  );
+}

package/glsl3/Slides.glsl

@@ -0,0 +1,41 @@
+// Slides — GLSL ES 3.00, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/Slides.glsl
+// Author: Mark Craig
+// mrmcsoftware on github and youtube ( http://www.youtube.com/MrMcSoftware )
+// License: MIT
+// Description: The outgoing image slides out, or the incoming one slides in, toward an edge, a corner or the center
+// Tags: slide, directional
+
+// Slides Transition by Mark Craig (Copyright © 2022)
+
+uniform int type; // = 0
+// @param Slide the incoming image in instead of the outgoing one out
+uniform bool In; // = false
+// type: slide to/from which edge, which corner, or center
+// In: if true slide new image in, otherwise slide old image out
+
+#define rad2 rad / 2.0
+
+vec4 transition(vec2 uv)
+{
+vec2 uv0 = uv;
+float rad = In ? progress : 1.0 - progress;
+float xc1, yc1;
+// I used if/else instead of switch in case it's an old GPU
+if (type == 0) { xc1 = .5 - rad2; yc1 = 0.0; }
+else if (type == 1) { xc1 = 1.0 - rad; yc1 = .5 - rad2; }
+else if (type == 2) { xc1 = .5 - rad2; yc1 = 1.0 - rad; }
+else if (type == 3) { xc1 = 0.0; yc1 = .5 - rad2; }
+else if (type == 4) { xc1 = 1.0 - rad; yc1 = 0.0; }
+else if (type == 5) { xc1 = 1.0 - rad; yc1 = 1.0 - rad; }
+else if (type == 6) { xc1 = 0.0; yc1 = 1.0 - rad; }
+else if (type == 7) { xc1 = 0.0; yc1 = 0.0; }
+else if (type == 8) { xc1 = .5 - rad2; yc1 = .5 - rad2; }
+uv.y = 1.0 - uv.y;
+vec2 uv2;
+if ((uv.x >= xc1) && (uv.x <= xc1 + rad) && (uv.y >= yc1) && (uv.y <= yc1 + rad))
+	{
+	uv2 = vec2((uv.x - xc1) / rad, 1.0 - (uv.y - yc1) / rad);
+	return(In ? getToColor(uv2) : getFromColor(uv2));
+	}
+return(In ? getFromColor(uv0) : getToColor(uv0));
+}

package/glsl3/StarWipe.glsl

@@ -0,0 +1,51 @@
+// StarWipe — GLSL ES 3.00, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/StarWipe.glsl
+// Author: Ben Lucas
+// License: MIT
+// Description: A growing star reveals the incoming image
+// Tags: wipe, shape, star
+#define PI 3.141592653589793
+#define STAR_ANGLE 1.2566370614359172
+
+// @param Thickness of the star's border
+uniform float border_thickness;// = 0.01
+uniform float star_rotation;// = 0.75
+// @color Color of the star's border
+uniform vec4 border_color; // = vec4(1.0)
+// @param Center of the star
+uniform vec2 star_center;// = vec2(0.5)
+
+vec2 rotate(vec2 v, float theta) {
+    float cosTheta = cos(theta);
+    float sinTheta = sin(theta);
+
+    return vec2(
+        cosTheta * v.x - sinTheta * v.y,
+        sinTheta * v.x + cosTheta * v.y
+    );
+}
+
+bool inStar(vec2 uv, vec2 center, float radius){
+  vec2 uv_centered = uv - center;
+  uv_centered = rotate(uv_centered, star_rotation * STAR_ANGLE);
+  float theta = atan(uv_centered.y, uv_centered.x) + PI;
+
+  vec2 uv_rotated = rotate(uv_centered, -STAR_ANGLE * (floor(theta / STAR_ANGLE) + 0.5));
+
+  float slope = 0.3;
+  if(uv_rotated.y > 0.0){
+      return (radius + uv_rotated.x * slope > uv_rotated.y);
+  } else {
+     return (-radius - uv_rotated.x * slope < uv_rotated.y);
+  }
+}
+
+vec4 transition (vec2 uv) {
+  float progressScaled = (2.0 * border_thickness + 1.0) * progress - border_thickness;
+  if(inStar(uv, star_center, progressScaled)){
+    return getToColor(uv);
+  } else if(inStar(uv, star_center, progressScaled+border_thickness)){
+    return border_color;
+  } else {
+    return getFromColor(uv);
+  }
+}

package/glsl3/StaticFade.glsl

@@ -0,0 +1,47 @@
+// StaticFade — GLSL ES 3.00, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/StaticFade.glsl
+// Author: Ben Lucas
+// License: MIT
+// Description: Cuts to the incoming image halfway, hidden behind a burst of TV static
+// Tags: static, noise, retro
+
+uniform float n_noise_pixels ; // = 200.0
+uniform float static_luminosity ; // = 0.8
+
+float rnd (vec2 st) {
+    return fract(sin(dot(st.xy,
+                         vec2(10.5302340293,70.23492931)))*
+        12345.5453123);
+}
+
+vec4 staticNoise (vec2 st, float offset, float luminosity) {
+  float staticR = luminosity * rnd(st * vec2(offset * 2.0, offset * 3.0));
+  float staticG = luminosity * rnd(st * vec2(offset * 3.0, offset * 5.0));
+  float staticB = luminosity * rnd(st * vec2(offset * 5.0, offset * 7.0));
+  return vec4(staticR, staticG, staticB, 1.0);
+}
+
+float staticIntensity(float t)
+{
+  float transitionProgress = abs(2.0*(t-0.5));
+  float transformedThreshold =1.2*(1.0 - transitionProgress)-0.1;
+  return min(1.0, transformedThreshold);
+}
+  
+vec4 transition (vec2 uv) {
+
+  float baseMix = step(0.5, progress);
+  vec4 transitionMix = mix(
+    getFromColor(uv),
+    getToColor(uv),
+    baseMix
+  );
+  
+  vec2 uvStatic = floor(uv * n_noise_pixels)/n_noise_pixels;
+  
+  vec4 staticColor = staticNoise(uvStatic, progress, static_luminosity);
+
+  float staticThresh = staticIntensity(progress);
+  float staticMix = step(rnd(uvStatic), staticThresh);
+
+  return mix(transitionMix, staticColor, staticMix);
+}

package/glsl3/StereoViewer.glsl

@@ -0,0 +1,214 @@
+// StereoViewer — GLSL ES 3.00, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/StereoViewer.glsl
+// Tunable parameters
+// How much to zoom (out) for the effect ~ 0.5 - 1.0
+// @range(0.5, 1) How much the images zoom out
+uniform float zoom; // = 0.88
+// Corner radius as a fraction of the image height
+uniform float corner_radius;  // = 0.22
+
+// Author: Ted Schundler
+// License: BSD 2 Clause
+// Description: Both images shrink into rounded cards that swap, like a stereo viewer toy
+// Tags: cards, zoom, retro
+// Free for use and modification by anyone with credit
+
+// Copyright (c) 2016, Theodore K Schundler
+// All rights reserved.
+
+// Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+
+// 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+
+// 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+///////////////////////////////////////////////////////////////////////////////
+// Stereo Viewer Toy Transition                                              //
+//                                                                           //
+// Inspired by ViewMaster / Image3D image viewer devices.                    //
+// This effect is similar to what you see when you press the device's lever. //
+// There is a quick zoom in / out to make the transition 'valid' for GLSL.io //
+///////////////////////////////////////////////////////////////////////////////
+
+const vec4 black = vec4(0.0, 0.0, 0.0, 1.0);
+const vec2 c00 = vec2(0.0, 0.0); // the four corner points
+const vec2 c01 = vec2(0.0, 1.0);
+const vec2 c11 = vec2(1.0, 1.0);
+const vec2 c10 = vec2(1.0, 0.0);
+
+// Check if a point is within a given corner
+bool in_corner(vec2 p, vec2 corner, vec2 radius) {
+  // determine the direction we want to be filled
+  vec2 axis = (c11 - corner) - corner;
+
+  // warp the point so we are always testing the bottom left point with the
+  // circle centered on the origin
+  p = p - (corner + axis * radius);
+  p *= axis / radius;
+  return (p.x > 0.0 && p.y > -1.0) || (p.y > 0.0 && p.x > -1.0) || dot(p, p) < 1.0;
+}
+
+// Check all four corners
+// return a float for v2 for anti-aliasing?
+bool test_rounded_mask(vec2 p, vec2 corner_size) {
+  return
+      in_corner(p, c00, corner_size) &&
+      in_corner(p, c01, corner_size) &&
+      in_corner(p, c10, corner_size) &&
+      in_corner(p, c11, corner_size);
+}
+
+// Screen blend mode - https://en.wikipedia.org/wiki/Blend_modes
+// This more closely approximates what you see than linear blending
+vec4 screen(vec4 a, vec4 b) {
+  return 1.0 - (1.0 - a) * (1.0 -b);
+}
+
+// Given RGBA, find a value that when screened with itself
+// will yield the original value.
+vec4 unscreen(vec4 c) {
+  return 1.0 - sqrt(1.0 - c);
+}
+
+// Grab a pixel, only if it isn't masked out by the rounded corners
+vec4 sample_with_corners_from(vec2 p, vec2 corner_size) {
+  p = (p - 0.5) / zoom + 0.5;
+  if (!test_rounded_mask(p, corner_size)) {
+    return black;
+  }
+  return unscreen(getFromColor(p));
+}
+
+vec4 sample_with_corners_to(vec2 p, vec2 corner_size) {
+  p = (p - 0.5) / zoom + 0.5;
+  if (!test_rounded_mask(p, corner_size)) {
+    return black;
+  }
+  return unscreen(getToColor(p));
+}
+
+// special sampling used when zooming - extra zoom parameter and don't unscreen
+vec4 simple_sample_with_corners_from(vec2 p, vec2 corner_size, float zoom_amt) {
+  p = (p - 0.5) / (1.0 - zoom_amt + zoom * zoom_amt) + 0.5;
+  if (!test_rounded_mask(p, corner_size)) {
+    return black;
+  }
+  return getFromColor(p);
+}
+
+vec4 simple_sample_with_corners_to(vec2 p, vec2 corner_size, float zoom_amt) {
+  p = (p - 0.5) / (1.0 - zoom_amt + zoom * zoom_amt) + 0.5;
+  if (!test_rounded_mask(p, corner_size)) {
+    return black;
+  }
+  return getToColor(p);
+}
+
+// Basic 2D affine transform matrix helpers
+// These really shouldn't be used in a fragment shader - I should work out the
+// the math for a translate & rotate function as a pair of dot products instead
+
+mat3 rotate2d(float angle, float ratio) {
+  float s = sin(angle);
+  float c = cos(angle);
+  return mat3(
+    c, s ,0.0,
+    -s, c, 0.0,
+    0.0, 0.0, 1.0);
+}
+
+mat3 translate2d(float x, float y) {
+  return mat3(
+    1.0, 0.0, 0,
+    0.0, 1.0, 0,
+    -x, -y, 1.0);
+}
+
+mat3 scale2d(float x, float y) {
+  return mat3(
+    x, 0.0, 0,
+    0.0, y, 0,
+    0, 0, 1.0);
+}
+
+// Split an image and rotate one up and one down along off screen pivot points
+vec4 get_cross_rotated(vec3 p3, float angle, vec2 corner_size, float ratio) {
+  angle = angle * angle; // easing
+  angle /= 2.4; // works out to be a good number of radians
+
+  mat3 center_and_scale = translate2d(-0.5, -0.5) * scale2d(1.0, ratio);
+  mat3 unscale_and_uncenter = scale2d(1.0, 1.0/ratio) * translate2d(0.5,0.5);
+  mat3 slide_left = translate2d(-2.0,0.0);
+  mat3 slide_right = translate2d(2.0,0.0);
+  mat3 rotate = rotate2d(angle, ratio);
+
+  mat3 op_a = center_and_scale * slide_right * rotate * slide_left * unscale_and_uncenter;
+  mat3 op_b = center_and_scale * slide_left * rotate * slide_right * unscale_and_uncenter;
+
+  vec4 a = sample_with_corners_from((op_a * p3).xy, corner_size);
+  vec4 b = sample_with_corners_from((op_b * p3).xy, corner_size);
+
+  return screen(a, b);
+}
+
+// Image stays put, but this time move two masks
+vec4 get_cross_masked(vec3 p3, float angle, vec2 corner_size, float ratio) {
+  angle = 1.0 - angle;
+  angle = angle * angle; // easing
+  angle /= 2.4;
+
+  vec4 img;
+
+  mat3 center_and_scale = translate2d(-0.5, -0.5) * scale2d(1.0, ratio);
+  mat3 unscale_and_uncenter = scale2d(1.0 / zoom, 1.0 / (zoom * ratio)) * translate2d(0.5,0.5);
+  mat3 slide_left = translate2d(-2.0,0.0);
+  mat3 slide_right = translate2d(2.0,0.0);
+  mat3 rotate = rotate2d(angle, ratio);
+
+  mat3 op_a = center_and_scale * slide_right * rotate * slide_left * unscale_and_uncenter;
+  mat3 op_b = center_and_scale * slide_left * rotate * slide_right * unscale_and_uncenter;
+
+  bool mask_a = test_rounded_mask((op_a * p3).xy, corner_size);
+  bool mask_b = test_rounded_mask((op_b * p3).xy, corner_size);
+
+  if (mask_a || mask_b) {
+    img = sample_with_corners_to(p3.xy, corner_size);
+    return screen(mask_a ? img : black, mask_b ? img : black);
+  } else {
+    return black;
+  }
+}
+
+vec4 transition(vec2 uv) {
+  float a;
+  vec2 p=uv.xy/vec2(1.0).xy;
+  vec3 p3 = vec3(p.xy, 1.0); // for 2D matrix transforms
+
+  // corner is warped to represent to size after mapping to 1.0, 1.0
+  vec2 corner_size = vec2(corner_radius / ratio, corner_radius);
+
+  if (progress <= 0.0) {
+    // 0.0: start with the base frame always
+    return getFromColor(p);
+  } else if (progress < 0.1) {
+    // 0.0-0.1: zoom out and add rounded corners
+    a = progress / 0.1;
+    return  simple_sample_with_corners_from(p, corner_size * a, a);
+  } else if (progress < 0.48) {
+    // 0.1-0.48: Split original image apart
+    a = (progress - 0.1)/0.38;
+    return get_cross_rotated(p3, a, corner_size, ratio);
+  } else if (progress < 0.9) {
+    // 0.48-0.52: black
+    // 0.52 - 0.9: unmask new image
+    return get_cross_masked(p3, (progress - 0.52)/0.38, corner_size, ratio);
+  } else if (progress < 1.0) {
+    // zoom out and add rounded corners
+    a = (1.0 - progress) / 0.1;
+    return simple_sample_with_corners_to(p, corner_size * a, a);
+  } else {
+    // 1.0 end with base frame
+    return getToColor(p);
+  }
+}

package/glsl3/StripDatamoshGlitch.glsl

@@ -0,0 +1,187 @@
+// StripDatamoshGlitch — GLSL ES 3.00, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/StripDatamoshGlitch.glsl
+// Author: bread
+// License: MIT
+// Description: A datamosh glitch: torn strips, chroma shifts and scan noise drag the outgoing image into the incoming one
+// Tags: glitch, datamosh, chromatic
+
+uniform float strength;       // = 1.0
+uniform float horizontalBars; // = 42.0
+uniform float verticalSlits;  // = 18.0
+uniform float tear;           // = 0.18
+uniform float chroma;         // = 0.032
+uniform float residue;        // = 0.62
+uniform float noiseAmount;    // = 0.16
+uniform float scanAmount;     // = 0.13
+uniform float flashAmount;    // = 0.20
+
+const float PI = 3.141592653589793;
+
+float hash(float n) {
+  return fract(sin(n) * 43758.5453123);
+}
+
+float hash(vec2 p) {
+  return fract(sin(dot(p, vec2(127.1, 311.7))) * 43758.5453123);
+}
+
+float sat(float v) {
+  return clamp(v, 0.0, 1.0);
+}
+
+float burst() {
+  return pow(max(0.0, sin(progress * PI)), 0.42) * strength;
+}
+
+vec2 safeUv(vec2 uv) {
+  return clamp(uv, vec2(0.0), vec2(1.0));
+}
+
+float stripeY(vec2 uv, float density, float seed, float minWidth, float maxWidth) {
+  float y = uv.y * density + seed * 0.137;
+  float id = floor(y);
+  float f = fract(y);
+  float c = hash(vec2(id, seed));
+  float w = mix(minWidth, maxWidth, hash(vec2(id + 9.17, seed + 2.31)));
+  return 1.0 - smoothstep(w, w + 0.018, abs(f - c));
+}
+
+float stripeX(vec2 uv, float density, float seed, float minWidth, float maxWidth) {
+  float x = uv.x * density + seed * 0.091;
+  float id = floor(x);
+  float f = fract(x);
+  float c = hash(vec2(id, seed + 41.0));
+  float w = mix(minWidth, maxWidth, hash(vec2(id + 4.7, seed + 8.9)));
+  return 1.0 - smoothstep(w, w + 0.012, abs(f - c));
+}
+
+float brokenGate(vec2 uv, float row, float rnd, float frame) {
+  float segs = mix(1.0, 9.0, hash(vec2(row, frame + 44.0)));
+  float seg = floor(uv.x * segs);
+  return step(0.16, hash(vec2(seg, row + frame * 3.0 + rnd)));
+}
+
+float horizontalMask(vec2 uv, float frame) {
+  float r1 = floor((uv.y + hash(frame) * 0.031) * horizontalBars * 0.38);
+  float r2 = floor((uv.y + hash(frame + 2.0) * 0.013) * horizontalBars);
+  float r3 = floor((uv.y + hash(frame + 7.0) * 0.006) * horizontalBars * 3.4);
+
+  float thick = stripeY(uv, horizontalBars * 0.38, frame + 1.0, 0.035, 0.22);
+  float mid   = stripeY(uv, horizontalBars,        frame + 4.0, 0.014, 0.11);
+  float hair  = stripeY(uv, horizontalBars * 3.4,  frame + 9.0, 0.004, 0.035);
+
+  thick *= step(0.42, hash(vec2(r1, frame + 10.0)));
+  mid   *= step(0.48, hash(vec2(r2, frame + 20.0)));
+  hair  *= step(0.62, hash(vec2(r3, frame + 30.0)));
+
+  thick *= brokenGate(uv, r1, hash(vec2(r1, frame)), frame);
+  mid   *= brokenGate(uv, r2, hash(vec2(r2, frame)), frame + 3.0);
+
+  return sat(max(thick, max(mid, hair)));
+}
+
+float verticalMask(vec2 uv, float frame) {
+  float col = floor((uv.x + hash(frame + 12.0) * 0.017) * verticalSlits);
+  float slit = stripeX(uv, verticalSlits, frame + 13.0, 0.01, 0.075);
+  slit *= step(0.66, hash(vec2(col, frame + 19.0)));
+  return sat(slit);
+}
+
+vec4 chromaFrom(vec2 uv, vec2 s) {
+  uv = safeUv(uv);
+  return vec4(
+    getFromColor(safeUv(uv + s)).r,
+    getFromColor(uv).g,
+    getFromColor(safeUv(uv - s)).b,
+    1.0
+  );
+}
+
+vec4 chromaTo(vec2 uv, vec2 s) {
+  uv = safeUv(uv);
+  return vec4(
+    getToColor(safeUv(uv - s)).r,
+    getToColor(uv).g,
+    getToColor(safeUv(uv + s)).b,
+    1.0
+  );
+}
+
+vec2 distortUv(vec2 uv, float dir, float b, float h, float v, float frame) {
+  float row = floor(uv.y * horizontalBars);
+  float col = floor(uv.x * verticalSlits);
+
+  float rowRnd = hash(vec2(row, frame));
+  float colRnd = hash(vec2(col, frame + 27.0));
+
+  float xTear = (rowRnd - 0.5) * 2.0 * tear * b * h;
+  xTear += sin(uv.y * 120.0 + progress * 95.0) * 0.006 * b;
+
+  float yDrag = (colRnd - 0.5) * 0.13 * b * v;
+  float micro = (hash(vec2(row, col + frame)) - 0.5) * 0.018 * b * max(h, v);
+
+  return uv + vec2(xTear * dir + micro, yDrag);
+}
+
+vec4 transition(vec2 uv) {
+  if (progress <= 0.0) return getFromColor(uv);
+  if (progress >= 1.0) return getToColor(uv);
+
+  float b = burst();
+  float frame = floor(progress * 30.0);
+
+  float h = horizontalMask(uv, frame);
+  float v = verticalMask(uv, frame);
+  float glitch = sat(max(h, v * 0.75));
+
+  float row = floor(uv.y * horizontalBars);
+  float rowRnd = hash(vec2(row, frame + 5.0));
+
+  float bandDelay = (rowRnd - 0.5) * 0.30 * h;
+  float reveal = smoothstep(0.18, 0.84, progress + bandDelay);
+
+  vec2 split = vec2(chroma * b * (1.0 + 1.7 * glitch), chroma * 0.22 * b * v);
+
+  vec2 fromUv = distortUv(uv,  1.0, b, h, v, frame);
+  vec2 toUv   = distortUv(uv, -1.0, b, h, v, frame);
+
+  vec4 color = mix(
+    chromaFrom(fromUv, split),
+    chromaTo(toUv, split),
+    reveal
+  );
+
+  // Horizontal time-slice residue: old/new frames dragged through uneven scan bands.
+  vec2 smearUv = uv;
+  smearUv.x += (rowRnd - 0.5) * 0.46 * b * h;
+  smearUv.y += (hash(vec2(row, frame + 31.0)) - 0.5) * 0.045 * b * h;
+
+  float sliceReveal = smoothstep(0.28, 0.78, progress + (rowRnd - 0.5) * 0.22);
+  vec4 sliceColor = mix(
+    chromaFrom(smearUv, split * 1.65),
+    chromaTo(smearUv - vec2((rowRnd - 0.5) * 0.18 * b, 0.0), split * 1.65),
+    sliceReveal
+  );
+
+  color = mix(color, sliceColor, h * b * residue);
+
+  // Thin scan sparks and broken white lines, like the reference clip's bright horizontal noise.
+  float hairLine = stripeY(uv, 190.0, frame + 55.0, 0.002, 0.012);
+  hairLine *= step(0.70, hash(vec2(floor(uv.y * 190.0), frame + 56.0)));
+  color.rgb += vec3(0.72, 0.90, 1.0) * hairLine * b * 0.28;
+
+  float scan = 0.5 + 0.5 * sin(uv.y * 980.0 + progress * 130.0);
+  color.rgb *= 1.0 - scanAmount * b * scan;
+
+  vec2 nCell = floor(uv * vec2(360.0 * ratio, 210.0));
+  float n = hash(nCell + vec2(frame * 7.0, frame * 13.0));
+  color.rgb += (n - 0.5) * noiseAmount * b * (0.55 + glitch);
+
+  // Slight desaturation during the damage peak makes it feel more like broadcast/video signal corruption.
+  float luma = dot(color.rgb, vec3(0.299, 0.587, 0.114));
+  color.rgb = mix(color.rgb, vec3(luma), 0.18 * b * glitch);
+
+  float strobe = step(0.78, hash(vec2(frame, 3.14))) * pow(b, 1.65);
+  color.rgb += vec3(strobe * flashAmount);
+
+  return vec4(clamp(color.rgb, vec3(0.0), vec3(1.0)), 1.0);
+}

package/glsl3/Swirl.glsl

@@ -0,0 +1,34 @@
+// Swirl — GLSL ES 3.00, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/Swirl.glsl
+// License: MIT
+// Author: Sergey Kosarevsky
+// Description: Both images swirl around the center while crossfading
+// Tags: swirl, rotate, blend
+// ( http://www.linderdaum.com )
+// ported by gre from https://gist.github.com/corporateshark/cacfedb8cca0f5ce3f7c
+
+vec4 transition(vec2 UV)
+{
+	float Radius = 1.0;
+
+	float T = progress;
+
+	UV -= vec2( 0.5, 0.5 );
+
+	float Dist = length(UV);
+
+	if ( Dist < Radius )
+	{
+		float Percent = (Radius - Dist) / Radius;
+		float A = ( T <= 0.5 ) ? mix( 0.0, 1.0, T/0.5 ) : mix( 1.0, 0.0, (T-0.5)/0.5 );
+		float Theta = Percent * Percent * A * 8.0 * 3.14159;
+		float S = sin( Theta );
+		float C = cos( Theta );
+		UV = vec2( dot(UV, vec2(C, -S)), dot(UV, vec2(S, C)) );
+	}
+	UV += vec2( 0.5, 0.5 );
+
+	vec4 C0 = getFromColor(UV);
+	vec4 C1 = getToColor(UV);
+
+	return mix( C0, C1, T );
+}