gl-transitions 1.74.0 → 1.76.0

package/glsl3/AdvancedMosaic.glsl

@@ -0,0 +1,21 @@
+// AdvancedMosaic — GLSL ES 3.00, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/AdvancedMosaic.glsl
+// Author: Sergey Kosarevsky
+// License: MIT
+// Description: Both images break into large blocks that blend, then sharpen into the incoming image
+// Tags: pixelate, mosaic, blend
+// Ported from https://gist.github.com/corporateshark/21d2fdd24c706952dc8c
+
+uniform float pixelSize; // = 50.0
+
+vec4 transition(vec2 uv) {
+  float T = progress;
+  float half_ = 0.5;
+  float size = (T < half_) ? mix(1.0, pixelSize, T / half_) : mix(pixelSize, 1.0, (T - half_) / half_);
+  float D = size * 0.005;
+  // Remap UV to center the mosaic pattern
+  vec2 UV = (uv - 0.5) / D;
+  vec2 coord = clamp(D * (ceil(UV - 0.5)) + 0.5, 0.0, 1.0);
+  vec4 C0 = getFromColor(coord);
+  vec4 C1 = getToColor(coord);
+  return mix(C0, C1, T);
+}

package/glsl3/BlockDissolve.glsl

@@ -0,0 +1,16 @@
+// BlockDissolve — GLSL ES 3.00, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/BlockDissolve.glsl
+// Author: nwoeanhinnogaehr
+// License: MIT
+// Description: The incoming image appears in small random blocks
+// Tags: dissolve, blocks, noise
+// Ported from https://gist.github.com/nwoeanhinnogaehr/b93818de23d4511fde10
+
+uniform float blocksize; // = 0.02
+
+float rand(vec2 co) {
+  return fract(sin(dot(co, vec2(12.9898, 78.233))) * 43758.5453);
+}
+
+vec4 transition(vec2 uv) {
+  return mix(getFromColor(uv), getToColor(uv), step(rand(floor(uv / blocksize)), progress));
+}

package/glsl3/BookFlip.glsl

@@ -0,0 +1,37 @@
+// BookFlip — GLSL ES 3.00, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/BookFlip.glsl
+// Author: hong
+// License: MIT
+// Description: The outgoing image turns like a book page from right to left, revealing the incoming one
+// Tags: page, flip, 3d
+
+// Avoids dividing by zero when the page is edge-on (progress = 0.5).
+float nonZero(float x) {
+  return abs(x) < 1e-4 ? (x < 0.0 ? -1e-4 : 1e-4) : x;
+}
+
+vec2 skewRight(vec2 p) {
+  float skewX = (p.x - progress)/nonZero(0.5 - progress) * 0.5;
+  float skewY =  (p.y - 0.5)/(0.5 + progress * (p.x - 0.5) / 0.5)* 0.5  + 0.5;
+  return vec2(skewX, skewY);
+}
+
+vec2 skewLeft(vec2 p) {
+  float skewX = (p.x - 0.5)/nonZero(progress - 0.5) * 0.5 + 0.5;
+  float skewY = (p.y - 0.5) / (0.5 + (1.0 - progress ) * (0.5 - p.x) / 0.5) * 0.5  + 0.5;
+  return vec2(skewX, skewY);
+}
+
+vec4 addShade() {
+  float shadeVal  =  max(0.7, abs(progress - 0.5) * 2.0);
+  return vec4(vec3(shadeVal ), 1.0);
+}
+
+vec4 transition (vec2 p) {
+  float pr = step(1.0 - progress, p.x);
+
+  if (p.x < 0.5) {
+    return mix(getFromColor(p), getToColor(skewLeft(p)) * addShade(), pr);
+  } else {
+    return mix(getFromColor(skewRight(p)) * addShade(), getToColor(p),   pr);
+  }
+}

package/glsl3/Bounce.glsl

@@ -0,0 +1,35 @@
+// Bounce — GLSL ES 3.00, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/Bounce.glsl
+// Author: Adrian Purser
+// License: MIT
+// Description: The outgoing image drops out of the frame with a few bounces, revealing the incoming one
+// Tags: bounce, slide, vertical, shadow
+
+// @color Color of the shadow cast on the incoming image
+uniform vec4 shadow_colour; // = vec4(0.,0.,0.,.6)
+// @range(0.01, 0.5) Height of the shadow, relative to the image height
+uniform float shadow_height; // = 0.075
+// @range(1, 10, 1) Number of bounces before settling
+uniform float bounces; // = 3.0
+
+const float PI = 3.14159265358;
+
+vec4 transition (vec2 uv) {
+  float time = progress;
+  float stime = sin(time * PI / 2.);
+  float phase = time * PI * bounces;
+  float y = (abs(cos(phase))) * (1.0 - stime);
+  float d = uv.y - y;
+  return mix(
+    mix(
+      getToColor(uv),
+      shadow_colour,
+      step(d, shadow_height) * (1. - mix(
+        ((d / shadow_height) * shadow_colour.a) + (1.0 - shadow_colour.a),
+        1.0,
+        smoothstep(0.95, 1., progress) // fade-out the shadow at the end
+      ))
+    ),
+    getFromColor(vec2(uv.x, uv.y + (1.0 - y))),
+    step(d, 0.0)
+  );
+}

package/glsl3/BowTieHorizontal.glsl

@@ -0,0 +1,123 @@
+// BowTieHorizontal — GLSL ES 3.00, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/BowTieHorizontal.glsl
+// Author: huynx
+// License: MIT
+// Description: Two triangles grow from the left and right edges into a bow tie that reveals the incoming image
+// Tags: wipe, shape, horizontal
+
+const vec2 bottom_left = vec2(0.0, 1.0);
+const vec2 bottom_right = vec2(1.0, 1.0);
+const vec2 top_left = vec2(0.0, 0.0);
+const vec2 top_right = vec2(1.0, 0.0);
+const vec2 center = vec2(0.5, 0.5);
+
+float check(vec2 p1, vec2 p2, vec2 p3)
+{
+  return (p1.x - p3.x) * (p2.y - p3.y) - (p2.x - p3.x) * (p1.y - p3.y);
+}
+
+bool PointInTriangle (vec2 pt, vec2 p1, vec2 p2, vec2 p3)
+{
+    bool b1, b2, b3;
+    b1 = check(pt, p1, p2) < 0.0;
+    b2 = check(pt, p2, p3) < 0.0;
+    b3 = check(pt, p3, p1) < 0.0;
+    return ((b1 == b2) && (b2 == b3));
+}
+
+bool in_left_triangle(vec2 p){
+  vec2 vertex1, vertex2, vertex3;
+  vertex1 = vec2(progress, 0.5);
+  vertex2 = vec2(0.0, 0.5-progress);
+  vertex3 = vec2(0.0, 0.5+progress);
+  if (PointInTriangle(p, vertex1, vertex2, vertex3))
+  {
+    return true;
+  }
+  return false;
+}
+
+bool in_right_triangle(vec2 p){
+  vec2 vertex1, vertex2, vertex3;
+  vertex1 = vec2(1.0-progress, 0.5);
+  vertex2 = vec2(1.0, 0.5-progress);
+  vertex3 = vec2(1.0, 0.5+progress);
+  if (PointInTriangle(p, vertex1, vertex2, vertex3))
+  {
+    return true;
+  }
+  return false;
+}
+
+float blur_edge(vec2 bot1, vec2 bot2, vec2 top, vec2 testPt)
+{
+  vec2 lineDir = bot1 - top;
+  vec2 perpDir = vec2(lineDir.y, -lineDir.x);
+  vec2 dirToPt1 = bot1 - testPt;
+  float dist1 = abs(dot(normalize(perpDir), dirToPt1));
+  
+  lineDir = bot2 - top;
+  perpDir = vec2(lineDir.y, -lineDir.x);
+  dirToPt1 = bot2 - testPt;
+  float min_dist = min(abs(dot(normalize(perpDir), dirToPt1)), dist1);
+  
+  if (min_dist < 0.005) {
+    return min_dist / 0.005;
+  }
+  else  {
+    return 1.0;
+  };
+}
+
+
+vec4 transition (vec2 uv) {
+  if (in_left_triangle(uv))
+  {
+    if (progress < 0.1)
+    {
+      return getFromColor(uv);
+    }
+    if (uv.x < 0.5)
+    {
+      vec2 vertex1 = vec2(progress, 0.5);
+      vec2 vertex2 = vec2(0.0, 0.5-progress);
+      vec2 vertex3 = vec2(0.0, 0.5+progress);
+      return mix(
+        getFromColor(uv),
+        getToColor(uv),
+        blur_edge(vertex2, vertex3, vertex1, uv)
+      );
+    }
+    else
+    {
+      if (progress > 0.0)
+      {
+        return getToColor(uv);
+      }
+      else
+      {
+        return getFromColor(uv);
+      }
+    }    
+  }
+  else if (in_right_triangle(uv))
+  {
+    if (uv.x >= 0.5)
+    {
+      vec2 vertex1 = vec2(1.0-progress, 0.5);
+      vec2 vertex2 = vec2(1.0, 0.5-progress);
+      vec2 vertex3 = vec2(1.0, 0.5+progress);
+      return mix(
+        getFromColor(uv),
+        getToColor(uv),
+        blur_edge(vertex2, vertex3, vertex1, uv)
+      );  
+    }
+    else
+    {
+      return getFromColor(uv);
+    }
+  }
+  else {
+    return getFromColor(uv);
+  }
+}

package/glsl3/BowTieVertical.glsl

@@ -0,0 +1,117 @@
+// BowTieVertical — GLSL ES 3.00, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/BowTieVertical.glsl
+// Author: huynx
+// License: MIT
+// Description: Two triangles grow from the top and bottom edges into a bow tie that reveals the incoming image
+// Tags: wipe, shape, vertical
+
+float check(vec2 p1, vec2 p2, vec2 p3)
+{
+  return (p1.x - p3.x) * (p2.y - p3.y) - (p2.x - p3.x) * (p1.y - p3.y);
+}
+
+bool PointInTriangle (vec2 pt, vec2 p1, vec2 p2, vec2 p3)
+{
+    bool b1, b2, b3;
+    b1 = check(pt, p1, p2) < 0.0;
+    b2 = check(pt, p2, p3) < 0.0;
+    b3 = check(pt, p3, p1) < 0.0;
+    return ((b1 == b2) && (b2 == b3));
+}
+
+bool in_top_triangle(vec2 p){
+  vec2 vertex1, vertex2, vertex3;
+  vertex1 = vec2(0.5, progress);
+  vertex2 = vec2(0.5-progress, 0.0);
+  vertex3 = vec2(0.5+progress, 0.0);
+  if (PointInTriangle(p, vertex1, vertex2, vertex3))
+  {
+    return true;
+  }
+  return false;
+}
+
+bool in_bottom_triangle(vec2 p){
+  vec2 vertex1, vertex2, vertex3;
+  vertex1 = vec2(0.5, 1.0 - progress);
+  vertex2 = vec2(0.5-progress, 1.0);
+  vertex3 = vec2(0.5+progress, 1.0);
+  if (PointInTriangle(p, vertex1, vertex2, vertex3))
+  {
+    return true;
+  }
+  return false;
+}
+
+float blur_edge(vec2 bot1, vec2 bot2, vec2 top, vec2 testPt)
+{
+  vec2 lineDir = bot1 - top;
+  vec2 perpDir = vec2(lineDir.y, -lineDir.x);
+  vec2 dirToPt1 = bot1 - testPt;
+  float dist1 = abs(dot(normalize(perpDir), dirToPt1));
+  
+  lineDir = bot2 - top;
+  perpDir = vec2(lineDir.y, -lineDir.x);
+  dirToPt1 = bot2 - testPt;
+  float min_dist = min(abs(dot(normalize(perpDir), dirToPt1)), dist1);
+  
+  if (min_dist < 0.005) {
+    return min_dist / 0.005;
+  }
+  else  {
+    return 1.0;
+  };
+}
+
+
+vec4 transition (vec2 uv) {
+  if (in_top_triangle(uv))
+  {
+    if (progress < 0.1)
+    {
+      return getFromColor(uv);
+    }
+    if (uv.y < 0.5)
+    {
+      vec2 vertex1 = vec2(0.5, progress);
+      vec2 vertex2 = vec2(0.5-progress, 0.0);
+      vec2 vertex3 = vec2(0.5+progress, 0.0);
+      return mix(
+        getFromColor(uv),
+        getToColor(uv),
+        blur_edge(vertex2, vertex3, vertex1, uv)
+      );
+    }
+    else
+    {
+      if (progress > 0.0)
+      {
+        return getToColor(uv);
+      }
+      else
+      {
+        return getFromColor(uv);
+      }
+    }    
+  }
+  else if (in_bottom_triangle(uv))
+  {
+    if (uv.y >= 0.5)
+    {
+      vec2 vertex1 = vec2(0.5, 1.0-progress);
+      vec2 vertex2 = vec2(0.5-progress, 1.0);
+      vec2 vertex3 = vec2(0.5+progress, 1.0);
+      return mix(
+        getFromColor(uv),
+        getToColor(uv),
+        blur_edge(vertex2, vertex3, vertex1, uv)
+      );  
+    }
+    else
+    {
+      return getFromColor(uv);
+    }
+  }
+  else {
+    return getFromColor(uv);
+  }
+}

package/glsl3/BowTieWithParameter.glsl

@@ -0,0 +1,74 @@
+// BowTieWithParameter — GLSL ES 3.00, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/BowTieWithParameter.glsl
+// Author: KMojek
+// License: MIT
+// Description: A bow-tie wipe with an adjustable shape that can run in reverse
+// Tags: wipe, shape
+
+uniform float adjust; // = 0.5
+// @param Run the wipe in reverse
+uniform bool reverse; // = false
+
+float check(vec2 p1, vec2 p2, vec2 p3)
+{
+  return (p1.x - p3.x) * (p2.y - p3.y) - (p2.x - p3.x) * (p1.y - p3.y);
+}
+
+bool pointInTriangle(vec2 pt, vec2 p1, vec2 p2, vec2 p3)
+{
+
+    bool b1 = check(pt, p1, p2) < 0.0;
+    bool b2 = check(pt, p2, p3) < 0.0;
+    bool b3 = check(pt, p3, p1) < 0.0;
+    return b1 == b2 && b2 == b3;
+}
+
+const float height = 0.5;
+
+vec4 transition_firstHalf( vec2 uv, float prog )
+{
+  if ( uv.y < 0.5 )
+  {
+    vec2 botLeft = vec2( -0., prog-height );
+    vec2 botRight = vec2( 1., prog-height );
+    vec2 tip = vec2( adjust, prog );
+    if ( pointInTriangle( uv, botLeft, botRight, tip ) )
+        return getToColor(uv);
+    }
+  else
+  {
+    vec2 topLeft = vec2( -0., 1.-prog+height );
+    vec2 topRight = vec2( 1., 1.-prog+height );
+    vec2 tip = vec2( adjust, 1.-prog );
+    if ( pointInTriangle( uv, topLeft, topRight, tip ) )
+      return getToColor( uv );
+  }
+  return getFromColor( uv );
+}
+
+vec4 transition_secondHalf( vec2 uv, float prog )
+{
+  if ( uv.x > adjust )
+  {
+    vec2 top = vec2( prog + height,  1. );
+    vec2 bot = vec2( prog + height, -0. );
+    vec2 tip = vec2( mix( adjust, 1.0, 2.0 * (prog - 0.5) ), 0.5 );
+    if ( pointInTriangle( uv, top, bot, tip) )
+      return getFromColor( uv );
+  }
+  else
+  {
+    vec2 top = vec2( 1.0-prog - height,  1. );
+    vec2 bot = vec2( 1.0-prog - height, -0. );
+    vec2 tip = vec2( mix( adjust, 0.0, 2.0 * (prog - 0.5)  ), 0.5 );
+    if ( pointInTriangle( uv, top, bot, tip) )
+      return getFromColor( uv );
+  }
+  return getToColor( uv );
+}
+
+vec4 transition (vec2 uv) {
+  if ( reverse )
+    return ( progress < 0.5 ) ? transition_secondHalf( uv, 1.-progress ) : transition_firstHalf( uv, 1.-progress );
+  else
+    return ( progress < 0.5 ) ? transition_firstHalf( uv, progress ) : transition_secondHalf( uv, progress );
+}

package/glsl3/Box.glsl

@@ -0,0 +1,33 @@
+// Box — GLSL ES 3.00, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/Box.glsl
+// Author: lql
+// License: MIT
+// Description: The outgoing image shrinks into a box, toward the center or a corner, revealing the incoming one
+// Tags: box, zoom, shape
+uniform int rectIn; // =1
+// center:0, left_top:1, left_bottom:2, right_top:3, right_bottom:4
+// @range(0, 4, 1) Where the box goes: 0 center, 1 left top, 2 left bottom, 3 right top, 4 right bottom
+uniform int location; // =0
+
+vec4 transition(vec2 uv) {
+    float p = rectIn == 1 ? 1.0 - progress : progress;
+    float x1, y1, x2, y2;
+
+    // Determine rectangle coordinates based on location
+    if (location == 0) {
+        x1 = y1 = 0.5 * (1.0 - p);
+        x2 = y2 = 1.0 - x1;
+    } else {
+        // Calculate the x and y coordinates based on the location
+        x1 = (location == 1 || location == 2) ? 0.0 : 1.0 - p;
+        y1 = (location == 1 || location == 3) ? 1.0 - p : 0.0;
+        x2 = (location == 1 || location == 2) ? p : 1.0;
+        y2 = (location == 1 || location == 3) ? 1.0 : p;
+    }
+
+    // Determine if the point is inside the rectangle
+    float in_rect = step(x1, uv.x) * step(uv.x, x2) * step(y1, uv.y) * step(uv.y, y2);
+    in_rect = rectIn == 1 ? 1.0 - in_rect : in_rect;
+
+    // Mix colors based on the in_rect value
+    return mix(getFromColor(uv), getToColor(uv), in_rect);
+}

package/glsl3/ButterflyWaveScrawler.glsl

@@ -0,0 +1,33 @@
+// ButterflyWaveScrawler — GLSL ES 3.00, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/ButterflyWaveScrawler.glsl
+// Author: mandubian
+// License: MIT
+// Description: Wavy, color-separated ripples scramble the outgoing image into the incoming one
+// Tags: wave, distort, chromatic
+uniform float amplitude; // = 1.0
+uniform float waves; // = 30.0
+uniform float colorSeparation; // = 0.3
+const float PI = 3.14159265358979323846264;
+float compute(vec2 p, float progress, vec2 center) {
+vec2 o = p*sin(progress * amplitude)-center;
+// horizontal vector
+vec2 h = vec2(1., 0.);
+// butterfly polar function (don't ask me why this one :))
+float theta = acos(dot(o, h)) * waves;
+float s = sin((2.*theta - PI) / 24.);
+float s2 = s * s;
+return (exp(cos(theta)) - 2.*cos(4.*theta) + s2 * s2 * s) / 10.;
+}
+vec4 transition(vec2 uv) {
+  if (progress <= 0.0) return getFromColor(uv);
+  if (progress >= 1.0) return getToColor(uv);
+  vec2 p = uv;
+  float inv = 1. - progress;
+  float disp = compute(p, progress, vec2(0.5, 0.5));
+  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/CircleCrop.glsl

@@ -0,0 +1,20 @@
+// CircleCrop — GLSL ES 3.00, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/CircleCrop.glsl
+// License: MIT
+// Author: fkuteken
+// Description: The outgoing image closes into a circle over a background color, then the incoming one opens from it
+// Tags: circle, iris, shape
+// ported by gre from https://gist.github.com/fkuteken/f63e3009c1143950dee9063c3b83fb88
+
+// @color Background color
+uniform vec4 bgcolor; // = vec4(0.0, 0.0, 0.0, 1.0)
+
+vec4 transition(vec2 p) {
+  vec2 ratio2 = vec2(1.0, 1.0 / ratio);
+  float s = pow(2.0 * abs(progress - 0.5), 3.0);
+  float dist = length((vec2(p) - 0.5) * ratio2);
+  return mix(
+    progress < 0.5 ? getFromColor(p) : getToColor(p), // branching is ok here as we statically depend on progress uniform (branching won't change over pixels)
+    bgcolor,
+    step(s, dist)
+  );
+}

package/glsl3/ColourDistance.glsl

@@ -0,0 +1,19 @@
+// ColourDistance — GLSL ES 3.00, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/ColourDistance.glsl
+// License: MIT
+// Author: P-Seebauer
+// Description: Pixels switch to the incoming image in order of how close their colors are
+// Tags: blend, color
+// ported by gre from https://gist.github.com/P-Seebauer/2a5fa2f77c883dd661f9
+
+uniform float power; // = 5.0
+
+vec4 transition(vec2 p) {
+  vec4 fTex = getFromColor(p);
+  vec4 tTex = getToColor(p);
+  float m = step(distance(fTex, tTex), progress);
+  return mix(
+    mix(fTex, tTex, m),
+    tTex,
+    pow(progress, power)
+  );
+}

package/glsl3/CrazyParametricFun.glsl

@@ -0,0 +1,20 @@
+// CrazyParametricFun — GLSL ES 3.00, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/CrazyParametricFun.glsl
+// Author: mandubian
+// License: MIT
+// Description: The outgoing image is pulled along a parametric curve into a psychedelic swirl
+// Tags: distort, psychedelic
+
+uniform float a; // = 4
+uniform float b; // = 1
+uniform float amplitude; // = 120
+uniform float smoothness; // = 0.1
+
+vec4 transition(vec2 uv) {
+  vec2 p = uv.xy / vec2(1.0).xy;
+  vec2 dir = p - vec2(.5);
+  float dist = length(dir);
+  float x = (a - b) * cos(progress) + b * cos(progress * ((a / b) - 1.) );
+  float y = (a - b) * sin(progress) - b * sin(progress * ((a / b) - 1.));
+  vec2 offset = dir * vec2(sin(progress  * dist * amplitude * x), sin(progress * dist * amplitude * y)) / smoothness;
+  return mix(getFromColor(p + offset), getToColor(p), smoothstep(0.2, 1.0, progress));
+}

package/glsl3/CrossZoom.glsl

@@ -0,0 +1,68 @@
+// CrossZoom — GLSL ES 3.00, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/CrossZoom.glsl
+// License: MIT
+// Author: rectalogic
+// Description: A crossfade through a strong zoom blur
+// Tags: zoom, blur, blend
+// ported by gre from https://gist.github.com/rectalogic/b86b90161503a0023231
+
+// Converted from https://github.com/rectalogic/rendermix-basic-effects/blob/master/assets/com/rendermix/CrossZoom/CrossZoom.frag
+// Which is based on https://github.com/evanw/glfx.js/blob/master/src/filters/blur/zoomblur.js
+// With additional easing functions from https://github.com/rectalogic/rendermix-basic-effects/blob/master/assets/com/rendermix/Easing/Easing.glsllib
+
+// @range(0, 1) Blur strength
+uniform float strength; // = 0.4
+
+const float PI = 3.141592653589793;
+
+float Linear_ease(in float begin, in float change, in float duration, in float time) {
+    return change * time / duration + begin;
+}
+
+float Exponential_easeInOut(in float begin, in float change, in float duration, in float time) {
+    if (time == 0.0)
+        return begin;
+    else if (time == duration)
+        return begin + change;
+    time = time / (duration / 2.0);
+    if (time < 1.0)
+        return change / 2.0 * pow(2.0, 10.0 * (time - 1.0)) + begin;
+    return change / 2.0 * (-pow(2.0, -10.0 * (time - 1.0)) + 2.0) + begin;
+}
+
+float Sinusoidal_easeInOut(in float begin, in float change, in float duration, in float time) {
+    return -change / 2.0 * (cos(PI * time / duration) - 1.0) + begin;
+}
+
+float rand (vec2 co) {
+  return fract(sin(dot(co.xy ,vec2(12.9898,78.233))) * 43758.5453);
+}
+
+vec4 crossFade(in vec2 uv, in float dissolve) {
+    return mix(getFromColor(uv), getToColor(uv), dissolve);
+}
+
+vec4 transition(vec2 uv) {
+    vec2 texCoord = uv.xy / vec2(1.0).xy;
+
+    // Linear interpolate center across center half of the image
+    vec2 center = vec2(Linear_ease(0.25, 0.5, 1.0, progress), 0.5);
+    float dissolve = Exponential_easeInOut(0.0, 1.0, 1.0, progress);
+
+    // Mirrored sinusoidal loop. 0->strength then strength->0
+    float strength = Sinusoidal_easeInOut(0.0, strength, 0.5, progress);
+
+    vec4 color = vec4(0.0);
+    float total = 0.0;
+    vec2 toCenter = center - texCoord;
+
+    /* randomize the lookup values to hide the fixed number of samples */
+    float offset = rand(uv);
+
+    for (float t = 0.0; t <= 40.0; t++) {
+        float percent = (t + offset) / 40.0;
+        float weight = 4.0 * (percent - percent * percent);
+        color += crossFade(texCoord + toCenter * percent * strength, dissolve) * weight;
+        total += weight;
+    }
+    return color / total;
+}

package/glsl3/DefocusBlur.glsl

@@ -0,0 +1,47 @@
+// DefocusBlur — GLSL ES 3.00, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/DefocusBlur.glsl
+// Author: Sergey Kosarevsky
+// License: MIT
+// Description: A crossfade through an out-of-focus blur
+// Tags: blur, blend
+// Ported from https://gist.github.com/corporateshark/b9f8e5675c647e615419
+
+// @param Amount of blur
+uniform float blurSize; // = 0.02
+
+// 12-tap Poisson disk
+// https://github.com/spite/Wagner/blob/master/fragment-shaders/poisson-disc-blur-fs.glsl
+
+vec4 transition(vec2 uv) {
+  float T = progress;
+  float half_ = 0.5;
+  float D = (T < half_) ? mix(0.0, blurSize, T / half_) : mix(blurSize, 0.0, (T - half_) / half_);
+  vec4 C0 = getFromColor(uv);
+  vec4 C1 = getToColor(uv);
+  C0 += getFromColor(vec2(-0.326, -0.406) * D + uv);
+  C1 += getToColor(vec2(-0.326, -0.406) * D + uv);
+  C0 += getFromColor(vec2(-0.840, -0.074) * D + uv);
+  C1 += getToColor(vec2(-0.840, -0.074) * D + uv);
+  C0 += getFromColor(vec2(-0.696,  0.457) * D + uv);
+  C1 += getToColor(vec2(-0.696,  0.457) * D + uv);
+  C0 += getFromColor(vec2(-0.203,  0.621) * D + uv);
+  C1 += getToColor(vec2(-0.203,  0.621) * D + uv);
+  C0 += getFromColor(vec2( 0.962, -0.195) * D + uv);
+  C1 += getToColor(vec2( 0.962, -0.195) * D + uv);
+  C0 += getFromColor(vec2( 0.473, -0.480) * D + uv);
+  C1 += getToColor(vec2( 0.473, -0.480) * D + uv);
+  C0 += getFromColor(vec2( 0.519,  0.767) * D + uv);
+  C1 += getToColor(vec2( 0.519,  0.767) * D + uv);
+  C0 += getFromColor(vec2( 0.185, -0.893) * D + uv);
+  C1 += getToColor(vec2( 0.185, -0.893) * D + uv);
+  C0 += getFromColor(vec2( 0.507,  0.064) * D + uv);
+  C1 += getToColor(vec2( 0.507,  0.064) * D + uv);
+  C0 += getFromColor(vec2( 0.896,  0.412) * D + uv);
+  C1 += getToColor(vec2( 0.896,  0.412) * D + uv);
+  C0 += getFromColor(vec2(-0.322, -0.933) * D + uv);
+  C1 += getToColor(vec2(-0.322, -0.933) * D + uv);
+  C0 += getFromColor(vec2(-0.792, -0.598) * D + uv);
+  C1 += getToColor(vec2(-0.792, -0.598) * D + uv);
+  C0 /= 13.0;
+  C1 /= 13.0;
+  return mix(C0, C1, T);
+}