gl-transitions 1.74.0 → 1.76.0

package/glsl3/HorizontalOpen.glsl

@@ -0,0 +1,18 @@
+// HorizontalOpen — GLSL ES 3.00, 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
+// Tags: wipe, split
+
+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/glsl3/InvertedPageCurl.glsl

@@ -0,0 +1,228 @@
+// InvertedPageCurl — GLSL ES 3.00, 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
+// Tags: page, curl, 3d
+// Adapted by Sergey Kosarevsky from:
+// http://rectalogic.github.io/webvfx/examples_2transition-shader-pagecurl_8html-example.html
+
+/*
+Copyright (c) 2010 Hewlett-Packard Development Company, L.P. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+   * Redistributions of source code must retain the above copyright
+     notice, this list of conditions and the following disclaimer.
+   * Redistributions in binary form must reproduce the above
+     copyright notice, this list of conditions and the following disclaimer
+     in the documentation and/or other materials provided with the
+     distribution.
+   * Neither the name of Hewlett-Packard nor the names of its
+     contributors may be used to endorse or promote products derived from
+     this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+in vec2 texCoord;
+*/
+
+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;
+
+// These depend on the progress uniform and must be computed per-fragment.
+// Global initializers with uniforms are invalid in GLSL ES and fail on Mesa.
+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)
+        {
+                // Behind surface
+                return behindSurface(p,yc, point, rrotation);
+        }
+
+        if (yc > cylinderRadius)
+        {
+                // Flat surface
+                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);
+}

package/glsl3/LeftRight.glsl

@@ -0,0 +1,28 @@
+// LeftRight — GLSL ES 3.00, 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
+// Tags: slide, zoom, horizontal
+
+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/glsl3/LinearBlur.glsl

@@ -0,0 +1,30 @@
+// LinearBlur — GLSL ES 3.00, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/LinearBlur.glsl
+// Author: gre
+// License: MIT
+// Description: A crossfade through a blur
+// Tags: blur, blend
+// @param Amount of blur
+uniform float intensity; // = 0.1
+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);
+}

package/glsl3/Mosaic.glsl

@@ -0,0 +1,45 @@
+// Mosaic — GLSL ES 3.00, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/Mosaic.glsl
+// License: MIT
+// Author: Xaychru
+// Description: The view pans across a mosaic of rotated tiles from both images and settles on the incoming one
+// Tags: mosaic, tiles, zoom
+// ported by gre from https://gist.github.com/Xaychru/130bb7b7affedbda9df5
+
+#define PI 3.14159265358979323
+#define POW2(X) X*X
+#define POW3(X) X*X*X
+uniform int endx; // = 2
+uniform int endy; // = -1
+
+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*PI)/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), POW2(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*PI;
+    mrp = vec2(.5) + Rotate(mrp-vec2(.5), ang);
+  }
+  if(onEnd || Rand(floor(crp))>.5) {
+    return getToColor(mrp);
+  } else {
+    return getFromColor(mrp);
+  }
+}

package/glsl3/Overexposure.glsl

@@ -0,0 +1,25 @@
+// Overexposure — GLSL ES 3.00, 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
+// Tags: flash, light, fade
+
+// @param Amount of overexposure
+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/glsl3/PolkaDotsCurtain.glsl

@@ -0,0 +1,14 @@
+// PolkaDotsCurtain — GLSL ES 3.00, 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
+// Tags: dots, pattern
+const float SQRT_2 = 1.414213562373;
+// @param Number of dots across the image
+uniform float dots; // = 20.0
+uniform vec2 center; // = vec2(0, 0)
+
+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);
+}

package/glsl3/PuzzleRight.glsl

@@ -0,0 +1,57 @@
+// PuzzleRight — GLSL ES 3.00, 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
+// Tags: grid, tiles, flip
+// 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/glsl3/Radial.glsl

@@ -0,0 +1,19 @@
+// Radial — GLSL ES 3.00, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/Radial.glsl
+// License: MIT
+// Author: Xaychru
+// Description: A radial wipe that sweeps around the center like a clock hand
+// Tags: wipe, radial, clock
+// ported by gre from https://gist.github.com/Xaychru/ce1d48f0ce00bb379750
+
+uniform float smoothness; // = 1.0
+
+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)
+  );
+}

package/glsl3/Rectangle.glsl

@@ -0,0 +1,29 @@
+// Rectangle — GLSL ES 3.00, 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
+// Tags: box, shape, iris
+
+// @color Color of the rectangle
+uniform vec4 bgcolor; // = vec4(0.0, 0.0, 0.0, 1.0)
+
+vec4 transition(vec2 p) {
+  float s = pow(2.0 * abs(progress - 0.5), 3.0);
+  
+   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/glsl3/RectangleCrop.glsl

@@ -0,0 +1,30 @@
+// RectangleCrop — GLSL ES 3.00, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/RectangleCrop.glsl
+// License: MIT
+// Author: martiniti
+// Description: The outgoing image shrinks into a small rectangle over a background color, then the incoming one grows from it
+// Tags: box, iris, zoom
+
+// @color Background color
+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/glsl3/Revolve_Left.glsl

@@ -0,0 +1,98 @@
+// Revolve_Left — GLSL ES 3.00, 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
+// Tags: swirl, zoom, rotate, blur
+// gl-transitions v1 compatible
+
+// @param Center of the swirl
+uniform vec2 center;       // = vec2(0.46, 0.52)
+uniform float direction;   // = -1.0
+uniform float maxRotation; // = 1.95
+uniform float peakZoom;    // = 2.22
+uniform float swirl;       // = 2.85
+uniform float barrel;      // = 0.38
+uniform float motionBlur;  // = 1.0
+uniform float switchStart; // = 0.30
+uniform float switchEnd;   // = 0.50
+uniform float shadow;      // = 0.16
+
+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;
+}

package/glsl3/Rolls.glsl

@@ -0,0 +1,42 @@
+// Rolls — GLSL ES 3.00, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/Rolls.glsl
+// Author: Mark Craig
+// mrmcsoftware on github and youtube ( http://www.youtube.com/MrMcSoftware )
+// License: MIT
+// Description: The outgoing image rolls away around a corner, revealing the incoming one
+// Tags: rotate, roll
+
+// Rolls Transition by Mark Craig (Copyright © 2022)
+
+// @range(0, 3, 1) Corner to roll around
+uniform int type; // = 0
+// @param Roll the outgoing image down instead of up
+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));
+}