gl-transitions 1.71.0 → 1.72.0

package/sksl/Overexposure.sksl

@@ -0,0 +1,38 @@
+// Overexposure — generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/Overexposure.glsl
+// Author: Ben Zhang
+// License: MIT
+// Description: A crossfade through a washed-out, overexposed white
+
+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;
+
+vec4 transition (vec2 uv) {
+  vec4 from = getFromColor(uv);
+  vec4 to = getToColor(uv);
+
+  
+  float from_m = 1.0 - progress + sin(PI * progress) * strength;
+  float to_m = progress + sin(PI * progress) * strength;
+  
+  return vec4(
+    from.r * from.a * from_m + to.r * to.a * to_m,
+    from.g * from.a * from_m + to.g * to.a * to_m,
+    from.b * from.a * from_m + to.b * to.a * to_m,
+    mix(from.a, to.a, 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/PolkaDotsCurtain.sksl

@@ -0,0 +1,29 @@
+// PolkaDotsCurtain — generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/PolkaDotsCurtain.glsl
+// Author: bobylito
+// License: MIT
+// Description: The incoming image appears through growing polka dots
+
+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 SQRT_2 = 1.414213562373;
+
+uniform float dots; 
+uniform vec2 center; 
+
+vec4 transition(vec2 uv) {
+  bool nextImage = distance(fract(uv * dots), vec2(0.5, 0.5)) < ( progress / distance(uv, center));
+  return nextImage ? getToColor(uv) : getFromColor(uv);
+}
+
+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/PuzzleRight.sksl

@@ -0,0 +1,70 @@
+// PuzzleRight — generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/PuzzleRight.glsl
+// Author: JustKirillS
+// 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; 
+
+float rand(vec2 co) {
+  return fract(sin(dot(co, vec2(12.9898, 78.233))) * 43758.5453);
+}
+
+float getDelta(vec2 p) {
+  vec2 rectangleSize = 1.0 / vec2(size);
+  vec2 rectanglePos = floor(vec2(size) * p);
+  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);
+}
+
+vec4 transition(vec2 uv) {
+  if (progress < pause) {
+    float currentProg = progress / pause;
+    float a = 1.0;
+    if (getDelta(uv) < dividerWidth) { a = 1.0 - currentProg; }
+    return mix(vec4(0.0, 0.0, 0.0, 1.0), getFromColor(uv), a);
+  } else if (progress < 1.0 - pause) {
+    if (getDelta(uv) < dividerWidth) {
+      return vec4(0.0, 0.0, 0.0, 1.0);
+    }
+    float currentProg = (progress - pause) / (1.0 - pause * 2.0);
+    vec2 rectanglePos = floor(vec2(size) * uv);
+    float r = rand(rectanglePos) - 0.1;
+    float cp = smoothstep(0.0, 1.0 - r, currentProg);
+    float rectangleSize = 1.0 / float(size.x);
+    float delta = rectanglePos.x * rectangleSize;
+    float offset = rectangleSize / 2.0 + delta;
+    vec2 p = uv;
+    p.x = (p.x - offset) / abs(cp - 0.5) * 0.5 + offset;
+    vec4 a = getFromColor(p);
+    vec4 b = getToColor(p);
+    float s = step(abs(float(size.x) * (uv.x - delta) - 0.5), abs(cp - 0.5));
+    return vec4(mix(b, a, step(cp, 0.5)).rgb * s, 1.0);
+  } else {
+    float currentProg = (progress - 1.0 + pause) / pause;
+    float a = 1.0;
+    if (getDelta(uv) < dividerWidth) { a = currentProg; }
+    return mix(vec4(0.0, 0.0, 0.0, 1.0), getToColor(uv), 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/Radial.sksl

@@ -0,0 +1,32 @@
+// Radial — generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/Radial.glsl
+// Author: Xaychru
+// License: MIT
+// Description: A radial wipe that sweeps around the center like a clock hand
+
+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 smoothness; 
+
+const float PI = 3.141592653589;
+
+vec4 transition(vec2 p) {
+  vec2 rp = p*2.-1.;
+  return mix(
+    getToColor(p),
+    getFromColor(p),
+    smoothstep(0., smoothness, atan(rp.y,rp.x) - (progress-.5) * PI * 2.5)
+  );
+}
+
+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/Rectangle.sksl

@@ -0,0 +1,42 @@
+// Rectangle — generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/Rectangle.glsl
+// Author: martiniti
+// License: MIT
+// Description: A rectangle grows from the center to cover the outgoing image, then shrinks to 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 vec4 bgcolor; 
+
+vec4 transition(vec2 p) {
+  float s = pow(2.0 * abs(progress - 0.5), 3.0);
+  
+   vec2 sq = p.xy / vec2(1.0).xy;
+   
+    
+    vec2 bl = step(vec2(abs(1. - 2.*progress)), sq + .25);
+    float dist = bl.x * bl.y;
+
+    
+    vec2 tr = step(vec2(abs(1. - 2.*progress)), 1.25-sq);
+    dist *= 1. * tr.x * tr.y;
+  
+  return mix(
+    progress < 0.5 ? getFromColor(p) : getToColor(p),
+    bgcolor,
+    step(s, 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/RectangleCrop.sksl

@@ -0,0 +1,43 @@
+// RectangleCrop — generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/RectangleCrop.glsl
+// Author: martiniti
+// License: MIT
+// Description: The outgoing image shrinks into a small rectangle over a background color, then the incoming one grows from it
+
+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 vec4 bgcolor; 
+
+vec4 transition(vec2 uv) {
+  
+  float s = pow(2.0 * abs(progress - 0.5), 3.0);
+              
+  vec2 q = uv.xy / vec2(1.0).xy;
+  
+  
+  vec2 bl = step(vec2(1.0 - 2.0*abs(progress - 0.5)), q + 0.25);
+  
+  
+  vec2 tr = step(vec2(1.0 - 2.0*abs(progress - 0.5)), 1.25 - q);
+  
+  float dist = length(1.0 - bl.x * bl.y * tr.x * tr.y);
+  
+  return mix(
+    progress < 0.5 ? getFromColor(uv) : getToColor(uv),
+    bgcolor,
+    step(s, 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/Revolve_Left.sksl

@@ -0,0 +1,110 @@
+// Revolve_Left — generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/Revolve_Left.glsl
+// Author: bread
+// License: MIT
+// Description: The outgoing image swirls and zooms with motion blur into 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 vec2 center;       
+uniform float direction;   
+uniform float maxRotation; 
+uniform float peakZoom;    
+uniform float swirl;       
+uniform float barrel;      
+uniform float motionBlur;  
+uniform float switchStart; 
+uniform float switchEnd;   
+uniform float shadow;      
+
+float sat(float x) {
+  return clamp(x, 0.0, 1.0);
+}
+
+float ease(float x) {
+  x = sat(x);
+  return x * x * (3.0 - 2.0 * x);
+}
+
+float revolveEnvelope(float t) {
+  float rise = ease((t - 0.10) / 0.33);
+  float fall = 1.0 - ease((t - 0.43) / 0.29);
+  return rise * fall;
+}
+
+vec2 rotate2(vec2 p, float a) {
+  float s = sin(a);
+  float c = cos(a);
+  return vec2(c * p.x - s * p.y, s * p.x + c * p.y);
+}
+
+vec2 warpUv(vec2 uv, float t) {
+  float e = revolveEnvelope(t);
+
+  vec2 p = uv - center;
+  p.x *= ratio;
+
+  float r = length(p);
+  float edgeSpin = maxRotation * e;
+  float coreSpin = swirl * e * pow(1.0 - sat(r / 0.96), 1.55);
+  float visibleAngle = direction * (edgeSpin + coreSpin);
+
+  p = rotate2(p, -visibleAngle);
+
+  float sc = 1.0 + (peakZoom - 1.0) * pow(e, 0.85);
+  p /= sc;
+
+  float rr = length(p);
+  p *= 1.0 + barrel * e * rr * rr * 2.8;
+
+  p.x /= ratio;
+  return clamp(p + center, vec2(0.001), vec2(0.999));
+}
+
+vec4 sampleRevolve(vec2 uv, float t) {
+  vec2 p = warpUv(uv, t);
+  float reveal = smoothstep(switchStart, switchEnd, t);
+  return mix(getFromColor(p), getToColor(p), reveal);
+}
+
+vec4 transition(vec2 uv) {
+  if (progress <= 0.0) return getFromColor(uv);
+  if (progress >= 1.0) return getToColor(uv);
+
+  float e = revolveEnvelope(progress);
+  float span = 0.060 * motionBlur * e;
+
+  vec4 color = vec4(0.0);
+  float total = 0.0;
+
+  for (int i = -8; i <= 8; i++) {
+    float x = float(i) / 8.0;
+    float w = 1.0 - abs(x);
+    w = w * w + 0.01;
+
+    float t = sat(progress + x * span);
+    color += sampleRevolve(uv, t) * w;
+    total += w;
+  }
+
+  color /= total;
+
+  vec2 q = uv - vec2(0.5);
+  q.x *= ratio;
+  float vignette = 1.0 - shadow * e * smoothstep(0.35, 0.95, length(q));
+  color.rgb *= vignette;
+
+  return color;
+}
+
+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/Rolls.sksl

@@ -0,0 +1,48 @@
+// Rolls — generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/Rolls.glsl
+// Author: Mark Craig
+// License: MIT
+// Description: The outgoing image rolls away around a corner, 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))); }
+
+uniform int type; 
+
+uniform int RotDown; 
+
+vec4 transition(vec2 uv)
+{
+float theta, c1, s1;
+vec2 iResolution = vec2(ratio, 1.0);
+vec2 uvi;
+
+if (type == 0) { theta = ((RotDown != 0) ? 3.14159265358979323846 : -3.14159265358979323846) / 2.0 * progress; uvi.x = 1.0 - uv.x; uvi.y = uv.y; }
+else if (type == 1) { theta = ((RotDown != 0) ? 3.14159265358979323846 : -3.14159265358979323846) / 2.0 * progress; uvi = uv; }
+else if (type == 2) { theta = ((RotDown != 0) ? -3.14159265358979323846 : 3.14159265358979323846) / 2.0 * progress; uvi.x = uv.x; uvi.y = 1.0 - uv.y; }
+else if (type == 3) { theta = ((RotDown != 0) ? -3.14159265358979323846 : 3.14159265358979323846) / 2.0 * progress; uvi = 1.0 - uv; }
+c1 = cos(theta); s1 = sin(theta);
+vec2 uv2;
+uv2.x = (uvi.x * iResolution.x * c1 - uvi.y * iResolution.y * s1);
+uv2.y = (uvi.x * iResolution.x * s1 + uvi.y * iResolution.y * c1);
+if ((uv2.x >= 0.0) && (uv2.x <= iResolution.x) && (uv2.y >= 0.0) && (uv2.y <= iResolution.y))
+	{
+	uv2 /= iResolution;
+	if (type == 0) { uv2.x = 1.0 - uv2.x; }
+	else if (type == 2) { uv2.y = 1.0 - uv2.y; }
+	else if (type == 3) { uv2 = 1.0 - uv2; }
+	return(getFromColor(uv2));
+	}
+return(getToColor(uv));
+}
+
+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/RotateScaleVanish.sksl

@@ -0,0 +1,49 @@
+// RotateScaleVanish — generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/RotateScaleVanish.glsl
+// Author: Mark Craig
+// License: MIT
+// Description: The outgoing image spins and shrinks away over 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 FadeInSecond; 
+
+uniform int ReverseEffect; 
+
+uniform int ReverseRotation; 
+
+vec4 transition(vec2 uv)
+{
+vec2 iResolution = vec2(ratio, 1.0);
+float t = (ReverseEffect != 0) ? 1.0 - progress : progress;
+float theta = (ReverseRotation != 0) ? 6.283185307179586476925286766559 * t : -6.283185307179586476925286766559 * t;
+float c1 = cos(theta);
+float s1 = sin(theta);
+float rad = max(0.00001, 1.0 - t);
+float xc1 = (uv.x - 0.5) * iResolution.x;
+float yc1 = (uv.y - 0.5) * iResolution.y;
+float xc2 = (xc1 * c1 - yc1 * s1) / rad;
+float yc2 = (xc1 * s1 + yc1 * c1) / rad;
+vec2 uv2 = vec2(xc2 + iResolution.x / 2.0, yc2 + iResolution.y / 2.0);
+vec4 col3;
+vec4 ColorTo = (ReverseEffect != 0) ? getFromColor(uv) : getToColor(uv);
+if ((uv2.x >= 0.0) && (uv2.x <= iResolution.x) && (uv2.y >= 0.0) && (uv2.y <= iResolution.y))
+	{
+	uv2 /= iResolution;
+	col3 = (ReverseEffect != 0) ? getToColor(uv2) : getFromColor(uv2);
+	}
+else { col3 = (FadeInSecond != 0) ? vec4(0.0, 0.0, 0.0, 1.0) : ColorTo; }
+return((1.0 - t) * col3 + t * ColorTo); 
+}
+
+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/SimpleFlip.sksl

@@ -0,0 +1,27 @@
+// SimpleFlip — generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/SimpleFlip.glsl
+// Author: nwoeanhinnogaehr
+// License: MIT
+// Description: The outgoing image flips around the vertical axis into 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))); }
+
+vec4 transition(vec2 uv) {
+  vec2 q = uv;
+  uv.x = (uv.x - 0.5) / abs(progress - 0.5) * 0.5 + 0.5;
+  vec4 a = getFromColor(uv);
+  vec4 b = getToColor(uv);
+  return vec4(mix(a, b, step(0.5, progress)).rgb * step(abs(q.x - 0.5), abs(progress - 0.5)), 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/SimpleZoom.sksl

@@ -0,0 +1,33 @@
+// SimpleZoom — generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/SimpleZoom.glsl
+// Author: 0gust1
+// License: MIT
+// Description: Zooms into the outgoing image, then fades to 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 zoom_quickness; 
+vec2 zoom(vec2 uv, float amount) {
+  return 0.5 + ((uv - 0.5) * (1.0-amount));	
+}
+
+vec4 transition (vec2 uv) {
+  float nQuick = clamp(zoom_quickness,0.2,1.0);
+  return mix(
+    getFromColor(zoom(uv, smoothstep(0.0, nQuick, progress))),
+    getToColor(uv),
+   smoothstep(nQuick-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/SimpleZoomOut.sksl

@@ -0,0 +1,35 @@
+// SimpleZoomOut — generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/SimpleZoomOut.glsl
+// Author: Tianshuo
+// License: MIT
+// Description: The incoming image zooms out into place while fading in
+
+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 zoom_quickness; 
+
+uniform int fade; 
+vec2 zoom(vec2 uv, float amount) {
+  return 0.5 + ((uv - 0.5) * (1.0-amount));	
+}
+
+vec4 transition (vec2 uv) {
+  float nQuick = clamp(zoom_quickness,0.2,1.0);
+  return mix(
+    getFromColor(uv),
+    getToColor(zoom(uv,1.-smoothstep(1.-nQuick, 1., progress))),
+   (fade != 0)?smoothstep(1.0-nQuick, 1., progress):(progress<1.0-nQuick?0.0: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/Slides.sksl

@@ -0,0 +1,48 @@
+// Slides — generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/Slides.glsl
+// Author: Mark Craig
+// License: MIT
+// Description: The outgoing image slides out, or the incoming one slides in, toward an edge, a corner or the center
+
+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 type; 
+
+uniform int In; 
+
+vec4 transition(vec2 uv)
+{
+vec2 uv0 = uv;
+float rad = (In != 0) ? progress : 1.0 - progress;
+float xc1, yc1;
+
+if (type == 0) { xc1 = .5 - rad / 2.0; yc1 = 0.0; }
+else if (type == 1) { xc1 = 1.0 - rad; yc1 = .5 - rad / 2.0; }
+else if (type == 2) { xc1 = .5 - rad / 2.0; yc1 = 1.0 - rad; }
+else if (type == 3) { xc1 = 0.0; yc1 = .5 - rad / 2.0; }
+else if (type == 4) { xc1 = 1.0 - rad; yc1 = 0.0; }
+else if (type == 5) { xc1 = 1.0 - rad; yc1 = 1.0 - rad; }
+else if (type == 6) { xc1 = 0.0; yc1 = 1.0 - rad; }
+else if (type == 7) { xc1 = 0.0; yc1 = 0.0; }
+else if (type == 8) { xc1 = .5 - rad / 2.0; yc1 = .5 - rad / 2.0; }
+uv.y = 1.0 - uv.y;
+vec2 uv2;
+if ((uv.x >= xc1) && (uv.x <= xc1 + rad) && (uv.y >= yc1) && (uv.y <= yc1 + rad))
+	{
+	uv2 = vec2((uv.x - xc1) / rad, 1.0 - (uv.y - yc1) / rad);
+	return((In != 0) ? getToColor(uv2) : getFromColor(uv2));
+	}
+return((In != 0) ? getFromColor(uv0) : getToColor(uv0));
+}
+
+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/StarWipe.sksl

@@ -0,0 +1,62 @@
+// StarWipe — generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/StarWipe.glsl
+// Author: Ben Lucas
+// License: MIT
+// Description: A growing star reveals 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 border_thickness;
+uniform float star_rotation;
+
+uniform vec4 border_color; 
+
+uniform vec2 star_center;
+
+vec2 rotate(vec2 v, float theta) {
+    float cosTheta = cos(theta);
+    float sinTheta = sin(theta);
+
+    return vec2(
+        cosTheta * v.x - sinTheta * v.y,
+        sinTheta * v.x + cosTheta * v.y
+    );
+}
+
+bool inStar(vec2 uv, vec2 center, float radius){
+  vec2 uv_centered = uv - center;
+  uv_centered = rotate(uv_centered, star_rotation * 1.2566370614359172);
+  float theta = atan(uv_centered.y, uv_centered.x) + 3.141592653589793;
+
+  vec2 uv_rotated = rotate(uv_centered, -1.2566370614359172 * (floor(theta / 1.2566370614359172) + 0.5));
+
+  float slope = 0.3;
+  if(uv_rotated.y > 0.0){
+      return (radius + uv_rotated.x * slope > uv_rotated.y);
+  } else {
+     return (-radius - uv_rotated.x * slope < uv_rotated.y);
+  }
+}
+
+vec4 transition (vec2 uv) {
+  float progressScaled = (2.0 * border_thickness + 1.0) * progress - border_thickness;
+  if(inStar(uv, star_center, progressScaled)){
+    return getToColor(uv);
+  } else if(inStar(uv, star_center, progressScaled+border_thickness)){
+    return border_color;
+  } else {
+    return getFromColor(uv);
+  }
+}
+
+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);
+}