gl-transitions 1.71.0 → 1.72.0

package/sksl/CrazyParametricFun.sksl

@@ -0,0 +1,34 @@
+// CrazyParametricFun — 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
+
+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 a; 
+uniform float b; 
+uniform float amplitude; 
+uniform float smoothness; 
+
+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));
+}
+
+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/CrossZoom.sksl

@@ -0,0 +1,76 @@
+// CrossZoom — generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/CrossZoom.glsl
+// Author: rectalogic
+// License: MIT
+// Description: A crossfade through a strong zoom 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 strength; 
+
+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;
+
+    
+    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);
+
+    
+    float strength = Sinusoidal_easeInOut(0.0, strength, 0.5, progress);
+
+    vec4 color = vec4(0.0);
+    float total = 0.0;
+    vec2 toCenter = center - texCoord;
+
+                                                                         
+    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;
+}
+
+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/DefocusBlur.sksl

@@ -0,0 +1,56 @@
+// DefocusBlur — 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
+
+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 blurSize; 
+
+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);
+}
+
+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/Directional.sksl

@@ -0,0 +1,31 @@
+// Directional — 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
+
+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 vec2 direction; 
+
+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)
+  );
+}
+
+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/DirectionalScaled.sksl

@@ -0,0 +1,44 @@
+// DirectionalScaled — generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/DirectionalScaled.glsl
+// Author: Thibaut Foussard
+// License: MIT
+// Description: Like Directional, with both images scaled down while they slide
+
+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 vec2 direction; 
+uniform float scale; 
+
+float parabola(float x) {
+  float y = pow(sin(x * acos(-1.0)), 1.);
+  return y;
+}
+
+vec4 transition (vec2 uv) {
+  float easedProgress = pow(sin(progress  * acos(-1.0) / 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;
+}
+
+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/DoomScreenTransition.sksl

@@ -0,0 +1,65 @@
+// DoomScreenTransition — 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
+
+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 bars; 
+
+uniform float amplitude; 
+
+uniform float noise; 
+
+uniform float frequency; 
+
+uniform float dripScale; 
+
+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);
+  }
+
+  
+  return c;
+}
+
+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/Dreamy.sksl

@@ -0,0 +1,28 @@
+// Dreamy — 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
+
+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))); }
+
+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);
+}
+
+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/DreamyZoom.sksl

@@ -0,0 +1,46 @@
+// DreamyZoom — 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
+
+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 rotation; 
+
+uniform float scale; 
+
+vec4 transition(vec2 uv) {
+  
+  float phase = progress < 0.5 ? progress * 2.0 : (progress - 0.5) * 2.0;
+  float angleOffset = progress < 0.5 ? mix(0.0, rotation * 0.03926990816987241548078304229099, phase) : mix(-rotation * 0.03926990816987241548078304229099, 0.0, phase);
+  float newScale = progress < 0.5 ? mix(1.0, scale, phase) : mix(scale, 1.0, phase);
+  
+  vec2 center = vec2(0, 0);
+
+  
+  vec2 assumedCenter = vec2(0.5, 0.5);
+  vec2 p = (uv.xy - vec2(0.5, 0.5)) / newScale * vec2(ratio, 1.0);
+
+  
+  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);
+
+  
+  return c + (progress < 0.5 ? mix(0.0, 1.0, phase) : mix(1.0, 0.0, phase));
+}
+
+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/Drop_Zone_Flicker.sksl

@@ -0,0 +1,170 @@
+// Drop_Zone_Flicker — 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
+
+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 frameRate;    
+uniform float rgbOffset;    
+uniform float blockAmount;  
+uniform float ghostAmount;  
+uniform float redCyan;      
+uniform float scanline;     
+
+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));
+}
+
+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);
+
+  
+  
+  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);
+}
+
+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/EdgeTransition.sksl

@@ -0,0 +1,64 @@
+// EdgeTransition — 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
+
+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 edge_thickness; 
+uniform float edge_brightness; 
+
+vec4 detectEdgeColor(vec3[9] c) {
+                                        
+       
+       
+       
+    
+  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
+  );
+}
+
+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/FilmBurn.sksl

@@ -0,0 +1,75 @@
+// FilmBurn — 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
+
+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 Seed; 
+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.));
+}
+
+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.-clamp(length(p-vec2(smooth_random(vec2(progress*1.3),i+1.),smooth_random(vec2(progress*.5),i+6.25)))*mix(20.,70.,rand(i)),0.,1.);
+  }
+  f += 4.;
+  f /= 11.;
+  f = pow3(f*vec3(1.,0.7,0.6),vec3(1.,2.-sin(progress*3.14159265358979323),1.3));
+  f *= sin(progress*3.14159265358979323);
+  
+  p -= .5;
+  p *= 1.+(smooth_random(vec2(progress*5.),6.3)*sin(progress*3.14159265358979323)*.05);
+  p += .5;
+  
+  vec4 blurred_image = vec4(0.);
+  float bluramount = sin(progress*3.14159265358979323)*.03;
+
+  for (float i = 0.; i < 50.; i++) { 
+      vec2 q = vec2(cos(degrees((i/50.)*360.)),sin(degrees((i/50.)*360.))) *  (rand(vec2(i,p.x+p.y))+bluramount); 
+      vec2 uv2 = p+(q*bluramount);
+      blurred_image += blendedColor(uv2);
+  }
+  blurred_image /= 50.;
+  
+  return blurred_image+vec4(f,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);
+}