gl-transitions 1.74.0 → 1.76.0

package/glsl3/directionalwipe.glsl

@@ -0,0 +1,22 @@
+// directionalwipe — GLSL ES 3.00, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/directionalwipe.glsl
+// Author: gre
+// License: MIT
+// Description: A soft-edged diagonal wipe
+// Tags: wipe, directional
+
+// @param Direction of the wipe
+uniform vec2 direction; // = vec2(1.0, -1.0)
+// @param Softness of the edge
+uniform float smoothness; // = 0.5
+ 
+const vec2 center = vec2(0.5, 0.5);
+ 
+vec4 transition (vec2 uv) {
+  vec2 v = normalize(direction);
+  v /= abs(v.x)+abs(v.y);
+  float d = v.x * center.x + v.y * center.y;
+  float m =
+    (1.0-step(progress, 0.0)) * // there is something wrong with our formula that makes m not equals 0.0 with progress is 0.0
+    (1.0 - smoothstep(-smoothness, 0.0, v.x * uv.x + v.y * uv.y - (d-0.5+progress*(1.+smoothness))));
+  return mix(getFromColor(uv), getToColor(uv), m);
+}

package/glsl3/displacement.glsl

@@ -0,0 +1,26 @@
+// displacement — GLSL ES 3.00, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/displacement.glsl
+// Author: Travis Fischer
+// License: MIT
+// Description: A crossfade in which a displacement map (an extra grayscale texture) warps both images
+// Tags: displace, distort, blend
+//
+// Adapted from a Codrops article by Robin Delaporte
+// https://tympanus.net/Development/DistortionHoverEffect
+
+uniform sampler2D displacementMap;
+
+// @param Strength of the displacement
+uniform float strength; // = 0.5
+
+vec4 transition (vec2 uv) {
+  float displacement = texture(displacementMap, uv).r * strength;
+
+  vec2 uvFrom = vec2(uv.x + progress * displacement, uv.y);
+  vec2 uvTo = vec2(uv.x - (1.0 - progress) * displacement, uv.y);
+
+  return mix(
+    getFromColor(uvFrom),
+    getToColor(uvTo),
+    progress
+  );
+}

package/glsl3/dissolve.glsl

@@ -0,0 +1,54 @@
+// dissolve — GLSL ES 3.00, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/dissolve.glsl
+// Author: hjm1fb
+// License: MIT
+// Description: The incoming image spreads over the outgoing one with a hot, glowing edge
+// Tags: dissolve, burn, glow
+
+uniform float uLineWidth; // = 0.1
+// @color Color of the spreading edge
+uniform vec3 uSpreadClr; // = vec3(1.0, 0.0, 0.0)
+// @color Color of the hottest part of the edge
+uniform vec3 uHotClr; // = vec3(0.9, 0.9, 0.2)
+uniform float uPow; // = 5.0
+uniform float uIntensity; // = 1.0
+
+vec2 hash(vec2 p)  // replace this by something better
+{
+  p = vec2(dot(p, vec2(127.1, 311.7)), dot(p, vec2(269.5, 183.3)));
+  return -1.0 + 2.0 * fract(sin(p) * 43758.5453123);
+}
+
+float noise(in vec2 p) {
+  const float K1 = 0.366025404;  // (sqrt(3)-1)/2;
+  const float K2 = 0.211324865;  // (3-sqrt(3))/6;
+
+  vec2 i = floor(p + (p.x + p.y) * K1);
+  vec2 a = p - i + (i.x + i.y) * K2;
+  float m = step(a.y, a.x);
+  vec2 o = vec2(m, 1.0 - m);
+  vec2 b = a - o + K2;
+  vec2 c = a - 1.0 + 2.0 * K2;
+  vec3 h = max(0.5 - vec3(dot(a, a), dot(b, b), dot(c, c)), 0.0);
+  vec3 n = h * h * h * h * vec3(dot(a, hash(i + 0.0)), dot(b, hash(i + o)), dot(c, hash(i + 1.0)));
+  return dot(n, vec3(70.0));
+}
+
+vec4 transition(vec2 uv) {
+  vec4 from = getFromColor(uv);
+  vec4 to = getToColor(uv);
+  vec4 outColor;
+  float burn;
+  burn = 0.5 + 0.5 * (0.299 * from.r + 0.587 * from.g + 0.114 * from.b);
+
+  float show = burn - progress;
+  if (show < 0.001) {
+    outColor = to;
+  } else {
+    float factor = 1.0 - smoothstep(0.0, uLineWidth, show);
+    vec3 burnColor = mix(uSpreadClr, uHotClr, factor);
+    burnColor = pow(burnColor, vec3(uPow)) * uIntensity;
+    vec3 finalRGB = mix(from.rgb, burnColor, factor * step(0.0001, progress));
+    outColor = vec4(finalRGB * from.a, from.a);
+  }
+  return outColor;
+}

package/glsl3/doorway.glsl

@@ -0,0 +1,55 @@
+// doorway — GLSL ES 3.00, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/doorway.glsl
+// Author: gre
+// License: MIT
+// Description: The outgoing image opens like double doors as the incoming one comes forward, with a floor reflection
+// Tags: doors, 3d, reflection
+// @param Strength of the reflection
+uniform float reflection; // = 0.4
+// @param Amount of perspective
+uniform float perspective; // = 0.4
+uniform float depth; // = 3
+
+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 pto) {
+  vec4 c = black;
+  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 = vec2(-1.), pto = vec2(-1.);
+  float middleSlit = 2.0 * abs(p.x-0.5) - progress;
+  if (middleSlit > 0.0) {
+    pfr = p + (p.x > 0.5 ? -1.0 : 1.0) * vec2(0.5*progress, 0.0);
+    float d = 1.0/(1.0+perspective*progress*(1.0-middleSlit));
+    pfr.y -= d/2.;
+    pfr.y *= d;
+    pfr.y += d/2.;
+  }
+  float size = mix(1.0, depth, 1.-progress);
+  pto = (p + vec2(-0.5, -0.5)) * vec2(size, size) + vec2(0.5, 0.5);
+  if (inBounds(pfr)) {
+    return getFromColor(pfr);
+  }
+  else if (inBounds(pto)) {
+    return getToColor(pto);
+  }
+  else {
+    return bgColor(p, pto);
+  }
+}

package/glsl3/fade.glsl

@@ -0,0 +1,13 @@
+// fade — GLSL ES 3.00, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/fade.glsl
+// Author: gre
+// License: MIT
+// Description: A linear crossfade between the two images
+// Tags: fade, blend
+
+vec4 transition (vec2 uv) {
+  return mix(
+    getFromColor(uv),
+    getToColor(uv),
+    progress
+  );
+}

package/glsl3/fadecolor.glsl

@@ -0,0 +1,15 @@
+// fadecolor — GLSL ES 3.00, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/fadecolor.glsl
+// Author: gre
+// License: MIT
+// Description: A fade through a solid color, black by default
+// Tags: fade, color
+// @color Color to fade through
+uniform vec3 color;// = vec3(0.0)
+// @range(0, 1) How long the color shows in the middle
+uniform float colorPhase; // = 0.4 ; // if 0.0, there is no black phase, if 0.9, the black phase is very important
+vec4 transition (vec2 uv) {
+  return mix(
+    mix(vec4(color, 1.0), getFromColor(uv), smoothstep(1.0-colorPhase, 0.0, progress)),
+    mix(vec4(color, 1.0), getToColor(uv), smoothstep(    colorPhase, 1.0, progress)),
+    progress);
+}

package/glsl3/fadegrayscale.glsl

@@ -0,0 +1,21 @@
+// fadegrayscale — GLSL ES 3.00, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/fadegrayscale.glsl
+// Author: gre
+// License: MIT
+// Description: A crossfade through grayscale
+// Tags: fade, grayscale, color
+
+// @range(0, 1) How long the grayscale phase lasts
+uniform float intensity; // = 0.3; // if 0.0, the image directly turn grayscale, if 0.9, the grayscale transition phase is very important
+ 
+vec3 grayscale (vec3 color) {
+  return vec3(0.2126*color.r + 0.7152*color.g + 0.0722*color.b);
+}
+ 
+vec4 transition (vec2 uv) {
+  vec4 fc = getFromColor(uv);
+  vec4 tc = getToColor(uv);
+  return mix(
+    mix(vec4(grayscale(fc.rgb), 1.0), fc, smoothstep(1.0-intensity, 0.0, progress)),
+    mix(vec4(grayscale(tc.rgb), 1.0), tc, smoothstep(    intensity, 1.0, progress)),
+    progress);
+}

package/glsl3/flyeye.glsl

@@ -0,0 +1,20 @@
+// flyeye — GLSL ES 3.00, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/flyeye.glsl
+// Author: gre
+// License: MIT
+// Description: The image breaks into a fly's-eye grid of lenses with color separation
+// Tags: lens, distort, chromatic
+uniform float size; // = 0.04
+uniform float zoom; // = 50.0
+uniform float colorSeparation; // = 0.3
+
+vec4 transition(vec2 p) {
+  float inv = 1. - progress;
+  vec2 disp = size*vec2(cos(zoom*p.x), sin(zoom*p.y));
+  vec4 texTo = getToColor(p + inv*disp);
+  vec4 texFrom = vec4(
+    getFromColor(p + progress*disp*(1.0 - colorSeparation)).r,
+    getFromColor(p + progress*disp).g,
+    getFromColor(p + progress*disp*(1.0 + colorSeparation)).b,
+    1.0);
+  return texTo*progress + texFrom*inv;
+}

package/glsl3/fragment.glsl

@@ -0,0 +1,54 @@
+// fragment — GLSL ES 3.00, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/fragment.glsl
+// Author: lbl
+// License: MIT
+// Description: The outgoing image shatters into fragments that fly away
+// Tags: shatter, fragments
+
+#define POINTS 10
+
+float random(vec2 par) {
+    return fract(sin(dot(par.xy, vec2(12.9898, 78.233))) * 43758.5453);
+}
+
+vec2 random2(vec2 par) {
+    float rand = random(par);
+    return vec2(rand, random(par + rand));
+}
+
+vec4 transition (vec2 uv) {
+    if (progress <= 0.0) return getFromColor(uv);
+    if (progress >= 1.0) return getToColor(uv);
+
+    const float duration = 8.0;
+    float time = progress * duration;
+    vec2 point[POINTS];
+    for (int i = 0; i < POINTS; i++) {
+        point[i] = random2(vec2(float(i)));
+    }
+
+    vec4 col = getToColor(uv);
+
+    for (int i = 0; i < POINTS; i++) {
+        vec2 dir = normalize(random2(vec2(float(i), float(i) + 11.)));
+        float v = (1.0 + random(dir) * 0.5) * 0.2;
+        vec2 ofst = dir * clamp(time - 0.5, 0.0, duration) * v;
+        vec2 U = uv - ofst;
+
+        if (U.x < 0.0 || U.x > 1.0 || U.y < 0.0 || U.y > 1.0) continue;
+
+        float dist_i = distance(U, point[i]);
+        bool closest = true;
+        for (int j = 0; j < POINTS; j++) {
+            if (distance(U, point[j]) < dist_i) {
+                closest = false;
+                break;
+            }
+        }
+
+        if (closest) {
+            col = getFromColor(U);
+            break;
+        }
+    }
+    return col;
+}

package/glsl3/heart.glsl

@@ -0,0 +1,19 @@
+// heart — GLSL ES 3.00, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/heart.glsl
+// Author: gre
+// License: MIT
+// Description: A heart shape grows from the center to reveal the incoming image
+// Tags: shape, wipe, heart
+
+float inHeart (vec2 p, vec2 center, float size) {
+  if (size==0.0) return 0.0;
+  vec2 o = (p-center)/(1.6*size);
+  float a = o.x*o.x+o.y*o.y-0.3;
+  return step(a*a*a, o.x*o.x*o.y*o.y*o.y);
+}
+vec4 transition (vec2 uv) {
+  return mix(
+    getFromColor(uv),
+    getToColor(uv),
+    inHeart(uv, vec2(0.5, 0.4), progress)
+  );
+}

package/glsl3/hexagonalize.glsl

@@ -0,0 +1,78 @@
+// hexagonalize — GLSL ES 3.00, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/hexagonalize.glsl
+// Author: Fernando Kuteken
+// License: MIT
+// Description: Both images turn into hexagons, crossfade, then sharpen again
+// Tags: pixelate, hexagon, blend
+// Hexagonal math from: http://www.redblobgames.com/grids/hexagons/
+
+uniform int steps; // = 50
+// @param Number of hexagons across
+uniform float horizontalHexagons; // = 20
+
+struct Hexagon {
+  float q;
+  float r;
+  float s;
+};
+
+Hexagon createHexagon(float q, float r){
+  Hexagon hex;
+  hex.q = q;
+  hex.r = r;
+  hex.s = -q - r;
+  return hex;
+}
+
+Hexagon roundHexagon(Hexagon hex){
+  
+  float q = floor(hex.q + 0.5);
+  float r = floor(hex.r + 0.5);
+  float s = floor(hex.s + 0.5);
+
+  float deltaQ = abs(q - hex.q);
+  float deltaR = abs(r - hex.r);
+  float deltaS = abs(s - hex.s);
+
+  if (deltaQ > deltaR && deltaQ > deltaS)
+    q = -r - s;
+  else if (deltaR > deltaS)
+    r = -q - s;
+  else
+    s = -q - r;
+
+  return createHexagon(q, r);
+}
+
+Hexagon hexagonFromPoint(vec2 point, float size) {
+  
+  point.y /= ratio;
+  point = (point - 0.5) / size;
+  
+  float q = (sqrt(3.0) / 3.0) * point.x + (-1.0 / 3.0) * point.y;
+  float r = 0.0 * point.x + 2.0 / 3.0 * point.y;
+
+  Hexagon hex = createHexagon(q, r);
+  return roundHexagon(hex);
+  
+}
+
+vec2 pointFromHexagon(Hexagon hex, float size) {
+  
+  float x = (sqrt(3.0) * hex.q + (sqrt(3.0) / 2.0) * hex.r) * size + 0.5;
+  float y = (0.0 * hex.q + (3.0 / 2.0) * hex.r) * size + 0.5;
+  
+  return vec2(x, y * ratio);
+}
+
+vec4 transition (vec2 uv) {
+  
+  float dist = 2.0 * min(progress, 1.0 - progress);
+  dist = steps > 0 ? ceil(dist * float(steps)) / float(steps) : dist;
+  
+  float size = (sqrt(3.0) / 3.0) * dist / horizontalHexagons;
+  
+  vec2 point = dist > 0.0 ? pointFromHexagon(hexagonFromPoint(uv, size), size) : uv;
+
+  return mix(getFromColor(point), getToColor(point), progress);
+  
+}

package/glsl3/kaleidoscope.glsl

@@ -0,0 +1,25 @@
+// kaleidoscope — GLSL ES 3.00, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/kaleidoscope.glsl
+// Author: nwoeanhinnogaehr
+// License: MIT
+// Description: A crossfade through a spinning kaleidoscope
+// Tags: kaleidoscope, distort, blend
+
+uniform float speed; // = 1.0
+uniform float angle; // = 1.0
+uniform float power; // = 1.5
+
+vec4 transition(vec2 uv) {
+  vec2 p = uv.xy / vec2(1.0).xy;
+  vec2 q = p;
+  float t = pow(progress, power)*speed;
+  p = p -0.5;
+  for (int i = 0; i < 7; i++) {
+    p = vec2(sin(t)*p.x + cos(t)*p.y, sin(t)*p.y - cos(t)*p.x);
+    t += angle;
+    p = abs(mod(p, 2.0) - 1.0);
+  }
+  abs(mod(p, 1.0));
+  return mix(
+    mix(getFromColor(q), getToColor(q), progress),
+    mix(getFromColor(p), getToColor(p), progress), 1.0 - 2.0*abs(progress - 0.5));
+}

package/glsl3/luma.glsl

@@ -0,0 +1,15 @@
+// luma — GLSL ES 3.00, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/luma.glsl
+// Author: gre
+// License: MIT
+// Description: A wipe that follows the brightness of a grayscale mask (the luma texture)
+// Tags: wipe, luma, mask
+
+uniform sampler2D luma;
+
+vec4 transition(vec2 uv) {
+  return mix(
+    getToColor(uv),
+    getFromColor(uv),
+    step(progress, texture(luma, uv).r)
+  );
+}

package/glsl3/luminance_melt.glsl

@@ -0,0 +1,131 @@
+// luminance_melt — GLSL ES 3.00, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/luminance_melt.glsl
+// Author: 0gust1
+// License: MIT
+// Description: The outgoing image melts away in noisy vertical streaks, depending on its brightness
+// Tags: melt, noise, luma
+//My own first transition — based on crosshatch code (from pthrasher), using  simplex noise formula (copied and pasted)
+//-> cooler with high contrasted images (isolated dark subject on light background f.e.)
+//TODO : try to rebase it on DoomTransition (from zeh)?
+//optimizations :
+//luminance (see http://stackoverflow.com/questions/596216/formula-to-determine-brightness-of-rgb-color#answer-596241)
+// Y = (R+R+B+G+G+G)/6
+//or Y = (R+R+R+B+G+G+G+G)>>3 
+
+
+//direction of movement :  0 : up, 1, down
+// @param Direction of the melt (false: up, true: down)
+uniform bool direction; // = true
+//luminance threshold
+// @range(0, 1) Luminance threshold
+uniform float l_threshold; // = 0.8 
+//does the movement takes effect above or below luminance threshold ?
+// @param Melt the parts above the threshold instead of below
+uniform bool above; // = false 
+
+
+//Random function borrowed from everywhere
+float rand(vec2 co){
+  return fract(sin(dot(co.xy ,vec2(12.9898,78.233))) * 43758.5453);
+}
+
+
+// Simplex noise :
+// Description : Array and textureless GLSL 2D simplex noise function.
+//      Author : Ian McEwan, Ashima Arts.
+//  Maintainer : ijm
+//     Lastmod : 20110822 (ijm)
+//     License : MIT  
+//               2011 Ashima Arts. All rights reserved.
+//               Distributed under the MIT License. See LICENSE file.
+//               https://github.com/ashima/webgl-noise
+// 
+
+vec3 mod289(vec3 x) {
+  return x - floor(x * (1.0 / 289.0)) * 289.0;
+}
+
+vec2 mod289(vec2 x) {
+  return x - floor(x * (1.0 / 289.0)) * 289.0;
+}
+
+vec3 permute(vec3 x) {
+  return mod289(((x*34.0)+1.0)*x);
+}
+
+float snoise(vec2 v)
+  {
+  const vec4 C = vec4(0.211324865405187,  // (3.0-sqrt(3.0))/6.0
+                      0.366025403784439,  // 0.5*(sqrt(3.0)-1.0)
+                     -0.577350269189626,  // -1.0 + 2.0 * C.x
+                      0.024390243902439); // 1.0 / 41.0
+// First corner
+  vec2 i  = floor(v + dot(v, C.yy) );
+  vec2 x0 = v -   i + dot(i, C.xx);
+
+// Other corners
+  vec2 i1;
+  //i1.x = step( x0.y, x0.x ); // x0.x > x0.y ? 1.0 : 0.0
+  //i1.y = 1.0 - i1.x;
+  i1 = (x0.x > x0.y) ? vec2(1.0, 0.0) : vec2(0.0, 1.0);
+  // x0 = x0 - 0.0 + 0.0 * C.xx ;
+  // x1 = x0 - i1 + 1.0 * C.xx ;
+  // x2 = x0 - 1.0 + 2.0 * C.xx ;
+  vec4 x12 = x0.xyxy + C.xxzz;
+  x12.xy -= i1;
+
+// Permutations
+  i = mod289(i); // Avoid truncation effects in permutation
+  vec3 p = permute( permute( i.y + vec3(0.0, i1.y, 1.0 ))
+		+ i.x + vec3(0.0, i1.x, 1.0 ));
+
+  vec3 m = max(0.5 - vec3(dot(x0,x0), dot(x12.xy,x12.xy), dot(x12.zw,x12.zw)), 0.0);
+  m = m*m ;
+  m = m*m ;
+
+// Gradients: 41 points uniformly over a line, mapped onto a diamond.
+// The ring size 17*17 = 289 is close to a multiple of 41 (41*7 = 287)
+
+  vec3 x = 2.0 * fract(p * C.www) - 1.0;
+  vec3 h = abs(x) - 0.5;
+  vec3 ox = floor(x + 0.5);
+  vec3 a0 = x - ox;
+
+// Normalise gradients implicitly by scaling m
+// Approximation of: m *= inversesqrt( a0*a0 + h*h );
+  m *= 1.79284291400159 - 0.85373472095314 * ( a0*a0 + h*h );
+
+// Compute final noise value at P
+  vec3 g;
+  g.x  = a0.x  * x0.x  + h.x  * x0.y;
+  g.yz = a0.yz * x12.xz + h.yz * x12.yw;
+  return 130.0 * dot(m, g);
+}
+
+// Simplex noise -- end
+
+float luminance(vec4 color){
+  //(0.299*R + 0.587*G + 0.114*B)
+  return color.r*0.299+color.g*0.587+color.b*0.114;
+}
+
+vec4 transition(vec2 uv) {
+  vec2 center = vec2(1.0, direction);
+  vec2 p = uv.xy / vec2(1.0).xy;
+  if (progress == 0.0) {
+    return getFromColor(p);
+  } else if (progress == 1.0) {
+    return getToColor(p);
+  } else {
+    float x = progress;
+    float dist = distance(center, p)- progress*exp(snoise(vec2(p.x, 0.0)));
+    float r = x - rand(vec2(p.x, 0.1));
+    float m;
+    if(above){
+     m = dist <= r && luminance(getFromColor(p))>l_threshold ? 1.0 : (progress*progress*progress);
+    }
+    else{
+     m = dist <= r && luminance(getFromColor(p))<l_threshold ? 1.0 : (progress*progress*progress);  
+    }
+    return mix(getFromColor(p), getToColor(p), m);    
+  }
+}

package/glsl3/morph.glsl

@@ -0,0 +1,20 @@
+// morph — GLSL ES 3.00, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/morph.glsl
+// Author: paniq
+// License: MIT
+// Description: A crossfade in which each image is displaced by the other's colors, like a morph
+// Tags: morph, distort, blend
+// @param Strength of the displacement
+uniform float strength; // = 0.1
+
+vec4 transition(vec2 p) {
+  vec4 ca = getFromColor(p);
+  vec4 cb = getToColor(p);
+  
+  vec2 oa = (((ca.rg+ca.b)*0.5)*2.0-1.0);
+  vec2 ob = (((cb.rg+cb.b)*0.5)*2.0-1.0);
+  vec2 oc = mix(oa,ob,0.5)*strength;
+  
+  float w0 = progress;
+  float w1 = 1.0-w0;
+  return mix(getFromColor(p+oc*w0), getToColor(p-oc*w1), progress);
+}

package/glsl3/mosaic_transition.glsl

@@ -0,0 +1,20 @@
+// mosaic_transition — GLSL ES 3.00, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/mosaic_transition.glsl
+// Author: YueDev
+// License: MIT
+// Description: Both images break into mosaic blocks that blend, then sharpen into the incoming image
+// Tags: mosaic, pixelate, blend
+
+// @param Number of mosaic blocks
+uniform float mosaicNum;// = 10.0
+
+vec2 getMosaicUV(vec2 uv) {
+  float mosaicWidth = 2.0 / mosaicNum * min(progress, 1.0 - progress);
+  float mX = floor(uv.x / mosaicWidth) + 0.5;
+  float mY = floor(uv.y / mosaicWidth) + 0.5;
+  return vec2(mX * mosaicWidth, mY * mosaicWidth);
+}
+
+vec4 transition (vec2 uv) {
+  vec2 mosaicUV = min(progress, 1.0 - progress) == 0.0 ? uv : getMosaicUV(uv);
+  return mix(getFromColor(mosaicUV), getToColor(mosaicUV), progress * progress);
+}

package/glsl3/multiply_blend.glsl

@@ -0,0 +1,19 @@
+// multiply_blend — GLSL ES 3.00, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/multiply_blend.glsl
+// Author: Fernando Kuteken
+// License: MIT
+// Description: A crossfade through the multiplied blend of both images
+// Tags: blend, fade
+
+vec4 blend(vec4 a, vec4 b) {
+  return a * b;
+}
+
+vec4 transition (vec2 uv) {
+  
+  vec4 blended = blend(getFromColor(uv), getToColor(uv));
+  
+  if (progress < 0.5)
+    return mix(getFromColor(uv), blended, 2.0 * progress);
+  else
+    return mix(blended, getToColor(uv), 2.0 * progress - 1.0);
+}

package/glsl3/old_tv_lost_signal.glsl

@@ -0,0 +1,51 @@
+// old_tv_lost_signal — GLSL ES 3.00, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/old_tv_lost_signal.glsl
+// Author: mernking (gitlab.com/Godswork)
+// License: MIT
+// Description: A crossfade with drifting tracking lines and tearing, like a TV losing its signal
+// Tags: retro, glitch, scanlines
+
+float hash(vec2 p) {
+    return fract(sin(dot(p, vec2(127.1, 311.7))) * 43758.5453);
+}
+
+vec4 transition(vec2 uv) {
+
+    float p = progress;
+    float strength = sin(p * 3.14159265);
+
+    vec2 tv = uv;
+
+    vec4 fromColor = getFromColor(tv);
+    vec4 toColor   = getToColor(tv);
+
+    vec4 color = mix(fromColor, toColor, p);
+
+    // horizontal tracking lines (key effect)
+    float lineY = floor(tv.y * 120.0);
+
+    float noise = hash(vec2(lineY, p * 20.0));
+
+    float line = step(0.92, noise);
+
+    // make lines drift during transition
+    float drift =
+        sin(tv.y * 30.0 + p * 10.0)
+        * 0.02
+        * strength;
+
+    vec4 shiftedFrom = getFromColor(tv + vec2(drift, 0.0));
+    vec4 shiftedTo   = getToColor(tv + vec2(drift, 0.0));
+
+    vec4 lineColor = mix(shiftedFrom, shiftedTo, p);
+
+    // apply tearing only on selected scanlines
+    color = mix(color, lineColor, line * strength);
+
+    // mild scanline darkening (CRT feel)
+    float scan =
+        sin(tv.y * 900.0) * 0.03;
+
+    color.rgb -= scan * strength;
+
+    return color;
+}