gl-transitions 1.71.0 → 1.72.0

package/sksl/Fold.sksl

@@ -0,0 +1,25 @@
+// Fold — 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
+
+uniform shader _from;
+uniform shader _to;
+uniform float2 _resolution;
+uniform float progress;
+uniform float ratio;
+
+vec4 getFromColor(vec2 uv) { return vec4(unpremul(_from.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }
+vec4 getToColor(vec2 uv) { return vec4(unpremul(_to.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }
+
+vec4 transition(vec2 uv) {
+  vec4 a = getFromColor((uv - vec2(progress, 0.0)) / vec2(1.0 - progress, 1.0));
+  vec4 b = getToColor(uv / vec2(progress, 1.0));
+  return mix(a, b, step(uv.x, progress));
+}
+
+half4 main(float2 _coord) {
+  vec2 _uv = _coord / _resolution;
+  vec4 _c = clamp(transition(vec2(_uv.x, 1.0 - _uv.y)), 0.0, 1.0);
+  return half4(_c.rgb * _c.a, _c.a);
+}

package/sksl/GlitchDisplace.sksl

@@ -0,0 +1,90 @@
+// GlitchDisplace — 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
+
+uniform shader _from;
+uniform shader _to;
+uniform float2 _resolution;
+uniform float progress;
+uniform float ratio;
+
+vec4 getFromColor(vec2 uv) { return vec4(unpremul(_from.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }
+vec4 getToColor(vec2 uv) { return vec4(unpremul(_to.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }
+
+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);
+  
+
+   
+}
+
+half4 main(float2 _coord) {
+  vec2 _uv = _coord / _resolution;
+  vec4 _c = clamp(transition(vec2(_uv.x, 1.0 - _uv.y)), 0.0, 1.0);
+  return half4(_c.rgb * _c.a, _c.a);
+}

package/sksl/GlitchMemories.sksl

@@ -0,0 +1,31 @@
+// GlitchMemories — generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/GlitchMemories.glsl
+// Author: Gunnar Roth
+// License: MIT
+// Description: A crossfade with glitchy, color-shifted blocks
+
+uniform shader _from;
+uniform shader _to;
+uniform float2 _resolution;
+uniform float progress;
+uniform float ratio;
+
+vec4 getFromColor(vec2 uv) { return vec4(unpremul(_from.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }
+vec4 getToColor(vec2 uv) { return vec4(unpremul(_to.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }
+
+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);
+}
+
+half4 main(float2 _coord) {
+  vec2 _uv = _coord / _resolution;
+  vec4 _c = clamp(transition(vec2(_uv.x, 1.0 - _uv.y)), 0.0, 1.0);
+  return half4(_c.rgb * _c.a, _c.a);
+}

package/sksl/GridFlip.sksl

@@ -0,0 +1,89 @@
+// GridFlip — generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/GridFlip.glsl
+// Author: TimDonselaar
+// License: MIT
+// Description: The image splits into a grid of tiles that flip one by one to the incoming image
+
+uniform shader _from;
+uniform shader _to;
+uniform float2 _resolution;
+uniform float progress;
+uniform float ratio;
+
+vec4 getFromColor(vec2 uv) { return vec4(unpremul(_from.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }
+vec4 getToColor(vec2 uv) { return vec4(unpremul(_to.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }
+
+uniform ivec2 size; 
+uniform float pause; 
+uniform float dividerWidth; 
+
+uniform vec4 bgcolor; 
+uniform float randomness; 
+ 
+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);
+  }
+}
+
+half4 main(float2 _coord) {
+  vec2 _uv = _coord / _resolution;
+  vec4 _c = clamp(transition(vec2(_uv.x, 1.0 - _uv.y)), 0.0, 1.0);
+  return half4(_c.rgb * _c.a, _c.a);
+}

package/sksl/HSVfade.sksl

@@ -0,0 +1,40 @@
+// HSVfade — 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
+
+uniform shader _from;
+uniform shader _to;
+uniform float2 _resolution;
+uniform float progress;
+uniform float ratio;
+
+vec4 getFromColor(vec2 uv) { return vec4(unpremul(_from.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }
+vec4 getToColor(vec2 uv) { return vec4(unpremul(_to.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }
+
+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);
+}
+
+half4 main(float2 _coord) {
+  vec2 _uv = _coord / _resolution;
+  vec4 _c = clamp(transition(vec2(_uv.x, 1.0 - _uv.y)), 0.0, 1.0);
+  return half4(_c.rgb * _c.a, _c.a);
+}

package/sksl/HorizontalClose.sksl

@@ -0,0 +1,30 @@
+// HorizontalClose — 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
+
+uniform shader _from;
+uniform shader _to;
+uniform float2 _resolution;
+uniform float progress;
+uniform float ratio;
+
+vec4 getFromColor(vec2 uv) { return vec4(unpremul(_from.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }
+vec4 getToColor(vec2 uv) { return vec4(unpremul(_to.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }
+
+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)
+  ); 
+}
+
+half4 main(float2 _coord) {
+  vec2 _uv = _coord / _resolution;
+  vec4 _c = clamp(transition(vec2(_uv.x, 1.0 - _uv.y)), 0.0, 1.0);
+  return half4(_c.rgb * _c.a, _c.a);
+}

package/sksl/HorizontalOpen.sksl

@@ -0,0 +1,32 @@
+// HorizontalOpen — generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/HorizontalOpen.glsl
+// Author: martiniti
+// License: MIT
+// Description: The incoming image opens from a line in the middle toward the top and bottom edges
+
+uniform shader _from;
+uniform shader _to;
+uniform float2 _resolution;
+uniform float progress;
+uniform float ratio;
+
+vec4 getFromColor(vec2 uv) { return vec4(unpremul(_from.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }
+vec4 getToColor(vec2 uv) { return vec4(unpremul(_to.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }
+
+vec4 transition (vec2 uv) {
+  
+  float regress = 1.0 - progress;
+
+  float s = 2.0 - abs((uv.y - 0.5) / (regress - 1.0)) - 2.0 * regress;
+  
+  return mix(
+    getFromColor(uv),
+    getToColor(uv),
+    smoothstep(0.0, 0.5, s)
+  );
+}
+
+half4 main(float2 _coord) {
+  vec2 _uv = _coord / _resolution;
+  vec4 _c = clamp(transition(vec2(_uv.x, 1.0 - _uv.y)), 0.0, 1.0);
+  return half4(_c.rgb * _c.a, _c.a);
+}

package/sksl/InvertedPageCurl.sksl

@@ -0,0 +1,207 @@
+// InvertedPageCurl — generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/InvertedPageCurl.glsl
+// Author: Hewlett-Packard
+// License: BSD 3 Clause
+// Description: The outgoing image curls away like a page, revealing the incoming one
+
+uniform shader _from;
+uniform shader _to;
+uniform float2 _resolution;
+uniform float progress;
+uniform float ratio;
+
+vec4 getFromColor(vec2 uv) { return vec4(unpremul(_from.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }
+vec4 getToColor(vec2 uv) { return vec4(unpremul(_to.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }
+
+const float MIN_AMOUNT = -0.16;
+const float MAX_AMOUNT = 1.5;
+
+const float PI = 3.141592653589793;
+
+const float scale = 512.0;
+const float sharpness = 3.0;
+
+const float cylinderRadius = 1.0 / PI / 2.0;
+
+float amount;
+float cylinderCenter;
+float cylinderAngle;
+
+vec3 hitPoint(float hitAngle, float yc, vec3 point, mat3 rrotation)
+{
+        float hitPoint = hitAngle / (2.0 * PI);
+        point.y = hitPoint;
+        return rrotation * point;
+}
+
+vec4 antiAlias(vec4 color1, vec4 color2, float distanc)
+{
+        distanc *= scale;
+        if (distanc < 0.0) return color2;
+        if (distanc > 2.0) return color1;
+        float dd = pow(1.0 - distanc / 2.0, sharpness);
+        return ((color2 - color1) * dd) + color1;
+}
+
+float distanceToEdge(vec3 point)
+{
+        float dx = abs(point.x > 0.5 ? 1.0 - point.x : point.x);
+        float dy = abs(point.y > 0.5 ? 1.0 - point.y : point.y);
+        if (point.x < 0.0) dx = -point.x;
+        if (point.x > 1.0) dx = point.x - 1.0;
+        if (point.y < 0.0) dy = -point.y;
+        if (point.y > 1.0) dy = point.y - 1.0;
+        if ((point.x < 0.0 || point.x > 1.0) && (point.y < 0.0 || point.y > 1.0)) return sqrt(dx * dx + dy * dy);
+        return min(dx, dy);
+}
+
+vec4 seeThrough(float yc, vec2 p, mat3 rotation, mat3 rrotation)
+{
+        float hitAngle = PI - (acos(clamp(yc / cylinderRadius, -1.0, 1.0)) - cylinderAngle);
+        vec3 point = hitPoint(hitAngle, yc, rotation * vec3(p, 1.0), rrotation);
+        if (yc <= 0.0 && (point.x < 0.0 || point.y < 0.0 || point.x > 1.0 || point.y > 1.0))
+        {
+            return getToColor(p);
+        }
+
+        if (yc > 0.0) return getFromColor(p);
+
+        vec4 color = getFromColor(point.xy);
+        vec4 tcolor = vec4(0.0);
+
+        return antiAlias(color, tcolor, distanceToEdge(point));
+}
+
+vec4 seeThroughWithShadow(float yc, vec2 p, vec3 point, mat3 rotation, mat3 rrotation)
+{
+        float shadow = distanceToEdge(point) * 30.0;
+        shadow = (1.0 - shadow) / 3.0;
+
+        if (shadow < 0.0) shadow = 0.0; else shadow *= amount;
+
+        vec4 shadowColor = seeThrough(yc, p, rotation, rrotation);
+        shadowColor.r -= shadow;
+        shadowColor.g -= shadow;
+        shadowColor.b -= shadow;
+
+        return shadowColor;
+}
+
+vec4 backside(float yc, vec3 point)
+{
+        vec4 color = getFromColor(point.xy);
+        float gray = (color.r + color.b + color.g) / 15.0;
+        gray += (8.0 / 10.0) * (pow(max(0.0, 1.0 - abs(yc / cylinderRadius)), 2.0 / 10.0) / 2.0 + (5.0 / 10.0));
+        color.rgb = vec3(gray);
+        return color;
+}
+
+vec4 behindSurface(vec2 p, float yc, vec3 point, mat3 rrotation)
+{
+        float safeAmount = amount >= 0.0 ? max(amount, 1e-4) : min(amount, -1e-4);
+        float shado = (1.0 - ((-cylinderRadius - yc) / safeAmount * 7.0)) / 6.0;
+        shado *= 1.0 - abs(point.x - 0.5);
+
+        yc = (-cylinderRadius - cylinderRadius - yc);
+
+        float hitAngle = (acos(clamp(yc / cylinderRadius, -1.0, 1.0)) + cylinderAngle) - PI;
+        point = hitPoint(hitAngle, yc, point, rrotation);
+
+        if (yc < 0.0 && point.x >= 0.0 && point.y >= 0.0 && point.x <= 1.0 && point.y <= 1.0 && (hitAngle < PI || amount > 0.5))
+        {
+                float dx = point.x - 0.5;
+                float dy = point.y - 0.5;
+                shado = 1.0 - (sqrt(dx * dx + dy * dy) / (71.0 / 100.0));
+                float nyc = -yc / cylinderRadius;
+                shado *= nyc * nyc * nyc;
+                shado *= 0.5;
+        }
+        else
+        {
+                shado = 0.0;
+        }
+        return vec4(getToColor(p).rgb - shado, 1.0);
+}
+
+vec4 transition(vec2 p) {
+  amount = progress * (MAX_AMOUNT - MIN_AMOUNT) + MIN_AMOUNT;
+  cylinderCenter = amount;
+  cylinderAngle = 2.0 * PI * amount;
+
+  const float angle = 100.0 * PI / 180.0;
+        float c = cos(-angle);
+        float s = sin(-angle);
+
+        mat3 rotation = mat3( c, s, 0,
+                                                                -s, c, 0,
+                                                                -0.801, 0.8900, 1
+                                                                );
+        c = cos(angle);
+        s = sin(angle);
+
+        mat3 rrotation = mat3(	c, s, 0,
+                                                                        -s, c, 0,
+                                                                        0.98500, 0.985, 1
+                                                                );
+
+        vec3 point = rotation * vec3(p, 1.0);
+
+        float yc = point.y - cylinderCenter;
+
+        if (yc < -cylinderRadius)
+        {
+                
+                return behindSurface(p,yc, point, rrotation);
+        }
+
+        if (yc > cylinderRadius)
+        {
+                
+                return getFromColor(p);
+        }
+
+        float hitAngle = (acos(clamp(yc / cylinderRadius, -1.0, 1.0)) + cylinderAngle) - PI;
+
+        float hitAngleMod = mod(hitAngle, 2.0 * PI);
+        if ((hitAngleMod > PI && amount < 0.5) || (hitAngleMod > PI/2.0 && amount < 0.0))
+        {
+                return seeThrough(yc, p, rotation, rrotation);
+        }
+
+        point = hitPoint(hitAngle, yc, point, rrotation);
+
+        if (point.x < 0.0 || point.y < 0.0 || point.x > 1.0 || point.y > 1.0)
+        {
+                return seeThroughWithShadow(yc, p, point, rotation, rrotation);
+        }
+
+        vec4 color = backside(yc, point);
+
+        vec4 otherColor;
+        if (yc < 0.0)
+        {
+                float dx2 = point.x - 0.5;
+                float dy2 = point.y - 0.5;
+                float shado = 1.0 - (sqrt(dx2 * dx2 + dy2 * dy2) / 0.71);
+                float nyc2 = -yc / cylinderRadius;
+                shado *= nyc2 * nyc2 * nyc2;
+                shado *= 0.5;
+                otherColor = vec4(0.0, 0.0, 0.0, shado);
+        }
+        else
+        {
+                otherColor = getFromColor(p);
+        }
+
+        color = antiAlias(color, otherColor, cylinderRadius - abs(yc));
+
+        vec4 cl = seeThroughWithShadow(yc, p, point, rotation, rrotation);
+        float dist = distanceToEdge(point);
+
+        return antiAlias(color, cl, dist);
+}
+
+half4 main(float2 _coord) {
+  vec2 _uv = _coord / _resolution;
+  vec4 _c = clamp(transition(vec2(_uv.x, 1.0 - _uv.y)), 0.0, 1.0);
+  return half4(_c.rgb * _c.a, _c.a);
+}

package/sksl/LeftRight.sksl

@@ -0,0 +1,42 @@
+// LeftRight — generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/LeftRight.glsl
+// Author: zhmy
+// License: MIT
+// Description: The outgoing image shrinks away to the left while the incoming one slides in from the right
+
+uniform shader _from;
+uniform shader _to;
+uniform float2 _resolution;
+uniform float progress;
+uniform float ratio;
+
+vec4 getFromColor(vec2 uv) { return vec4(unpremul(_from.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }
+vec4 getToColor(vec2 uv) { return vec4(unpremul(_to.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }
+
+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));
+}
+
+vec4 transition (vec2 uv) {
+    vec2 spfr,spto = vec2(-1.);
+
+    float size = mix(1.0, 3.0, progress*0.2);
+    spto = (uv + vec2(-0.5,-0.5))*vec2(size,size)+vec2(0.5,0.5);
+    spfr = (uv - vec2(1.-progress, 0.0));
+    if(inBounds(spfr)){
+        return getToColor(spfr);
+    }else if(inBounds(spto)){
+        return getFromColor(spto) * (1.0 - progress);
+    } else{
+        return black;
+    }
+}
+
+half4 main(float2 _coord) {
+  vec2 _uv = _coord / _resolution;
+  vec4 _c = clamp(transition(vec2(_uv.x, 1.0 - _uv.y)), 0.0, 1.0);
+  return half4(_c.rgb * _c.a, _c.a);
+}

package/sksl/LinearBlur.sksl

@@ -0,0 +1,44 @@
+// LinearBlur — generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/LinearBlur.glsl
+// Author: gre
+// License: MIT
+// Description: A crossfade through a blur
+
+uniform shader _from;
+uniform shader _to;
+uniform float2 _resolution;
+uniform float progress;
+uniform float ratio;
+
+vec4 getFromColor(vec2 uv) { return vec4(unpremul(_from.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }
+vec4 getToColor(vec2 uv) { return vec4(unpremul(_to.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }
+
+uniform float intensity; 
+const int passes = 6;
+
+vec4 transition(vec2 uv) {
+    vec4 c1 = vec4(0.0);
+    vec4 c2 = vec4(0.0);
+
+    float disp = intensity*(0.5-distance(0.5, progress));
+    for (int xi=0; xi<passes; xi++)
+    {
+        float x = float(xi) / float(passes) - 0.5;
+        for (int yi=0; yi<passes; yi++)
+        {
+            float y = float(yi) / float(passes) - 0.5;
+            vec2 v = vec2(x,y);
+            float d = disp;
+            c1 += getFromColor( uv + d*v);
+            c2 += getToColor( uv + d*v);
+        }
+    }
+    c1 /= float(passes*passes);
+    c2 /= float(passes*passes);
+    return mix(c1, c2, progress);
+}
+
+half4 main(float2 _coord) {
+  vec2 _uv = _coord / _resolution;
+  vec4 _c = clamp(transition(vec2(_uv.x, 1.0 - _uv.y)), 0.0, 1.0);
+  return half4(_c.rgb * _c.a, _c.a);
+}

package/sksl/Mosaic.sksl

@@ -0,0 +1,55 @@
+// Mosaic — generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/Mosaic.glsl
+// Author: Xaychru
+// License: MIT
+// Description: The view pans across a mosaic of rotated tiles from both images and settles on the incoming one
+
+uniform shader _from;
+uniform shader _to;
+uniform float2 _resolution;
+uniform float progress;
+uniform float ratio;
+
+vec4 getFromColor(vec2 uv) { return vec4(unpremul(_from.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }
+vec4 getToColor(vec2 uv) { return vec4(unpremul(_to.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }
+
+uniform int endx; 
+uniform int endy; 
+
+float Rand(vec2 v) {
+  return fract(sin(dot(v.xy ,vec2(12.9898,78.233))) * 43758.5453);
+}
+vec2 Rotate(vec2 v, float a) {
+  mat2 rm = mat2(cos(a), -sin(a),
+                 sin(a), cos(a));
+  return rm*v;
+}
+float CosInterpolation(float x) {
+  return -cos(x*3.14159265358979323)/2.+.5;
+}
+vec4 transition(vec2 uv) {
+  vec2 p = uv.xy / vec2(1.0).xy - .5;
+  vec2 rp = p;
+  float rpr = (progress*2.-1.);
+  float z = -(rpr*rpr*2.) + 3.;
+  float az = abs(z);
+  rp *= az;
+  rp += mix(vec2(.5, .5), vec2(float(endx) + .5, float(endy) + .5), CosInterpolation(progress)*CosInterpolation(progress));
+  vec2 mrp = mod(rp, 1.);
+  vec2 crp = rp;
+  bool onEnd = int(floor(crp.x))==endx&&int(floor(crp.y))==endy;
+  if(!onEnd) {
+    float ang = float(int(Rand(floor(crp))*4.))*.5*3.14159265358979323;
+    mrp = vec2(.5) + Rotate(mrp-vec2(.5), ang);
+  }
+  if(onEnd || Rand(floor(crp))>.5) {
+    return getToColor(mrp);
+  } else {
+    return getFromColor(mrp);
+  }
+}
+
+half4 main(float2 _coord) {
+  vec2 _uv = _coord / _resolution;
+  vec4 _c = clamp(transition(vec2(_uv.x, 1.0 - _uv.y)), 0.0, 1.0);
+  return half4(_c.rgb * _c.a, _c.a);
+}