gl-transitions 1.74.0 → 1.76.0

package/glsl3/Directional.glsl

@@ -0,0 +1,18 @@
+// Directional — GLSL ES 3.00, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/Directional.glsl
+// Author: Gaëtan Renaudeau
+// License: MIT
+// Description: The incoming image pushes the outgoing one out in a given direction
+// Tags: slide, push, directional
+
+// @param Direction of the movement
+uniform vec2 direction; // = vec2(0.0, 1.0)
+
+vec4 transition (vec2 uv) {
+  vec2 p = uv + progress * sign(direction);
+  vec2 f = fract(p);
+  return mix(
+    getToColor(f),
+    getFromColor(f),
+    step(0.0, p.y) * step(p.y, 1.0) * step(0.0, p.x) * step(p.x, 1.0)
+  );
+}

package/glsl3/DirectionalScaled.glsl

@@ -0,0 +1,35 @@
+// DirectionalScaled — GLSL ES 3.00, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/DirectionalScaled.glsl
+// Author: Thibaut Foussard
+// based on Directional transition by Gaëtan Renaudeau
+// https://gl-transitions.com/editor/Directional
+// License: MIT
+// Description: Like Directional, with both images scaled down while they slide
+// Tags: slide, push, zoom, directional
+
+#define PI acos(-1.0)
+
+// @param Direction of the movement
+uniform vec2 direction; // = vec2(0.0, 1.0)
+uniform float scale; // = .7
+
+float parabola(float x) {
+  float y = pow(sin(x * PI), 1.);
+  return y;
+}
+
+vec4 transition (vec2 uv) {
+  float easedProgress = pow(sin(progress  * PI / 2.), 3.);
+  vec2 p = uv + easedProgress * sign(direction);
+  vec2 f = fract(p);
+  
+  float s = 1. - (1. - (1. / scale)) * parabola(progress);
+  f = (f - 0.5) * s  + 0.5;
+  
+  float mixer = step(0.0, p.y) * step(p.y, 1.0) * step(0.0, p.x) * step(p.x, 1.0);
+  vec4 col = mix(getToColor(f), getFromColor(f), mixer);
+  
+  float border = step(0., f.x) * step(0., (1. - f.x)) * step(0., f.y) * step(0., 1. - f.y);
+  col *= border;
+  
+  return col;
+}

package/glsl3/DoomScreenTransition.glsl

@@ -0,0 +1,62 @@
+// DoomScreenTransition — GLSL ES 3.00, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/DoomScreenTransition.glsl
+// Author: Zeh Fernando
+// License: MIT
+// Description: The outgoing image melts down in uneven columns, like the Doom screen wipe
+// Tags: melt, columns, retro
+
+
+// Transition parameters --------
+
+// Number of total bars/columns
+uniform int bars; // = 30
+
+// Multiplier for speed ratio. 0 = no variation when going down, higher = some elements go much faster
+uniform float amplitude; // = 2
+
+// Further variations in speed. 0 = no noise, 1 = super noisy (ignore frequency)
+uniform float noise; // = 0.1
+
+// Speed variation horizontally. the bigger the value, the shorter the waves
+uniform float frequency; // = 0.5
+
+// How much the bars seem to "run" from the middle of the screen first (sticking to the sides). 0 = no drip, 1 = curved drip
+uniform float dripScale; // = 0.5
+
+
+// The code proper --------
+
+float rand(int num) {
+  return fract(mod(float(num) * 67123.313, 12.0) * sin(float(num) * 10.3) * cos(float(num)));
+}
+
+float wave(int num) {
+  float fn = float(num) * frequency * 0.1 * float(bars);
+  return cos(fn * 0.5) * cos(fn * 0.13) * sin((fn+10.0) * 0.3) / 2.0 + 0.5;
+}
+
+float drip(int num) {
+  return sin(float(num) / float(bars - 1) * 3.141592) * dripScale;
+}
+
+float pos(int num) {
+  return (noise == 0.0 ? wave(num) : mix(wave(num), rand(num), noise)) + (dripScale == 0.0 ? 0.0 : drip(num));
+}
+
+vec4 transition(vec2 uv) {
+  int bar = int(uv.x * (float(bars)));
+  float scale = 1.0 + pos(bar) * amplitude;
+  float phase = progress * scale;
+  float posY = uv.y / vec2(1.0).y;
+  vec2 p;
+  vec4 c;
+  if (phase + posY < 1.0) {
+    p = vec2(uv.x, uv.y + mix(0.0, vec2(1.0).y, phase)) / vec2(1.0).xy;
+    c = getFromColor(p);
+  } else {
+    p = uv.xy / vec2(1.0).xy;
+    c = getToColor(p);
+  }
+
+  // Finally, apply the color
+  return c;
+}

package/glsl3/Dreamy.glsl

@@ -0,0 +1,14 @@
+// Dreamy — GLSL ES 3.00, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/Dreamy.glsl
+// Author: mikolalysenko
+// License: MIT
+// Description: A crossfade with a gentle wavy distortion
+// Tags: wave, blend
+
+vec2 offset(float progress, float x, float theta) {
+  float phase = progress*progress + progress + theta;
+  float shifty = 0.03*progress*cos(10.0*(progress+x));
+  return vec2(0, shifty);
+}
+vec4 transition(vec2 p) {
+  return mix(getFromColor(p + offset(progress, p.x, 0.0)), getToColor(p + offset(1.0-progress, p.x, 3.14)), progress);
+}

package/glsl3/DreamyZoom.glsl

@@ -0,0 +1,43 @@
+// DreamyZoom — GLSL ES 3.00, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/DreamyZoom.glsl
+// Author: Zeh Fernando
+// License: MIT
+// Description: Zooms and rotates into a bright flash, then out to the incoming image
+// Tags: zoom, rotate, flash
+
+// Definitions --------
+#define DEG2RAD 0.03926990816987241548078304229099 // 1/180*PI
+
+
+// Transition parameters --------
+
+// In degrees
+uniform float rotation; // = 6
+
+// Multiplier
+uniform float scale; // = 1.2
+
+
+// The code proper --------
+
+vec4 transition(vec2 uv) {
+  // Massage parameters
+  float phase = progress < 0.5 ? progress * 2.0 : (progress - 0.5) * 2.0;
+  float angleOffset = progress < 0.5 ? mix(0.0, rotation * DEG2RAD, phase) : mix(-rotation * DEG2RAD, 0.0, phase);
+  float newScale = progress < 0.5 ? mix(1.0, scale, phase) : mix(scale, 1.0, phase);
+  
+  vec2 center = vec2(0, 0);
+
+  // Calculate the source point
+  vec2 assumedCenter = vec2(0.5, 0.5);
+  vec2 p = (uv.xy - vec2(0.5, 0.5)) / newScale * vec2(ratio, 1.0);
+
+  // This can probably be optimized (with distance())
+  float angle = atan(p.y, p.x) + angleOffset;
+  float dist = distance(center, p);
+  p.x = cos(angle) * dist / ratio + 0.5;
+  p.y = sin(angle) * dist + 0.5;
+  vec4 c = progress < 0.5 ? getFromColor(p) : getToColor(p);
+
+  // Finally, apply the color
+  return c + (progress < 0.5 ? mix(0.0, 1.0, phase) : mix(1.0, 0.0, phase));
+}

package/glsl3/Drop_Zone_Flicker.glsl

@@ -0,0 +1,159 @@
+// Drop_Zone_Flicker — GLSL ES 3.00, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/Drop_Zone_Flicker.glsl
+// Author: bread
+// License: MIT
+// Description: A flickering glitch with RGB offset, ghosting and scanlines that flashes back to the outgoing image
+// Tags: glitch, flicker, chromatic, scanlines
+// Drop_Zone_Flicker.glsl
+// gl-transitions compatible: progress, ratio, getFromColor, getToColor
+uniform float frameRate;    // = 24.0
+uniform float rgbOffset;    // = 0.014
+uniform float blockAmount;  // = 0.72
+uniform float ghostAmount;  // = 0.62
+uniform float redCyan;      // = 0.58
+uniform float scanline;     // = 0.075
+
+float sat(float x) {
+  return clamp(x, 0.0, 1.0);
+}
+
+float hash12(vec2 p) {
+  p = fract(p * vec2(443.8975, 397.2973));
+  p += dot(p, p.yx + 19.19);
+  return fract(p.x * p.y);
+}
+
+vec2 safeUv(vec2 uv) {
+  return clamp(uv, vec2(0.001), vec2(0.999));
+}
+
+// 24fps reference-matched reveal curve.
+// Non-monotonic on purpose: the reference flashes back to the old clip.
+float frameReveal(float f) {
+  if (f < 0.5) return 0.00;
+  if (f < 1.5) return 0.28;
+  if (f < 2.5) return 0.43;
+  if (f < 3.5) return 0.46;
+  if (f < 4.5) return 0.38;
+  if (f < 5.5) return 0.48;
+  if (f < 6.5) return 0.26;
+  if (f < 7.5) return 0.10;
+  if (f < 8.5) return 0.00;
+  if (f < 9.5) return 0.00;
+  if (f < 10.5) return 0.30;
+  if (f < 11.5) return 0.58;
+  if (f < 12.5) return 1.00;
+  if (f < 13.5) return 0.70;
+  if (f < 14.5) return 0.42;
+  if (f < 15.5) return 0.55;
+  if (f < 16.5) return 0.72;
+  if (f < 17.5) return 0.88;
+  if (f < 18.5) return 0.34;
+  if (f < 19.5) return 0.48;
+  if (f < 20.5) return 0.56;
+  if (f < 21.5) return 0.76;
+  if (f < 22.5) return 0.93;
+  return 1.00;
+}
+
+float frameGlitch(float f) {
+  if (f < 0.5) return 0.00;
+  if (f < 6.5) return 0.92;
+  if (f < 10.5) return 0.38;
+  if (f < 11.5) return 0.78;
+  if (f < 12.5) return 0.12;
+  if (f < 17.5) return 0.74;
+  if (f < 22.5) return 0.88;
+  if (f < 23.5) return 0.28;
+  return 0.00;
+}
+
+vec4 chromaFrom(vec2 uv, float amt) {
+  vec2 o = vec2(amt, 0.0);
+  return vec4(
+    getFromColor(safeUv(uv + o)).r,
+    getFromColor(safeUv(uv)).g,
+    getFromColor(safeUv(uv - o)).b,
+    1.0
+  );
+}
+
+vec4 chromaTo(vec2 uv, float amt) {
+  vec2 o = vec2(amt, 0.0);
+  return vec4(
+    getToColor(safeUv(uv - o)).r,
+    getToColor(safeUv(uv)).g,
+    getToColor(safeUv(uv + o)).b,
+    1.0
+  );
+}
+
+float blockMask(vec2 uv, float f) {
+  vec2 big = floor(uv * vec2(4.0, 2.0));
+  vec2 small = floor(uv * vec2(8.0, 4.0));
+
+  float wide = step(0.48, hash12(vec2(big.x, f * 1.37)));
+  float chunks = step(0.56, hash12(small + vec2(f * 2.11, f * 0.73)));
+
+  float verticalCut = smoothstep(
+    -0.035,
+    0.035,
+    uv.x - mix(0.18, 0.78, hash12(vec2(f, 4.7)))
+  );
+
+  return sat(mix(wide, chunks, 0.38) * 0.72 + verticalCut * 0.28);
+}
+
+vec4 transition(vec2 uv) {
+  if (progress <= 0.0) return getFromColor(uv);
+  if (progress >= 1.0) return getToColor(uv);
+
+  float f = floor(progress * frameRate);
+  float reveal = frameReveal(f);
+  float glitch = frameGlitch(f);
+
+  float rnd = hash12(vec2(f, 9.13));
+  vec2 jitter = vec2(
+    (rnd - 0.5) * 0.042,
+    (hash12(vec2(f, 2.71)) - 0.5) * 0.010
+  ) * glitch;
+
+  vec2 fromUv = safeUv(uv + jitter);
+  vec2 toUv = safeUv(uv - jitter * 0.55);
+
+  float block = blockMask(uv, f);
+  float localReveal = sat(
+    reveal +
+    (block - 0.5) * blockAmount * glitch +
+    (hash12(vec2(f, floor(uv.y * 9.0))) - 0.5) * 0.18 * glitch
+  );
+
+  localReveal = smoothstep(0.22, 0.78, localReveal);
+
+  vec4 oldClip = chromaFrom(fromUv, rgbOffset * glitch);
+  vec4 newClip = chromaTo(toUv, rgbOffset * glitch);
+
+  vec4 color = mix(oldClip, newClip, localReveal);
+
+  float leftWash = (1.0 - smoothstep(0.10, 0.78, uv.x)) * glitch;
+  float cyanWash = smoothstep(0.08, 0.62, uv.x) * (1.0 - smoothstep(0.86, 1.0, uv.x)) * glitch;
+
+  vec3 redGhost = oldClip.rgb * vec3(1.34, 0.42, 0.38);
+  vec3 cyanGhost = newClip.rgb * vec3(0.48, 1.12, 1.24);
+
+  color.rgb = mix(color.rgb, redGhost, leftWash * redCyan * 0.42);
+  color.rgb = mix(color.rgb, cyanGhost, cyanWash * redCyan * 0.30);
+
+  // Keeps the old circular "drop zone" visible as a translucent flash,
+  // especially after the first full new-frame hit.
+  float oldReturn = glitch * (1.0 - smoothstep(0.94, 1.0, reveal));
+  oldReturn *= 0.18 + 0.52 * (1.0 - abs(localReveal - 0.5) * 2.0);
+  color.rgb = mix(color.rgb, oldClip.rgb, oldReturn * ghostAmount);
+
+  float lines = sin((uv.y + f * 0.017) * 1080.0);
+  color.rgb += lines * scanline * glitch;
+
+  float exposurePulse = (hash12(vec2(f, 12.4)) - 0.35) * 0.10 * glitch;
+  color.rgb += exposurePulse;
+
+  return vec4(sat(color.r), sat(color.g), sat(color.b), 1.0);
+}

package/glsl3/EdgeTransition.glsl

@@ -0,0 +1,50 @@
+// EdgeTransition — GLSL ES 3.00, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/EdgeTransition.glsl
+// Author: Woohyun Kim
+// License: MIT
+// Description: Both images fade through black with their edges glowing
+// Tags: edges, fade
+
+uniform float edge_thickness; // = 0.001
+uniform float edge_brightness; // = 8.0
+
+vec4 detectEdgeColor(vec3[9] c) {
+  /* adjacent texel array for texel c[4]
+    036
+    147
+    258
+  */
+  vec3 dx = 2.0 * abs(c[7]-c[1]) + abs(c[2] - c[6]) + abs(c[8] - c[0]);
+	vec3 dy = 2.0 * abs(c[3]-c[5]) + abs(c[6] - c[8]) + abs(c[0] - c[2]);
+  float delta = length(0.25 * (dx + dy) * 0.5);
+	return vec4(clamp(edge_brightness * delta, 0.0, 1.0) * c[4], 1.0);
+}
+
+vec4 getFromEdgeColor(vec2 uv) {
+	vec3 c[9];
+	for (int i=0; i < 3; ++i) for (int j=0; j < 3; ++j)
+	{
+	  vec4 color = getFromColor(uv + edge_thickness * vec2(i-1,j-1));
+    c[3*i + j] = color.rgb;
+	}
+	return detectEdgeColor(c);
+}
+
+vec4 getToEdgeColor(vec2 uv) {
+	vec3 c[9];
+	for (int i=0; i < 3; ++i) for (int j=0; j < 3; ++j)
+	{
+	  vec4 color = getToColor(uv + edge_thickness * vec2(i-1,j-1));
+    c[3*i + j] = color.rgb;
+	}
+	return detectEdgeColor(c);
+}
+
+vec4 transition (vec2 uv) {
+  vec4 start = mix(getFromColor(uv), getFromEdgeColor(uv), clamp(2.0 * progress, 0.0, 1.0));
+  vec4 end = mix(getToEdgeColor(uv), getToColor(uv), clamp(2.0 * (progress - 0.5), 0.0, 1.0));
+  return mix(
+    start,
+    end,
+    progress
+  );
+}

package/glsl3/FilmBurn.glsl

@@ -0,0 +1,63 @@
+// FilmBurn — GLSL ES 3.00, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/FilmBurn.glsl
+// Author: Anastasia Dunbar
+// License: MIT
+// Description: Glowing film-burn light leaks wash over the image and reveal the incoming one
+// Tags: burn, film, light-leak
+// @param Random seed
+uniform float Seed; // = 2.31
+float sigmoid(float x, float a) {
+    float b = pow(x*2.,a)/2.;
+    if (x > .5) {
+        b = 1.-pow(2.-(x*2.),a)/2.;
+    }
+	return b;
+}
+float rand(float co){
+    return fract(sin((co*24.9898)+Seed)*43758.5453);
+}
+float rand(vec2 co){
+    return fract(sin(dot(co.xy ,vec2(12.9898,78.233))) * 43758.5453);
+}
+float apow(float a,float b) { return pow(abs(a),b)*sign(b); }
+vec3 pow3(vec3 a,vec3 b) { return vec3(apow(a.r,b.r),apow(a.g,b.g),apow(a.b,b.b)); }
+float smooth_mix(float a,float b,float c) { return mix(a,b,sigmoid(c,2.)); }
+float random(vec2 co, float shft){
+    co += 10.;
+    return smooth_mix(fract(sin(dot(co.xy ,vec2(12.9898+(floor(shft)*.5),78.233+Seed))) * 43758.5453),fract(sin(dot(co.xy ,vec2(12.9898+(floor(shft+1.)*.5),78.233+Seed))) * 43758.5453),fract(shft));
+}
+float smooth_random(vec2 co, float shft) {
+	return smooth_mix(smooth_mix(random(floor(co),shft),random(floor(co+vec2(1.,0.)),shft),fract(co.x)),smooth_mix(random(floor(co+vec2(0.,1.)),shft),random(floor(co+vec2(1.,1.)),shft),fract(co.x)),fract(co.y));
+}
+vec4 blendedColor(vec2 p) {
+    return mix(getFromColor(p), getToColor(p), sigmoid(progress,10.));
+}
+#define pi 3.14159265358979323
+#define clamps(x) clamp(x,0.,1.)
+
+vec4 transition(vec2 p) {
+  vec3 f = vec3(0.);
+  for (float i = 0.; i < 13.; i++) {
+    f += sin(((p.x*rand(i)*6.)+(progress*8.))+rand(i+1.43))*sin(((p.y*rand(i+4.4)*6.)+(progress*6.))+rand(i+2.4));
+    f += 1.-clamps(length(p-vec2(smooth_random(vec2(progress*1.3),i+1.),smooth_random(vec2(progress*.5),i+6.25)))*mix(20.,70.,rand(i)));
+  }
+  f += 4.;
+  f /= 11.;
+  f = pow3(f*vec3(1.,0.7,0.6),vec3(1.,2.-sin(progress*pi),1.3));
+  f *= sin(progress*pi);
+  
+  p -= .5;
+  p *= 1.+(smooth_random(vec2(progress*5.),6.3)*sin(progress*pi)*.05);
+  p += .5;
+  
+  vec4 blurred_image = vec4(0.);
+  float bluramount = sin(progress*pi)*.03;
+  #define repeats  50.
+  for (float i = 0.; i < repeats; i++) { 
+      vec2 q = vec2(cos(degrees((i/repeats)*360.)),sin(degrees((i/repeats)*360.))) *  (rand(vec2(i,p.x+p.y))+bluramount); 
+      vec2 uv2 = p+(q*bluramount);
+      blurred_image += blendedColor(uv2);
+  }
+  blurred_image /= repeats;
+  
+  return blurred_image+vec4(f,0.);
+}

package/glsl3/Fold.glsl

@@ -0,0 +1,12 @@
+// Fold — GLSL ES 3.00, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/Fold.glsl
+// Author: nwoeanhinnogaehr
+// License: MIT
+// Description: The incoming image unfolds from the left while the outgoing one folds away to the right
+// Tags: fold, slide, horizontal
+// Ported from https://gist.github.com/nwoeanhinnogaehr/f6fc39f4cfcbb97f96a6
+
+vec4 transition(vec2 uv) {
+  // Only sample the visible side: the other one divides by zero at progress 0 and 1.
+  if (progress == 0.0 || uv.x > progress) return getFromColor((uv - vec2(progress, 0.0)) / vec2(1.0 - progress, 1.0));
+  return getToColor(uv / vec2(progress, 1.0));
+}

package/glsl3/GlitchDisplace.glsl

@@ -0,0 +1,78 @@
+// GlitchDisplace — GLSL ES 3.00, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/GlitchDisplace.glsl
+// Author: Matt DesLauriers
+// License: MIT
+// Description: Blocks of the image are displaced in a glitch that flashes into the incoming image
+// Tags: glitch, displace
+
+float random(vec2 co)
+{
+    float a = 12.9898;
+    float b = 78.233;
+    float c = 43758.5453;
+    float dt= dot(co.xy ,vec2(a,b));
+    float sn= mod(dt,3.14);
+    return fract(sin(sn) * c);
+}
+float voronoi( in vec2 x ) {
+    vec2 p = floor( x );
+    vec2 f = fract( x );
+    float res = 8.0;
+    for( float j=-1.; j<=1.; j++ )
+    for( float i=-1.; i<=1.; i++ ) {
+        vec2  b = vec2( i, j );
+        vec2  r = b - f + random( p + b );
+        float d = dot( r, r );
+        res = min( res, d );
+    }
+    return sqrt( res );
+}
+
+vec2 displace(vec4 tex, vec2 texCoord, float dotDepth, float textureDepth, float strength) {
+    float b = voronoi(.003 * texCoord + 2.0);
+    float g = voronoi(0.2 * texCoord);
+    float r = voronoi(texCoord - 1.0);
+    vec4 dt = tex * 1.0;
+    vec4 dis = dt * dotDepth + 1.0 - tex * textureDepth;
+
+    dis.x = dis.x - 1.0 + textureDepth*dotDepth;
+    dis.y = dis.y - 1.0 + textureDepth*dotDepth;
+    dis.x *= strength;
+    dis.y *= strength;
+    vec2 res_uv = texCoord ;
+    res_uv.x = res_uv.x + dis.x - 0.0;
+    res_uv.y = res_uv.y + dis.y;
+    return res_uv;
+}
+
+float ease1(float t) {
+  return t == 0.0 || t == 1.0
+    ? t
+    : t < 0.5
+      ? +0.5 * pow(2.0, (20.0 * t) - 10.0)
+      : -0.5 * pow(2.0, 10.0 - (t * 20.0)) + 1.0;
+}
+float ease2(float t) {
+  return t == 1.0 ? t : 1.0 - pow(2.0, -10.0 * t);
+}
+
+
+
+vec4 transition(vec2 uv) {
+  vec2 p = uv.xy / vec2(1.0).xy;
+  vec4 color1 = getFromColor(p);
+  vec4 color2 = getToColor(p);
+  vec2 disp = displace(color1, p, 0.33, 0.7, 1.0-ease1(progress));
+  vec2 disp2 = displace(color2, p, 0.33, 0.5, ease2(progress));
+  vec4 dColor1 = getToColor(disp);
+  vec4 dColor2 = getFromColor(disp2);
+  float val = ease1(progress);
+  vec3 gray = vec3(dot(min(dColor2, dColor1).rgb, vec3(0.299, 0.587, 0.114)));
+  dColor2 = vec4(gray, 1.0);
+  dColor2 *= 2.0;
+  color1 = mix(color1, dColor2, smoothstep(0.0, 0.5, progress));
+  color2 = mix(color2, dColor1, smoothstep(1.0, 0.5, progress));
+  return mix(color1, color2, val);
+  //gl_FragColor = mix(gl_FragColor, dColor, smoothstep(0.0, 0.5, progress));
+
+   //gl_FragColor = mix(texture(from, p), texture(to, p), progress);
+}

package/glsl3/GlitchMemories.glsl

@@ -0,0 +1,17 @@
+// GlitchMemories — GLSL ES 3.00, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/GlitchMemories.glsl
+// Author: Gunnar Roth
+// based on work from natewave
+// License: MIT
+// Description: A crossfade with glitchy, color-shifted blocks
+// Tags: glitch, chromatic, blend
+vec4 transition(vec2 p) {
+  vec2 block = floor(p.xy / vec2(16));
+  vec2 uv_noise = block / vec2(64);
+  uv_noise += floor(vec2(progress) * vec2(1200.0, 3500.0)) / vec2(64);
+  vec2 dist = progress > 0.0 ? (fract(uv_noise) - 0.5) * 0.3 *(1.0 -progress) : vec2(0.0);
+  vec2 red = p + dist * 0.2;
+  vec2 green = p + dist * .3;
+  vec2 blue = p + dist * .5;
+
+  return vec4(mix(getFromColor(red), getToColor(red), progress).r,mix(getFromColor(green), getToColor(green), progress).g,mix(getFromColor(blue), getToColor(blue), progress).b,1.0);
+}

package/glsl3/GridFlip.glsl

@@ -0,0 +1,77 @@
+// GridFlip — GLSL ES 3.00, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/GridFlip.glsl
+// License: MIT
+// Author: TimDonselaar
+// Description: The image splits into a grid of tiles that flip one by one to the incoming image
+// Tags: grid, tiles, flip
+// ported by gre from https://gist.github.com/TimDonselaar/9bcd1c4b5934ba60087bdb55c2ea92e5
+
+// @param Number of tiles (columns, rows)
+uniform ivec2 size; // = ivec2(4)
+uniform float pause; // = 0.1
+uniform float dividerWidth; // = 0.05
+// @color Color behind the tiles
+uniform vec4 bgcolor; // = vec4(0.0, 0.0, 0.0, 1.0)
+uniform float randomness; // = 0.1
+ 
+float rand (vec2 co) {
+  return fract(sin(dot(co.xy ,vec2(12.9898,78.233))) * 43758.5453);
+}
+
+float getDelta(vec2 p) {
+  vec2 rectanglePos = floor(vec2(size) * p);
+  vec2 rectangleSize = vec2(1.0 / vec2(size).x, 1.0 / vec2(size).y);
+  float top = rectangleSize.y * (rectanglePos.y + 1.0);
+  float bottom = rectangleSize.y * rectanglePos.y;
+  float left = rectangleSize.x * rectanglePos.x;
+  float right = rectangleSize.x * (rectanglePos.x + 1.0);
+  float minX = min(abs(p.x - left), abs(p.x - right));
+  float minY = min(abs(p.y - top), abs(p.y - bottom));
+  return min(minX, minY);
+}
+
+float getDividerSize() {
+  vec2 rectangleSize = vec2(1.0 / vec2(size).x, 1.0 / vec2(size).y);
+  return min(rectangleSize.x, rectangleSize.y) * dividerWidth;
+}
+
+vec4 transition(vec2 p) {
+  if(progress < pause) {
+    float currentProg = progress / pause;
+    float a = 1.0;
+    if(getDelta(p) < getDividerSize()) {
+      a = 1.0 - currentProg;
+    }
+    return mix(bgcolor, getFromColor(p), a);
+  }
+  else if(progress < 1.0 - pause){
+    if(getDelta(p) < getDividerSize()) {
+      return bgcolor;
+    } else {
+      float currentProg = (progress - pause) / (1.0 - pause * 2.0);
+      vec2 q = p;
+      vec2 rectanglePos = floor(vec2(size) * q);
+      
+      float r = rand(rectanglePos) - randomness;
+      float cp = smoothstep(0.0, 1.0 - r, currentProg);
+    
+      float rectangleSize = 1.0 / vec2(size).x;
+      float delta = rectanglePos.x * rectangleSize;
+      float offset = rectangleSize / 2.0 + delta;
+      
+      p.x = (p.x - offset)/abs(cp - 0.5)*0.5 + offset;
+      vec4 a = getFromColor(p);
+      vec4 b = getToColor(p);
+      
+      float s = step(abs(vec2(size).x * (q.x - delta) - 0.5), abs(cp - 0.5));
+      return mix(bgcolor, mix(b, a, step(cp, 0.5)), s);
+    }
+  }
+  else {
+    float currentProg = (progress - 1.0 + pause) / pause;
+    float a = 1.0;
+    if(getDelta(p) < getDividerSize()) {
+      a = currentProg;
+    }
+    return mix(bgcolor, getToColor(p), a);
+  }
+}

package/glsl3/HSVfade.glsl

@@ -0,0 +1,29 @@
+// HSVfade — GLSL ES 3.00, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/HSVfade.glsl
+// Author: nwoeanhinnogaehr
+// License: MIT
+// Description: A crossfade through the HSV color space that cycles through hues
+// Tags: fade, color, hue
+// Ported from https://gist.github.com/nwoeanhinnogaehr/b185145363d65751009b
+
+// HSV functions from http://lolengine.net/blog/2013/07/27/rgb-to-hsv-in-glsl
+
+vec3 hsv2rgb(vec3 c) {
+  const vec4 K = vec4(1.0, 2.0 / 3.0, 1.0 / 3.0, 3.0);
+  vec3 p = abs(fract(c.xxx + K.xyz) * 6.0 - K.www);
+  return c.z * mix(K.xxx, clamp(p - K.xxx, 0.0, 1.0), c.y);
+}
+
+vec3 rgb2hsv(vec3 c) {
+  const vec4 K = vec4(0.0, -1.0 / 3.0, 2.0 / 3.0, -1.0);
+  vec4 p = mix(vec4(c.bg, K.wz), vec4(c.gb, K.xy), step(c.b, c.g));
+  vec4 q = mix(vec4(p.xyw, c.r), vec4(c.r, p.yzx), step(p.x, c.r));
+  float d = q.x - min(q.w, q.y);
+  return vec3(abs(q.z + (q.w - q.y) / (6.0 * d + 0.001)), d / (q.x + 0.001), q.x);
+}
+
+vec4 transition(vec2 uv) {
+  vec3 a = rgb2hsv(getFromColor(uv).rgb);
+  vec3 b = rgb2hsv(getToColor(uv).rgb);
+  vec3 m = mix(a, b, progress);
+  return vec4(hsv2rgb(m), 1.0);
+}

package/glsl3/HorizontalClose.glsl

@@ -0,0 +1,16 @@
+// HorizontalClose — GLSL ES 3.00, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/HorizontalClose.glsl
+// Author: martiniti
+// License: MIT
+// Description: The incoming image closes in from the top and bottom edges toward the middle
+// Tags: wipe, split
+
+vec4 transition (vec2 uv) {
+
+  float s = 2.0 - abs((uv.y - 0.5) / (progress - 1.0)) - 2.0 * progress;
+  
+  return mix(
+    getFromColor(uv),
+    getToColor(uv),
+    smoothstep(0.5, 0.0, s)
+  ); 
+}