gl-transitions 1.43.0 → 1.45.0

package/package.json

@@ -1,8 +1,9 @@
 {
   "name": "gl-transitions",
-  "version": "1.43.0",
+  "version": "1.45.0",
   "description": "The open collection of GL Transitions",
   "main": "index.js",
+  "license": "MIT",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/gl-transitions/gl-transitions.git"
@@ -10,5 +11,14 @@
   "bugs": {
     "url": "https://github.com/gl-transitions/gl-transitions/issues"
   },
-  "homepage": "https://github.com/gl-transitions/gl-transitions#readme"
+  "homepage": "https://gl-transitions.com",
+  "keywords": [
+    "glsl",
+    "webgl",
+    "transitions",
+    "shader",
+    "opengl",
+    "video",
+    "animation"
+  ]
 }

package/transitions/AdvancedMosaic.glsl

@@ -0,0 +1,18 @@
+// Author: Sergey Kosarevsky
+// License: MIT
+// 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/transitions/BlockDissolve.glsl

@@ -0,0 +1,13 @@
+// Author: nwoeanhinnogaehr
+// License: MIT
+// 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/transitions/BookFlip.glsl

@@ -0,0 +1,29 @@
+// Author: hong
+// License: MIT
+
+vec2 skewRight(vec2 p) {
+  float skewX = (p.x - progress)/(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)/(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/transitions/BowTieWithParameter.glsl

@@ -0,0 +1,70 @@
+// Author:KMojek
+// License: MIT
+
+uniform float adjust; // = 0.5;
+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/transitions/DefocusBlur.glsl

@@ -0,0 +1,43 @@
+// Author: Sergey Kosarevsky
+// License: MIT
+// Ported from https://gist.github.com/corporateshark/b9f8e5675c647e615419
+
+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);
+}

package/transitions/DirectionalScaled.glsl

@@ -0,0 +1,31 @@
+// Author: Thibaut Foussard
+// based on Directional transition by Gaëtan Renaudeau
+// https://gl-transitions.com/editor/Directional
+// License: MIT
+
+#define PI acos(-1.0)
+
+uniform vec2 direction; // = vec2(0.0, 1.0)
+uniform float scale; // = .7
+
+float parabola(float x) {
+  float y = pow(sin(x * PI), 1.);
+  return y;
+}
+
+vec4 transition (vec2 uv) {
+  float easedProgress = pow(sin(progress  * PI / 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;
+}

package/transitions/EdgeTransition.glsl

@@ -0,0 +1,47 @@
+// Author: Woohyun Kim
+// License: MIT
+
+uniform float edge_thickness; // = 0.001;
+uniform float edge_brightness; // = 8.0;
+
+vec4 detectEdgeColor(vec3[9] c) {
+  /* adjacent texel array for texel c[4]
+    036
+    147
+    258
+  */
+  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
+  );
+}

package/transitions/FilmBurn.glsl

@@ -0,0 +1,59 @@
+// author: Anastasia Dunbar
+// license: MIT
+uniform float Seed; // = 2.31
+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 texture(vec2 p) {
+    return mix(getFromColor(p), getToColor(p), sigmoid(progress,10.));
+}
+#define pi 3.14159265358979323
+#define clamps(x) clamp(x,0.,1.)
+
+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.-clamps(length(p-vec2(smooth_random(vec2(progress*1.3),i+1.),smooth_random(vec2(progress*.5),i+6.25)))*mix(20.,70.,rand(i)));
+  }
+  f += 4.;
+  f /= 11.;
+  f = pow3(f*vec3(1.,0.7,0.6),vec3(1.,2.-sin(progress*pi),1.3));
+  f *= sin(progress*pi);
+  
+  p -= .5;
+  p *= 1.+(smooth_random(vec2(progress*5.),6.3)*sin(progress*pi)*.05);
+  p += .5;
+  
+  vec4 blurred_image = vec4(0.);
+  float bluramount = sin(progress*pi)*.03;
+  #define repeats  50.
+  for (float i = 0.; i < repeats; i++) { 
+      vec2 q = vec2(cos(degrees((i/repeats)*360.)),sin(degrees((i/repeats)*360.))) *  (rand(vec2(i,p.x+p.y))+bluramount); 
+      vec2 uv2 = p+(q*bluramount);
+      blurred_image += texture(uv2);
+  }
+  blurred_image /= repeats;
+  
+  return blurred_image+vec4(f,0.);
+}

package/transitions/Fold.glsl

@@ -0,0 +1,9 @@
+// Author: nwoeanhinnogaehr
+// License: MIT
+// Ported from https://gist.github.com/nwoeanhinnogaehr/f6fc39f4cfcbb97f96a6
+
+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));
+}

package/transitions/GlitchDisplace.glsl

@@ -1,13 +1,17 @@
 // Author: Matt DesLauriers
 // License: MIT
 
-highp float random(vec2 co)
+#ifdef GL_ES
+precision highp float;
+#endif
+
+float random(vec2 co)
 {
-    highp float a = 12.9898;
-    highp float b = 78.233;
-    highp float c = 43758.5453;
-    highp float dt= dot(co.xy ,vec2(a,b));
-    highp float sn= mod(dt,3.14);
+    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 ) {
@@ -70,6 +74,6 @@ vec4 transition(vec2 uv) {
   color2 = mix(color2, dColor1, smoothstep(1.0, 0.5, progress));
   return mix(color1, color2, val);
   //gl_FragColor = mix(gl_FragColor, dColor, smoothstep(0.0, 0.5, progress));
-  
+
    //gl_FragColor = mix(texture2D(from, p), texture2D(to, p), progress);
 }

package/transitions/HSVfade.glsl

@@ -0,0 +1,26 @@
+// Author: nwoeanhinnogaehr
+// License: MIT
+// Ported from https://gist.github.com/nwoeanhinnogaehr/b185145363d65751009b
+
+// HSV functions from http://lolengine.net/blog/2013/07/27/rgb-to-hsv-in-glsl
+
+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);
+}

package/transitions/HorizontalClose.glsl

@@ -0,0 +1,13 @@
+// Author: martiniti
+// License: MIT
+
+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)
+  ); 
+}

package/transitions/HorizontalOpen.glsl

@@ -0,0 +1,15 @@
+// Author: martiniti
+// License: MIT
+
+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)
+  );
+}

package/transitions/LeftRight.glsl

@@ -0,0 +1,25 @@
+// Author:zhmy
+// License: MIT
+
+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;
+    }
+}

package/transitions/Overexposure.glsl

@@ -0,0 +1,21 @@
+// Author: Ben Zhang
+// License: MIT
+
+uniform float strength; //= 0.6;
+const float PI = 3.141592653589793;
+
+vec4 transition (vec2 uv) {
+  vec4 from = getFromColor(uv);
+  vec4 to = getToColor(uv);
+
+  // Multipliers
+  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)
+  );
+}

package/transitions/PuzzleRight.glsl

@@ -0,0 +1,54 @@
+// Author: JustKirillS
+// License: MIT
+// Ported from https://gist.github.com/JustKirillS/714f095318834f4d2375de872c53af1e
+
+uniform ivec2 size; // = ivec2(4, 4)
+uniform float pause; // = 0.1
+uniform float dividerWidth; // = 0.005
+
+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);
+  }
+}

package/transitions/Rectangle.glsl

@@ -0,0 +1,26 @@
+// Author: martiniti
+// License: MIT
+
+uniform vec4 bgcolor; // = vec4(0.0, 0.0, 0.0, 1.0)
+
+float s = pow(2.0 * abs(progress - 0.5), 3.0);
+
+vec4 transition(vec2 p) {
+  
+   vec2 sq = p.xy / vec2(1.0).xy;
+   
+    // bottom-left
+    vec2 bl = step(vec2(abs(1. - 2.*progress)), sq + .25);
+    float dist = bl.x * bl.y;
+
+    // top-right
+    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)
+  );
+  
+}

package/transitions/RectangleCrop.glsl

@@ -0,0 +1,26 @@
+// License: MIT
+// Author: martiniti
+
+uniform vec4 bgcolor; // = vec4(0.0, 0.0, 0.0, 1.0)
+
+vec4 transition(vec2 uv) {
+  
+  float s = pow(2.0 * abs(progress - 0.5), 3.0);
+              
+  vec2 q = uv.xy / vec2(1.0).xy;
+  
+  // bottom-left
+  vec2 bl = step(vec2(1.0 - 2.0*abs(progress - 0.5)), q + 0.25);
+  
+  // top-right
+  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)
+  );
+  
+}

package/transitions/Rolls.glsl

@@ -0,0 +1,37 @@
+// Author: Mark Craig
+// mrmcsoftware on github and youtube ( http://www.youtube.com/MrMcSoftware )
+// License: MIT
+
+// Rolls Transition by Mark Craig (Copyright © 2022)
+
+uniform int type; // = 0
+uniform bool RotDown; // = false
+// type (0-3): Rotate/Roll from which corner
+// RotDown: if true rotate old image down, otherwise rotate old image up
+
+#define M_PI 3.14159265358979323846
+
+vec4 transition(vec2 uv)
+{
+float theta, c1, s1;
+vec2 iResolution = vec2(ratio, 1.0);
+vec2 uvi;
+// I used if/else instead of switch in case it's an old GPU
+if (type == 0) { theta = (RotDown ? M_PI : -M_PI) / 2.0 * progress; uvi.x = 1.0 - uv.x; uvi.y = uv.y; }
+else if (type == 1) { theta = (RotDown ? M_PI : -M_PI) / 2.0 * progress; uvi = uv; }
+else if (type == 2) { theta = (RotDown ? -M_PI : M_PI) / 2.0 * progress; uvi.x = uv.x; uvi.y = 1.0 - uv.y; }
+else if (type == 3) { theta = (RotDown ? -M_PI : M_PI) / 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));
+}

package/transitions/RotateScaleVanish.glsl

@@ -0,0 +1,36 @@
+// Author: Mark Craig
+// mrmcsoftware on github and youtube ( http://www.youtube.com/MrMcSoftware )
+// License: MIT
+
+// RotateScaleVanish Transition by Mark Craig (Copyright © 2022)
+
+uniform bool FadeInSecond; // = true
+uniform bool ReverseEffect; // = false
+uniform bool ReverseRotation; // = false
+
+#define M_PI 3.14159265358979323846
+#define _TWOPI 6.283185307179586476925286766559
+
+vec4 transition(vec2 uv)
+{
+vec2 iResolution = vec2(ratio, 1.0);
+float t = ReverseEffect ? 1.0 - progress : progress;
+float theta = ReverseRotation ? _TWOPI * t : -_TWOPI * 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 ? 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 ? getToColor(uv2) : getFromColor(uv2);
+	}
+else { col3 = FadeInSecond ? vec4(0.0, 0.0, 0.0, 1.0) : ColorTo; }
+return((1.0 - t) * col3 + t * ColorTo); // could have used mix
+}