gl-transitions 1.74.0 → 1.76.0

package/glsl3/parametric_glitch.glsl

@@ -0,0 +1,29 @@
+// parametric_glitch — GLSL ES 3.00, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/parametric_glitch.glsl
+// Author: Yoni Maltsman @friendlyspinach
+// License: MIT
+// Description: A crossfade with glitchy horizontal bands and color shifts
+// Tags: glitch, blend
+
+
+
+// @param Horizontal amplitude of the glitch
+uniform float ampx; // =1.0
+// @param Vertical amplitude of the glitch
+uniform float ampy; //=1.0
+
+vec4 transition (vec2 uv) {
+  vec4 from = getFromColor(uv);
+  vec4 to = getToColor(uv);
+  float r = from.r;
+  float g = from.g;
+  float b = from.b;
+  float sphere = r*r + g*g + b*b - 1.0; //3 to 1
+  float spiralX = cos(sphere - uv.x/(progress + .01));
+  float spiralY = sin(sphere - uv.y/(progress+.01));
+  vec2 st = uv;
+  st.x = fract(ampx*st.x*spiralX); //1 to 2
+  st.y = fract(ampy*st.y*spiralY);
+  vec2 diff = uv - st;
+  from = getFromColor(uv + progress*diff);
+  return mix(from, to, progress);
+}

package/glsl3/perlin.glsl

@@ -0,0 +1,66 @@
+// perlin — GLSL ES 3.00, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/perlin.glsl
+// Author: Rich Harris
+// License: MIT
+// Description: The incoming image appears through blobs of Perlin noise
+// Tags: noise, dissolve
+
+// @param Scale of the noise; higher values make smaller blobs
+uniform float scale; // = 4.0
+// @param Softness of the blob edges
+uniform float smoothness; // = 0.01
+
+// @param Random seed
+uniform float seed; // = 12.9898
+
+// http://byteblacksmith.com/improvements-to-the-canonical-one-liner-glsl-rand-for-opengl-es-2-0/
+float random(vec2 co)
+{
+    float a = seed;
+    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);
+}
+
+// 2D Noise based on Morgan McGuire @morgan3d
+// https://www.shadertoy.com/view/4dS3Wd
+float noise (in vec2 st) {
+    vec2 i = floor(st);
+    vec2 f = fract(st);
+
+    // Four corners in 2D of a tile
+    float a = random(i);
+    float b = random(i + vec2(1.0, 0.0));
+    float c = random(i + vec2(0.0, 1.0));
+    float d = random(i + vec2(1.0, 1.0));
+
+    // Smooth Interpolation
+
+    // Cubic Hermine Curve.  Same as SmoothStep()
+    vec2 u = f*f*(3.0-2.0*f);
+    // u = smoothstep(0.,1.,f);
+
+    // Mix 4 coorners porcentages
+    return mix(a, b, u.x) +
+            (c - a)* u.y * (1.0 - u.x) +
+            (d - b) * u.x * u.y;
+}
+
+vec4 transition (vec2 uv) {
+  vec4 from = getFromColor(uv);
+  vec4 to = getToColor(uv);
+  float n = noise(uv * scale);
+
+  float p = mix(-smoothness, 1.0 + smoothness, progress);
+  float lower = p - smoothness;
+  float higher = p + smoothness;
+
+  float q = smoothstep(lower, higher, n);
+
+  return mix(
+    from,
+    to,
+    1.0 - q
+  );
+}

package/glsl3/pinwheel.glsl

@@ -0,0 +1,20 @@
+// pinwheel — GLSL ES 3.00, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/pinwheel.glsl
+// Author: Mr Speaker
+// License: MIT
+// Description: A spinning pinwheel reveals the incoming image
+// Tags: pinwheel, radial, rotate
+
+// @param Rotation speed
+uniform float speed; // = 2.0
+
+vec4 transition(vec2 uv) {
+  
+  vec2 p = uv.xy / vec2(1.0).xy;
+  
+  float circPos = atan(p.y - 0.5, p.x - 0.5) + progress * speed;
+  float modPos = mod(circPos, 3.1415 / 4.);
+  float signed = sign(progress - modPos);
+  
+  return mix(getToColor(p), getFromColor(p), step(signed, 0.5));
+  
+}

package/glsl3/pixelize.glsl

@@ -0,0 +1,21 @@
+// pixelize — GLSL ES 3.00, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/pixelize.glsl
+// Author: gre
+// License: MIT
+// Description: Both images pixelate, crossfade, then sharpen again
+// Tags: pixelate, blend
+// forked from https://gist.github.com/benraziel/c528607361d90a072e98
+
+// minimum number of squares (when the effect is at its higher level)
+// @param Number of squares at the strongest pixelation
+uniform ivec2 squaresMin; // = ivec2(20)
+// zero disable the stepping
+// @param Number of pixelation steps; 0 for a continuous effect
+uniform int steps; // = 50
+
+vec4 transition(vec2 uv) {
+  float d = min(progress, 1.0 - progress);
+  float dist = steps>0 ? ceil(d * float(steps)) / float(steps) : d;
+  vec2 squareSize = 2.0 * dist / vec2(squaresMin);
+  vec2 p = dist>0.0 ? (floor(uv / squareSize) + 0.5) * squareSize : uv;
+  return mix(getFromColor(p), getToColor(p), progress);
+}

package/glsl3/polar_function.glsl

@@ -0,0 +1,24 @@
+// polar_function — GLSL ES 3.00, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/polar_function.glsl
+// Author: Fernando Kuteken
+// License: MIT
+// Description: A flower shape with several petals grows to reveal the incoming image
+// Tags: shape, wipe, polar
+
+#define PI 3.14159265359
+
+// @param Number of petals
+uniform int segments; // = 5
+
+vec4 transition (vec2 uv) {
+  
+  float angle = atan(uv.y - 0.5, uv.x - 0.5) - 0.5 * PI;
+  float normalized = (angle + 1.5 * PI) * (2.0 * PI);
+  
+  float radius = (cos(float(segments) * angle) + 4.0) / 4.0;
+  float difference = length(uv - vec2(0.5, 0.5));
+  
+  if (difference > radius * progress)
+    return getFromColor(uv);
+  else
+    return getToColor(uv);
+}

package/glsl3/powerKaleido.glsl

@@ -0,0 +1,57 @@
+// powerKaleido — GLSL ES 3.00, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/powerKaleido.glsl
+// Name: Power Kaleido
+// Author: Boundless
+// License: MIT
+// Description: The image folds into an animated kaleidoscope before revealing the incoming one
+// Tags: kaleidoscope, distort
+#define PI 3.14159265358979
+const float rad = 120.; // change this value to get different mirror effects
+const float deg = rad / 180. * PI;
+uniform float scale; // = 2.0
+uniform float z; // = 1.5
+uniform float speed; // = 5.
+vec2 refl(vec2 p,vec2 o,vec2 n)
+{
+	return 2.0*o+2.0*n*dot(p-o,n)-p;
+}
+
+vec2 rot(vec2 p, vec2 o, float a)
+{
+    float s = sin(a);
+    float c = cos(a);
+	return o + mat2(c, -s, s, c) * (p - o);
+}
+
+vec4 mainImage(vec2 uv)
+{
+  float dist = scale / 10.;
+  vec2 uv0 = uv;
+	uv -= 0.5;
+  uv.x *= ratio;
+  uv *= z;
+  uv = rot(uv, vec2(0.0), progress*speed);
+  // uv.x = fract(uv.x/l/3.0)*l*3.0;
+	float theta = progress*6.+PI/.5;
+	for(int iter = 0; iter < 10; iter++) {
+    for(float i = 0.; i < 2. * PI; i+=deg) {
+	    float ts = sign(asin(cos(i))) == 1.0 ? 1.0 : 0.0;
+      if(((ts == 1.0) && (uv.y-dist*cos(i) > tan(i)*(uv.x+dist*+sin(i)))) || ((ts == 0.0) && (uv.y-dist*cos(i) < tan(i)*(uv.x+dist*+sin(i))))) {
+        uv = refl(vec2(uv.x+sin(i)*dist*2.,uv.y-cos(i)*dist*2.), vec2(0.,0.), vec2(cos(i),sin(i)));
+      }
+    }
+  }
+  uv += 0.5;
+  uv = rot(uv, vec2(0.5), progress*-speed);
+  uv -= 0.5;
+  uv.x /= ratio;
+  uv += 0.5;
+  uv = 2.*abs(uv/2.-floor(uv/2.+0.5));
+  vec2 uvMix = mix(uv,uv0,cos(progress*PI*2.)/2.+0.5);
+  vec4 color = mix(getFromColor(uvMix),getToColor(uvMix),cos((progress-1.)*PI)/2.+0.5);
+	return color;
+    
+}
+vec4 transition (vec2 uv) {
+  vec4 color = mainImage(uv);
+  return color;
+}

package/glsl3/randomNoisex.glsl

@@ -0,0 +1,15 @@
+// randomNoisex — GLSL ES 3.00, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/randomNoisex.glsl
+// Author: towrabbit
+// License: MIT
+// Description: The incoming image appears pixel by pixel in random noise
+// Tags: dissolve, noise
+
+float random (vec2 st) {
+    return fract(sin(dot(st.xy,vec2(12.9898,78.233)))*43758.5453123);
+}
+vec4 transition (vec2 uv) {
+  vec4 leftSide = getFromColor(uv);
+  vec4 rightSide = getToColor(uv);
+  float uvz = floor(random(uv)+progress);
+  return mix(leftSide,rightSide,uvz);
+}

package/glsl3/randomsquares.glsl

@@ -0,0 +1,20 @@
+// randomsquares — GLSL ES 3.00, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/randomsquares.glsl
+// Author: gre
+// License: MIT
+// Description: The incoming image appears in random squares
+// Tags: squares, grid, dissolve
+
+// @param Number of squares (columns, rows)
+uniform ivec2 size; // = ivec2(10, 10)
+// @param Softness of each square's switch
+uniform float smoothness; // = 0.5
+ 
+float rand (vec2 co) {
+  return fract(sin(dot(co.xy ,vec2(12.9898,78.233))) * 43758.5453);
+}
+
+vec4 transition(vec2 p) {
+  float r = rand(floor(vec2(size) * p));
+  float m = smoothstep(0.0, -smoothness, r - (progress * (1.0 + smoothness)));
+  return mix(getFromColor(p), getToColor(p), m);
+}

package/glsl3/ripple.glsl

@@ -0,0 +1,20 @@
+// ripple — GLSL ES 3.00, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/ripple.glsl
+// Author: gre
+// License: MIT
+// Description: Ripples spread from the center while crossfading
+// Tags: ripple, wave, blend
+// @param Frequency of the ripples
+uniform float amplitude; // = 100.0
+// @param Speed of the ripples
+uniform float speed; // = 50.0
+
+vec4 transition (vec2 uv) {
+  vec2 dir = uv - vec2(.5);
+  float dist = length(dir);
+  vec2 offset = dir * (sin(progress * dist * amplitude - progress * speed) + .5) / 30. * progress;
+  return mix(
+    getFromColor(uv + offset),
+    getToColor(uv),
+    smoothstep(0.2, 1.0, progress)
+  );
+}

package/glsl3/rotateTransition.glsl

@@ -0,0 +1,22 @@
+// rotateTransition — GLSL ES 3.00, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/rotateTransition.glsl
+// Author: haiyoucuv
+// License: MIT
+// Description: The images spin around the center while crossfading
+// Tags: rotate, spin, blend
+
+#define PI 3.1415926
+
+vec2 rotate2D(in vec2 uv, in float angle){
+  
+  return uv * mat2(cos(angle), -sin(angle), sin(angle), cos(angle));
+}
+vec4 transition (vec2 uv) {
+  
+  vec2 p = fract(rotate2D(uv - 0.5, progress * PI * 2.0) + 0.5);
+
+  return mix(
+    getFromColor(p),
+    getToColor(p),
+    progress
+  );
+}

package/glsl3/rotate_scale_fade.glsl

@@ -0,0 +1,39 @@
+// rotate_scale_fade — GLSL ES 3.00, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/rotate_scale_fade.glsl
+// Author: Fernando Kuteken
+// License: MIT
+// Description: The outgoing image spins and zooms while fading to the incoming one, over a background color
+// Tags: rotate, zoom, fade
+
+#define PI 3.14159265359
+
+// @param Center of the rotation
+uniform vec2 center; // = vec2(0.5, 0.5)
+// @param Number of turns
+uniform float rotations; // = 1
+// @param Maximum zoom
+uniform float scale; // = 8
+// @color Background color
+uniform vec4 backColor; // = vec4(0.15, 0.15, 0.15, 1.0)
+
+vec4 transition (vec2 uv) {
+  
+  vec2 difference = uv - center;
+  vec2 dir = normalize(difference);
+  float dist = length(difference);
+  
+  float angle = 2.0 * PI * rotations * progress;
+  
+  float c = cos(angle);
+  float s = sin(angle);
+  
+  float currentScale = mix(scale, 1.0, 2.0 * abs(progress - 0.5));
+  
+  vec2 rotatedDir = vec2(dir.x  * c - dir.y * s, dir.x * s + dir.y * c);
+  vec2 rotatedUv = center + rotatedDir * dist / currentScale;
+  
+  if (rotatedUv.x < 0.0 || rotatedUv.x > 1.0 ||
+      rotatedUv.y < 0.0 || rotatedUv.y > 1.0)
+    return backColor;
+    
+  return mix(getFromColor(rotatedUv), getToColor(rotatedUv), progress);
+}

package/glsl3/scale-in.glsl

@@ -0,0 +1,18 @@
+// scale-in — GLSL ES 3.00, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/scale-in.glsl
+// Author: haiyoucuv
+// License: MIT
+// Description: The incoming image scales in from the center while fading in
+// Tags: zoom, fade
+
+vec4 scale(in vec2 uv){
+    uv = 0.5 + (uv - 0.5) * progress;
+    return getToColor(uv);
+}
+
+vec4 transition (vec2 uv) {
+  return mix(
+    getFromColor(uv),
+    scale(uv),
+    progress
+  );
+}

package/glsl3/splitSlideInHorizontal.glsl

@@ -0,0 +1,26 @@
+// splitSlideInHorizontal — GLSL ES 3.00, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/splitSlideInHorizontal.glsl
+// Author: OllyOllyOlly
+// License: MIT
+// Description: The incoming image slides in as two halves moving horizontally in opposite directions
+// Tags: slide, split, horizontal
+
+// @param Swap the directions of the halves
+uniform bool reverse; // = false
+
+const vec2 boundMin = vec2(0.0, 0.0);
+const vec2 boundMax = vec2(1.0, 1.0);
+
+bool inBounds (vec2 p) {
+  return all(lessThan(boundMin, p)) && all(lessThan(p, boundMax));
+}
+
+vec4 transition (vec2 uv) {
+  float modifier = reverse ? -1.0 : 1.0;
+  vec2 toP = (uv.y > 0.5) ?
+    vec2((uv.x - (progress * modifier)) + modifier, uv.y) :
+    vec2((uv.x + (progress * modifier)) - modifier, uv.y);
+
+  vec2 fromP = uv;
+
+  return inBounds(toP) ? getToColor(toP) : getFromColor(fromP);
+}

package/glsl3/splitSlideInOutHorizontal.glsl

@@ -0,0 +1,23 @@
+// splitSlideInOutHorizontal — GLSL ES 3.00, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/splitSlideInOutHorizontal.glsl
+// Author: OllyOllyOlly
+// License: MIT
+// Description: The halves of both images slide horizontally in opposite directions, out and in at once
+// Tags: slide, split, horizontal
+
+// @param Swap the directions of the halves
+uniform bool reverse; // = false
+
+const vec2 boundMin = vec2(0.0, 0.0);
+const vec2 boundMax = vec2(1.0, 1.0);
+
+bool inBounds (vec2 p) {
+  return all(lessThan(boundMin, p)) && all(lessThan(p, boundMax));
+}
+
+vec4 transition (vec2 uv) {
+  float modifier = (uv.y > 0.5 ? 1.0 : -1.0) * (reverse ? -1.0 : 1.0) ;
+  vec2 fromP = vec2(uv.x + (progress * modifier), uv.y);
+  vec2 toP = vec2((uv.x + (progress * modifier)) - modifier, uv.y);
+
+  return inBounds(fromP) ? getFromColor(fromP) : getToColor(toP);
+}

package/glsl3/splitSlideInOutVertical.glsl

@@ -0,0 +1,23 @@
+// splitSlideInOutVertical — GLSL ES 3.00, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/splitSlideInOutVertical.glsl
+// Author: OllyOllyOlly
+// License: MIT
+// Description: The halves of both images slide vertically in opposite directions, out and in at once
+// Tags: slide, split, vertical
+
+// @param Swap the directions of the halves
+uniform bool reverse; // = false
+
+const vec2 boundMin = vec2(0.0, 0.0);
+const vec2 boundMax = vec2(1.0, 1.0);
+
+bool inBounds (vec2 p) {
+  return all(lessThan(boundMin, p)) && all(lessThan(p, boundMax));
+}
+
+vec4 transition (vec2 uv) {
+  float modifier = (uv.x > 0.5 ? 1.0 : -1.0) * (reverse ? -1.0 : 1.0) ;
+  vec2 fromP = vec2(uv.x, uv.y + (progress * modifier));
+  vec2 toP = vec2(uv.x, (uv.y + (progress * modifier)) - modifier);
+
+  return inBounds(fromP) ? getFromColor(fromP) : getToColor(toP);
+}

package/glsl3/splitSlideInVertical.glsl

@@ -0,0 +1,24 @@
+// splitSlideInVertical — GLSL ES 3.00, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/splitSlideInVertical.glsl
+// Author: OllyOllyOlly
+// License: MIT
+// Description: The incoming image slides in as two halves moving vertically in opposite directions
+// Tags: slide, split, vertical
+
+// @param Swap the directions of the halves
+uniform bool reverse; // = false
+
+const vec2 boundMin = vec2(0.0, 0.0);
+const vec2 boundMax = vec2(1.0, 1.0);
+
+bool inBounds (vec2 p) {
+  return all(lessThan(boundMin, p)) && all(lessThan(p, boundMax));
+}
+
+vec4 transition (vec2 uv) {
+  float modifier = reverse ? -1.0 : 1.0;
+  vec2 p = (uv.x > 0.5) ?
+    vec2(uv.x, (uv.y - (progress * modifier)) + modifier) :
+    vec2(uv.x, (uv.y + (progress * modifier)) - modifier);
+
+  return inBounds(p) ? getToColor(p) : getFromColor(uv);
+}

package/glsl3/splitSlideOutHorizontal.glsl

@@ -0,0 +1,22 @@
+// splitSlideOutHorizontal — GLSL ES 3.00, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/splitSlideOutHorizontal.glsl
+// Author: OllyOllyOlly
+// License: MIT
+// Description: The outgoing image slides out as two halves moving horizontally in opposite directions
+// Tags: slide, split, horizontal
+
+// @param Swap the directions of the halves
+uniform bool reverse; // = false
+
+const vec2 boundMin = vec2(0.0, 0.0);
+const vec2 boundMax = vec2(1.0, 1.0);
+
+bool inBounds (vec2 p) {
+  return all(lessThan(boundMin, p)) && all(lessThan(p, boundMax));
+}
+
+vec4 transition (vec2 uv) {
+  float modifier = (uv.y > 0.5 ? 1.0 : -1.0) * (reverse ? -1.0 : 1.0) ;
+  vec2 p = vec2(uv.x + (progress * modifier), uv.y);
+
+  return inBounds(p) ? getFromColor(p) : getToColor(uv);
+}

package/glsl3/splitSlideOutVertical.glsl

@@ -0,0 +1,22 @@
+// splitSlideOutVertical — GLSL ES 3.00, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/splitSlideOutVertical.glsl
+// Author: OllyOllyOlly
+// License: MIT
+// Description: The outgoing image slides out as two halves moving vertically in opposite directions
+// Tags: slide, split, vertical
+
+// @param Swap the directions of the halves
+uniform bool reverse; // = false
+
+const vec2 boundMin = vec2(0.0, 0.0);
+const vec2 boundMax = vec2(1.0, 1.0);
+
+bool inBounds (vec2 p) {
+  return all(lessThan(boundMin, p)) && all(lessThan(p, boundMax));
+}
+
+vec4 transition (vec2 uv) {
+  float modifier = (uv.x > 0.5 ? 1.0 : -1.0) * (reverse ? -1.0 : 1.0) ;
+  vec2 p = vec2(uv.x, uv.y + (progress * modifier));
+
+  return inBounds(p) ? getFromColor(p) : getToColor(uv);
+}

package/glsl3/squareswire.glsl

@@ -0,0 +1,26 @@
+// squareswire — GLSL ES 3.00, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/squareswire.glsl
+// Author: gre
+// License: MIT
+// Description: Squares grow along a diagonal sweep to reveal the incoming image
+// Tags: squares, grid, wipe, directional
+ 
+// @param Number of squares (columns, rows)
+uniform ivec2 squares;// = ivec2(10,10)
+// @param Direction of the sweep
+uniform vec2 direction;// = vec2(1.0, -0.5)
+// @param Softness of the sweep
+uniform float smoothness; // = 1.6
+
+const vec2 center = vec2(0.5, 0.5);
+vec4 transition (vec2 p) {
+  vec2 v = normalize(direction);
+  v /= abs(v.x)+abs(v.y);
+  float d = v.x * center.x + v.y * center.y;
+  float offset = smoothness;
+  float pr = smoothstep(-offset, 0.0, v.x * p.x + v.y * p.y - (d-0.5+progress*(1.+offset)));
+  vec2 squarep = fract(p*vec2(squares));
+  vec2 squaremin = vec2(pr/2.0);
+  vec2 squaremax = vec2(1.0 - pr/2.0);
+  float a = (1.0 - step(progress, 0.0)) * step(squaremin.x, squarep.x) * step(squaremin.y, squarep.y) * step(squarep.x, squaremax.x) * step(squarep.y, squaremax.y);
+  return mix(getFromColor(p), getToColor(p), a);
+}

package/glsl3/squeeze.glsl

@@ -0,0 +1,23 @@
+// squeeze — GLSL ES 3.00, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/squeeze.glsl
+// Author: gre
+// License: MIT
+// Description: The outgoing image is squeezed into a line with color separation, revealing the incoming one
+// Tags: squeeze, chromatic, vertical
+ 
+// @param Amount of color separation
+uniform float colorSeparation; // = 0.04
+ 
+vec4 transition (vec2 uv) {
+  float y = 0.5 + (uv.y-0.5) / (1.0-progress);
+  if (y < 0.0 || y > 1.0) {
+     return getToColor(uv);
+  }
+  else {
+    vec2 fp = vec2(uv.x, y);
+    vec2 off = progress * vec2(0.0, colorSeparation);
+    vec4 c = getFromColor(fp);
+    vec4 cn = getFromColor(fp - off);
+    vec4 cp = getFromColor(fp + off);
+    return vec4(cn.r, c.g, cp.b, c.a);
+  }
+}

package/glsl3/static_wipe.glsl

@@ -0,0 +1,39 @@
+// static_wipe — GLSL ES 3.00, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/static_wipe.glsl
+// Author: Ben Lucas
+// License: MIT
+// Description: A wipe from top to bottom with a band of TV static at its edge
+// Tags: wipe, static, noise, vertical
+
+#define PI 3.14159265359
+
+float rnd (vec2 st) {
+    return fract(sin(dot(st.xy,
+                         vec2(10,70)))*
+        12345.5453123);
+}
+
+// @param Wipe from top to bottom; false wipes from bottom to top
+uniform bool u_transitionUpToDown; // = true
+// @param Maximum height of the static band
+uniform float u_max_static_span; // = 0.5
+
+vec4 transition (vec2 uv) {
+  
+
+  float span = u_max_static_span*pow(sin(PI*progress),0.5);
+  
+  float transitionEdge = u_transitionUpToDown ? 1.0-uv.y : uv.y;
+  float mixRatio = 1.0 - step(progress, transitionEdge);
+
+  vec4 transitionMix = mix(
+    getFromColor(uv),
+    getToColor(uv),
+    mixRatio
+  );
+  
+  float noiseEnvelope = smoothstep(progress-span, progress, transitionEdge) * (1.0 - smoothstep(progress, progress + span, transitionEdge));
+  vec4 noise = vec4(vec3(rnd(uv*(1.0+progress))), 1.0);
+  
+
+  return mix(transitionMix, noise, noiseEnvelope);
+}

package/glsl3/swap.glsl

@@ -0,0 +1,64 @@
+// swap — GLSL ES 3.00, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/swap.glsl
+// Author: gre
+// License: MIT
+// Description: The two images swap places in 3D, with a floor reflection
+// Tags: 3d, swap, reflection
+// General parameters
+// @param Strength of the reflection
+uniform float reflection; // = 0.4
+// @param Amount of perspective
+uniform float perspective; // = 0.2
+uniform float depth; // = 3.0
+ 
+const vec4 black = vec4(0.0, 0.0, 0.0, 1.0);
+const vec2 boundMin = vec2(0.0, 0.0);
+const vec2 boundMax = vec2(1.0, 1.0);
+ 
+bool inBounds (vec2 p) {
+  return all(lessThan(boundMin, p)) && all(lessThan(p, boundMax));
+}
+ 
+vec2 project (vec2 p) {
+  return p * vec2(1.0, -1.2) + vec2(0.0, -0.02);
+}
+ 
+vec4 bgColor (vec2 p, vec2 pfr, vec2 pto) {
+  vec4 c = black;
+  pfr = project(pfr);
+  if (inBounds(pfr)) {
+    c += mix(black, getFromColor(pfr), reflection * mix(1.0, 0.0, pfr.y));
+  }
+  pto = project(pto);
+  if (inBounds(pto)) {
+    c += mix(black, getToColor(pto), reflection * mix(1.0, 0.0, pto.y));
+  }
+  return c;
+}
+ 
+vec4 transition(vec2 p) {
+  vec2 pfr, pto = vec2(-1.);
+ 
+  float size = mix(1.0, depth, progress);
+  float persp = perspective * progress;
+  pfr = (p + vec2(-0.0, -0.5)) * vec2(size/(1.0-perspective*progress), size/(1.0-size*persp*p.x)) + vec2(0.0, 0.5);
+ 
+  size = mix(1.0, depth, 1.-progress);
+  persp = perspective * (1.-progress);
+  pto = (p + vec2(-1.0, -0.5)) * vec2(size/(1.0-perspective*(1.0-progress)), size/(1.0-size*persp*(0.5-p.x))) + vec2(1.0, 0.5);
+
+  if (progress < 0.5) {
+    if (inBounds(pfr)) {
+      return getFromColor(pfr);
+    }
+    if (inBounds(pto)) {
+      return getToColor(pto);
+    }  
+  }
+  if (inBounds(pto)) {
+    return getToColor(pto);
+  }
+  if (inBounds(pfr)) {
+    return getFromColor(pfr);
+  }
+  return bgColor(p, pfr, pto);
+}