gl-transitions 1.75.0 → 1.76.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (7) hide show
  1. package/README.md +1 -0
  2. package/llms-full.txt +251 -251
  3. package/llms.txt +130 -130
  4. package/package.json +1 -1
  5. package/skills/gl-transitions/references/catalog.md +2 -2
  6. package/sksl/index.d.ts +4 -0
  7. package/sksl/index.js +1 -0
package/sksl/index.js ADDED
@@ -0,0 +1 @@
1
+ module.exports={"AdvancedMosaic":"// AdvancedMosaic — generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/AdvancedMosaic.glsl\n// Author: Sergey Kosarevsky\n// License: MIT\n// Description: Both images break into large blocks that blend, then sharpen into the incoming image\n\nuniform shader _from;\nuniform shader _to;\nuniform float2 _resolution;\nuniform float progress;\nuniform float ratio;\n\nvec4 getFromColor(vec2 uv) { return vec4(unpremul(_from.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\nvec4 getToColor(vec2 uv) { return vec4(unpremul(_to.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\n\nuniform float pixelSize; \n\nvec4 transition(vec2 uv) {\n float T = progress;\n float half_ = 0.5;\n float size = (T < half_) ? mix(1.0, pixelSize, T / half_) : mix(pixelSize, 1.0, (T - half_) / half_);\n float D = size * 0.005;\n \n vec2 UV = (uv - 0.5) / D;\n vec2 coord = clamp(D * (ceil(UV - 0.5)) + 0.5, 0.0, 1.0);\n vec4 C0 = getFromColor(coord);\n vec4 C1 = getToColor(coord);\n return mix(C0, C1, T);\n}\n\nhalf4 main(float2 _coord) {\n vec2 _uv = _coord / _resolution;\n vec4 _c = clamp(transition(vec2(_uv.x, 1.0 - _uv.y)), 0.0, 1.0);\n return half4(_c.rgb * _c.a, _c.a);\n}\n","BlockDissolve":"// BlockDissolve — generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/BlockDissolve.glsl\n// Author: nwoeanhinnogaehr\n// License: MIT\n// Description: The incoming image appears in small random blocks\n\nuniform shader _from;\nuniform shader _to;\nuniform float2 _resolution;\nuniform float progress;\nuniform float ratio;\n\nvec4 getFromColor(vec2 uv) { return vec4(unpremul(_from.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\nvec4 getToColor(vec2 uv) { return vec4(unpremul(_to.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\n\nuniform float blocksize; \n\nfloat rand(vec2 co) {\n return fract(sin(dot(co, vec2(12.9898, 78.233))) * 43758.5453);\n}\n\nvec4 transition(vec2 uv) {\n return mix(getFromColor(uv), getToColor(uv), step(rand(floor(uv / blocksize)), progress));\n}\n\nhalf4 main(float2 _coord) {\n vec2 _uv = _coord / _resolution;\n vec4 _c = clamp(transition(vec2(_uv.x, 1.0 - _uv.y)), 0.0, 1.0);\n return half4(_c.rgb * _c.a, _c.a);\n}\n","BookFlip":"// BookFlip — generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/BookFlip.glsl\n// Author: hong\n// License: MIT\n// Description: The outgoing image turns like a book page from right to left, revealing the incoming one\n\nuniform shader _from;\nuniform shader _to;\nuniform float2 _resolution;\nuniform float progress;\nuniform float ratio;\n\nvec4 getFromColor(vec2 uv) { return vec4(unpremul(_from.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\nvec4 getToColor(vec2 uv) { return vec4(unpremul(_to.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\n\nfloat nonZero(float x) {\n return abs(x) < 1e-4 ? (x < 0.0 ? -1e-4 : 1e-4) : x;\n}\n\nvec2 skewRight(vec2 p) {\n float skewX = (p.x - progress)/nonZero(0.5 - progress) * 0.5;\n float skewY = (p.y - 0.5)/(0.5 + progress * (p.x - 0.5) / 0.5)* 0.5 + 0.5;\n return vec2(skewX, skewY);\n}\n\nvec2 skewLeft(vec2 p) {\n float skewX = (p.x - 0.5)/nonZero(progress - 0.5) * 0.5 + 0.5;\n float skewY = (p.y - 0.5) / (0.5 + (1.0 - progress ) * (0.5 - p.x) / 0.5) * 0.5 + 0.5;\n return vec2(skewX, skewY);\n}\n\nvec4 addShade() {\n float shadeVal = max(0.7, abs(progress - 0.5) * 2.0);\n return vec4(vec3(shadeVal ), 1.0);\n}\n\nvec4 transition (vec2 p) {\n float pr = step(1.0 - progress, p.x);\n\n if (p.x < 0.5) {\n return mix(getFromColor(p), getToColor(skewLeft(p)) * addShade(), pr);\n } else {\n return mix(getFromColor(skewRight(p)) * addShade(), getToColor(p), pr);\n }\n}\n\nhalf4 main(float2 _coord) {\n vec2 _uv = _coord / _resolution;\n vec4 _c = clamp(transition(vec2(_uv.x, 1.0 - _uv.y)), 0.0, 1.0);\n return half4(_c.rgb * _c.a, _c.a);\n}\n","Bounce":"// Bounce — generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/Bounce.glsl\n// Author: Adrian Purser\n// License: MIT\n// Description: The outgoing image drops out of the frame with a few bounces, revealing the incoming one\n\nuniform shader _from;\nuniform shader _to;\nuniform float2 _resolution;\nuniform float progress;\nuniform float ratio;\n\nvec4 getFromColor(vec2 uv) { return vec4(unpremul(_from.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\nvec4 getToColor(vec2 uv) { return vec4(unpremul(_to.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\n\nuniform vec4 shadow_colour; \n\nuniform float shadow_height; \n\nuniform float bounces; \n\nconst float PI = 3.14159265358;\n\nvec4 transition (vec2 uv) {\n float time = progress;\n float stime = sin(time * PI / 2.);\n float phase = time * PI * bounces;\n float y = (abs(cos(phase))) * (1.0 - stime);\n float d = uv.y - y;\n return mix(\n mix(\n getToColor(uv),\n shadow_colour,\n step(d, shadow_height) * (1. - mix(\n ((d / shadow_height) * shadow_colour.a) + (1.0 - shadow_colour.a),\n 1.0,\n smoothstep(0.95, 1., progress) \n ))\n ),\n getFromColor(vec2(uv.x, uv.y + (1.0 - y))),\n step(d, 0.0)\n );\n}\n\nhalf4 main(float2 _coord) {\n vec2 _uv = _coord / _resolution;\n vec4 _c = clamp(transition(vec2(_uv.x, 1.0 - _uv.y)), 0.0, 1.0);\n return half4(_c.rgb * _c.a, _c.a);\n}\n","BowTieHorizontal":"// BowTieHorizontal — generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/BowTieHorizontal.glsl\n// Author: huynx\n// License: MIT\n// Description: Two triangles grow from the left and right edges into a bow tie that reveals the incoming image\n\nuniform shader _from;\nuniform shader _to;\nuniform float2 _resolution;\nuniform float progress;\nuniform float ratio;\n\nvec4 getFromColor(vec2 uv) { return vec4(unpremul(_from.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\nvec4 getToColor(vec2 uv) { return vec4(unpremul(_to.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\n\nconst vec2 bottom_left = vec2(0.0, 1.0);\nconst vec2 bottom_right = vec2(1.0, 1.0);\nconst vec2 top_left = vec2(0.0, 0.0);\nconst vec2 top_right = vec2(1.0, 0.0);\nconst vec2 center = vec2(0.5, 0.5);\n\nfloat check(vec2 p1, vec2 p2, vec2 p3)\n{\n return (p1.x - p3.x) * (p2.y - p3.y) - (p2.x - p3.x) * (p1.y - p3.y);\n}\n\nbool PointInTriangle (vec2 pt, vec2 p1, vec2 p2, vec2 p3)\n{\n bool b1, b2, b3;\n b1 = check(pt, p1, p2) < 0.0;\n b2 = check(pt, p2, p3) < 0.0;\n b3 = check(pt, p3, p1) < 0.0;\n return ((b1 == b2) && (b2 == b3));\n}\n\nbool in_left_triangle(vec2 p){\n vec2 vertex1, vertex2, vertex3;\n vertex1 = vec2(progress, 0.5);\n vertex2 = vec2(0.0, 0.5-progress);\n vertex3 = vec2(0.0, 0.5+progress);\n if (PointInTriangle(p, vertex1, vertex2, vertex3))\n {\n return true;\n }\n return false;\n}\n\nbool in_right_triangle(vec2 p){\n vec2 vertex1, vertex2, vertex3;\n vertex1 = vec2(1.0-progress, 0.5);\n vertex2 = vec2(1.0, 0.5-progress);\n vertex3 = vec2(1.0, 0.5+progress);\n if (PointInTriangle(p, vertex1, vertex2, vertex3))\n {\n return true;\n }\n return false;\n}\n\nfloat blur_edge(vec2 bot1, vec2 bot2, vec2 top, vec2 testPt)\n{\n vec2 lineDir = bot1 - top;\n vec2 perpDir = vec2(lineDir.y, -lineDir.x);\n vec2 dirToPt1 = bot1 - testPt;\n float dist1 = abs(dot(normalize(perpDir), dirToPt1));\n \n lineDir = bot2 - top;\n perpDir = vec2(lineDir.y, -lineDir.x);\n dirToPt1 = bot2 - testPt;\n float min_dist = min(abs(dot(normalize(perpDir), dirToPt1)), dist1);\n \n if (min_dist < 0.005) {\n return min_dist / 0.005;\n }\n else {\n return 1.0;\n };\n}\n\nvec4 transition (vec2 uv) {\n if (in_left_triangle(uv))\n {\n if (progress < 0.1)\n {\n return getFromColor(uv);\n }\n if (uv.x < 0.5)\n {\n vec2 vertex1 = vec2(progress, 0.5);\n vec2 vertex2 = vec2(0.0, 0.5-progress);\n vec2 vertex3 = vec2(0.0, 0.5+progress);\n return mix(\n getFromColor(uv),\n getToColor(uv),\n blur_edge(vertex2, vertex3, vertex1, uv)\n );\n }\n else\n {\n if (progress > 0.0)\n {\n return getToColor(uv);\n }\n else\n {\n return getFromColor(uv);\n }\n } \n }\n else if (in_right_triangle(uv))\n {\n if (uv.x >= 0.5)\n {\n vec2 vertex1 = vec2(1.0-progress, 0.5);\n vec2 vertex2 = vec2(1.0, 0.5-progress);\n vec2 vertex3 = vec2(1.0, 0.5+progress);\n return mix(\n getFromColor(uv),\n getToColor(uv),\n blur_edge(vertex2, vertex3, vertex1, uv)\n ); \n }\n else\n {\n return getFromColor(uv);\n }\n }\n else {\n return getFromColor(uv);\n }\n}\n\nhalf4 main(float2 _coord) {\n vec2 _uv = _coord / _resolution;\n vec4 _c = clamp(transition(vec2(_uv.x, 1.0 - _uv.y)), 0.0, 1.0);\n return half4(_c.rgb * _c.a, _c.a);\n}\n","BowTieVertical":"// BowTieVertical — generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/BowTieVertical.glsl\n// Author: huynx\n// License: MIT\n// Description: Two triangles grow from the top and bottom edges into a bow tie that reveals the incoming image\n\nuniform shader _from;\nuniform shader _to;\nuniform float2 _resolution;\nuniform float progress;\nuniform float ratio;\n\nvec4 getFromColor(vec2 uv) { return vec4(unpremul(_from.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\nvec4 getToColor(vec2 uv) { return vec4(unpremul(_to.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\n\nfloat check(vec2 p1, vec2 p2, vec2 p3)\n{\n return (p1.x - p3.x) * (p2.y - p3.y) - (p2.x - p3.x) * (p1.y - p3.y);\n}\n\nbool PointInTriangle (vec2 pt, vec2 p1, vec2 p2, vec2 p3)\n{\n bool b1, b2, b3;\n b1 = check(pt, p1, p2) < 0.0;\n b2 = check(pt, p2, p3) < 0.0;\n b3 = check(pt, p3, p1) < 0.0;\n return ((b1 == b2) && (b2 == b3));\n}\n\nbool in_top_triangle(vec2 p){\n vec2 vertex1, vertex2, vertex3;\n vertex1 = vec2(0.5, progress);\n vertex2 = vec2(0.5-progress, 0.0);\n vertex3 = vec2(0.5+progress, 0.0);\n if (PointInTriangle(p, vertex1, vertex2, vertex3))\n {\n return true;\n }\n return false;\n}\n\nbool in_bottom_triangle(vec2 p){\n vec2 vertex1, vertex2, vertex3;\n vertex1 = vec2(0.5, 1.0 - progress);\n vertex2 = vec2(0.5-progress, 1.0);\n vertex3 = vec2(0.5+progress, 1.0);\n if (PointInTriangle(p, vertex1, vertex2, vertex3))\n {\n return true;\n }\n return false;\n}\n\nfloat blur_edge(vec2 bot1, vec2 bot2, vec2 top, vec2 testPt)\n{\n vec2 lineDir = bot1 - top;\n vec2 perpDir = vec2(lineDir.y, -lineDir.x);\n vec2 dirToPt1 = bot1 - testPt;\n float dist1 = abs(dot(normalize(perpDir), dirToPt1));\n \n lineDir = bot2 - top;\n perpDir = vec2(lineDir.y, -lineDir.x);\n dirToPt1 = bot2 - testPt;\n float min_dist = min(abs(dot(normalize(perpDir), dirToPt1)), dist1);\n \n if (min_dist < 0.005) {\n return min_dist / 0.005;\n }\n else {\n return 1.0;\n };\n}\n\nvec4 transition (vec2 uv) {\n if (in_top_triangle(uv))\n {\n if (progress < 0.1)\n {\n return getFromColor(uv);\n }\n if (uv.y < 0.5)\n {\n vec2 vertex1 = vec2(0.5, progress);\n vec2 vertex2 = vec2(0.5-progress, 0.0);\n vec2 vertex3 = vec2(0.5+progress, 0.0);\n return mix(\n getFromColor(uv),\n getToColor(uv),\n blur_edge(vertex2, vertex3, vertex1, uv)\n );\n }\n else\n {\n if (progress > 0.0)\n {\n return getToColor(uv);\n }\n else\n {\n return getFromColor(uv);\n }\n } \n }\n else if (in_bottom_triangle(uv))\n {\n if (uv.y >= 0.5)\n {\n vec2 vertex1 = vec2(0.5, 1.0-progress);\n vec2 vertex2 = vec2(0.5-progress, 1.0);\n vec2 vertex3 = vec2(0.5+progress, 1.0);\n return mix(\n getFromColor(uv),\n getToColor(uv),\n blur_edge(vertex2, vertex3, vertex1, uv)\n ); \n }\n else\n {\n return getFromColor(uv);\n }\n }\n else {\n return getFromColor(uv);\n }\n}\n\nhalf4 main(float2 _coord) {\n vec2 _uv = _coord / _resolution;\n vec4 _c = clamp(transition(vec2(_uv.x, 1.0 - _uv.y)), 0.0, 1.0);\n return half4(_c.rgb * _c.a, _c.a);\n}\n","BowTieWithParameter":"// BowTieWithParameter — generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/BowTieWithParameter.glsl\n// Author: KMojek\n// License: MIT\n// Description: A bow-tie wipe with an adjustable shape that can run in reverse\n\nuniform shader _from;\nuniform shader _to;\nuniform float2 _resolution;\nuniform float progress;\nuniform float ratio;\n\nvec4 getFromColor(vec2 uv) { return vec4(unpremul(_from.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\nvec4 getToColor(vec2 uv) { return vec4(unpremul(_to.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\n\nuniform float adjust; \n\nuniform int reverse; \n\nfloat check(vec2 p1, vec2 p2, vec2 p3)\n{\n return (p1.x - p3.x) * (p2.y - p3.y) - (p2.x - p3.x) * (p1.y - p3.y);\n}\n\nbool pointInTriangle(vec2 pt, vec2 p1, vec2 p2, vec2 p3)\n{\n\n bool b1 = check(pt, p1, p2) < 0.0;\n bool b2 = check(pt, p2, p3) < 0.0;\n bool b3 = check(pt, p3, p1) < 0.0;\n return b1 == b2 && b2 == b3;\n}\n\nconst float height = 0.5;\n\nvec4 transition_firstHalf( vec2 uv, float prog )\n{\n if ( uv.y < 0.5 )\n {\n vec2 botLeft = vec2( -0., prog-height );\n vec2 botRight = vec2( 1., prog-height );\n vec2 tip = vec2( adjust, prog );\n if ( pointInTriangle( uv, botLeft, botRight, tip ) )\n return getToColor(uv);\n }\n else\n {\n vec2 topLeft = vec2( -0., 1.-prog+height );\n vec2 topRight = vec2( 1., 1.-prog+height );\n vec2 tip = vec2( adjust, 1.-prog );\n if ( pointInTriangle( uv, topLeft, topRight, tip ) )\n return getToColor( uv );\n }\n return getFromColor( uv );\n}\n\nvec4 transition_secondHalf( vec2 uv, float prog )\n{\n if ( uv.x > adjust )\n {\n vec2 top = vec2( prog + height, 1. );\n vec2 bot = vec2( prog + height, -0. );\n vec2 tip = vec2( mix( adjust, 1.0, 2.0 * (prog - 0.5) ), 0.5 );\n if ( pointInTriangle( uv, top, bot, tip) )\n return getFromColor( uv );\n }\n else\n {\n vec2 top = vec2( 1.0-prog - height, 1. );\n vec2 bot = vec2( 1.0-prog - height, -0. );\n vec2 tip = vec2( mix( adjust, 0.0, 2.0 * (prog - 0.5) ), 0.5 );\n if ( pointInTriangle( uv, top, bot, tip) )\n return getFromColor( uv );\n }\n return getToColor( uv );\n}\n\nvec4 transition (vec2 uv) {\n if ( (reverse != 0) )\n return ( progress < 0.5 ) ? transition_secondHalf( uv, 1.-progress ) : transition_firstHalf( uv, 1.-progress );\n else\n return ( progress < 0.5 ) ? transition_firstHalf( uv, progress ) : transition_secondHalf( uv, progress );\n}\n\nhalf4 main(float2 _coord) {\n vec2 _uv = _coord / _resolution;\n vec4 _c = clamp(transition(vec2(_uv.x, 1.0 - _uv.y)), 0.0, 1.0);\n return half4(_c.rgb * _c.a, _c.a);\n}\n","Box":"// Box — generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/Box.glsl\n// Author: lql\n// License: MIT\n// Description: The outgoing image shrinks into a box, toward the center or a corner, revealing the incoming one\n\nuniform shader _from;\nuniform shader _to;\nuniform float2 _resolution;\nuniform float progress;\nuniform float ratio;\n\nvec4 getFromColor(vec2 uv) { return vec4(unpremul(_from.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\nvec4 getToColor(vec2 uv) { return vec4(unpremul(_to.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\n\nuniform int rectIn; \n\nuniform int location; \n\nvec4 transition(vec2 uv) {\n float p = rectIn == 1 ? 1.0 - progress : progress;\n float x1, y1, x2, y2;\n\n \n if (location == 0) {\n x1 = y1 = 0.5 * (1.0 - p);\n x2 = y2 = 1.0 - x1;\n } else {\n \n x1 = (location == 1 || location == 2) ? 0.0 : 1.0 - p;\n y1 = (location == 1 || location == 3) ? 1.0 - p : 0.0;\n x2 = (location == 1 || location == 2) ? p : 1.0;\n y2 = (location == 1 || location == 3) ? 1.0 : p;\n }\n\n \n float in_rect = step(x1, uv.x) * step(uv.x, x2) * step(y1, uv.y) * step(uv.y, y2);\n in_rect = rectIn == 1 ? 1.0 - in_rect : in_rect;\n\n \n return mix(getFromColor(uv), getToColor(uv), in_rect);\n}\n\nhalf4 main(float2 _coord) {\n vec2 _uv = _coord / _resolution;\n vec4 _c = clamp(transition(vec2(_uv.x, 1.0 - _uv.y)), 0.0, 1.0);\n return half4(_c.rgb * _c.a, _c.a);\n}\n","ButterflyWaveScrawler":"// ButterflyWaveScrawler — generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/ButterflyWaveScrawler.glsl\n// Author: mandubian\n// License: MIT\n// Description: Wavy, color-separated ripples scramble the outgoing image into the incoming one\n\nuniform shader _from;\nuniform shader _to;\nuniform float2 _resolution;\nuniform float progress;\nuniform float ratio;\n\nvec4 getFromColor(vec2 uv) { return vec4(unpremul(_from.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\nvec4 getToColor(vec2 uv) { return vec4(unpremul(_to.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\n\nuniform float amplitude; \nuniform float waves; \nuniform float colorSeparation; \nconst float PI = 3.14159265358979323846264;\nfloat compute(vec2 p, float progress, vec2 center) {\nvec2 o = p*sin(progress * amplitude)-center;\n\nvec2 h = vec2(1., 0.);\n\nfloat theta = acos(dot(o, h)) * waves;\nfloat s = sin((2.*theta - PI) / 24.);\nfloat s2 = s * s;\nreturn (exp(cos(theta)) - 2.*cos(4.*theta) + s2 * s2 * s) / 10.;\n}\nvec4 transition(vec2 uv) {\n if (progress <= 0.0) return getFromColor(uv);\n if (progress >= 1.0) return getToColor(uv);\n vec2 p = uv;\n float inv = 1. - progress;\n float disp = compute(p, progress, vec2(0.5, 0.5));\n vec4 texTo = getToColor(p + inv*disp);\n vec4 texFrom = vec4(\n getFromColor(p + progress*disp*(1.0 - colorSeparation)).r,\n getFromColor(p + progress*disp).g,\n getFromColor(p + progress*disp*(1.0 + colorSeparation)).b,\n 1.0);\n return texTo*progress + texFrom*inv;\n}\n\nhalf4 main(float2 _coord) {\n vec2 _uv = _coord / _resolution;\n vec4 _c = clamp(transition(vec2(_uv.x, 1.0 - _uv.y)), 0.0, 1.0);\n return half4(_c.rgb * _c.a, _c.a);\n}\n","CircleCrop":"// CircleCrop — generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/CircleCrop.glsl\n// Author: fkuteken\n// License: MIT\n// Description: The outgoing image closes into a circle over a background color, then the incoming one opens from it\n\nuniform shader _from;\nuniform shader _to;\nuniform float2 _resolution;\nuniform float progress;\nuniform float ratio;\n\nvec4 getFromColor(vec2 uv) { return vec4(unpremul(_from.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\nvec4 getToColor(vec2 uv) { return vec4(unpremul(_to.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\n\nuniform vec4 bgcolor; \n\nvec4 transition(vec2 p) {\n vec2 ratio2 = vec2(1.0, 1.0 / ratio);\n float s = pow(2.0 * abs(progress - 0.5), 3.0);\n float dist = length((vec2(p) - 0.5) * ratio2);\n return mix(\n progress < 0.5 ? getFromColor(p) : getToColor(p), \n bgcolor,\n step(s, dist)\n );\n}\n\nhalf4 main(float2 _coord) {\n vec2 _uv = _coord / _resolution;\n vec4 _c = clamp(transition(vec2(_uv.x, 1.0 - _uv.y)), 0.0, 1.0);\n return half4(_c.rgb * _c.a, _c.a);\n}\n","ColourDistance":"// ColourDistance — generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/ColourDistance.glsl\n// Author: P-Seebauer\n// License: MIT\n// Description: Pixels switch to the incoming image in order of how close their colors are\n\nuniform shader _from;\nuniform shader _to;\nuniform float2 _resolution;\nuniform float progress;\nuniform float ratio;\n\nvec4 getFromColor(vec2 uv) { return vec4(unpremul(_from.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\nvec4 getToColor(vec2 uv) { return vec4(unpremul(_to.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\n\nuniform float power; \n\nvec4 transition(vec2 p) {\n vec4 fTex = getFromColor(p);\n vec4 tTex = getToColor(p);\n float m = step(distance(fTex, tTex), progress);\n return mix(\n mix(fTex, tTex, m),\n tTex,\n pow(progress, power)\n );\n}\n\nhalf4 main(float2 _coord) {\n vec2 _uv = _coord / _resolution;\n vec4 _c = clamp(transition(vec2(_uv.x, 1.0 - _uv.y)), 0.0, 1.0);\n return half4(_c.rgb * _c.a, _c.a);\n}\n","CrazyParametricFun":"// CrazyParametricFun — generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/CrazyParametricFun.glsl\n// Author: mandubian\n// License: MIT\n// Description: The outgoing image is pulled along a parametric curve into a psychedelic swirl\n\nuniform shader _from;\nuniform shader _to;\nuniform float2 _resolution;\nuniform float progress;\nuniform float ratio;\n\nvec4 getFromColor(vec2 uv) { return vec4(unpremul(_from.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\nvec4 getToColor(vec2 uv) { return vec4(unpremul(_to.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\n\nuniform float a; \nuniform float b; \nuniform float amplitude; \nuniform float smoothness; \n\nvec4 transition(vec2 uv) {\n vec2 p = uv.xy / vec2(1.0).xy;\n vec2 dir = p - vec2(.5);\n float dist = length(dir);\n float x = (a - b) * cos(progress) + b * cos(progress * ((a / b) - 1.) );\n float y = (a - b) * sin(progress) - b * sin(progress * ((a / b) - 1.));\n vec2 offset = dir * vec2(sin(progress * dist * amplitude * x), sin(progress * dist * amplitude * y)) / smoothness;\n return mix(getFromColor(p + offset), getToColor(p), smoothstep(0.2, 1.0, progress));\n}\n\nhalf4 main(float2 _coord) {\n vec2 _uv = _coord / _resolution;\n vec4 _c = clamp(transition(vec2(_uv.x, 1.0 - _uv.y)), 0.0, 1.0);\n return half4(_c.rgb * _c.a, _c.a);\n}\n","CrossZoom":"// CrossZoom — generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/CrossZoom.glsl\n// Author: rectalogic\n// License: MIT\n// Description: A crossfade through a strong zoom blur\n\nuniform shader _from;\nuniform shader _to;\nuniform float2 _resolution;\nuniform float progress;\nuniform float ratio;\n\nvec4 getFromColor(vec2 uv) { return vec4(unpremul(_from.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\nvec4 getToColor(vec2 uv) { return vec4(unpremul(_to.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\n\nuniform float strength; \n\nconst float PI = 3.141592653589793;\n\nfloat Linear_ease(in float begin, in float change, in float duration, in float time) {\n return change * time / duration + begin;\n}\n\nfloat Exponential_easeInOut(in float begin, in float change, in float duration, in float time) {\n if (time == 0.0)\n return begin;\n else if (time == duration)\n return begin + change;\n time = time / (duration / 2.0);\n if (time < 1.0)\n return change / 2.0 * pow(2.0, 10.0 * (time - 1.0)) + begin;\n return change / 2.0 * (-pow(2.0, -10.0 * (time - 1.0)) + 2.0) + begin;\n}\n\nfloat Sinusoidal_easeInOut(in float begin, in float change, in float duration, in float time) {\n return -change / 2.0 * (cos(PI * time / duration) - 1.0) + begin;\n}\n\nfloat rand (vec2 co) {\n return fract(sin(dot(co.xy ,vec2(12.9898,78.233))) * 43758.5453);\n}\n\nvec4 crossFade(in vec2 uv, in float dissolve) {\n return mix(getFromColor(uv), getToColor(uv), dissolve);\n}\n\nvec4 transition(vec2 uv) {\n vec2 texCoord = uv.xy / vec2(1.0).xy;\n\n \n vec2 center = vec2(Linear_ease(0.25, 0.5, 1.0, progress), 0.5);\n float dissolve = Exponential_easeInOut(0.0, 1.0, 1.0, progress);\n\n \n float strength = Sinusoidal_easeInOut(0.0, strength, 0.5, progress);\n\n vec4 color = vec4(0.0);\n float total = 0.0;\n vec2 toCenter = center - texCoord;\n\n \n float offset = rand(uv);\n\n for (float t = 0.0; t <= 40.0; t++) {\n float percent = (t + offset) / 40.0;\n float weight = 4.0 * (percent - percent * percent);\n color += crossFade(texCoord + toCenter * percent * strength, dissolve) * weight;\n total += weight;\n }\n return color / total;\n}\n\nhalf4 main(float2 _coord) {\n vec2 _uv = _coord / _resolution;\n vec4 _c = clamp(transition(vec2(_uv.x, 1.0 - _uv.y)), 0.0, 1.0);\n return half4(_c.rgb * _c.a, _c.a);\n}\n","DefocusBlur":"// DefocusBlur — generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/DefocusBlur.glsl\n// Author: Sergey Kosarevsky\n// License: MIT\n// Description: A crossfade through an out-of-focus blur\n\nuniform shader _from;\nuniform shader _to;\nuniform float2 _resolution;\nuniform float progress;\nuniform float ratio;\n\nvec4 getFromColor(vec2 uv) { return vec4(unpremul(_from.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\nvec4 getToColor(vec2 uv) { return vec4(unpremul(_to.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\n\nuniform float blurSize; \n\nvec4 transition(vec2 uv) {\n float T = progress;\n float half_ = 0.5;\n float D = (T < half_) ? mix(0.0, blurSize, T / half_) : mix(blurSize, 0.0, (T - half_) / half_);\n vec4 C0 = getFromColor(uv);\n vec4 C1 = getToColor(uv);\n C0 += getFromColor(vec2(-0.326, -0.406) * D + uv);\n C1 += getToColor(vec2(-0.326, -0.406) * D + uv);\n C0 += getFromColor(vec2(-0.840, -0.074) * D + uv);\n C1 += getToColor(vec2(-0.840, -0.074) * D + uv);\n C0 += getFromColor(vec2(-0.696, 0.457) * D + uv);\n C1 += getToColor(vec2(-0.696, 0.457) * D + uv);\n C0 += getFromColor(vec2(-0.203, 0.621) * D + uv);\n C1 += getToColor(vec2(-0.203, 0.621) * D + uv);\n C0 += getFromColor(vec2( 0.962, -0.195) * D + uv);\n C1 += getToColor(vec2( 0.962, -0.195) * D + uv);\n C0 += getFromColor(vec2( 0.473, -0.480) * D + uv);\n C1 += getToColor(vec2( 0.473, -0.480) * D + uv);\n C0 += getFromColor(vec2( 0.519, 0.767) * D + uv);\n C1 += getToColor(vec2( 0.519, 0.767) * D + uv);\n C0 += getFromColor(vec2( 0.185, -0.893) * D + uv);\n C1 += getToColor(vec2( 0.185, -0.893) * D + uv);\n C0 += getFromColor(vec2( 0.507, 0.064) * D + uv);\n C1 += getToColor(vec2( 0.507, 0.064) * D + uv);\n C0 += getFromColor(vec2( 0.896, 0.412) * D + uv);\n C1 += getToColor(vec2( 0.896, 0.412) * D + uv);\n C0 += getFromColor(vec2(-0.322, -0.933) * D + uv);\n C1 += getToColor(vec2(-0.322, -0.933) * D + uv);\n C0 += getFromColor(vec2(-0.792, -0.598) * D + uv);\n C1 += getToColor(vec2(-0.792, -0.598) * D + uv);\n C0 /= 13.0;\n C1 /= 13.0;\n return mix(C0, C1, T);\n}\n\nhalf4 main(float2 _coord) {\n vec2 _uv = _coord / _resolution;\n vec4 _c = clamp(transition(vec2(_uv.x, 1.0 - _uv.y)), 0.0, 1.0);\n return half4(_c.rgb * _c.a, _c.a);\n}\n","Directional":"// Directional — generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/Directional.glsl\n// Author: Gaëtan Renaudeau\n// License: MIT\n// Description: The incoming image pushes the outgoing one out in a given direction\n\nuniform shader _from;\nuniform shader _to;\nuniform float2 _resolution;\nuniform float progress;\nuniform float ratio;\n\nvec4 getFromColor(vec2 uv) { return vec4(unpremul(_from.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\nvec4 getToColor(vec2 uv) { return vec4(unpremul(_to.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\n\nuniform vec2 direction; \n\nvec4 transition (vec2 uv) {\n vec2 p = uv + progress * sign(direction);\n vec2 f = fract(p);\n return mix(\n getToColor(f),\n getFromColor(f),\n step(0.0, p.y) * step(p.y, 1.0) * step(0.0, p.x) * step(p.x, 1.0)\n );\n}\n\nhalf4 main(float2 _coord) {\n vec2 _uv = _coord / _resolution;\n vec4 _c = clamp(transition(vec2(_uv.x, 1.0 - _uv.y)), 0.0, 1.0);\n return half4(_c.rgb * _c.a, _c.a);\n}\n","DirectionalScaled":"// DirectionalScaled — generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/DirectionalScaled.glsl\n// Author: Thibaut Foussard\n// License: MIT\n// Description: Like Directional, with both images scaled down while they slide\n\nuniform shader _from;\nuniform shader _to;\nuniform float2 _resolution;\nuniform float progress;\nuniform float ratio;\n\nvec4 getFromColor(vec2 uv) { return vec4(unpremul(_from.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\nvec4 getToColor(vec2 uv) { return vec4(unpremul(_to.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\n\nuniform vec2 direction; \nuniform float scale; \n\nfloat parabola(float x) {\n float y = pow(sin(x * acos(-1.0)), 1.);\n return y;\n}\n\nvec4 transition (vec2 uv) {\n float easedProgress = pow(sin(progress * acos(-1.0) / 2.), 3.);\n vec2 p = uv + easedProgress * sign(direction);\n vec2 f = fract(p);\n \n float s = 1. - (1. - (1. / scale)) * parabola(progress);\n f = (f - 0.5) * s + 0.5;\n \n float mixer = step(0.0, p.y) * step(p.y, 1.0) * step(0.0, p.x) * step(p.x, 1.0);\n vec4 col = mix(getToColor(f), getFromColor(f), mixer);\n \n float border = step(0., f.x) * step(0., (1. - f.x)) * step(0., f.y) * step(0., 1. - f.y);\n col *= border;\n \n return col;\n}\n\nhalf4 main(float2 _coord) {\n vec2 _uv = _coord / _resolution;\n vec4 _c = clamp(transition(vec2(_uv.x, 1.0 - _uv.y)), 0.0, 1.0);\n return half4(_c.rgb * _c.a, _c.a);\n}\n","DoomScreenTransition":"// DoomScreenTransition — generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/DoomScreenTransition.glsl\n// Author: Zeh Fernando\n// License: MIT\n// Description: The outgoing image melts down in uneven columns, like the Doom screen wipe\n\nuniform shader _from;\nuniform shader _to;\nuniform float2 _resolution;\nuniform float progress;\nuniform float ratio;\n\nvec4 getFromColor(vec2 uv) { return vec4(unpremul(_from.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\nvec4 getToColor(vec2 uv) { return vec4(unpremul(_to.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\n\nuniform int bars; \n\nuniform float amplitude; \n\nuniform float noise; \n\nuniform float frequency; \n\nuniform float dripScale; \n\nfloat rand(int num) {\n return fract(mod(float(num) * 67123.313, 12.0) * sin(float(num) * 10.3) * cos(float(num)));\n}\n\nfloat wave(int num) {\n float fn = float(num) * frequency * 0.1 * float(bars);\n return cos(fn * 0.5) * cos(fn * 0.13) * sin((fn+10.0) * 0.3) / 2.0 + 0.5;\n}\n\nfloat drip(int num) {\n return sin(float(num) / float(bars - 1) * 3.141592) * dripScale;\n}\n\nfloat pos(int num) {\n return (noise == 0.0 ? wave(num) : mix(wave(num), rand(num), noise)) + (dripScale == 0.0 ? 0.0 : drip(num));\n}\n\nvec4 transition(vec2 uv) {\n int bar = int(uv.x * (float(bars)));\n float scale = 1.0 + pos(bar) * amplitude;\n float phase = progress * scale;\n float posY = uv.y / vec2(1.0).y;\n vec2 p;\n vec4 c;\n if (phase + posY < 1.0) {\n p = vec2(uv.x, uv.y + mix(0.0, vec2(1.0).y, phase)) / vec2(1.0).xy;\n c = getFromColor(p);\n } else {\n p = uv.xy / vec2(1.0).xy;\n c = getToColor(p);\n }\n\n \n return c;\n}\n\nhalf4 main(float2 _coord) {\n vec2 _uv = _coord / _resolution;\n vec4 _c = clamp(transition(vec2(_uv.x, 1.0 - _uv.y)), 0.0, 1.0);\n return half4(_c.rgb * _c.a, _c.a);\n}\n","Dreamy":"// Dreamy — generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/Dreamy.glsl\n// Author: mikolalysenko\n// License: MIT\n// Description: A crossfade with a gentle wavy distortion\n\nuniform shader _from;\nuniform shader _to;\nuniform float2 _resolution;\nuniform float progress;\nuniform float ratio;\n\nvec4 getFromColor(vec2 uv) { return vec4(unpremul(_from.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\nvec4 getToColor(vec2 uv) { return vec4(unpremul(_to.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\n\nvec2 offset(float progress, float x, float theta) {\n float phase = progress*progress + progress + theta;\n float shifty = 0.03*progress*cos(10.0*(progress+x));\n return vec2(0, shifty);\n}\nvec4 transition(vec2 p) {\n return mix(getFromColor(p + offset(progress, p.x, 0.0)), getToColor(p + offset(1.0-progress, p.x, 3.14)), progress);\n}\n\nhalf4 main(float2 _coord) {\n vec2 _uv = _coord / _resolution;\n vec4 _c = clamp(transition(vec2(_uv.x, 1.0 - _uv.y)), 0.0, 1.0);\n return half4(_c.rgb * _c.a, _c.a);\n}\n","DreamyZoom":"// DreamyZoom — generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/DreamyZoom.glsl\n// Author: Zeh Fernando\n// License: MIT\n// Description: Zooms and rotates into a bright flash, then out to the incoming image\n\nuniform shader _from;\nuniform shader _to;\nuniform float2 _resolution;\nuniform float progress;\nuniform float ratio;\n\nvec4 getFromColor(vec2 uv) { return vec4(unpremul(_from.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\nvec4 getToColor(vec2 uv) { return vec4(unpremul(_to.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\n\nuniform float rotation; \n\nuniform float scale; \n\nvec4 transition(vec2 uv) {\n \n float phase = progress < 0.5 ? progress * 2.0 : (progress - 0.5) * 2.0;\n float angleOffset = progress < 0.5 ? mix(0.0, rotation * 0.03926990816987241548078304229099, phase) : mix(-rotation * 0.03926990816987241548078304229099, 0.0, phase);\n float newScale = progress < 0.5 ? mix(1.0, scale, phase) : mix(scale, 1.0, phase);\n \n vec2 center = vec2(0, 0);\n\n \n vec2 assumedCenter = vec2(0.5, 0.5);\n vec2 p = (uv.xy - vec2(0.5, 0.5)) / newScale * vec2(ratio, 1.0);\n\n \n float angle = atan(p.y, p.x) + angleOffset;\n float dist = distance(center, p);\n p.x = cos(angle) * dist / ratio + 0.5;\n p.y = sin(angle) * dist + 0.5;\n vec4 c = progress < 0.5 ? getFromColor(p) : getToColor(p);\n\n \n return c + (progress < 0.5 ? mix(0.0, 1.0, phase) : mix(1.0, 0.0, phase));\n}\n\nhalf4 main(float2 _coord) {\n vec2 _uv = _coord / _resolution;\n vec4 _c = clamp(transition(vec2(_uv.x, 1.0 - _uv.y)), 0.0, 1.0);\n return half4(_c.rgb * _c.a, _c.a);\n}\n","Drop_Zone_Flicker":"// Drop_Zone_Flicker — generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/Drop_Zone_Flicker.glsl\n// Author: bread\n// License: MIT\n// Description: A flickering glitch with RGB offset, ghosting and scanlines that flashes back to the outgoing image\n\nuniform shader _from;\nuniform shader _to;\nuniform float2 _resolution;\nuniform float progress;\nuniform float ratio;\n\nvec4 getFromColor(vec2 uv) { return vec4(unpremul(_from.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\nvec4 getToColor(vec2 uv) { return vec4(unpremul(_to.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\n\nuniform float frameRate; \nuniform float rgbOffset; \nuniform float blockAmount; \nuniform float ghostAmount; \nuniform float redCyan; \nuniform float scanline; \n\nfloat sat(float x) {\n return clamp(x, 0.0, 1.0);\n}\n\nfloat hash12(vec2 p) {\n p = fract(p * vec2(443.8975, 397.2973));\n p += dot(p, p.yx + 19.19);\n return fract(p.x * p.y);\n}\n\nvec2 safeUv(vec2 uv) {\n return clamp(uv, vec2(0.001), vec2(0.999));\n}\n\nfloat frameReveal(float f) {\n if (f < 0.5) return 0.00;\n if (f < 1.5) return 0.28;\n if (f < 2.5) return 0.43;\n if (f < 3.5) return 0.46;\n if (f < 4.5) return 0.38;\n if (f < 5.5) return 0.48;\n if (f < 6.5) return 0.26;\n if (f < 7.5) return 0.10;\n if (f < 8.5) return 0.00;\n if (f < 9.5) return 0.00;\n if (f < 10.5) return 0.30;\n if (f < 11.5) return 0.58;\n if (f < 12.5) return 1.00;\n if (f < 13.5) return 0.70;\n if (f < 14.5) return 0.42;\n if (f < 15.5) return 0.55;\n if (f < 16.5) return 0.72;\n if (f < 17.5) return 0.88;\n if (f < 18.5) return 0.34;\n if (f < 19.5) return 0.48;\n if (f < 20.5) return 0.56;\n if (f < 21.5) return 0.76;\n if (f < 22.5) return 0.93;\n return 1.00;\n}\n\nfloat frameGlitch(float f) {\n if (f < 0.5) return 0.00;\n if (f < 6.5) return 0.92;\n if (f < 10.5) return 0.38;\n if (f < 11.5) return 0.78;\n if (f < 12.5) return 0.12;\n if (f < 17.5) return 0.74;\n if (f < 22.5) return 0.88;\n if (f < 23.5) return 0.28;\n return 0.00;\n}\n\nvec4 chromaFrom(vec2 uv, float amt) {\n vec2 o = vec2(amt, 0.0);\n return vec4(\n getFromColor(safeUv(uv + o)).r,\n getFromColor(safeUv(uv)).g,\n getFromColor(safeUv(uv - o)).b,\n 1.0\n );\n}\n\nvec4 chromaTo(vec2 uv, float amt) {\n vec2 o = vec2(amt, 0.0);\n return vec4(\n getToColor(safeUv(uv - o)).r,\n getToColor(safeUv(uv)).g,\n getToColor(safeUv(uv + o)).b,\n 1.0\n );\n}\n\nfloat blockMask(vec2 uv, float f) {\n vec2 big = floor(uv * vec2(4.0, 2.0));\n vec2 small = floor(uv * vec2(8.0, 4.0));\n\n float wide = step(0.48, hash12(vec2(big.x, f * 1.37)));\n float chunks = step(0.56, hash12(small + vec2(f * 2.11, f * 0.73)));\n\n float verticalCut = smoothstep(\n -0.035,\n 0.035,\n uv.x - mix(0.18, 0.78, hash12(vec2(f, 4.7)))\n );\n\n return sat(mix(wide, chunks, 0.38) * 0.72 + verticalCut * 0.28);\n}\n\nvec4 transition(vec2 uv) {\n if (progress <= 0.0) return getFromColor(uv);\n if (progress >= 1.0) return getToColor(uv);\n\n float f = floor(progress * frameRate);\n float reveal = frameReveal(f);\n float glitch = frameGlitch(f);\n\n float rnd = hash12(vec2(f, 9.13));\n vec2 jitter = vec2(\n (rnd - 0.5) * 0.042,\n (hash12(vec2(f, 2.71)) - 0.5) * 0.010\n ) * glitch;\n\n vec2 fromUv = safeUv(uv + jitter);\n vec2 toUv = safeUv(uv - jitter * 0.55);\n\n float block = blockMask(uv, f);\n float localReveal = sat(\n reveal +\n (block - 0.5) * blockAmount * glitch +\n (hash12(vec2(f, floor(uv.y * 9.0))) - 0.5) * 0.18 * glitch\n );\n\n localReveal = smoothstep(0.22, 0.78, localReveal);\n\n vec4 oldClip = chromaFrom(fromUv, rgbOffset * glitch);\n vec4 newClip = chromaTo(toUv, rgbOffset * glitch);\n\n vec4 color = mix(oldClip, newClip, localReveal);\n\n float leftWash = (1.0 - smoothstep(0.10, 0.78, uv.x)) * glitch;\n float cyanWash = smoothstep(0.08, 0.62, uv.x) * (1.0 - smoothstep(0.86, 1.0, uv.x)) * glitch;\n\n vec3 redGhost = oldClip.rgb * vec3(1.34, 0.42, 0.38);\n vec3 cyanGhost = newClip.rgb * vec3(0.48, 1.12, 1.24);\n\n color.rgb = mix(color.rgb, redGhost, leftWash * redCyan * 0.42);\n color.rgb = mix(color.rgb, cyanGhost, cyanWash * redCyan * 0.30);\n\n \n \n float oldReturn = glitch * (1.0 - smoothstep(0.94, 1.0, reveal));\n oldReturn *= 0.18 + 0.52 * (1.0 - abs(localReveal - 0.5) * 2.0);\n color.rgb = mix(color.rgb, oldClip.rgb, oldReturn * ghostAmount);\n\n float lines = sin((uv.y + f * 0.017) * 1080.0);\n color.rgb += lines * scanline * glitch;\n\n float exposurePulse = (hash12(vec2(f, 12.4)) - 0.35) * 0.10 * glitch;\n color.rgb += exposurePulse;\n\n return vec4(sat(color.r), sat(color.g), sat(color.b), 1.0);\n}\n\nhalf4 main(float2 _coord) {\n vec2 _uv = _coord / _resolution;\n vec4 _c = clamp(transition(vec2(_uv.x, 1.0 - _uv.y)), 0.0, 1.0);\n return half4(_c.rgb * _c.a, _c.a);\n}\n","EdgeTransition":"// EdgeTransition — generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/EdgeTransition.glsl\n// Author: Woohyun Kim\n// License: MIT\n// Description: Both images fade through black with their edges glowing\n\nuniform shader _from;\nuniform shader _to;\nuniform float2 _resolution;\nuniform float progress;\nuniform float ratio;\n\nvec4 getFromColor(vec2 uv) { return vec4(unpremul(_from.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\nvec4 getToColor(vec2 uv) { return vec4(unpremul(_to.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\n\nuniform float edge_thickness; \nuniform float edge_brightness; \n\nvec4 detectEdgeColor(vec3[9] c) {\n \n \n \n \n \n vec3 dx = 2.0 * abs(c[7]-c[1]) + abs(c[2] - c[6]) + abs(c[8] - c[0]);\n\tvec3 dy = 2.0 * abs(c[3]-c[5]) + abs(c[6] - c[8]) + abs(c[0] - c[2]);\n float delta = length(0.25 * (dx + dy) * 0.5);\n\treturn vec4(clamp(edge_brightness * delta, 0.0, 1.0) * c[4], 1.0);\n}\n\nvec4 getFromEdgeColor(vec2 uv) {\n\tvec3 c[9];\n\tfor (int i=0; i < 3; ++i) for (int j=0; j < 3; ++j)\n\t{\n\t vec4 color = getFromColor(uv + edge_thickness * vec2(i-1,j-1));\n c[3*i + j] = color.rgb;\n\t}\n\treturn detectEdgeColor(c);\n}\n\nvec4 getToEdgeColor(vec2 uv) {\n\tvec3 c[9];\n\tfor (int i=0; i < 3; ++i) for (int j=0; j < 3; ++j)\n\t{\n\t vec4 color = getToColor(uv + edge_thickness * vec2(i-1,j-1));\n c[3*i + j] = color.rgb;\n\t}\n\treturn detectEdgeColor(c);\n}\n\nvec4 transition (vec2 uv) {\n vec4 start = mix(getFromColor(uv), getFromEdgeColor(uv), clamp(2.0 * progress, 0.0, 1.0));\n vec4 end = mix(getToEdgeColor(uv), getToColor(uv), clamp(2.0 * (progress - 0.5), 0.0, 1.0));\n return mix(\n start,\n end,\n progress\n );\n}\n\nhalf4 main(float2 _coord) {\n vec2 _uv = _coord / _resolution;\n vec4 _c = clamp(transition(vec2(_uv.x, 1.0 - _uv.y)), 0.0, 1.0);\n return half4(_c.rgb * _c.a, _c.a);\n}\n","FilmBurn":"// FilmBurn — generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/FilmBurn.glsl\n// Author: Anastasia Dunbar\n// License: MIT\n// Description: Glowing film-burn light leaks wash over the image and reveal the incoming one\n\nuniform shader _from;\nuniform shader _to;\nuniform float2 _resolution;\nuniform float progress;\nuniform float ratio;\n\nvec4 getFromColor(vec2 uv) { return vec4(unpremul(_from.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\nvec4 getToColor(vec2 uv) { return vec4(unpremul(_to.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\n\nuniform float Seed; \nfloat sigmoid(float x, float a) {\n float b = pow(x*2.,a)/2.;\n if (x > .5) {\n b = 1.-pow(2.-(x*2.),a)/2.;\n }\n\treturn b;\n}\nfloat rand(float co){\n return fract(sin((co*24.9898)+Seed)*43758.5453);\n}\nfloat rand(vec2 co){\n return fract(sin(dot(co.xy ,vec2(12.9898,78.233))) * 43758.5453);\n}\nfloat apow(float a,float b) { return pow(abs(a),b)*sign(b); }\nvec3 pow3(vec3 a,vec3 b) { return vec3(apow(a.r,b.r),apow(a.g,b.g),apow(a.b,b.b)); }\nfloat smooth_mix(float a,float b,float c) { return mix(a,b,sigmoid(c,2.)); }\nfloat random(vec2 co, float shft){\n co += 10.;\n 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));\n}\nfloat smooth_random(vec2 co, float shft) {\n\treturn 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));\n}\nvec4 blendedColor(vec2 p) {\n return mix(getFromColor(p), getToColor(p), sigmoid(progress,10.));\n}\n\nvec4 transition(vec2 p) {\n vec3 f = vec3(0.);\n for (float i = 0.; i < 13.; i++) {\n 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));\n 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.);\n }\n f += 4.;\n f /= 11.;\n f = pow3(f*vec3(1.,0.7,0.6),vec3(1.,2.-sin(progress*3.14159265358979323),1.3));\n f *= sin(progress*3.14159265358979323);\n \n p -= .5;\n p *= 1.+(smooth_random(vec2(progress*5.),6.3)*sin(progress*3.14159265358979323)*.05);\n p += .5;\n \n vec4 blurred_image = vec4(0.);\n float bluramount = sin(progress*3.14159265358979323)*.03;\n\n for (float i = 0.; i < 50.; i++) { \n vec2 q = vec2(cos(degrees((i/50.)*360.)),sin(degrees((i/50.)*360.))) * (rand(vec2(i,p.x+p.y))+bluramount); \n vec2 uv2 = p+(q*bluramount);\n blurred_image += blendedColor(uv2);\n }\n blurred_image /= 50.;\n \n return blurred_image+vec4(f,0.);\n}\n\nhalf4 main(float2 _coord) {\n vec2 _uv = _coord / _resolution;\n vec4 _c = clamp(transition(vec2(_uv.x, 1.0 - _uv.y)), 0.0, 1.0);\n return half4(_c.rgb * _c.a, _c.a);\n}\n","Fold":"// Fold — generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/Fold.glsl\n// Author: nwoeanhinnogaehr\n// License: MIT\n// Description: The incoming image unfolds from the left while the outgoing one folds away to the right\n\nuniform shader _from;\nuniform shader _to;\nuniform float2 _resolution;\nuniform float progress;\nuniform float ratio;\n\nvec4 getFromColor(vec2 uv) { return vec4(unpremul(_from.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\nvec4 getToColor(vec2 uv) { return vec4(unpremul(_to.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\n\nvec4 transition(vec2 uv) {\n \n if (progress == 0.0 || uv.x > progress) return getFromColor((uv - vec2(progress, 0.0)) / vec2(1.0 - progress, 1.0));\n return getToColor(uv / vec2(progress, 1.0));\n}\n\nhalf4 main(float2 _coord) {\n vec2 _uv = _coord / _resolution;\n vec4 _c = clamp(transition(vec2(_uv.x, 1.0 - _uv.y)), 0.0, 1.0);\n return half4(_c.rgb * _c.a, _c.a);\n}\n","GlitchDisplace":"// GlitchDisplace — generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/GlitchDisplace.glsl\n// Author: Matt DesLauriers\n// License: MIT\n// Description: Blocks of the image are displaced in a glitch that flashes into the incoming image\n\nuniform shader _from;\nuniform shader _to;\nuniform float2 _resolution;\nuniform float progress;\nuniform float ratio;\n\nvec4 getFromColor(vec2 uv) { return vec4(unpremul(_from.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\nvec4 getToColor(vec2 uv) { return vec4(unpremul(_to.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\n\nfloat random(vec2 co)\n{\n float a = 12.9898;\n float b = 78.233;\n float c = 43758.5453;\n float dt= dot(co.xy ,vec2(a,b));\n float sn= mod(dt,3.14);\n return fract(sin(sn) * c);\n}\nfloat voronoi( in vec2 x ) {\n vec2 p = floor( x );\n vec2 f = fract( x );\n float res = 8.0;\n for( float j=-1.; j<=1.; j++ )\n for( float i=-1.; i<=1.; i++ ) {\n vec2 b = vec2( i, j );\n vec2 r = b - f + random( p + b );\n float d = dot( r, r );\n res = min( res, d );\n }\n return sqrt( res );\n}\n\nvec2 displace(vec4 tex, vec2 texCoord, float dotDepth, float textureDepth, float strength) {\n float b = voronoi(.003 * texCoord + 2.0);\n float g = voronoi(0.2 * texCoord);\n float r = voronoi(texCoord - 1.0);\n vec4 dt = tex * 1.0;\n vec4 dis = dt * dotDepth + 1.0 - tex * textureDepth;\n\n dis.x = dis.x - 1.0 + textureDepth*dotDepth;\n dis.y = dis.y - 1.0 + textureDepth*dotDepth;\n dis.x *= strength;\n dis.y *= strength;\n vec2 res_uv = texCoord ;\n res_uv.x = res_uv.x + dis.x - 0.0;\n res_uv.y = res_uv.y + dis.y;\n return res_uv;\n}\n\nfloat ease1(float t) {\n return t == 0.0 || t == 1.0\n ? t\n : t < 0.5\n ? +0.5 * pow(2.0, (20.0 * t) - 10.0)\n : -0.5 * pow(2.0, 10.0 - (t * 20.0)) + 1.0;\n}\nfloat ease2(float t) {\n return t == 1.0 ? t : 1.0 - pow(2.0, -10.0 * t);\n}\n\nvec4 transition(vec2 uv) {\n vec2 p = uv.xy / vec2(1.0).xy;\n vec4 color1 = getFromColor(p);\n vec4 color2 = getToColor(p);\n vec2 disp = displace(color1, p, 0.33, 0.7, 1.0-ease1(progress));\n vec2 disp2 = displace(color2, p, 0.33, 0.5, ease2(progress));\n vec4 dColor1 = getToColor(disp);\n vec4 dColor2 = getFromColor(disp2);\n float val = ease1(progress);\n vec3 gray = vec3(dot(min(dColor2, dColor1).rgb, vec3(0.299, 0.587, 0.114)));\n dColor2 = vec4(gray, 1.0);\n dColor2 *= 2.0;\n color1 = mix(color1, dColor2, smoothstep(0.0, 0.5, progress));\n color2 = mix(color2, dColor1, smoothstep(1.0, 0.5, progress));\n return mix(color1, color2, val);\n \n\n \n}\n\nhalf4 main(float2 _coord) {\n vec2 _uv = _coord / _resolution;\n vec4 _c = clamp(transition(vec2(_uv.x, 1.0 - _uv.y)), 0.0, 1.0);\n return half4(_c.rgb * _c.a, _c.a);\n}\n","GlitchMemories":"// GlitchMemories — generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/GlitchMemories.glsl\n// Author: Gunnar Roth\n// License: MIT\n// Description: A crossfade with glitchy, color-shifted blocks\n\nuniform shader _from;\nuniform shader _to;\nuniform float2 _resolution;\nuniform float progress;\nuniform float ratio;\n\nvec4 getFromColor(vec2 uv) { return vec4(unpremul(_from.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\nvec4 getToColor(vec2 uv) { return vec4(unpremul(_to.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\n\nvec4 transition(vec2 p) {\n vec2 block = floor(p.xy / vec2(16));\n vec2 uv_noise = block / vec2(64);\n uv_noise += floor(vec2(progress) * vec2(1200.0, 3500.0)) / vec2(64);\n vec2 dist = progress > 0.0 ? (fract(uv_noise) - 0.5) * 0.3 *(1.0 -progress) : vec2(0.0);\n vec2 red = p + dist * 0.2;\n vec2 green = p + dist * .3;\n vec2 blue = p + dist * .5;\n\n 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);\n}\n\nhalf4 main(float2 _coord) {\n vec2 _uv = _coord / _resolution;\n vec4 _c = clamp(transition(vec2(_uv.x, 1.0 - _uv.y)), 0.0, 1.0);\n return half4(_c.rgb * _c.a, _c.a);\n}\n","GridFlip":"// GridFlip — generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/GridFlip.glsl\n// Author: TimDonselaar\n// License: MIT\n// Description: The image splits into a grid of tiles that flip one by one to the incoming image\n\nuniform shader _from;\nuniform shader _to;\nuniform float2 _resolution;\nuniform float progress;\nuniform float ratio;\n\nvec4 getFromColor(vec2 uv) { return vec4(unpremul(_from.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\nvec4 getToColor(vec2 uv) { return vec4(unpremul(_to.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\n\nuniform ivec2 size; \nuniform float pause; \nuniform float dividerWidth; \n\nuniform vec4 bgcolor; \nuniform float randomness; \n \nfloat rand (vec2 co) {\n return fract(sin(dot(co.xy ,vec2(12.9898,78.233))) * 43758.5453);\n}\n\nfloat getDelta(vec2 p) {\n vec2 rectanglePos = floor(vec2(size) * p);\n vec2 rectangleSize = vec2(1.0 / vec2(size).x, 1.0 / vec2(size).y);\n float top = rectangleSize.y * (rectanglePos.y + 1.0);\n float bottom = rectangleSize.y * rectanglePos.y;\n float left = rectangleSize.x * rectanglePos.x;\n float right = rectangleSize.x * (rectanglePos.x + 1.0);\n float minX = min(abs(p.x - left), abs(p.x - right));\n float minY = min(abs(p.y - top), abs(p.y - bottom));\n return min(minX, minY);\n}\n\nfloat getDividerSize() {\n vec2 rectangleSize = vec2(1.0 / vec2(size).x, 1.0 / vec2(size).y);\n return min(rectangleSize.x, rectangleSize.y) * dividerWidth;\n}\n\nvec4 transition(vec2 p) {\n if(progress < pause) {\n float currentProg = progress / pause;\n float a = 1.0;\n if(getDelta(p) < getDividerSize()) {\n a = 1.0 - currentProg;\n }\n return mix(bgcolor, getFromColor(p), a);\n }\n else if(progress < 1.0 - pause){\n if(getDelta(p) < getDividerSize()) {\n return bgcolor;\n } else {\n float currentProg = (progress - pause) / (1.0 - pause * 2.0);\n vec2 q = p;\n vec2 rectanglePos = floor(vec2(size) * q);\n \n float r = rand(rectanglePos) - randomness;\n float cp = smoothstep(0.0, 1.0 - r, currentProg);\n \n float rectangleSize = 1.0 / vec2(size).x;\n float delta = rectanglePos.x * rectangleSize;\n float offset = rectangleSize / 2.0 + delta;\n \n p.x = (p.x - offset)/abs(cp - 0.5)*0.5 + offset;\n vec4 a = getFromColor(p);\n vec4 b = getToColor(p);\n \n float s = step(abs(vec2(size).x * (q.x - delta) - 0.5), abs(cp - 0.5));\n return mix(bgcolor, mix(b, a, step(cp, 0.5)), s);\n }\n }\n else {\n float currentProg = (progress - 1.0 + pause) / pause;\n float a = 1.0;\n if(getDelta(p) < getDividerSize()) {\n a = currentProg;\n }\n return mix(bgcolor, getToColor(p), a);\n }\n}\n\nhalf4 main(float2 _coord) {\n vec2 _uv = _coord / _resolution;\n vec4 _c = clamp(transition(vec2(_uv.x, 1.0 - _uv.y)), 0.0, 1.0);\n return half4(_c.rgb * _c.a, _c.a);\n}\n","HSVfade":"// HSVfade — generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/HSVfade.glsl\n// Author: nwoeanhinnogaehr\n// License: MIT\n// Description: A crossfade through the HSV color space that cycles through hues\n\nuniform shader _from;\nuniform shader _to;\nuniform float2 _resolution;\nuniform float progress;\nuniform float ratio;\n\nvec4 getFromColor(vec2 uv) { return vec4(unpremul(_from.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\nvec4 getToColor(vec2 uv) { return vec4(unpremul(_to.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\n\nvec3 hsv2rgb(vec3 c) {\n const vec4 K = vec4(1.0, 2.0 / 3.0, 1.0 / 3.0, 3.0);\n vec3 p = abs(fract(c.xxx + K.xyz) * 6.0 - K.www);\n return c.z * mix(K.xxx, clamp(p - K.xxx, 0.0, 1.0), c.y);\n}\n\nvec3 rgb2hsv(vec3 c) {\n const vec4 K = vec4(0.0, -1.0 / 3.0, 2.0 / 3.0, -1.0);\n vec4 p = mix(vec4(c.bg, K.wz), vec4(c.gb, K.xy), step(c.b, c.g));\n vec4 q = mix(vec4(p.xyw, c.r), vec4(c.r, p.yzx), step(p.x, c.r));\n float d = q.x - min(q.w, q.y);\n return vec3(abs(q.z + (q.w - q.y) / (6.0 * d + 0.001)), d / (q.x + 0.001), q.x);\n}\n\nvec4 transition(vec2 uv) {\n vec3 a = rgb2hsv(getFromColor(uv).rgb);\n vec3 b = rgb2hsv(getToColor(uv).rgb);\n vec3 m = mix(a, b, progress);\n return vec4(hsv2rgb(m), 1.0);\n}\n\nhalf4 main(float2 _coord) {\n vec2 _uv = _coord / _resolution;\n vec4 _c = clamp(transition(vec2(_uv.x, 1.0 - _uv.y)), 0.0, 1.0);\n return half4(_c.rgb * _c.a, _c.a);\n}\n","HorizontalClose":"// HorizontalClose — generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/HorizontalClose.glsl\n// Author: martiniti\n// License: MIT\n// Description: The incoming image closes in from the top and bottom edges toward the middle\n\nuniform shader _from;\nuniform shader _to;\nuniform float2 _resolution;\nuniform float progress;\nuniform float ratio;\n\nvec4 getFromColor(vec2 uv) { return vec4(unpremul(_from.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\nvec4 getToColor(vec2 uv) { return vec4(unpremul(_to.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\n\nvec4 transition (vec2 uv) {\n\n float s = 2.0 - abs((uv.y - 0.5) / (progress - 1.0)) - 2.0 * progress;\n \n return mix(\n getFromColor(uv),\n getToColor(uv),\n smoothstep(0.5, 0.0, s)\n ); \n}\n\nhalf4 main(float2 _coord) {\n vec2 _uv = _coord / _resolution;\n vec4 _c = clamp(transition(vec2(_uv.x, 1.0 - _uv.y)), 0.0, 1.0);\n return half4(_c.rgb * _c.a, _c.a);\n}\n","HorizontalOpen":"// HorizontalOpen — generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/HorizontalOpen.glsl\n// Author: martiniti\n// License: MIT\n// Description: The incoming image opens from a line in the middle toward the top and bottom edges\n\nuniform shader _from;\nuniform shader _to;\nuniform float2 _resolution;\nuniform float progress;\nuniform float ratio;\n\nvec4 getFromColor(vec2 uv) { return vec4(unpremul(_from.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\nvec4 getToColor(vec2 uv) { return vec4(unpremul(_to.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\n\nvec4 transition (vec2 uv) {\n \n float regress = 1.0 - progress;\n\n float s = 2.0 - abs((uv.y - 0.5) / (regress - 1.0)) - 2.0 * regress;\n \n return mix(\n getFromColor(uv),\n getToColor(uv),\n smoothstep(0.0, 0.5, s)\n );\n}\n\nhalf4 main(float2 _coord) {\n vec2 _uv = _coord / _resolution;\n vec4 _c = clamp(transition(vec2(_uv.x, 1.0 - _uv.y)), 0.0, 1.0);\n return half4(_c.rgb * _c.a, _c.a);\n}\n","InvertedPageCurl":"// InvertedPageCurl — generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/InvertedPageCurl.glsl\n// Author: Hewlett-Packard\n// License: BSD 3 Clause\n// Description: The outgoing image curls away like a page, revealing the incoming one\n\nuniform shader _from;\nuniform shader _to;\nuniform float2 _resolution;\nuniform float progress;\nuniform float ratio;\n\nvec4 getFromColor(vec2 uv) { return vec4(unpremul(_from.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\nvec4 getToColor(vec2 uv) { return vec4(unpremul(_to.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\n\nconst float MIN_AMOUNT = -0.16;\nconst float MAX_AMOUNT = 1.5;\n\nconst float PI = 3.141592653589793;\n\nconst float scale = 512.0;\nconst float sharpness = 3.0;\n\nconst float cylinderRadius = 1.0 / PI / 2.0;\n\nfloat amount;\nfloat cylinderCenter;\nfloat cylinderAngle;\n\nvec3 hitPoint(float hitAngle, float yc, vec3 point, mat3 rrotation)\n{\n float hitPoint = hitAngle / (2.0 * PI);\n point.y = hitPoint;\n return rrotation * point;\n}\n\nvec4 antiAlias(vec4 color1, vec4 color2, float distanc)\n{\n distanc *= scale;\n if (distanc < 0.0) return color2;\n if (distanc > 2.0) return color1;\n float dd = pow(1.0 - distanc / 2.0, sharpness);\n return ((color2 - color1) * dd) + color1;\n}\n\nfloat distanceToEdge(vec3 point)\n{\n float dx = abs(point.x > 0.5 ? 1.0 - point.x : point.x);\n float dy = abs(point.y > 0.5 ? 1.0 - point.y : point.y);\n if (point.x < 0.0) dx = -point.x;\n if (point.x > 1.0) dx = point.x - 1.0;\n if (point.y < 0.0) dy = -point.y;\n if (point.y > 1.0) dy = point.y - 1.0;\n if ((point.x < 0.0 || point.x > 1.0) && (point.y < 0.0 || point.y > 1.0)) return sqrt(dx * dx + dy * dy);\n return min(dx, dy);\n}\n\nvec4 seeThrough(float yc, vec2 p, mat3 rotation, mat3 rrotation)\n{\n float hitAngle = PI - (acos(clamp(yc / cylinderRadius, -1.0, 1.0)) - cylinderAngle);\n vec3 point = hitPoint(hitAngle, yc, rotation * vec3(p, 1.0), rrotation);\n if (yc <= 0.0 && (point.x < 0.0 || point.y < 0.0 || point.x > 1.0 || point.y > 1.0))\n {\n return getToColor(p);\n }\n\n if (yc > 0.0) return getFromColor(p);\n\n vec4 color = getFromColor(point.xy);\n vec4 tcolor = vec4(0.0);\n\n return antiAlias(color, tcolor, distanceToEdge(point));\n}\n\nvec4 seeThroughWithShadow(float yc, vec2 p, vec3 point, mat3 rotation, mat3 rrotation)\n{\n float shadow = distanceToEdge(point) * 30.0;\n shadow = (1.0 - shadow) / 3.0;\n\n if (shadow < 0.0) shadow = 0.0; else shadow *= amount;\n\n vec4 shadowColor = seeThrough(yc, p, rotation, rrotation);\n shadowColor.r -= shadow;\n shadowColor.g -= shadow;\n shadowColor.b -= shadow;\n\n return shadowColor;\n}\n\nvec4 backside(float yc, vec3 point)\n{\n vec4 color = getFromColor(point.xy);\n float gray = (color.r + color.b + color.g) / 15.0;\n gray += (8.0 / 10.0) * (pow(max(0.0, 1.0 - abs(yc / cylinderRadius)), 2.0 / 10.0) / 2.0 + (5.0 / 10.0));\n color.rgb = vec3(gray);\n return color;\n}\n\nvec4 behindSurface(vec2 p, float yc, vec3 point, mat3 rrotation)\n{\n float safeAmount = amount >= 0.0 ? max(amount, 1e-4) : min(amount, -1e-4);\n float shado = (1.0 - ((-cylinderRadius - yc) / safeAmount * 7.0)) / 6.0;\n shado *= 1.0 - abs(point.x - 0.5);\n\n yc = (-cylinderRadius - cylinderRadius - yc);\n\n float hitAngle = (acos(clamp(yc / cylinderRadius, -1.0, 1.0)) + cylinderAngle) - PI;\n point = hitPoint(hitAngle, yc, point, rrotation);\n\n 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))\n {\n float dx = point.x - 0.5;\n float dy = point.y - 0.5;\n shado = 1.0 - (sqrt(dx * dx + dy * dy) / (71.0 / 100.0));\n float nyc = -yc / cylinderRadius;\n shado *= nyc * nyc * nyc;\n shado *= 0.5;\n }\n else\n {\n shado = 0.0;\n }\n return vec4(getToColor(p).rgb - shado, 1.0);\n}\n\nvec4 transition(vec2 p) {\n amount = progress * (MAX_AMOUNT - MIN_AMOUNT) + MIN_AMOUNT;\n cylinderCenter = amount;\n cylinderAngle = 2.0 * PI * amount;\n\n const float angle = 100.0 * PI / 180.0;\n float c = cos(-angle);\n float s = sin(-angle);\n\n mat3 rotation = mat3( c, s, 0,\n -s, c, 0,\n -0.801, 0.8900, 1\n );\n c = cos(angle);\n s = sin(angle);\n\n mat3 rrotation = mat3(\tc, s, 0,\n -s, c, 0,\n 0.98500, 0.985, 1\n );\n\n vec3 point = rotation * vec3(p, 1.0);\n\n float yc = point.y - cylinderCenter;\n\n if (yc < -cylinderRadius)\n {\n \n return behindSurface(p,yc, point, rrotation);\n }\n\n if (yc > cylinderRadius)\n {\n \n return getFromColor(p);\n }\n\n float hitAngle = (acos(clamp(yc / cylinderRadius, -1.0, 1.0)) + cylinderAngle) - PI;\n\n float hitAngleMod = mod(hitAngle, 2.0 * PI);\n if ((hitAngleMod > PI && amount < 0.5) || (hitAngleMod > PI/2.0 && amount < 0.0))\n {\n return seeThrough(yc, p, rotation, rrotation);\n }\n\n point = hitPoint(hitAngle, yc, point, rrotation);\n\n if (point.x < 0.0 || point.y < 0.0 || point.x > 1.0 || point.y > 1.0)\n {\n return seeThroughWithShadow(yc, p, point, rotation, rrotation);\n }\n\n vec4 color = backside(yc, point);\n\n vec4 otherColor;\n if (yc < 0.0)\n {\n float dx2 = point.x - 0.5;\n float dy2 = point.y - 0.5;\n float shado = 1.0 - (sqrt(dx2 * dx2 + dy2 * dy2) / 0.71);\n float nyc2 = -yc / cylinderRadius;\n shado *= nyc2 * nyc2 * nyc2;\n shado *= 0.5;\n otherColor = vec4(0.0, 0.0, 0.0, shado);\n }\n else\n {\n otherColor = getFromColor(p);\n }\n\n color = antiAlias(color, otherColor, cylinderRadius - abs(yc));\n\n vec4 cl = seeThroughWithShadow(yc, p, point, rotation, rrotation);\n float dist = distanceToEdge(point);\n\n return antiAlias(color, cl, dist);\n}\n\nhalf4 main(float2 _coord) {\n vec2 _uv = _coord / _resolution;\n vec4 _c = clamp(transition(vec2(_uv.x, 1.0 - _uv.y)), 0.0, 1.0);\n return half4(_c.rgb * _c.a, _c.a);\n}\n","LeftRight":"// LeftRight — generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/LeftRight.glsl\n// Author: zhmy\n// License: MIT\n// Description: The outgoing image shrinks away to the left while the incoming one slides in from the right\n\nuniform shader _from;\nuniform shader _to;\nuniform float2 _resolution;\nuniform float progress;\nuniform float ratio;\n\nvec4 getFromColor(vec2 uv) { return vec4(unpremul(_from.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\nvec4 getToColor(vec2 uv) { return vec4(unpremul(_to.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\n\nconst vec4 black = vec4(0.0, 0.0, 0.0, 1.0);\nconst vec2 boundMin = vec2(0.0, 0.0);\nconst vec2 boundMax = vec2(1.0, 1.0);\n\nbool inBounds (vec2 p) {\n return all(lessThan(boundMin, p)) && all(lessThan(p, boundMax));\n}\n\nvec4 transition (vec2 uv) {\n vec2 spfr,spto = vec2(-1.);\n\n float size = mix(1.0, 3.0, progress*0.2);\n spto = (uv + vec2(-0.5,-0.5))*vec2(size,size)+vec2(0.5,0.5);\n spfr = (uv - vec2(1.-progress, 0.0));\n if(inBounds(spfr)){\n return getToColor(spfr);\n }else if(inBounds(spto)){\n return getFromColor(spto) * (1.0 - progress);\n } else{\n return black;\n }\n}\n\nhalf4 main(float2 _coord) {\n vec2 _uv = _coord / _resolution;\n vec4 _c = clamp(transition(vec2(_uv.x, 1.0 - _uv.y)), 0.0, 1.0);\n return half4(_c.rgb * _c.a, _c.a);\n}\n","LinearBlur":"// LinearBlur — generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/LinearBlur.glsl\n// Author: gre\n// License: MIT\n// Description: A crossfade through a blur\n\nuniform shader _from;\nuniform shader _to;\nuniform float2 _resolution;\nuniform float progress;\nuniform float ratio;\n\nvec4 getFromColor(vec2 uv) { return vec4(unpremul(_from.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\nvec4 getToColor(vec2 uv) { return vec4(unpremul(_to.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\n\nuniform float intensity; \nconst int passes = 6;\n\nvec4 transition(vec2 uv) {\n vec4 c1 = vec4(0.0);\n vec4 c2 = vec4(0.0);\n\n float disp = intensity*(0.5-distance(0.5, progress));\n for (int xi=0; xi<passes; xi++)\n {\n float x = float(xi) / float(passes) - 0.5;\n for (int yi=0; yi<passes; yi++)\n {\n float y = float(yi) / float(passes) - 0.5;\n vec2 v = vec2(x,y);\n float d = disp;\n c1 += getFromColor( uv + d*v);\n c2 += getToColor( uv + d*v);\n }\n }\n c1 /= float(passes*passes);\n c2 /= float(passes*passes);\n return mix(c1, c2, progress);\n}\n\nhalf4 main(float2 _coord) {\n vec2 _uv = _coord / _resolution;\n vec4 _c = clamp(transition(vec2(_uv.x, 1.0 - _uv.y)), 0.0, 1.0);\n return half4(_c.rgb * _c.a, _c.a);\n}\n","Mosaic":"// Mosaic — generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/Mosaic.glsl\n// Author: Xaychru\n// License: MIT\n// Description: The view pans across a mosaic of rotated tiles from both images and settles on the incoming one\n\nuniform shader _from;\nuniform shader _to;\nuniform float2 _resolution;\nuniform float progress;\nuniform float ratio;\n\nvec4 getFromColor(vec2 uv) { return vec4(unpremul(_from.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\nvec4 getToColor(vec2 uv) { return vec4(unpremul(_to.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\n\nuniform int endx; \nuniform int endy; \n\nfloat Rand(vec2 v) {\n return fract(sin(dot(v.xy ,vec2(12.9898,78.233))) * 43758.5453);\n}\nvec2 Rotate(vec2 v, float a) {\n mat2 rm = mat2(cos(a), -sin(a),\n sin(a), cos(a));\n return rm*v;\n}\nfloat CosInterpolation(float x) {\n return -cos(x*3.14159265358979323)/2.+.5;\n}\nvec4 transition(vec2 uv) {\n vec2 p = uv.xy / vec2(1.0).xy - .5;\n vec2 rp = p;\n float rpr = (progress*2.-1.);\n float z = -(rpr*rpr*2.) + 3.;\n float az = abs(z);\n rp *= az;\n rp += mix(vec2(.5, .5), vec2(float(endx) + .5, float(endy) + .5), CosInterpolation(progress)*CosInterpolation(progress));\n vec2 mrp = mod(rp, 1.);\n vec2 crp = rp;\n bool onEnd = int(floor(crp.x))==endx&&int(floor(crp.y))==endy;\n if(!onEnd) {\n float ang = float(int(Rand(floor(crp))*4.))*.5*3.14159265358979323;\n mrp = vec2(.5) + Rotate(mrp-vec2(.5), ang);\n }\n if(onEnd || Rand(floor(crp))>.5) {\n return getToColor(mrp);\n } else {\n return getFromColor(mrp);\n }\n}\n\nhalf4 main(float2 _coord) {\n vec2 _uv = _coord / _resolution;\n vec4 _c = clamp(transition(vec2(_uv.x, 1.0 - _uv.y)), 0.0, 1.0);\n return half4(_c.rgb * _c.a, _c.a);\n}\n","Overexposure":"// Overexposure — generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/Overexposure.glsl\n// Author: Ben Zhang\n// License: MIT\n// Description: A crossfade through a washed-out, overexposed white\n\nuniform shader _from;\nuniform shader _to;\nuniform float2 _resolution;\nuniform float progress;\nuniform float ratio;\n\nvec4 getFromColor(vec2 uv) { return vec4(unpremul(_from.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\nvec4 getToColor(vec2 uv) { return vec4(unpremul(_to.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\n\nuniform float strength; \nconst float PI = 3.141592653589793;\n\nvec4 transition (vec2 uv) {\n vec4 from = getFromColor(uv);\n vec4 to = getToColor(uv);\n\n \n float from_m = 1.0 - progress + sin(PI * progress) * strength;\n float to_m = progress + sin(PI * progress) * strength;\n \n return vec4(\n from.r * from.a * from_m + to.r * to.a * to_m,\n from.g * from.a * from_m + to.g * to.a * to_m,\n from.b * from.a * from_m + to.b * to.a * to_m,\n mix(from.a, to.a, progress)\n );\n}\n\nhalf4 main(float2 _coord) {\n vec2 _uv = _coord / _resolution;\n vec4 _c = clamp(transition(vec2(_uv.x, 1.0 - _uv.y)), 0.0, 1.0);\n return half4(_c.rgb * _c.a, _c.a);\n}\n","PolkaDotsCurtain":"// PolkaDotsCurtain — generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/PolkaDotsCurtain.glsl\n// Author: bobylito\n// License: MIT\n// Description: The incoming image appears through growing polka dots\n\nuniform shader _from;\nuniform shader _to;\nuniform float2 _resolution;\nuniform float progress;\nuniform float ratio;\n\nvec4 getFromColor(vec2 uv) { return vec4(unpremul(_from.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\nvec4 getToColor(vec2 uv) { return vec4(unpremul(_to.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\n\nconst float SQRT_2 = 1.414213562373;\n\nuniform float dots; \nuniform vec2 center; \n\nvec4 transition(vec2 uv) {\n bool nextImage = distance(fract(uv * dots), vec2(0.5, 0.5)) < ( progress / distance(uv, center));\n return nextImage ? getToColor(uv) : getFromColor(uv);\n}\n\nhalf4 main(float2 _coord) {\n vec2 _uv = _coord / _resolution;\n vec4 _c = clamp(transition(vec2(_uv.x, 1.0 - _uv.y)), 0.0, 1.0);\n return half4(_c.rgb * _c.a, _c.a);\n}\n","PuzzleRight":"// PuzzleRight — generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/PuzzleRight.glsl\n// Author: JustKirillS\n// License: MIT\n// Description: The image splits into a grid of tiles that flip one by one to the incoming image\n\nuniform shader _from;\nuniform shader _to;\nuniform float2 _resolution;\nuniform float progress;\nuniform float ratio;\n\nvec4 getFromColor(vec2 uv) { return vec4(unpremul(_from.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\nvec4 getToColor(vec2 uv) { return vec4(unpremul(_to.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\n\nuniform ivec2 size; \nuniform float pause; \nuniform float dividerWidth; \n\nfloat rand(vec2 co) {\n return fract(sin(dot(co, vec2(12.9898, 78.233))) * 43758.5453);\n}\n\nfloat getDelta(vec2 p) {\n vec2 rectangleSize = 1.0 / vec2(size);\n vec2 rectanglePos = floor(vec2(size) * p);\n float top = rectangleSize.y * (rectanglePos.y + 1.0);\n float bottom = rectangleSize.y * rectanglePos.y;\n float left = rectangleSize.x * rectanglePos.x;\n float right = rectangleSize.x * (rectanglePos.x + 1.0);\n float minX = min(abs(p.x - left), abs(p.x - right));\n float minY = min(abs(p.y - top), abs(p.y - bottom));\n return min(minX, minY);\n}\n\nvec4 transition(vec2 uv) {\n if (progress < pause) {\n float currentProg = progress / pause;\n float a = 1.0;\n if (getDelta(uv) < dividerWidth) { a = 1.0 - currentProg; }\n return mix(vec4(0.0, 0.0, 0.0, 1.0), getFromColor(uv), a);\n } else if (progress < 1.0 - pause) {\n if (getDelta(uv) < dividerWidth) {\n return vec4(0.0, 0.0, 0.0, 1.0);\n }\n float currentProg = (progress - pause) / (1.0 - pause * 2.0);\n vec2 rectanglePos = floor(vec2(size) * uv);\n float r = rand(rectanglePos) - 0.1;\n float cp = smoothstep(0.0, 1.0 - r, currentProg);\n float rectangleSize = 1.0 / float(size.x);\n float delta = rectanglePos.x * rectangleSize;\n float offset = rectangleSize / 2.0 + delta;\n vec2 p = uv;\n p.x = (p.x - offset) / abs(cp - 0.5) * 0.5 + offset;\n vec4 a = getFromColor(p);\n vec4 b = getToColor(p);\n float s = step(abs(float(size.x) * (uv.x - delta) - 0.5), abs(cp - 0.5));\n return vec4(mix(b, a, step(cp, 0.5)).rgb * s, 1.0);\n } else {\n float currentProg = (progress - 1.0 + pause) / pause;\n float a = 1.0;\n if (getDelta(uv) < dividerWidth) { a = currentProg; }\n return mix(vec4(0.0, 0.0, 0.0, 1.0), getToColor(uv), a);\n }\n}\n\nhalf4 main(float2 _coord) {\n vec2 _uv = _coord / _resolution;\n vec4 _c = clamp(transition(vec2(_uv.x, 1.0 - _uv.y)), 0.0, 1.0);\n return half4(_c.rgb * _c.a, _c.a);\n}\n","Radial":"// Radial — generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/Radial.glsl\n// Author: Xaychru\n// License: MIT\n// Description: A radial wipe that sweeps around the center like a clock hand\n\nuniform shader _from;\nuniform shader _to;\nuniform float2 _resolution;\nuniform float progress;\nuniform float ratio;\n\nvec4 getFromColor(vec2 uv) { return vec4(unpremul(_from.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\nvec4 getToColor(vec2 uv) { return vec4(unpremul(_to.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\n\nuniform float smoothness; \n\nconst float PI = 3.141592653589;\n\nvec4 transition(vec2 p) {\n vec2 rp = p*2.-1.;\n return mix(\n getToColor(p),\n getFromColor(p),\n smoothstep(0., smoothness, atan(rp.y,rp.x) - (progress-.5) * PI * 2.5)\n );\n}\n\nhalf4 main(float2 _coord) {\n vec2 _uv = _coord / _resolution;\n vec4 _c = clamp(transition(vec2(_uv.x, 1.0 - _uv.y)), 0.0, 1.0);\n return half4(_c.rgb * _c.a, _c.a);\n}\n","Rectangle":"// Rectangle — generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/Rectangle.glsl\n// Author: martiniti\n// License: MIT\n// Description: A rectangle grows from the center to cover the outgoing image, then shrinks to reveal the incoming one\n\nuniform shader _from;\nuniform shader _to;\nuniform float2 _resolution;\nuniform float progress;\nuniform float ratio;\n\nvec4 getFromColor(vec2 uv) { return vec4(unpremul(_from.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\nvec4 getToColor(vec2 uv) { return vec4(unpremul(_to.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\n\nuniform vec4 bgcolor; \n\nvec4 transition(vec2 p) {\n float s = pow(2.0 * abs(progress - 0.5), 3.0);\n \n vec2 sq = p.xy / vec2(1.0).xy;\n \n \n vec2 bl = step(vec2(abs(1. - 2.*progress)), sq + .25);\n float dist = bl.x * bl.y;\n\n \n vec2 tr = step(vec2(abs(1. - 2.*progress)), 1.25-sq);\n dist *= 1. * tr.x * tr.y;\n \n return mix(\n progress < 0.5 ? getFromColor(p) : getToColor(p),\n bgcolor,\n step(s, dist)\n );\n \n}\n\nhalf4 main(float2 _coord) {\n vec2 _uv = _coord / _resolution;\n vec4 _c = clamp(transition(vec2(_uv.x, 1.0 - _uv.y)), 0.0, 1.0);\n return half4(_c.rgb * _c.a, _c.a);\n}\n","RectangleCrop":"// RectangleCrop — generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/RectangleCrop.glsl\n// Author: martiniti\n// License: MIT\n// Description: The outgoing image shrinks into a small rectangle over a background color, then the incoming one grows from it\n\nuniform shader _from;\nuniform shader _to;\nuniform float2 _resolution;\nuniform float progress;\nuniform float ratio;\n\nvec4 getFromColor(vec2 uv) { return vec4(unpremul(_from.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\nvec4 getToColor(vec2 uv) { return vec4(unpremul(_to.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\n\nuniform vec4 bgcolor; \n\nvec4 transition(vec2 uv) {\n \n float s = pow(2.0 * abs(progress - 0.5), 3.0);\n \n vec2 q = uv.xy / vec2(1.0).xy;\n \n \n vec2 bl = step(vec2(1.0 - 2.0*abs(progress - 0.5)), q + 0.25);\n \n \n vec2 tr = step(vec2(1.0 - 2.0*abs(progress - 0.5)), 1.25 - q);\n \n float dist = length(1.0 - bl.x * bl.y * tr.x * tr.y);\n \n return mix(\n progress < 0.5 ? getFromColor(uv) : getToColor(uv),\n bgcolor,\n step(s, dist)\n );\n \n}\n\nhalf4 main(float2 _coord) {\n vec2 _uv = _coord / _resolution;\n vec4 _c = clamp(transition(vec2(_uv.x, 1.0 - _uv.y)), 0.0, 1.0);\n return half4(_c.rgb * _c.a, _c.a);\n}\n","Revolve_Left":"// Revolve_Left — generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/Revolve_Left.glsl\n// Author: bread\n// License: MIT\n// Description: The outgoing image swirls and zooms with motion blur into the incoming one\n\nuniform shader _from;\nuniform shader _to;\nuniform float2 _resolution;\nuniform float progress;\nuniform float ratio;\n\nvec4 getFromColor(vec2 uv) { return vec4(unpremul(_from.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\nvec4 getToColor(vec2 uv) { return vec4(unpremul(_to.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\n\nuniform vec2 center; \nuniform float direction; \nuniform float maxRotation; \nuniform float peakZoom; \nuniform float swirl; \nuniform float barrel; \nuniform float motionBlur; \nuniform float switchStart; \nuniform float switchEnd; \nuniform float shadow; \n\nfloat sat(float x) {\n return clamp(x, 0.0, 1.0);\n}\n\nfloat ease(float x) {\n x = sat(x);\n return x * x * (3.0 - 2.0 * x);\n}\n\nfloat revolveEnvelope(float t) {\n float rise = ease((t - 0.10) / 0.33);\n float fall = 1.0 - ease((t - 0.43) / 0.29);\n return rise * fall;\n}\n\nvec2 rotate2(vec2 p, float a) {\n float s = sin(a);\n float c = cos(a);\n return vec2(c * p.x - s * p.y, s * p.x + c * p.y);\n}\n\nvec2 warpUv(vec2 uv, float t) {\n float e = revolveEnvelope(t);\n\n vec2 p = uv - center;\n p.x *= ratio;\n\n float r = length(p);\n float edgeSpin = maxRotation * e;\n float coreSpin = swirl * e * pow(1.0 - sat(r / 0.96), 1.55);\n float visibleAngle = direction * (edgeSpin + coreSpin);\n\n p = rotate2(p, -visibleAngle);\n\n float sc = 1.0 + (peakZoom - 1.0) * pow(e, 0.85);\n p /= sc;\n\n float rr = length(p);\n p *= 1.0 + barrel * e * rr * rr * 2.8;\n\n p.x /= ratio;\n return clamp(p + center, vec2(0.001), vec2(0.999));\n}\n\nvec4 sampleRevolve(vec2 uv, float t) {\n vec2 p = warpUv(uv, t);\n float reveal = smoothstep(switchStart, switchEnd, t);\n return mix(getFromColor(p), getToColor(p), reveal);\n}\n\nvec4 transition(vec2 uv) {\n if (progress <= 0.0) return getFromColor(uv);\n if (progress >= 1.0) return getToColor(uv);\n\n float e = revolveEnvelope(progress);\n float span = 0.060 * motionBlur * e;\n\n vec4 color = vec4(0.0);\n float total = 0.0;\n\n for (int i = -8; i <= 8; i++) {\n float x = float(i) / 8.0;\n float w = 1.0 - abs(x);\n w = w * w + 0.01;\n\n float t = sat(progress + x * span);\n color += sampleRevolve(uv, t) * w;\n total += w;\n }\n\n color /= total;\n\n vec2 q = uv - vec2(0.5);\n q.x *= ratio;\n float vignette = 1.0 - shadow * e * smoothstep(0.35, 0.95, length(q));\n color.rgb *= vignette;\n\n return color;\n}\n\nhalf4 main(float2 _coord) {\n vec2 _uv = _coord / _resolution;\n vec4 _c = clamp(transition(vec2(_uv.x, 1.0 - _uv.y)), 0.0, 1.0);\n return half4(_c.rgb * _c.a, _c.a);\n}\n","Rolls":"// Rolls — generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/Rolls.glsl\n// Author: Mark Craig\n// License: MIT\n// Description: The outgoing image rolls away around a corner, revealing the incoming one\n\nuniform shader _from;\nuniform shader _to;\nuniform float2 _resolution;\nuniform float progress;\nuniform float ratio;\n\nvec4 getFromColor(vec2 uv) { return vec4(unpremul(_from.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\nvec4 getToColor(vec2 uv) { return vec4(unpremul(_to.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\n\nuniform int type; \n\nuniform int RotDown; \n\nvec4 transition(vec2 uv)\n{\nfloat theta, c1, s1;\nvec2 iResolution = vec2(ratio, 1.0);\nvec2 uvi;\n\nif (type == 0) { theta = ((RotDown != 0) ? 3.14159265358979323846 : -3.14159265358979323846) / 2.0 * progress; uvi.x = 1.0 - uv.x; uvi.y = uv.y; }\nelse if (type == 1) { theta = ((RotDown != 0) ? 3.14159265358979323846 : -3.14159265358979323846) / 2.0 * progress; uvi = uv; }\nelse if (type == 2) { theta = ((RotDown != 0) ? -3.14159265358979323846 : 3.14159265358979323846) / 2.0 * progress; uvi.x = uv.x; uvi.y = 1.0 - uv.y; }\nelse if (type == 3) { theta = ((RotDown != 0) ? -3.14159265358979323846 : 3.14159265358979323846) / 2.0 * progress; uvi = 1.0 - uv; }\nc1 = cos(theta); s1 = sin(theta);\nvec2 uv2;\nuv2.x = (uvi.x * iResolution.x * c1 - uvi.y * iResolution.y * s1);\nuv2.y = (uvi.x * iResolution.x * s1 + uvi.y * iResolution.y * c1);\nif ((uv2.x >= 0.0) && (uv2.x <= iResolution.x) && (uv2.y >= 0.0) && (uv2.y <= iResolution.y))\n\t{\n\tuv2 /= iResolution;\n\tif (type == 0) { uv2.x = 1.0 - uv2.x; }\n\telse if (type == 2) { uv2.y = 1.0 - uv2.y; }\n\telse if (type == 3) { uv2 = 1.0 - uv2; }\n\treturn(getFromColor(uv2));\n\t}\nreturn(getToColor(uv));\n}\n\nhalf4 main(float2 _coord) {\n vec2 _uv = _coord / _resolution;\n vec4 _c = clamp(transition(vec2(_uv.x, 1.0 - _uv.y)), 0.0, 1.0);\n return half4(_c.rgb * _c.a, _c.a);\n}\n","RotateScaleVanish":"// RotateScaleVanish — generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/RotateScaleVanish.glsl\n// Author: Mark Craig\n// License: MIT\n// Description: The outgoing image spins and shrinks away over the incoming one\n\nuniform shader _from;\nuniform shader _to;\nuniform float2 _resolution;\nuniform float progress;\nuniform float ratio;\n\nvec4 getFromColor(vec2 uv) { return vec4(unpremul(_from.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\nvec4 getToColor(vec2 uv) { return vec4(unpremul(_to.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\n\nuniform int FadeInSecond; \n\nuniform int ReverseEffect; \n\nuniform int ReverseRotation; \n\nvec4 transition(vec2 uv)\n{\nvec2 iResolution = vec2(ratio, 1.0);\nfloat t = (ReverseEffect != 0) ? 1.0 - progress : progress;\nfloat theta = (ReverseRotation != 0) ? 6.283185307179586476925286766559 * t : -6.283185307179586476925286766559 * t;\nfloat c1 = cos(theta);\nfloat s1 = sin(theta);\nfloat rad = max(0.00001, 1.0 - t);\nfloat xc1 = (uv.x - 0.5) * iResolution.x;\nfloat yc1 = (uv.y - 0.5) * iResolution.y;\nfloat xc2 = (xc1 * c1 - yc1 * s1) / rad;\nfloat yc2 = (xc1 * s1 + yc1 * c1) / rad;\nvec2 uv2 = vec2(xc2 + iResolution.x / 2.0, yc2 + iResolution.y / 2.0);\nvec4 col3;\nvec4 ColorTo = (ReverseEffect != 0) ? getFromColor(uv) : getToColor(uv);\nif ((uv2.x >= 0.0) && (uv2.x <= iResolution.x) && (uv2.y >= 0.0) && (uv2.y <= iResolution.y))\n\t{\n\tuv2 /= iResolution;\n\tcol3 = (ReverseEffect != 0) ? getToColor(uv2) : getFromColor(uv2);\n\t}\nelse { col3 = (FadeInSecond != 0) ? vec4(0.0, 0.0, 0.0, 1.0) : ColorTo; }\nreturn((1.0 - t) * col3 + t * ColorTo); \n}\n\nhalf4 main(float2 _coord) {\n vec2 _uv = _coord / _resolution;\n vec4 _c = clamp(transition(vec2(_uv.x, 1.0 - _uv.y)), 0.0, 1.0);\n return half4(_c.rgb * _c.a, _c.a);\n}\n","SimpleFlip":"// SimpleFlip — generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/SimpleFlip.glsl\n// Author: nwoeanhinnogaehr\n// License: MIT\n// Description: The outgoing image flips around the vertical axis into the incoming one\n\nuniform shader _from;\nuniform shader _to;\nuniform float2 _resolution;\nuniform float progress;\nuniform float ratio;\n\nvec4 getFromColor(vec2 uv) { return vec4(unpremul(_from.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\nvec4 getToColor(vec2 uv) { return vec4(unpremul(_to.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\n\nvec4 transition(vec2 uv) {\n vec2 q = uv;\n uv.x = (uv.x - 0.5) / abs(progress - 0.5) * 0.5 + 0.5;\n vec4 a = getFromColor(uv);\n vec4 b = getToColor(uv);\n return vec4(mix(a, b, step(0.5, progress)).rgb * step(abs(q.x - 0.5), abs(progress - 0.5)), 1.0);\n}\n\nhalf4 main(float2 _coord) {\n vec2 _uv = _coord / _resolution;\n vec4 _c = clamp(transition(vec2(_uv.x, 1.0 - _uv.y)), 0.0, 1.0);\n return half4(_c.rgb * _c.a, _c.a);\n}\n","SimpleZoom":"// SimpleZoom — generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/SimpleZoom.glsl\n// Author: 0gust1\n// License: MIT\n// Description: Zooms into the outgoing image, then fades to the incoming one\n\nuniform shader _from;\nuniform shader _to;\nuniform float2 _resolution;\nuniform float progress;\nuniform float ratio;\n\nvec4 getFromColor(vec2 uv) { return vec4(unpremul(_from.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\nvec4 getToColor(vec2 uv) { return vec4(unpremul(_to.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\n\nuniform float zoom_quickness; \nvec2 zoom(vec2 uv, float amount) {\n return 0.5 + ((uv - 0.5) * (1.0-amount));\t\n}\n\nvec4 transition (vec2 uv) {\n float nQuick = clamp(zoom_quickness,0.2,1.0);\n return mix(\n getFromColor(zoom(uv, smoothstep(0.0, nQuick, progress))),\n getToColor(uv),\n smoothstep(nQuick-0.2, 1.0, progress)\n );\n}\n\nhalf4 main(float2 _coord) {\n vec2 _uv = _coord / _resolution;\n vec4 _c = clamp(transition(vec2(_uv.x, 1.0 - _uv.y)), 0.0, 1.0);\n return half4(_c.rgb * _c.a, _c.a);\n}\n","SimpleZoomOut":"// SimpleZoomOut — generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/SimpleZoomOut.glsl\n// Author: Tianshuo\n// License: MIT\n// Description: The incoming image zooms out into place while fading in\n\nuniform shader _from;\nuniform shader _to;\nuniform float2 _resolution;\nuniform float progress;\nuniform float ratio;\n\nvec4 getFromColor(vec2 uv) { return vec4(unpremul(_from.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\nvec4 getToColor(vec2 uv) { return vec4(unpremul(_to.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\n\nuniform float zoom_quickness; \n\nuniform int fade; \nvec2 zoom(vec2 uv, float amount) {\n return 0.5 + ((uv - 0.5) * (1.0-amount));\t\n}\n\nvec4 transition (vec2 uv) {\n float nQuick = clamp(zoom_quickness,0.2,1.0);\n return mix(\n getFromColor(uv),\n getToColor(zoom(uv,1.-smoothstep(1.-nQuick, 1., progress))),\n (fade != 0)?smoothstep(1.0-nQuick, 1., progress):(progress<1.0-nQuick?0.0:1.0)\n );\n}\n\nhalf4 main(float2 _coord) {\n vec2 _uv = _coord / _resolution;\n vec4 _c = clamp(transition(vec2(_uv.x, 1.0 - _uv.y)), 0.0, 1.0);\n return half4(_c.rgb * _c.a, _c.a);\n}\n","Slides":"// Slides — generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/Slides.glsl\n// Author: Mark Craig\n// License: MIT\n// Description: The outgoing image slides out, or the incoming one slides in, toward an edge, a corner or the center\n\nuniform shader _from;\nuniform shader _to;\nuniform float2 _resolution;\nuniform float progress;\nuniform float ratio;\n\nvec4 getFromColor(vec2 uv) { return vec4(unpremul(_from.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\nvec4 getToColor(vec2 uv) { return vec4(unpremul(_to.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\n\nuniform int type; \n\nuniform int In; \n\nvec4 transition(vec2 uv)\n{\nvec2 uv0 = uv;\nfloat rad = (In != 0) ? progress : 1.0 - progress;\nfloat xc1, yc1;\n\nif (type == 0) { xc1 = .5 - rad / 2.0; yc1 = 0.0; }\nelse if (type == 1) { xc1 = 1.0 - rad; yc1 = .5 - rad / 2.0; }\nelse if (type == 2) { xc1 = .5 - rad / 2.0; yc1 = 1.0 - rad; }\nelse if (type == 3) { xc1 = 0.0; yc1 = .5 - rad / 2.0; }\nelse if (type == 4) { xc1 = 1.0 - rad; yc1 = 0.0; }\nelse if (type == 5) { xc1 = 1.0 - rad; yc1 = 1.0 - rad; }\nelse if (type == 6) { xc1 = 0.0; yc1 = 1.0 - rad; }\nelse if (type == 7) { xc1 = 0.0; yc1 = 0.0; }\nelse if (type == 8) { xc1 = .5 - rad / 2.0; yc1 = .5 - rad / 2.0; }\nuv.y = 1.0 - uv.y;\nvec2 uv2;\nif ((uv.x >= xc1) && (uv.x <= xc1 + rad) && (uv.y >= yc1) && (uv.y <= yc1 + rad))\n\t{\n\tuv2 = vec2((uv.x - xc1) / rad, 1.0 - (uv.y - yc1) / rad);\n\treturn((In != 0) ? getToColor(uv2) : getFromColor(uv2));\n\t}\nreturn((In != 0) ? getFromColor(uv0) : getToColor(uv0));\n}\n\nhalf4 main(float2 _coord) {\n vec2 _uv = _coord / _resolution;\n vec4 _c = clamp(transition(vec2(_uv.x, 1.0 - _uv.y)), 0.0, 1.0);\n return half4(_c.rgb * _c.a, _c.a);\n}\n","StarWipe":"// StarWipe — generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/StarWipe.glsl\n// Author: Ben Lucas\n// License: MIT\n// Description: A growing star reveals the incoming image\n\nuniform shader _from;\nuniform shader _to;\nuniform float2 _resolution;\nuniform float progress;\nuniform float ratio;\n\nvec4 getFromColor(vec2 uv) { return vec4(unpremul(_from.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\nvec4 getToColor(vec2 uv) { return vec4(unpremul(_to.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\n\nuniform float border_thickness;\nuniform float star_rotation;\n\nuniform vec4 border_color; \n\nuniform vec2 star_center;\n\nvec2 rotate(vec2 v, float theta) {\n float cosTheta = cos(theta);\n float sinTheta = sin(theta);\n\n return vec2(\n cosTheta * v.x - sinTheta * v.y,\n sinTheta * v.x + cosTheta * v.y\n );\n}\n\nbool inStar(vec2 uv, vec2 center, float radius){\n vec2 uv_centered = uv - center;\n uv_centered = rotate(uv_centered, star_rotation * 1.2566370614359172);\n float theta = atan(uv_centered.y, uv_centered.x) + 3.141592653589793;\n\n vec2 uv_rotated = rotate(uv_centered, -1.2566370614359172 * (floor(theta / 1.2566370614359172) + 0.5));\n\n float slope = 0.3;\n if(uv_rotated.y > 0.0){\n return (radius + uv_rotated.x * slope > uv_rotated.y);\n } else {\n return (-radius - uv_rotated.x * slope < uv_rotated.y);\n }\n}\n\nvec4 transition (vec2 uv) {\n float progressScaled = (2.0 * border_thickness + 1.0) * progress - border_thickness;\n if(inStar(uv, star_center, progressScaled)){\n return getToColor(uv);\n } else if(inStar(uv, star_center, progressScaled+border_thickness)){\n return border_color;\n } else {\n return getFromColor(uv);\n }\n}\n\nhalf4 main(float2 _coord) {\n vec2 _uv = _coord / _resolution;\n vec4 _c = clamp(transition(vec2(_uv.x, 1.0 - _uv.y)), 0.0, 1.0);\n return half4(_c.rgb * _c.a, _c.a);\n}\n","StaticFade":"// StaticFade — generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/StaticFade.glsl\n// Author: Ben Lucas\n// License: MIT\n// Description: Cuts to the incoming image halfway, hidden behind a burst of TV static\n\nuniform shader _from;\nuniform shader _to;\nuniform float2 _resolution;\nuniform float progress;\nuniform float ratio;\n\nvec4 getFromColor(vec2 uv) { return vec4(unpremul(_from.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\nvec4 getToColor(vec2 uv) { return vec4(unpremul(_to.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\n\nuniform float n_noise_pixels ; \nuniform float static_luminosity ; \n\nfloat rnd (vec2 st) {\n return fract(sin(dot(st.xy,\n vec2(10.5302340293,70.23492931)))*\n 12345.5453123);\n}\n\nvec4 staticNoise (vec2 st, float offset, float luminosity) {\n float staticR = luminosity * rnd(st * vec2(offset * 2.0, offset * 3.0));\n float staticG = luminosity * rnd(st * vec2(offset * 3.0, offset * 5.0));\n float staticB = luminosity * rnd(st * vec2(offset * 5.0, offset * 7.0));\n return vec4(staticR, staticG, staticB, 1.0);\n}\n\nfloat staticIntensity(float t)\n{\n float transitionProgress = abs(2.0*(t-0.5));\n float transformedThreshold =1.2*(1.0 - transitionProgress)-0.1;\n return min(1.0, transformedThreshold);\n}\n \nvec4 transition (vec2 uv) {\n\n float baseMix = step(0.5, progress);\n vec4 transitionMix = mix(\n getFromColor(uv),\n getToColor(uv),\n baseMix\n );\n \n vec2 uvStatic = floor(uv * n_noise_pixels)/n_noise_pixels;\n \n vec4 staticColor = staticNoise(uvStatic, progress, static_luminosity);\n\n float staticThresh = staticIntensity(progress);\n float staticMix = step(rnd(uvStatic), staticThresh);\n\n return mix(transitionMix, staticColor, staticMix);\n}\n\nhalf4 main(float2 _coord) {\n vec2 _uv = _coord / _resolution;\n vec4 _c = clamp(transition(vec2(_uv.x, 1.0 - _uv.y)), 0.0, 1.0);\n return half4(_c.rgb * _c.a, _c.a);\n}\n","StereoViewer":"// StereoViewer — generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/StereoViewer.glsl\n// Author: Ted Schundler\n// License: BSD 2 Clause\n// Description: Both images shrink into rounded cards that swap, like a stereo viewer toy\n\nuniform shader _from;\nuniform shader _to;\nuniform float2 _resolution;\nuniform float progress;\nuniform float ratio;\n\nvec4 getFromColor(vec2 uv) { return vec4(unpremul(_from.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\nvec4 getToColor(vec2 uv) { return vec4(unpremul(_to.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\n\nuniform float zoom; \n\nuniform float corner_radius; \n\nconst vec4 black = vec4(0.0, 0.0, 0.0, 1.0);\nconst vec2 c00 = vec2(0.0, 0.0); \nconst vec2 c01 = vec2(0.0, 1.0);\nconst vec2 c11 = vec2(1.0, 1.0);\nconst vec2 c10 = vec2(1.0, 0.0);\n\nbool in_corner(vec2 p, vec2 corner, vec2 radius) {\n \n vec2 axis = (c11 - corner) - corner;\n\n \n \n p = p - (corner + axis * radius);\n p *= axis / radius;\n return (p.x > 0.0 && p.y > -1.0) || (p.y > 0.0 && p.x > -1.0) || dot(p, p) < 1.0;\n}\n\nbool test_rounded_mask(vec2 p, vec2 corner_size) {\n return\n in_corner(p, c00, corner_size) &&\n in_corner(p, c01, corner_size) &&\n in_corner(p, c10, corner_size) &&\n in_corner(p, c11, corner_size);\n}\n\nvec4 screen(vec4 a, vec4 b) {\n return 1.0 - (1.0 - a) * (1.0 -b);\n}\n\nvec4 unscreen(vec4 c) {\n return 1.0 - sqrt(1.0 - c);\n}\n\nvec4 sample_with_corners_from(vec2 p, vec2 corner_size) {\n p = (p - 0.5) / zoom + 0.5;\n if (!test_rounded_mask(p, corner_size)) {\n return black;\n }\n return unscreen(getFromColor(p));\n}\n\nvec4 sample_with_corners_to(vec2 p, vec2 corner_size) {\n p = (p - 0.5) / zoom + 0.5;\n if (!test_rounded_mask(p, corner_size)) {\n return black;\n }\n return unscreen(getToColor(p));\n}\n\nvec4 simple_sample_with_corners_from(vec2 p, vec2 corner_size, float zoom_amt) {\n p = (p - 0.5) / (1.0 - zoom_amt + zoom * zoom_amt) + 0.5;\n if (!test_rounded_mask(p, corner_size)) {\n return black;\n }\n return getFromColor(p);\n}\n\nvec4 simple_sample_with_corners_to(vec2 p, vec2 corner_size, float zoom_amt) {\n p = (p - 0.5) / (1.0 - zoom_amt + zoom * zoom_amt) + 0.5;\n if (!test_rounded_mask(p, corner_size)) {\n return black;\n }\n return getToColor(p);\n}\n\nmat3 rotate2d(float angle, float ratio) {\n float s = sin(angle);\n float c = cos(angle);\n return mat3(\n c, s ,0.0,\n -s, c, 0.0,\n 0.0, 0.0, 1.0);\n}\n\nmat3 translate2d(float x, float y) {\n return mat3(\n 1.0, 0.0, 0,\n 0.0, 1.0, 0,\n -x, -y, 1.0);\n}\n\nmat3 scale2d(float x, float y) {\n return mat3(\n x, 0.0, 0,\n 0.0, y, 0,\n 0, 0, 1.0);\n}\n\nvec4 get_cross_rotated(vec3 p3, float angle, vec2 corner_size, float ratio) {\n angle = angle * angle; \n angle /= 2.4; \n\n mat3 center_and_scale = translate2d(-0.5, -0.5) * scale2d(1.0, ratio);\n mat3 unscale_and_uncenter = scale2d(1.0, 1.0/ratio) * translate2d(0.5,0.5);\n mat3 slide_left = translate2d(-2.0,0.0);\n mat3 slide_right = translate2d(2.0,0.0);\n mat3 rotate = rotate2d(angle, ratio);\n\n mat3 op_a = center_and_scale * slide_right * rotate * slide_left * unscale_and_uncenter;\n mat3 op_b = center_and_scale * slide_left * rotate * slide_right * unscale_and_uncenter;\n\n vec4 a = sample_with_corners_from((op_a * p3).xy, corner_size);\n vec4 b = sample_with_corners_from((op_b * p3).xy, corner_size);\n\n return screen(a, b);\n}\n\nvec4 get_cross_masked(vec3 p3, float angle, vec2 corner_size, float ratio) {\n angle = 1.0 - angle;\n angle = angle * angle; \n angle /= 2.4;\n\n vec4 img;\n\n mat3 center_and_scale = translate2d(-0.5, -0.5) * scale2d(1.0, ratio);\n mat3 unscale_and_uncenter = scale2d(1.0 / zoom, 1.0 / (zoom * ratio)) * translate2d(0.5,0.5);\n mat3 slide_left = translate2d(-2.0,0.0);\n mat3 slide_right = translate2d(2.0,0.0);\n mat3 rotate = rotate2d(angle, ratio);\n\n mat3 op_a = center_and_scale * slide_right * rotate * slide_left * unscale_and_uncenter;\n mat3 op_b = center_and_scale * slide_left * rotate * slide_right * unscale_and_uncenter;\n\n bool mask_a = test_rounded_mask((op_a * p3).xy, corner_size);\n bool mask_b = test_rounded_mask((op_b * p3).xy, corner_size);\n\n if (mask_a || mask_b) {\n img = sample_with_corners_to(p3.xy, corner_size);\n return screen(mask_a ? img : black, mask_b ? img : black);\n } else {\n return black;\n }\n}\n\nvec4 transition(vec2 uv) {\n float a;\n vec2 p=uv.xy/vec2(1.0).xy;\n vec3 p3 = vec3(p.xy, 1.0); \n\n \n vec2 corner_size = vec2(corner_radius / ratio, corner_radius);\n\n if (progress <= 0.0) {\n \n return getFromColor(p);\n } else if (progress < 0.1) {\n \n a = progress / 0.1;\n return simple_sample_with_corners_from(p, corner_size * a, a);\n } else if (progress < 0.48) {\n \n a = (progress - 0.1)/0.38;\n return get_cross_rotated(p3, a, corner_size, ratio);\n } else if (progress < 0.9) {\n \n \n return get_cross_masked(p3, (progress - 0.52)/0.38, corner_size, ratio);\n } else if (progress < 1.0) {\n \n a = (1.0 - progress) / 0.1;\n return simple_sample_with_corners_to(p, corner_size * a, a);\n } else {\n \n return getToColor(p);\n }\n}\n\nhalf4 main(float2 _coord) {\n vec2 _uv = _coord / _resolution;\n vec4 _c = clamp(transition(vec2(_uv.x, 1.0 - _uv.y)), 0.0, 1.0);\n return half4(_c.rgb * _c.a, _c.a);\n}\n","StripDatamoshGlitch":"// StripDatamoshGlitch — generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/StripDatamoshGlitch.glsl\n// Author: bread\n// License: MIT\n// Description: A datamosh glitch: torn strips, chroma shifts and scan noise drag the outgoing image into the incoming one\n\nuniform shader _from;\nuniform shader _to;\nuniform float2 _resolution;\nuniform float progress;\nuniform float ratio;\n\nvec4 getFromColor(vec2 uv) { return vec4(unpremul(_from.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\nvec4 getToColor(vec2 uv) { return vec4(unpremul(_to.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\n\nuniform float strength; \nuniform float horizontalBars; \nuniform float verticalSlits; \nuniform float tear; \nuniform float chroma; \nuniform float residue; \nuniform float noiseAmount; \nuniform float scanAmount; \nuniform float flashAmount; \n\nconst float PI = 3.141592653589793;\n\nfloat hash(float n) {\n return fract(sin(n) * 43758.5453123);\n}\n\nfloat hash(vec2 p) {\n return fract(sin(dot(p, vec2(127.1, 311.7))) * 43758.5453123);\n}\n\nfloat sat(float v) {\n return clamp(v, 0.0, 1.0);\n}\n\nfloat burst() {\n return pow(max(0.0, sin(progress * PI)), 0.42) * strength;\n}\n\nvec2 safeUv(vec2 uv) {\n return clamp(uv, vec2(0.0), vec2(1.0));\n}\n\nfloat stripeY(vec2 uv, float density, float seed, float minWidth, float maxWidth) {\n float y = uv.y * density + seed * 0.137;\n float id = floor(y);\n float f = fract(y);\n float c = hash(vec2(id, seed));\n float w = mix(minWidth, maxWidth, hash(vec2(id + 9.17, seed + 2.31)));\n return 1.0 - smoothstep(w, w + 0.018, abs(f - c));\n}\n\nfloat stripeX(vec2 uv, float density, float seed, float minWidth, float maxWidth) {\n float x = uv.x * density + seed * 0.091;\n float id = floor(x);\n float f = fract(x);\n float c = hash(vec2(id, seed + 41.0));\n float w = mix(minWidth, maxWidth, hash(vec2(id + 4.7, seed + 8.9)));\n return 1.0 - smoothstep(w, w + 0.012, abs(f - c));\n}\n\nfloat brokenGate(vec2 uv, float row, float rnd, float frame) {\n float segs = mix(1.0, 9.0, hash(vec2(row, frame + 44.0)));\n float seg = floor(uv.x * segs);\n return step(0.16, hash(vec2(seg, row + frame * 3.0 + rnd)));\n}\n\nfloat horizontalMask(vec2 uv, float frame) {\n float r1 = floor((uv.y + hash(frame) * 0.031) * horizontalBars * 0.38);\n float r2 = floor((uv.y + hash(frame + 2.0) * 0.013) * horizontalBars);\n float r3 = floor((uv.y + hash(frame + 7.0) * 0.006) * horizontalBars * 3.4);\n\n float thick = stripeY(uv, horizontalBars * 0.38, frame + 1.0, 0.035, 0.22);\n float mid = stripeY(uv, horizontalBars, frame + 4.0, 0.014, 0.11);\n float hair = stripeY(uv, horizontalBars * 3.4, frame + 9.0, 0.004, 0.035);\n\n thick *= step(0.42, hash(vec2(r1, frame + 10.0)));\n mid *= step(0.48, hash(vec2(r2, frame + 20.0)));\n hair *= step(0.62, hash(vec2(r3, frame + 30.0)));\n\n thick *= brokenGate(uv, r1, hash(vec2(r1, frame)), frame);\n mid *= brokenGate(uv, r2, hash(vec2(r2, frame)), frame + 3.0);\n\n return sat(max(thick, max(mid, hair)));\n}\n\nfloat verticalMask(vec2 uv, float frame) {\n float col = floor((uv.x + hash(frame + 12.0) * 0.017) * verticalSlits);\n float slit = stripeX(uv, verticalSlits, frame + 13.0, 0.01, 0.075);\n slit *= step(0.66, hash(vec2(col, frame + 19.0)));\n return sat(slit);\n}\n\nvec4 chromaFrom(vec2 uv, vec2 s) {\n uv = safeUv(uv);\n return vec4(\n getFromColor(safeUv(uv + s)).r,\n getFromColor(uv).g,\n getFromColor(safeUv(uv - s)).b,\n 1.0\n );\n}\n\nvec4 chromaTo(vec2 uv, vec2 s) {\n uv = safeUv(uv);\n return vec4(\n getToColor(safeUv(uv - s)).r,\n getToColor(uv).g,\n getToColor(safeUv(uv + s)).b,\n 1.0\n );\n}\n\nvec2 distortUv(vec2 uv, float dir, float b, float h, float v, float frame) {\n float row = floor(uv.y * horizontalBars);\n float col = floor(uv.x * verticalSlits);\n\n float rowRnd = hash(vec2(row, frame));\n float colRnd = hash(vec2(col, frame + 27.0));\n\n float xTear = (rowRnd - 0.5) * 2.0 * tear * b * h;\n xTear += sin(uv.y * 120.0 + progress * 95.0) * 0.006 * b;\n\n float yDrag = (colRnd - 0.5) * 0.13 * b * v;\n float micro = (hash(vec2(row, col + frame)) - 0.5) * 0.018 * b * max(h, v);\n\n return uv + vec2(xTear * dir + micro, yDrag);\n}\n\nvec4 transition(vec2 uv) {\n if (progress <= 0.0) return getFromColor(uv);\n if (progress >= 1.0) return getToColor(uv);\n\n float b = burst();\n float frame = floor(progress * 30.0);\n\n float h = horizontalMask(uv, frame);\n float v = verticalMask(uv, frame);\n float glitch = sat(max(h, v * 0.75));\n\n float row = floor(uv.y * horizontalBars);\n float rowRnd = hash(vec2(row, frame + 5.0));\n\n float bandDelay = (rowRnd - 0.5) * 0.30 * h;\n float reveal = smoothstep(0.18, 0.84, progress + bandDelay);\n\n vec2 split = vec2(chroma * b * (1.0 + 1.7 * glitch), chroma * 0.22 * b * v);\n\n vec2 fromUv = distortUv(uv, 1.0, b, h, v, frame);\n vec2 toUv = distortUv(uv, -1.0, b, h, v, frame);\n\n vec4 color = mix(\n chromaFrom(fromUv, split),\n chromaTo(toUv, split),\n reveal\n );\n\n \n vec2 smearUv = uv;\n smearUv.x += (rowRnd - 0.5) * 0.46 * b * h;\n smearUv.y += (hash(vec2(row, frame + 31.0)) - 0.5) * 0.045 * b * h;\n\n float sliceReveal = smoothstep(0.28, 0.78, progress + (rowRnd - 0.5) * 0.22);\n vec4 sliceColor = mix(\n chromaFrom(smearUv, split * 1.65),\n chromaTo(smearUv - vec2((rowRnd - 0.5) * 0.18 * b, 0.0), split * 1.65),\n sliceReveal\n );\n\n color = mix(color, sliceColor, h * b * residue);\n\n \n float hairLine = stripeY(uv, 190.0, frame + 55.0, 0.002, 0.012);\n hairLine *= step(0.70, hash(vec2(floor(uv.y * 190.0), frame + 56.0)));\n color.rgb += vec3(0.72, 0.90, 1.0) * hairLine * b * 0.28;\n\n float scan = 0.5 + 0.5 * sin(uv.y * 980.0 + progress * 130.0);\n color.rgb *= 1.0 - scanAmount * b * scan;\n\n vec2 nCell = floor(uv * vec2(360.0 * ratio, 210.0));\n float n = hash(nCell + vec2(frame * 7.0, frame * 13.0));\n color.rgb += (n - 0.5) * noiseAmount * b * (0.55 + glitch);\n\n \n float luma = dot(color.rgb, vec3(0.299, 0.587, 0.114));\n color.rgb = mix(color.rgb, vec3(luma), 0.18 * b * glitch);\n\n float strobe = step(0.78, hash(vec2(frame, 3.14))) * pow(b, 1.65);\n color.rgb += vec3(strobe * flashAmount);\n\n return vec4(clamp(color.rgb, vec3(0.0), vec3(1.0)), 1.0);\n}\n\nhalf4 main(float2 _coord) {\n vec2 _uv = _coord / _resolution;\n vec4 _c = clamp(transition(vec2(_uv.x, 1.0 - _uv.y)), 0.0, 1.0);\n return half4(_c.rgb * _c.a, _c.a);\n}\n","Swirl":"// Swirl — generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/Swirl.glsl\n// Author: Sergey Kosarevsky\n// License: MIT\n// Description: Both images swirl around the center while crossfading\n\nuniform shader _from;\nuniform shader _to;\nuniform float2 _resolution;\nuniform float progress;\nuniform float ratio;\n\nvec4 getFromColor(vec2 uv) { return vec4(unpremul(_from.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\nvec4 getToColor(vec2 uv) { return vec4(unpremul(_to.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\n\nvec4 transition(vec2 UV)\n{\n\tfloat Radius = 1.0;\n\n\tfloat T = progress;\n\n\tUV -= vec2( 0.5, 0.5 );\n\n\tfloat Dist = length(UV);\n\n\tif ( Dist < Radius )\n\t{\n\t\tfloat Percent = (Radius - Dist) / Radius;\n\t\tfloat A = ( T <= 0.5 ) ? mix( 0.0, 1.0, T/0.5 ) : mix( 1.0, 0.0, (T-0.5)/0.5 );\n\t\tfloat Theta = Percent * Percent * A * 8.0 * 3.14159;\n\t\tfloat S = sin( Theta );\n\t\tfloat C = cos( Theta );\n\t\tUV = vec2( dot(UV, vec2(C, -S)), dot(UV, vec2(S, C)) );\n\t}\n\tUV += vec2( 0.5, 0.5 );\n\n\tvec4 C0 = getFromColor(UV);\n\tvec4 C1 = getToColor(UV);\n\n\treturn mix( C0, C1, T );\n}\n\nhalf4 main(float2 _coord) {\n vec2 _uv = _coord / _resolution;\n vec4 _c = clamp(transition(vec2(_uv.x, 1.0 - _uv.y)), 0.0, 1.0);\n return half4(_c.rgb * _c.a, _c.a);\n}\n","TVStatic":"// TVStatic — generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/TVStatic.glsl\n// Author: Brandon Anzaldi\n// License: MIT\n// Description: Cuts to full-screen TV static, then to the incoming image\n\nuniform shader _from;\nuniform shader _to;\nuniform float2 _resolution;\nuniform float progress;\nuniform float ratio;\n\nvec4 getFromColor(vec2 uv) { return vec4(unpremul(_from.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\nvec4 getToColor(vec2 uv) { return vec4(unpremul(_to.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\n\nuniform float offset; \n\nhighp float noise(vec2 co)\n{\n highp float a = 12.9898;\n highp float b = 78.233;\n highp float c = 43758.5453;\n highp float dt= dot(co.xy * progress, vec2(a, b));\n highp float sn= mod(dt,3.14);\n return fract(sin(sn) * c);\n}\n\nvec4 transition(vec2 p) {\n if (progress < offset) {\n return getFromColor(p);\n } else if (progress > (1.0 - offset)) {\n return getToColor(p);\n } else {\n return vec4(vec3(noise(p)), 1.0);\n }\n}\n\nhalf4 main(float2 _coord) {\n vec2 _uv = _coord / _resolution;\n vec4 _c = clamp(transition(vec2(_uv.x, 1.0 - _uv.y)), 0.0, 1.0);\n return half4(_c.rgb * _c.a, _c.a);\n}\n","TilesWave":"// TilesWave — generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/TilesWave.glsl\n// Author: numb3r23\n// License: MIT\n// Description: The incoming image is revealed tile by tile in a diagonal wave\n\nuniform shader _from;\nuniform shader _to;\nuniform float2 _resolution;\nuniform float progress;\nuniform float ratio;\n\nvec4 getFromColor(vec2 uv) { return vec4(unpremul(_from.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\nvec4 getToColor(vec2 uv) { return vec4(unpremul(_to.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\n\nuniform ivec2 tileCount; \nuniform int flipX; \nuniform int flipY; \n\nvec4 transition(vec2 uv) {\n vec2 tileSize = 1.0 / vec2(tileCount);\n vec2 posInTile = fract(uv * vec2(tileCount));\n vec2 tileNum = floor(uv * vec2(tileCount));\n float countTiles = float(tileCount.x * tileCount.y);\n\n \n float offset = (tileNum.y + tileNum.x * float(tileCount.y)) / countTiles;\n float timeOffset = clamp((progress - offset) * countTiles, 0.0, 0.5);\n float sinTime = 1.0 - abs(cos(fract(timeOffset) * 3.1415926));\n\n vec2 texC = posInTile;\n\n if (sinTime <= 0.5) {\n if ((flipX != 0)) {\n if (texC.x < sinTime || texC.x > 1.0 - sinTime)\n return getFromColor(uv);\n texC.x = texC.x < 0.5\n ? (texC.x - sinTime) * 0.5 / (0.5 - sinTime)\n : (texC.x - 0.5) * 0.5 / (0.5 - sinTime) + 0.5;\n }\n if ((flipY != 0)) {\n if (texC.y < sinTime || texC.y > 1.0 - sinTime)\n return getFromColor(uv);\n texC.y = texC.y < 0.5\n ? (texC.y - sinTime) * 0.5 / (0.5 - sinTime)\n : (texC.y - 0.5) * 0.5 / (0.5 - sinTime) + 0.5;\n }\n vec2 globalUV = tileNum * tileSize + texC * tileSize;\n return getFromColor(globalUV);\n } else {\n if ((flipX != 0)) {\n if (texC.x > sinTime || texC.x < 1.0 - sinTime)\n return getToColor(uv);\n texC.x = texC.x < 0.5\n ? (texC.x - sinTime) * 0.5 / (0.5 - sinTime)\n : (texC.x - 0.5) * 0.5 / (0.5 - sinTime) + 0.5;\n texC.x = 1.0 - texC.x;\n }\n if ((flipY != 0)) {\n if (texC.y > sinTime || texC.y < 1.0 - sinTime)\n return getToColor(uv);\n texC.y = texC.y < 0.5\n ? (texC.y - sinTime) * 0.5 / (0.5 - sinTime)\n : (texC.y - 0.5) * 0.5 / (0.5 - sinTime) + 0.5;\n texC.y = 1.0 - texC.y;\n }\n vec2 globalUV = tileNum * tileSize + texC * tileSize;\n return getToColor(globalUV);\n }\n}\n\nhalf4 main(float2 _coord) {\n vec2 _uv = _coord / _resolution;\n vec4 _c = clamp(transition(vec2(_uv.x, 1.0 - _uv.y)), 0.0, 1.0);\n return half4(_c.rgb * _c.a, _c.a);\n}\n","TopBottom":"// TopBottom — generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/TopBottom.glsl\n// Author: zhmy\n// License: MIT\n// Description: The outgoing image shrinks away upward while the incoming one slides in from the bottom\n\nuniform shader _from;\nuniform shader _to;\nuniform float2 _resolution;\nuniform float progress;\nuniform float ratio;\n\nvec4 getFromColor(vec2 uv) { return vec4(unpremul(_from.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\nvec4 getToColor(vec2 uv) { return vec4(unpremul(_to.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\n\nconst vec4 black = vec4(0.0, 0.0, 0.0, 1.0);\nconst vec2 boundMin = vec2(0.0, 0.0);\nconst vec2 boundMax = vec2(1.0, 1.0);\n\nbool inBounds (vec2 p) {\n return all(lessThan(boundMin, p)) && all(lessThan(p, boundMax));\n}\n\nvec4 transition (vec2 uv) {\n vec2 spfr,spto = vec2(-1.);\n float size = mix(1.0, 3.0, progress*0.2);\n spto = (uv + vec2(-0.5,-0.5))*vec2(size,size)+vec2(0.5,0.5);\n spfr = (uv + vec2(0.0, 1.0 - progress));\n if(inBounds(spfr)){\n return getToColor(spfr);\n } else if(inBounds(spto)){\n return getFromColor(spto) * (1.0 - progress);\n } else{\n return black;\n }\n}\n\nhalf4 main(float2 _coord) {\n vec2 _uv = _coord / _resolution;\n vec4 _c = clamp(transition(vec2(_uv.x, 1.0 - _uv.y)), 0.0, 1.0);\n return half4(_c.rgb * _c.a, _c.a);\n}\n","VerticalClose":"// VerticalClose — generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/VerticalClose.glsl\n// Author: martiniti\n// License: MIT\n// Description: The incoming image closes in from the left and right edges toward the middle\n\nuniform shader _from;\nuniform shader _to;\nuniform float2 _resolution;\nuniform float progress;\nuniform float ratio;\n\nvec4 getFromColor(vec2 uv) { return vec4(unpremul(_from.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\nvec4 getToColor(vec2 uv) { return vec4(unpremul(_to.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\n\nvec4 transition (vec2 uv) {\n\n float s = 2.0 - abs((uv.x - 0.5) / (progress - 1.0)) - 2.0 * progress;\n \n return mix(\n getFromColor(uv),\n getToColor(uv),\n smoothstep(0.5, 0.0, s)\n );\n}\n\nhalf4 main(float2 _coord) {\n vec2 _uv = _coord / _resolution;\n vec4 _c = clamp(transition(vec2(_uv.x, 1.0 - _uv.y)), 0.0, 1.0);\n return half4(_c.rgb * _c.a, _c.a);\n}\n","VerticalOpen":"// VerticalOpen — generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/VerticalOpen.glsl\n// Author: martiniti\n// License: MIT\n// Description: The incoming image opens from a line in the middle toward the left and right edges\n\nuniform shader _from;\nuniform shader _to;\nuniform float2 _resolution;\nuniform float progress;\nuniform float ratio;\n\nvec4 getFromColor(vec2 uv) { return vec4(unpremul(_from.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\nvec4 getToColor(vec2 uv) { return vec4(unpremul(_to.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\n\nvec4 transition (vec2 uv) {\n\n float regress = 1.0 - progress;\n float s = 2.0 - abs((uv.x - 0.5) / (regress - 1.0)) - 2.0 * regress;\n \n return mix(\n getFromColor(uv),\n getToColor(uv),\n smoothstep(0.0, 0.5, s)\n );\n}\n\nhalf4 main(float2 _coord) {\n vec2 _uv = _coord / _resolution;\n vec4 _c = clamp(transition(vec2(_uv.x, 1.0 - _uv.y)), 0.0, 1.0);\n return half4(_c.rgb * _c.a, _c.a);\n}\n","WaterDrop":"// WaterDrop — generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/WaterDrop.glsl\n// Author: Paweł Płóciennik\n// License: MIT\n// Description: Ripples spread from the center like a drop falling into water, crossfading to the incoming image\n\nuniform shader _from;\nuniform shader _to;\nuniform float2 _resolution;\nuniform float progress;\nuniform float ratio;\n\nvec4 getFromColor(vec2 uv) { return vec4(unpremul(_from.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\nvec4 getToColor(vec2 uv) { return vec4(unpremul(_to.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\n\nuniform float amplitude; \n\nuniform float speed; \n\nvec4 transition(vec2 p) {\n vec2 dir = p - vec2(.5);\n float dist = length(dir);\n\n if (dist > progress) {\n return mix(getFromColor( p), getToColor( p), progress);\n } else {\n vec2 offset = dir * sin(dist * amplitude - progress * speed);\n return mix(getFromColor( p + offset), getToColor( p), progress);\n }\n}\n\nhalf4 main(float2 _coord) {\n vec2 _uv = _coord / _resolution;\n vec4 _c = clamp(transition(vec2(_uv.x, 1.0 - _uv.y)), 0.0, 1.0);\n return half4(_c.rgb * _c.a, _c.a);\n}\n","ZoomInCircles":"// ZoomInCircles — generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/ZoomInCircles.glsl\n// Author: dycm8009\n// License: MIT\n// Description: Concentric rings of the outgoing image zoom at different speeds before revealing the incoming one\n\nuniform shader _from;\nuniform shader _to;\nuniform float2 _resolution;\nuniform float progress;\nuniform float ratio;\n\nvec4 getFromColor(vec2 uv) { return vec4(unpremul(_from.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\nvec4 getToColor(vec2 uv) { return vec4(unpremul(_to.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\n\nvec2 zoom(vec2 uv, float amount) {\n return 0.5 + ((uv - 0.5) * amount);\t\n}\n\nvec4 transition(vec2 uv) {\n vec2 ratio2 = vec2(1.0, 1.0 / ratio);\n \n \n \n vec2 r = 2.0 * ((vec2(uv.xy) - 0.5) * ratio2);\n float pro = progress / 0.8;\n float z = pro * 0.2;\n float t = 0.0;\n if (pro > 1.0) {\n z = 0.2 + (pro - 1.0) * 5.;\n t = clamp((progress - 0.8) / 0.07, 0.0, 1.0);\n }\n if (length(r) < 0.5+z) {\n \n }\n else if (length(r) < 0.8+z*1.5) {\n uv = zoom(uv, 1.0 - 0.15 * pro);\n t = t * 0.5;\n }\n else if (length(r) < 1.2+z*2.5) {\n uv = zoom(uv, 1.0 - 0.2 * pro);\n t = t * 0.2;\n }\n else {\n uv = zoom(uv, 1.0 - 0.25 * pro);\n }\n return mix(getFromColor(uv), getToColor(uv), t);\n}\n\nhalf4 main(float2 _coord) {\n vec2 _uv = _coord / _resolution;\n vec4 _c = clamp(transition(vec2(_uv.x, 1.0 - _uv.y)), 0.0, 1.0);\n return half4(_c.rgb * _c.a, _c.a);\n}\n","ZoomLeftWipe":"// ZoomLeftWipe — generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/ZoomLeftWipe.glsl\n// Author: Handk\n// License: MIT\n// Description: Zooms into the outgoing image, then the incoming one wipes in from right to left\n\nuniform shader _from;\nuniform shader _to;\nuniform float2 _resolution;\nuniform float progress;\nuniform float ratio;\n\nvec4 getFromColor(vec2 uv) { return vec4(unpremul(_from.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\nvec4 getToColor(vec2 uv) { return vec4(unpremul(_to.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\n\nuniform float zoom_quickness; \nvec2 zoom(vec2 uv, float amount) {\n if(amount<0.5)\n return 0.5 + ((uv - 0.5) * (1.0-amount));\n else\n return 0.5 + ((uv - 0.5) * (amount));\n \n}\n\nvec4 transition (vec2 uv) {\n float nQuick = clamp(zoom_quickness,0.0,0.5);\n if(progress<0.5){\n vec4 c= mix(\n getFromColor(zoom(uv, smoothstep(0.0, nQuick, progress))),\n getToColor(uv),\n step(0.5, progress)\n );\n \n return c;\n }\n else{\n vec2 p=uv.xy/vec2(1.0).xy;\n vec4 d=getFromColor(p);\n vec4 e=getToColor(p);\n vec4 f= mix(d, e, step(1.0-p.x,(progress-0.5)*2.0));\n \n return f;\n }\n}\n\nhalf4 main(float2 _coord) {\n vec2 _uv = _coord / _resolution;\n vec4 _c = clamp(transition(vec2(_uv.x, 1.0 - _uv.y)), 0.0, 1.0);\n return half4(_c.rgb * _c.a, _c.a);\n}\n","ZoomRigthWipe":"// ZoomRigthWipe — generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/ZoomRigthWipe.glsl\n// Author: Handk\n// License: MIT\n// Description: Zooms into the outgoing image, then the incoming one wipes in from left to right\n\nuniform shader _from;\nuniform shader _to;\nuniform float2 _resolution;\nuniform float progress;\nuniform float ratio;\n\nvec4 getFromColor(vec2 uv) { return vec4(unpremul(_from.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\nvec4 getToColor(vec2 uv) { return vec4(unpremul(_to.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\n\nuniform float zoom_quickness; \nvec2 zoom(vec2 uv, float amount) {\n if(amount<0.5)\n return 0.5 + ((uv - 0.5) * (1.0-amount));\n else\n return 0.5 + ((uv - 0.5) * (amount));\n \n}\n\nvec4 transition (vec2 uv) {\n float nQuick = clamp(zoom_quickness,0.0,0.5);\n if(progress<0.5){\n vec4 c= mix(\n getFromColor(zoom(uv, smoothstep(0.0, nQuick, progress))),\n getToColor(uv),\n step(0.5, progress)\n );\n \n return c;\n }\n else{\n vec2 p=uv.xy/vec2(1.0).xy;\n vec4 d=getFromColor(p);\n vec4 e=getToColor(p);\n vec4 f= mix(d, e, step(0.0+p.x,(progress-0.5)*2.0));\n \n return f;\n }\n}\n\nhalf4 main(float2 _coord) {\n vec2 _uv = _coord / _resolution;\n vec4 _c = clamp(transition(vec2(_uv.x, 1.0 - _uv.y)), 0.0, 1.0);\n return half4(_c.rgb * _c.a, _c.a);\n}\n","angular":"// angular — generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/angular.glsl\n// Author: Fernando Kuteken\n// License: MIT\n// Description: A wipe that sweeps around the center from a starting angle\n\nuniform shader _from;\nuniform shader _to;\nuniform float2 _resolution;\nuniform float progress;\nuniform float ratio;\n\nvec4 getFromColor(vec2 uv) { return vec4(unpremul(_from.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\nvec4 getToColor(vec2 uv) { return vec4(unpremul(_to.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\n\nuniform float startingAngle; \n\nvec4 transition (vec2 uv) {\n \n float offset = startingAngle * 3.141592653589 / 180.0;\n float angle = atan(uv.y - 0.5, uv.x - 0.5) + offset;\n float normalizedAngle = (angle + 3.141592653589) / (2.0 * 3.141592653589);\n \n normalizedAngle = normalizedAngle - floor(normalizedAngle);\n\n return mix(\n getFromColor(uv),\n getToColor(uv),\n step(normalizedAngle, progress)\n );\n}\n\nhalf4 main(float2 _coord) {\n vec2 _uv = _coord / _resolution;\n vec4 _c = clamp(transition(vec2(_uv.x, 1.0 - _uv.y)), 0.0, 1.0);\n return half4(_c.rgb * _c.a, _c.a);\n}\n","burn":"// burn — generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/burn.glsl\n// Author: gre\n// License: MIT\n// Description: A crossfade that brightens toward a color in the middle\n\nuniform shader _from;\nuniform shader _to;\nuniform float2 _resolution;\nuniform float progress;\nuniform float ratio;\n\nvec4 getFromColor(vec2 uv) { return vec4(unpremul(_from.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\nvec4 getToColor(vec2 uv) { return vec4(unpremul(_to.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\n\nuniform vec3 color ;\nvec4 transition (vec2 uv) {\n return mix(\n getFromColor(uv) + vec4(progress*color, 1.0),\n getToColor(uv) + vec4((1.0-progress)*color, 1.0),\n progress\n );\n}\n\nhalf4 main(float2 _coord) {\n vec2 _uv = _coord / _resolution;\n vec4 _c = clamp(transition(vec2(_uv.x, 1.0 - _uv.y)), 0.0, 1.0);\n return half4(_c.rgb * _c.a, _c.a);\n}\n","burn0":"// burn0 — generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/burn0.glsl\n// Author: liubailin2020@gmail.com\n// License: MIT\n// Description: The outgoing image burns away in noisy, glowing patches\n\nuniform shader _from;\nuniform shader _to;\nuniform float2 _resolution;\nuniform float progress;\nuniform float ratio;\n\nvec4 getFromColor(vec2 uv) { return vec4(unpremul(_from.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\nvec4 getToColor(vec2 uv) { return vec4(unpremul(_to.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\n\nuniform vec3 burnColor; \n\nfloat random (in vec2 st) {\n return fract(sin(dot(st.xy,\n vec2(12.9898,78.233)))*\n 43758.5453123);\n}\n\nfloat noise (in vec2 st) {\n vec2 i = floor(st);\n vec2 f = fract(st);\n\n float a = random(i);\n float b = random(i + vec2(1.0, 0.0));\n float c = random(i + vec2(0.0, 1.0));\n float d = random(i + vec2(1.0, 1.0));\n\n vec2 u = f * f * (3.0 - 2.0 * f);\n\n return mix(a, b, u.x) +\n (c - a)* u.y * (1.0 - u.x) +\n (d - b) * u.x * u.y;\n}\n\nfloat fbm (in vec2 st) {\n float value = 0.0;\n float amplitude = .5;\n for (int i = 0; i < 4; i++) {\n value += amplitude * noise(st);\n st *= 2.;\n amplitude *= .5;\n }\n return value;\n}\n\nvec4 transition (vec2 uv) {\n if (progress <= 0.0) return getFromColor(uv);\n if (progress >= 1.0) return getToColor(uv);\n vec4 from = getFromColor(uv);\n vec4 to = getToColor(uv);\n float n = fbm(uv * 4.);\n float l = smoothstep(progress, progress + 0.05, n);\n float edge = (1.0 - l) * l * 5.0;\n return mix(to, from, l) + vec4(burnColor, 0.0) * edge;\n}\n\nhalf4 main(float2 _coord) {\n vec2 _uv = _coord / _resolution;\n vec4 _c = clamp(transition(vec2(_uv.x, 1.0 - _uv.y)), 0.0, 1.0);\n return half4(_c.rgb * _c.a, _c.a);\n}\n","cannabisleaf":"// cannabisleaf — generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/cannabisleaf.glsl\n// Author: @Flexi23\n// License: MIT\n// Description: A cannabis-leaf shape grows from the center to reveal the incoming image\n\nuniform shader _from;\nuniform shader _to;\nuniform float2 _resolution;\nuniform float progress;\nuniform float ratio;\n\nvec4 getFromColor(vec2 uv) { return vec4(unpremul(_from.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\nvec4 getToColor(vec2 uv) { return vec4(unpremul(_to.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\n\nvec4 transition (vec2 uv) {\n if(progress == 0.0){\n return getFromColor(uv);\n }\n vec2 leaf_uv = (uv - vec2(0.5))/10./pow(progress,3.5);\n\tleaf_uv.y += 0.35;\n\tfloat r = 0.18;\n\tfloat o = atan(leaf_uv.y, leaf_uv.x);\n return mix(getFromColor(uv), getToColor(uv), 1.-step(1. - length(leaf_uv)+r*(1.+sin(o))*(1.+0.9 * cos(8.*o))*(1.+0.1*cos(24.*o))*(0.9+0.05*cos(200.*o)), 1.));\n}\n\nhalf4 main(float2 _coord) {\n vec2 _uv = _coord / _resolution;\n vec4 _c = clamp(transition(vec2(_uv.x, 1.0 - _uv.y)), 0.0, 1.0);\n return half4(_c.rgb * _c.a, _c.a);\n}\n","chessboard":"// chessboard — generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/chessboard.glsl\n// Author: lql\n// License: MIT\n// Description: A chessboard pattern of squares reveals the incoming image\n\nuniform shader _from;\nuniform shader _to;\nuniform float2 _resolution;\nuniform float progress;\nuniform float ratio;\n\nvec4 getFromColor(vec2 uv) { return vec4(unpremul(_from.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\nvec4 getToColor(vec2 uv) { return vec4(unpremul(_to.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\n\nuniform float grid_num; \n\nvec4 transition(vec2 uv) {\n vec2 st = uv * grid_num;\n vec2 idx = floor(st);\n vec2 grid = fract(st);\n\n vec4 a = getFromColor(uv);\n vec4 b = getToColor(uv);\n\n float checker = mod(idx.x + idx.y, 2.0);\n float mixFactor;\n\n if (progress <= 0.5) {\n mixFactor = (checker > 0.5) ? step(grid.x, progress * 2.0) : 0.0;\n } else {\n mixFactor = (checker < 0.5) ? step(grid.x, (progress - 0.5) * 2.0) : 1.0;\n }\n\n return mix(a, b, mixFactor);\n}\n\nhalf4 main(float2 _coord) {\n vec2 _uv = _coord / _resolution;\n vec4 _c = clamp(transition(vec2(_uv.x, 1.0 - _uv.y)), 0.0, 1.0);\n return half4(_c.rgb * _c.a, _c.a);\n}\n","circle":"// circle — generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/circle.glsl\n// Author: Fernando Kuteken\n// License: MIT\n// Description: The outgoing image closes into a circle over a background color, then the incoming one opens from it\n\nuniform shader _from;\nuniform shader _to;\nuniform float2 _resolution;\nuniform float progress;\nuniform float ratio;\n\nvec4 getFromColor(vec2 uv) { return vec4(unpremul(_from.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\nvec4 getToColor(vec2 uv) { return vec4(unpremul(_to.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\n\nuniform vec2 center; \n\nuniform vec3 backColor; \n\nvec4 transition (vec2 uv) {\n \n float distance = length(uv - center);\n float radius = sqrt(8.0) * abs(progress - 0.5);\n \n if (distance > radius) {\n return vec4(backColor, 1.0);\n }\n else {\n if (progress < 0.5) return getFromColor(uv);\n else return getToColor(uv);\n }\n}\n\nhalf4 main(float2 _coord) {\n vec2 _uv = _coord / _resolution;\n vec4 _c = clamp(transition(vec2(_uv.x, 1.0 - _uv.y)), 0.0, 1.0);\n return half4(_c.rgb * _c.a, _c.a);\n}\n","circleopen":"// circleopen — generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/circleopen.glsl\n// Author: gre\n// License: MIT\n// Description: A soft-edged circle opens from the center to reveal the incoming image\n\nuniform shader _from;\nuniform shader _to;\nuniform float2 _resolution;\nuniform float progress;\nuniform float ratio;\n\nvec4 getFromColor(vec2 uv) { return vec4(unpremul(_from.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\nvec4 getToColor(vec2 uv) { return vec4(unpremul(_to.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\n\nuniform float smoothness; \n\nuniform int opening; \n\nconst vec2 center = vec2(0.5, 0.5);\nconst float SQRT_2 = 1.414213562373;\n\nvec4 transition (vec2 uv) {\n float x = (opening != 0) ? progress : 1.-progress;\n float m = smoothstep(-smoothness, 0.0, SQRT_2*distance(center, uv) - x*(1.+smoothness));\n return mix(getFromColor(uv), getToColor(uv), (opening != 0) ? 1.-m : m);\n}\n\nhalf4 main(float2 _coord) {\n vec2 _uv = _coord / _resolution;\n vec4 _c = clamp(transition(vec2(_uv.x, 1.0 - _uv.y)), 0.0, 1.0);\n return half4(_c.rgb * _c.a, _c.a);\n}\n","colorphase":"// colorphase — generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/colorphase.glsl\n// Author: gre\n// License: MIT\n// Description: A crossfade in which each color channel changes at a different time\n\nuniform shader _from;\nuniform shader _to;\nuniform float2 _resolution;\nuniform float progress;\nuniform float ratio;\n\nvec4 getFromColor(vec2 uv) { return vec4(unpremul(_from.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\nvec4 getToColor(vec2 uv) { return vec4(unpremul(_to.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\n\nuniform vec4 fromStep; \n\nuniform vec4 toStep; \n\nvec4 transition (vec2 uv) {\n vec4 a = getFromColor(uv);\n vec4 b = getToColor(uv);\n return mix(a, b, smoothstep(fromStep, toStep, vec4(progress)));\n}\n\nhalf4 main(float2 _coord) {\n vec2 _uv = _coord / _resolution;\n vec4 _c = clamp(transition(vec2(_uv.x, 1.0 - _uv.y)), 0.0, 1.0);\n return half4(_c.rgb * _c.a, _c.a);\n}\n","coord-from-in":"// coord-from-in — generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/coord-from-in.glsl\n// Author: haiyoucuv\n// License: MIT\n// Description: A crossfade in which the colors of one image displace the other\n\nuniform shader _from;\nuniform shader _to;\nuniform float2 _resolution;\nuniform float progress;\nuniform float ratio;\n\nvec4 getFromColor(vec2 uv) { return vec4(unpremul(_from.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\nvec4 getToColor(vec2 uv) { return vec4(unpremul(_to.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\n\nvec4 transition (vec2 uv) {\n\n vec4 coordTo = getToColor(uv);\n vec4 coordFrom = getFromColor(uv);\n\n return mix(\n getFromColor(mix(uv, coordTo.rg, progress)),\n getToColor(mix(coordFrom.rg, uv, progress)),\n progress\n );\n\n}\n\nhalf4 main(float2 _coord) {\n vec2 _uv = _coord / _resolution;\n vec4 _c = clamp(transition(vec2(_uv.x, 1.0 - _uv.y)), 0.0, 1.0);\n return half4(_c.rgb * _c.a, _c.a);\n}\n","crosshatch":"// crosshatch — generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/crosshatch.glsl\n// Author: pthrasher\n// License: MIT\n// Description: The incoming image appears through a crosshatch of lines spreading from the center\n\nuniform shader _from;\nuniform shader _to;\nuniform float2 _resolution;\nuniform float progress;\nuniform float ratio;\n\nvec4 getFromColor(vec2 uv) { return vec4(unpremul(_from.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\nvec4 getToColor(vec2 uv) { return vec4(unpremul(_to.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\n\nuniform vec2 center; \nuniform float threshold; \nuniform float fadeEdge; \n\nfloat rand(vec2 co) {\n return fract(sin(dot(co.xy ,vec2(12.9898,78.233))) * 43758.5453);\n}\nvec4 transition(vec2 p) {\n float dist = distance(center, p) / threshold;\n float r = progress - min(rand(vec2(p.y, 0.0)), rand(vec2(0.0, p.x)));\n return mix(getFromColor(p), getToColor(p), mix(0.0, mix(step(dist, r), 1.0, smoothstep(1.0-fadeEdge, 1.0, progress)), smoothstep(0.0, fadeEdge, progress))); \n}\n\nhalf4 main(float2 _coord) {\n vec2 _uv = _coord / _resolution;\n vec4 _c = clamp(transition(vec2(_uv.x, 1.0 - _uv.y)), 0.0, 1.0);\n return half4(_c.rgb * _c.a, _c.a);\n}\n","crosswarp":"// crosswarp — generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/crosswarp.glsl\n// Author: Eke Péter <peterekepeter@gmail.com>\n// License: MIT\n// Description: The outgoing image zooms in while the incoming one zooms out into place, sweeping from right to left\n\nuniform shader _from;\nuniform shader _to;\nuniform float2 _resolution;\nuniform float progress;\nuniform float ratio;\n\nvec4 getFromColor(vec2 uv) { return vec4(unpremul(_from.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\nvec4 getToColor(vec2 uv) { return vec4(unpremul(_to.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\n\nvec4 transition(vec2 p) {\n float x = progress;\n x=smoothstep(.0,1.0,(x*2.0+p.x-1.0));\n return mix(getFromColor((p-.5)*(1.-x)+.5), getToColor((p-.5)*x+.5), x);\n}\n\nhalf4 main(float2 _coord) {\n vec2 _uv = _coord / _resolution;\n vec4 _c = clamp(transition(vec2(_uv.x, 1.0 - _uv.y)), 0.0, 1.0);\n return half4(_c.rgb * _c.a, _c.a);\n}\n","cube":"// cube — generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/cube.glsl\n// Author: gre\n// License: MIT\n// Description: The two images are faces of a rotating 3D cube, with a floor reflection\n\nuniform shader _from;\nuniform shader _to;\nuniform float2 _resolution;\nuniform float progress;\nuniform float ratio;\n\nvec4 getFromColor(vec2 uv) { return vec4(unpremul(_from.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\nvec4 getToColor(vec2 uv) { return vec4(unpremul(_to.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\n\nuniform float persp; \nuniform float unzoom; \n\nuniform float reflection; \nuniform float floating; \n\nvec2 project (vec2 p) {\n return p * vec2(1.0, -1.2) + vec2(0.0, -floating/100.);\n}\n\nbool inBounds (vec2 p) {\n return all(lessThan(vec2(0.0), p)) && all(lessThan(p, vec2(1.0)));\n}\n\nvec4 bgColor (vec2 p, vec2 pfr, vec2 pto) {\n vec4 c = vec4(0.0, 0.0, 0.0, 1.0);\n pfr = project(pfr);\n \n if (inBounds(pfr)) {\n c += mix(vec4(0.0), getFromColor(pfr), reflection * mix(1.0, 0.0, pfr.y));\n }\n pto = project(pto);\n if (inBounds(pto)) {\n c += mix(vec4(0.0), getToColor(pto), reflection * mix(1.0, 0.0, pto.y));\n }\n return c;\n}\n\nvec2 xskew (vec2 p, float persp, float center) {\n float x = mix(p.x, 1.0-p.x, center);\n return (\n (\n vec2( x, (p.y - 0.5*(1.0-persp) * x) / (1.0+(persp-1.0)*x) )\n - vec2(0.5-distance(center, 0.5), 0.0)\n )\n * vec2(0.5 / distance(center, 0.5) * (center<0.5 ? 1.0 : -1.0), 1.0)\n + vec2(center<0.5 ? 0.0 : 1.0, 0.0)\n );\n}\n\nvec4 transition(vec2 op) {\n float uz = unzoom * 2.0*(0.5-distance(0.5, progress));\n vec2 p = -uz*0.5+(1.0+uz) * op;\n vec2 fromP = xskew(\n (p - vec2(progress, 0.0)) / vec2(1.0-progress, 1.0),\n 1.0-mix(progress, 0.0, persp),\n 0.0\n );\n vec2 toP = xskew(\n p / vec2(progress, 1.0),\n mix(pow(progress, 2.0), 1.0, persp),\n 1.0\n );\n \n if (inBounds(fromP)) {\n return getFromColor(fromP);\n }\n else if (inBounds(toP)) {\n return getToColor(toP);\n }\n return bgColor(op, fromP, toP);\n}\n\nhalf4 main(float2 _coord) {\n vec2 _uv = _coord / _resolution;\n vec4 _c = clamp(transition(vec2(_uv.x, 1.0 - _uv.y)), 0.0, 1.0);\n return half4(_c.rgb * _c.a, _c.a);\n}\n","directional-easing":"// directional-easing — generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/directional-easing.glsl\n// Author: Max Plotnikov\n// License: MIT\n// Description: Like Directional, with an eased movement\n\nuniform shader _from;\nuniform shader _to;\nuniform float2 _resolution;\nuniform float progress;\nuniform float ratio;\n\nvec4 getFromColor(vec2 uv) { return vec4(unpremul(_from.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\nvec4 getToColor(vec2 uv) { return vec4(unpremul(_to.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\n\nuniform vec2 direction; \n\nvec4 transition (vec2 uv) {\n float easing = sqrt((2.0 - progress) * progress);\n vec2 p = uv + easing * sign(direction);\n vec2 f = fract(p);\n return mix(\n getToColor(f),\n getFromColor(f),\n step(0.0, p.y) * step(p.y, 1.0) * step(0.0, p.x) * step(p.x, 1.0)\n );\n}\n\nhalf4 main(float2 _coord) {\n vec2 _uv = _coord / _resolution;\n vec4 _c = clamp(transition(vec2(_uv.x, 1.0 - _uv.y)), 0.0, 1.0);\n return half4(_c.rgb * _c.a, _c.a);\n}\n","directionalwarp":"// directionalwarp — generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/directionalwarp.glsl\n// Author: pschroen\n// License: MIT\n// Description: A diagonal wipe with a warped, smeared edge\n\nuniform shader _from;\nuniform shader _to;\nuniform float2 _resolution;\nuniform float progress;\nuniform float ratio;\n\nvec4 getFromColor(vec2 uv) { return vec4(unpremul(_from.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\nvec4 getToColor(vec2 uv) { return vec4(unpremul(_to.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\n\nuniform float smoothness; \n\nuniform vec2 direction; \n\nconst vec2 center = vec2(0.5, 0.5);\n\nvec4 transition (vec2 uv) {\n vec2 v = normalize(direction);\n v /= abs(v.x) + abs(v.y);\n float d = v.x * center.x + v.y * center.y;\n float m = 1.0 - smoothstep(-smoothness, 0.0, v.x * uv.x + v.y * uv.y - (d - 0.5 + progress * (1.0 + smoothness)));\n return mix(getFromColor((uv - 0.5) * (1.0 - m) + 0.5), getToColor((uv - 0.5) * m + 0.5), m);\n}\n\nhalf4 main(float2 _coord) {\n vec2 _uv = _coord / _resolution;\n vec4 _c = clamp(transition(vec2(_uv.x, 1.0 - _uv.y)), 0.0, 1.0);\n return half4(_c.rgb * _c.a, _c.a);\n}\n","directionalwipe":"// directionalwipe — generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/directionalwipe.glsl\n// Author: gre\n// License: MIT\n// Description: A soft-edged diagonal wipe\n\nuniform shader _from;\nuniform shader _to;\nuniform float2 _resolution;\nuniform float progress;\nuniform float ratio;\n\nvec4 getFromColor(vec2 uv) { return vec4(unpremul(_from.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\nvec4 getToColor(vec2 uv) { return vec4(unpremul(_to.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\n\nuniform vec2 direction; \n\nuniform float smoothness; \n \nconst vec2 center = vec2(0.5, 0.5);\n \nvec4 transition (vec2 uv) {\n vec2 v = normalize(direction);\n v /= abs(v.x)+abs(v.y);\n float d = v.x * center.x + v.y * center.y;\n float m =\n (1.0-step(progress, 0.0)) * \n (1.0 - smoothstep(-smoothness, 0.0, v.x * uv.x + v.y * uv.y - (d-0.5+progress*(1.+smoothness))));\n return mix(getFromColor(uv), getToColor(uv), m);\n}\n\nhalf4 main(float2 _coord) {\n vec2 _uv = _coord / _resolution;\n vec4 _c = clamp(transition(vec2(_uv.x, 1.0 - _uv.y)), 0.0, 1.0);\n return half4(_c.rgb * _c.a, _c.a);\n}\n","displacement":"// displacement — generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/displacement.glsl\n// Author: Travis Fischer\n// License: MIT\n// Description: A crossfade in which a displacement map (an extra grayscale texture) warps both images\n\nuniform shader _from;\nuniform shader _to;\nuniform float2 _resolution;\nuniform float progress;\nuniform float ratio;\n\nvec4 getFromColor(vec2 uv) { return vec4(unpremul(_from.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\nvec4 getToColor(vec2 uv) { return vec4(unpremul(_to.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\n\nuniform shader displacementMap;\nvec4 _texture_displacementMap(vec2 uv) { return vec4(unpremul(displacementMap.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\n\nuniform float strength; \n\nvec4 transition (vec2 uv) {\n float displacement = _texture_displacementMap( uv).r * strength;\n\n vec2 uvFrom = vec2(uv.x + progress * displacement, uv.y);\n vec2 uvTo = vec2(uv.x - (1.0 - progress) * displacement, uv.y);\n\n return mix(\n getFromColor(uvFrom),\n getToColor(uvTo),\n progress\n );\n}\n\nhalf4 main(float2 _coord) {\n vec2 _uv = _coord / _resolution;\n vec4 _c = clamp(transition(vec2(_uv.x, 1.0 - _uv.y)), 0.0, 1.0);\n return half4(_c.rgb * _c.a, _c.a);\n}\n","dissolve":"// dissolve — generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/dissolve.glsl\n// Author: hjm1fb\n// License: MIT\n// Description: The incoming image spreads over the outgoing one with a hot, glowing edge\n\nuniform shader _from;\nuniform shader _to;\nuniform float2 _resolution;\nuniform float progress;\nuniform float ratio;\n\nvec4 getFromColor(vec2 uv) { return vec4(unpremul(_from.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\nvec4 getToColor(vec2 uv) { return vec4(unpremul(_to.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\n\nuniform float uLineWidth; \n\nuniform vec3 uSpreadClr; \n\nuniform vec3 uHotClr; \nuniform float uPow; \nuniform float uIntensity; \n\nvec2 hash(vec2 p) \n{\n p = vec2(dot(p, vec2(127.1, 311.7)), dot(p, vec2(269.5, 183.3)));\n return -1.0 + 2.0 * fract(sin(p) * 43758.5453123);\n}\n\nfloat noise(in vec2 p) {\n const float K1 = 0.366025404; \n const float K2 = 0.211324865; \n\n vec2 i = floor(p + (p.x + p.y) * K1);\n vec2 a = p - i + (i.x + i.y) * K2;\n float m = step(a.y, a.x);\n vec2 o = vec2(m, 1.0 - m);\n vec2 b = a - o + K2;\n vec2 c = a - 1.0 + 2.0 * K2;\n vec3 h = max(0.5 - vec3(dot(a, a), dot(b, b), dot(c, c)), 0.0);\n vec3 n = h * h * h * h * vec3(dot(a, hash(i + 0.0)), dot(b, hash(i + o)), dot(c, hash(i + 1.0)));\n return dot(n, vec3(70.0));\n}\n\nvec4 transition(vec2 uv) {\n vec4 from = getFromColor(uv);\n vec4 to = getToColor(uv);\n vec4 outColor;\n float burn;\n burn = 0.5 + 0.5 * (0.299 * from.r + 0.587 * from.g + 0.114 * from.b);\n\n float show = burn - progress;\n if (show < 0.001) {\n outColor = to;\n } else {\n float factor = 1.0 - smoothstep(0.0, uLineWidth, show);\n vec3 burnColor = mix(uSpreadClr, uHotClr, factor);\n burnColor = pow(burnColor, vec3(uPow)) * uIntensity;\n vec3 finalRGB = mix(from.rgb, burnColor, factor * step(0.0001, progress));\n outColor = vec4(finalRGB * from.a, from.a);\n }\n return outColor;\n}\n\nhalf4 main(float2 _coord) {\n vec2 _uv = _coord / _resolution;\n vec4 _c = clamp(transition(vec2(_uv.x, 1.0 - _uv.y)), 0.0, 1.0);\n return half4(_c.rgb * _c.a, _c.a);\n}\n","doorway":"// doorway — generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/doorway.glsl\n// Author: gre\n// License: MIT\n// Description: The outgoing image opens like double doors as the incoming one comes forward, with a floor reflection\n\nuniform shader _from;\nuniform shader _to;\nuniform float2 _resolution;\nuniform float progress;\nuniform float ratio;\n\nvec4 getFromColor(vec2 uv) { return vec4(unpremul(_from.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\nvec4 getToColor(vec2 uv) { return vec4(unpremul(_to.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\n\nuniform float reflection; \n\nuniform float perspective; \nuniform float depth; \n\nconst vec4 black = vec4(0.0, 0.0, 0.0, 1.0);\nconst vec2 boundMin = vec2(0.0, 0.0);\nconst vec2 boundMax = vec2(1.0, 1.0);\n\nbool inBounds (vec2 p) {\n return all(lessThan(boundMin, p)) && all(lessThan(p, boundMax));\n}\n\nvec2 project (vec2 p) {\n return p * vec2(1.0, -1.2) + vec2(0.0, -0.02);\n}\n\nvec4 bgColor (vec2 p, vec2 pto) {\n vec4 c = black;\n pto = project(pto);\n if (inBounds(pto)) {\n c += mix(black, getToColor(pto), reflection * mix(1.0, 0.0, pto.y));\n }\n return c;\n}\n\nvec4 transition (vec2 p) {\n vec2 pfr = vec2(-1.), pto = vec2(-1.);\n float middleSlit = 2.0 * abs(p.x-0.5) - progress;\n if (middleSlit > 0.0) {\n pfr = p + (p.x > 0.5 ? -1.0 : 1.0) * vec2(0.5*progress, 0.0);\n float d = 1.0/(1.0+perspective*progress*(1.0-middleSlit));\n pfr.y -= d/2.;\n pfr.y *= d;\n pfr.y += d/2.;\n }\n float size = mix(1.0, depth, 1.-progress);\n pto = (p + vec2(-0.5, -0.5)) * vec2(size, size) + vec2(0.5, 0.5);\n if (inBounds(pfr)) {\n return getFromColor(pfr);\n }\n else if (inBounds(pto)) {\n return getToColor(pto);\n }\n else {\n return bgColor(p, pto);\n }\n}\n\nhalf4 main(float2 _coord) {\n vec2 _uv = _coord / _resolution;\n vec4 _c = clamp(transition(vec2(_uv.x, 1.0 - _uv.y)), 0.0, 1.0);\n return half4(_c.rgb * _c.a, _c.a);\n}\n","fade":"// fade — generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/fade.glsl\n// Author: gre\n// License: MIT\n// Description: A linear crossfade between the two images\n\nuniform shader _from;\nuniform shader _to;\nuniform float2 _resolution;\nuniform float progress;\nuniform float ratio;\n\nvec4 getFromColor(vec2 uv) { return vec4(unpremul(_from.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\nvec4 getToColor(vec2 uv) { return vec4(unpremul(_to.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\n\nvec4 transition (vec2 uv) {\n return mix(\n getFromColor(uv),\n getToColor(uv),\n progress\n );\n}\n\nhalf4 main(float2 _coord) {\n vec2 _uv = _coord / _resolution;\n vec4 _c = clamp(transition(vec2(_uv.x, 1.0 - _uv.y)), 0.0, 1.0);\n return half4(_c.rgb * _c.a, _c.a);\n}\n","fadecolor":"// fadecolor — generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/fadecolor.glsl\n// Author: gre\n// License: MIT\n// Description: A fade through a solid color, black by default\n\nuniform shader _from;\nuniform shader _to;\nuniform float2 _resolution;\nuniform float progress;\nuniform float ratio;\n\nvec4 getFromColor(vec2 uv) { return vec4(unpremul(_from.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\nvec4 getToColor(vec2 uv) { return vec4(unpremul(_to.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\n\nuniform vec3 color;\n\nuniform float colorPhase; \nvec4 transition (vec2 uv) {\n return mix(\n mix(vec4(color, 1.0), getFromColor(uv), smoothstep(1.0-colorPhase, 0.0, progress)),\n mix(vec4(color, 1.0), getToColor(uv), smoothstep( colorPhase, 1.0, progress)),\n progress);\n}\n\nhalf4 main(float2 _coord) {\n vec2 _uv = _coord / _resolution;\n vec4 _c = clamp(transition(vec2(_uv.x, 1.0 - _uv.y)), 0.0, 1.0);\n return half4(_c.rgb * _c.a, _c.a);\n}\n","fadegrayscale":"// fadegrayscale — generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/fadegrayscale.glsl\n// Author: gre\n// License: MIT\n// Description: A crossfade through grayscale\n\nuniform shader _from;\nuniform shader _to;\nuniform float2 _resolution;\nuniform float progress;\nuniform float ratio;\n\nvec4 getFromColor(vec2 uv) { return vec4(unpremul(_from.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\nvec4 getToColor(vec2 uv) { return vec4(unpremul(_to.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\n\nuniform float intensity; \n \nvec3 grayscale (vec3 color) {\n return vec3(0.2126*color.r + 0.7152*color.g + 0.0722*color.b);\n}\n \nvec4 transition (vec2 uv) {\n vec4 fc = getFromColor(uv);\n vec4 tc = getToColor(uv);\n return mix(\n mix(vec4(grayscale(fc.rgb), 1.0), fc, smoothstep(1.0-intensity, 0.0, progress)),\n mix(vec4(grayscale(tc.rgb), 1.0), tc, smoothstep( intensity, 1.0, progress)),\n progress);\n}\n\nhalf4 main(float2 _coord) {\n vec2 _uv = _coord / _resolution;\n vec4 _c = clamp(transition(vec2(_uv.x, 1.0 - _uv.y)), 0.0, 1.0);\n return half4(_c.rgb * _c.a, _c.a);\n}\n","flyeye":"// flyeye — generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/flyeye.glsl\n// Author: gre\n// License: MIT\n// Description: The image breaks into a fly's-eye grid of lenses with color separation\n\nuniform shader _from;\nuniform shader _to;\nuniform float2 _resolution;\nuniform float progress;\nuniform float ratio;\n\nvec4 getFromColor(vec2 uv) { return vec4(unpremul(_from.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\nvec4 getToColor(vec2 uv) { return vec4(unpremul(_to.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\n\nuniform float size; \nuniform float zoom; \nuniform float colorSeparation; \n\nvec4 transition(vec2 p) {\n float inv = 1. - progress;\n vec2 disp = size*vec2(cos(zoom*p.x), sin(zoom*p.y));\n vec4 texTo = getToColor(p + inv*disp);\n vec4 texFrom = vec4(\n getFromColor(p + progress*disp*(1.0 - colorSeparation)).r,\n getFromColor(p + progress*disp).g,\n getFromColor(p + progress*disp*(1.0 + colorSeparation)).b,\n 1.0);\n return texTo*progress + texFrom*inv;\n}\n\nhalf4 main(float2 _coord) {\n vec2 _uv = _coord / _resolution;\n vec4 _c = clamp(transition(vec2(_uv.x, 1.0 - _uv.y)), 0.0, 1.0);\n return half4(_c.rgb * _c.a, _c.a);\n}\n","fragment":"// fragment — generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/fragment.glsl\n// Author: lbl\n// License: MIT\n// Description: The outgoing image shatters into fragments that fly away\n\nuniform shader _from;\nuniform shader _to;\nuniform float2 _resolution;\nuniform float progress;\nuniform float ratio;\n\nvec4 getFromColor(vec2 uv) { return vec4(unpremul(_from.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\nvec4 getToColor(vec2 uv) { return vec4(unpremul(_to.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\n\nfloat random(vec2 par) {\n return fract(sin(dot(par.xy, vec2(12.9898, 78.233))) * 43758.5453);\n}\n\nvec2 random2(vec2 par) {\n float rand = random(par);\n return vec2(rand, random(par + rand));\n}\n\nvec4 transition (vec2 uv) {\n if (progress <= 0.0) return getFromColor(uv);\n if (progress >= 1.0) return getToColor(uv);\n\n const float duration = 8.0;\n float time = progress * duration;\n vec2 point[10];\n for (int i = 0; i < 10; i++) {\n point[i] = random2(vec2(float(i)));\n }\n\n vec4 col = getToColor(uv);\n\n for (int i = 0; i < 10; i++) {\n vec2 dir = normalize(random2(vec2(float(i), float(i) + 11.)));\n float v = (1.0 + random(dir) * 0.5) * 0.2;\n vec2 ofst = dir * clamp(time - 0.5, 0.0, duration) * v;\n vec2 U = uv - ofst;\n\n if (U.x < 0.0 || U.x > 1.0 || U.y < 0.0 || U.y > 1.0) continue;\n\n float dist_i = distance(U, point[i]);\n bool closest = true;\n for (int j = 0; j < 10; j++) {\n if (distance(U, point[j]) < dist_i) {\n closest = false;\n break;\n }\n }\n\n if (closest) {\n col = getFromColor(U);\n break;\n }\n }\n return col;\n}\n\nhalf4 main(float2 _coord) {\n vec2 _uv = _coord / _resolution;\n vec4 _c = clamp(transition(vec2(_uv.x, 1.0 - _uv.y)), 0.0, 1.0);\n return half4(_c.rgb * _c.a, _c.a);\n}\n","heart":"// heart — generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/heart.glsl\n// Author: gre\n// License: MIT\n// Description: A heart shape grows from the center to reveal the incoming image\n\nuniform shader _from;\nuniform shader _to;\nuniform float2 _resolution;\nuniform float progress;\nuniform float ratio;\n\nvec4 getFromColor(vec2 uv) { return vec4(unpremul(_from.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\nvec4 getToColor(vec2 uv) { return vec4(unpremul(_to.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\n\nfloat inHeart (vec2 p, vec2 center, float size) {\n if (size==0.0) return 0.0;\n vec2 o = (p-center)/(1.6*size);\n float a = o.x*o.x+o.y*o.y-0.3;\n return step(a*a*a, o.x*o.x*o.y*o.y*o.y);\n}\nvec4 transition (vec2 uv) {\n return mix(\n getFromColor(uv),\n getToColor(uv),\n inHeart(uv, vec2(0.5, 0.4), progress)\n );\n}\n\nhalf4 main(float2 _coord) {\n vec2 _uv = _coord / _resolution;\n vec4 _c = clamp(transition(vec2(_uv.x, 1.0 - _uv.y)), 0.0, 1.0);\n return half4(_c.rgb * _c.a, _c.a);\n}\n","hexagonalize":"// hexagonalize — generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/hexagonalize.glsl\n// Author: Fernando Kuteken\n// License: MIT\n// Description: Both images turn into hexagons, crossfade, then sharpen again\n\nuniform shader _from;\nuniform shader _to;\nuniform float2 _resolution;\nuniform float progress;\nuniform float ratio;\n\nvec4 getFromColor(vec2 uv) { return vec4(unpremul(_from.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\nvec4 getToColor(vec2 uv) { return vec4(unpremul(_to.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\n\nuniform int steps; \n\nuniform float horizontalHexagons; \n\nstruct Hexagon {\n float q;\n float r;\n float s;\n};\n\nHexagon createHexagon(float q, float r){\n Hexagon hex;\n hex.q = q;\n hex.r = r;\n hex.s = -q - r;\n return hex;\n}\n\nHexagon roundHexagon(Hexagon hex){\n \n float q = floor(hex.q + 0.5);\n float r = floor(hex.r + 0.5);\n float s = floor(hex.s + 0.5);\n\n float deltaQ = abs(q - hex.q);\n float deltaR = abs(r - hex.r);\n float deltaS = abs(s - hex.s);\n\n if (deltaQ > deltaR && deltaQ > deltaS)\n q = -r - s;\n else if (deltaR > deltaS)\n r = -q - s;\n else\n s = -q - r;\n\n return createHexagon(q, r);\n}\n\nHexagon hexagonFromPoint(vec2 point, float size) {\n \n point.y /= ratio;\n point = (point - 0.5) / size;\n \n float q = (sqrt(3.0) / 3.0) * point.x + (-1.0 / 3.0) * point.y;\n float r = 0.0 * point.x + 2.0 / 3.0 * point.y;\n\n Hexagon hex = createHexagon(q, r);\n return roundHexagon(hex);\n \n}\n\nvec2 pointFromHexagon(Hexagon hex, float size) {\n \n float x = (sqrt(3.0) * hex.q + (sqrt(3.0) / 2.0) * hex.r) * size + 0.5;\n float y = (0.0 * hex.q + (3.0 / 2.0) * hex.r) * size + 0.5;\n \n return vec2(x, y * ratio);\n}\n\nvec4 transition (vec2 uv) {\n \n float dist = 2.0 * min(progress, 1.0 - progress);\n dist = steps > 0 ? ceil(dist * float(steps)) / float(steps) : dist;\n \n float size = (sqrt(3.0) / 3.0) * dist / horizontalHexagons;\n \n vec2 point = dist > 0.0 ? pointFromHexagon(hexagonFromPoint(uv, size), size) : uv;\n\n return mix(getFromColor(point), getToColor(point), progress);\n \n}\n\nhalf4 main(float2 _coord) {\n vec2 _uv = _coord / _resolution;\n vec4 _c = clamp(transition(vec2(_uv.x, 1.0 - _uv.y)), 0.0, 1.0);\n return half4(_c.rgb * _c.a, _c.a);\n}\n","kaleidoscope":"// kaleidoscope — generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/kaleidoscope.glsl\n// Author: nwoeanhinnogaehr\n// License: MIT\n// Description: A crossfade through a spinning kaleidoscope\n\nuniform shader _from;\nuniform shader _to;\nuniform float2 _resolution;\nuniform float progress;\nuniform float ratio;\n\nvec4 getFromColor(vec2 uv) { return vec4(unpremul(_from.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\nvec4 getToColor(vec2 uv) { return vec4(unpremul(_to.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\n\nuniform float speed; \nuniform float angle; \nuniform float power; \n\nvec4 transition(vec2 uv) {\n vec2 p = uv.xy / vec2(1.0).xy;\n vec2 q = p;\n float t = pow(progress, power)*speed;\n p = p -0.5;\n for (int i = 0; i < 7; i++) {\n p = vec2(sin(t)*p.x + cos(t)*p.y, sin(t)*p.y - cos(t)*p.x);\n t += angle;\n p = abs(mod(p, 2.0) - 1.0);\n }\n abs(mod(p, 1.0));\n return mix(\n mix(getFromColor(q), getToColor(q), progress),\n mix(getFromColor(p), getToColor(p), progress), 1.0 - 2.0*abs(progress - 0.5));\n}\n\nhalf4 main(float2 _coord) {\n vec2 _uv = _coord / _resolution;\n vec4 _c = clamp(transition(vec2(_uv.x, 1.0 - _uv.y)), 0.0, 1.0);\n return half4(_c.rgb * _c.a, _c.a);\n}\n","luma":"// luma — generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/luma.glsl\n// Author: gre\n// License: MIT\n// Description: A wipe that follows the brightness of a grayscale mask (the luma texture)\n\nuniform shader _from;\nuniform shader _to;\nuniform float2 _resolution;\nuniform float progress;\nuniform float ratio;\n\nvec4 getFromColor(vec2 uv) { return vec4(unpremul(_from.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\nvec4 getToColor(vec2 uv) { return vec4(unpremul(_to.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\n\nuniform shader luma;\nvec4 _texture_luma(vec2 uv) { return vec4(unpremul(luma.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\n\nvec4 transition(vec2 uv) {\n return mix(\n getToColor(uv),\n getFromColor(uv),\n step(progress, _texture_luma( uv).r)\n );\n}\n\nhalf4 main(float2 _coord) {\n vec2 _uv = _coord / _resolution;\n vec4 _c = clamp(transition(vec2(_uv.x, 1.0 - _uv.y)), 0.0, 1.0);\n return half4(_c.rgb * _c.a, _c.a);\n}\n","luminance_melt":"// luminance_melt — generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/luminance_melt.glsl\n// Author: 0gust1\n// License: MIT\n// Description: The outgoing image melts away in noisy vertical streaks, depending on its brightness\n\nuniform shader _from;\nuniform shader _to;\nuniform float2 _resolution;\nuniform float progress;\nuniform float ratio;\n\nvec4 getFromColor(vec2 uv) { return vec4(unpremul(_from.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\nvec4 getToColor(vec2 uv) { return vec4(unpremul(_to.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\n\nuniform int direction; \n\nuniform float l_threshold; \n\nuniform int above; \n\nfloat rand(vec2 co){\n return fract(sin(dot(co.xy ,vec2(12.9898,78.233))) * 43758.5453);\n}\n\nvec3 mod289(vec3 x) {\n return x - floor(x * (1.0 / 289.0)) * 289.0;\n}\n\nvec2 mod289(vec2 x) {\n return x - floor(x * (1.0 / 289.0)) * 289.0;\n}\n\nvec3 permute(vec3 x) {\n return mod289(((x*34.0)+1.0)*x);\n}\n\nfloat snoise(vec2 v)\n {\n const vec4 C = vec4(0.211324865405187, \n 0.366025403784439, \n -0.577350269189626, \n 0.024390243902439); \n\n vec2 i = floor(v + dot(v, C.yy) );\n vec2 x0 = v - i + dot(i, C.xx);\n\n vec2 i1;\n \n \n i1 = (x0.x > x0.y) ? vec2(1.0, 0.0) : vec2(0.0, 1.0);\n \n \n \n vec4 x12 = x0.xyxy + C.xxzz;\n x12.xy -= i1;\n\n i = mod289(i); \n vec3 p = permute( permute( i.y + vec3(0.0, i1.y, 1.0 ))\n\t\t+ i.x + vec3(0.0, i1.x, 1.0 ));\n\n vec3 m = max(0.5 - vec3(dot(x0,x0), dot(x12.xy,x12.xy), dot(x12.zw,x12.zw)), 0.0);\n m = m*m ;\n m = m*m ;\n\n vec3 x = 2.0 * fract(p * C.www) - 1.0;\n vec3 h = abs(x) - 0.5;\n vec3 ox = floor(x + 0.5);\n vec3 a0 = x - ox;\n\n m *= 1.79284291400159 - 0.85373472095314 * ( a0*a0 + h*h );\n\n vec3 g;\n g.x = a0.x * x0.x + h.x * x0.y;\n g.yz = a0.yz * x12.xz + h.yz * x12.yw;\n return 130.0 * dot(m, g);\n}\n\nfloat luminance(vec4 color){\n \n return color.r*0.299+color.g*0.587+color.b*0.114;\n}\n\nvec4 transition(vec2 uv) {\n vec2 center = vec2(1.0, (direction != 0));\n vec2 p = uv.xy / vec2(1.0).xy;\n if (progress == 0.0) {\n return getFromColor(p);\n } else if (progress == 1.0) {\n return getToColor(p);\n } else {\n float x = progress;\n float dist = distance(center, p)- progress*exp(snoise(vec2(p.x, 0.0)));\n float r = x - rand(vec2(p.x, 0.1));\n float m;\n if((above != 0)){\n m = dist <= r && luminance(getFromColor(p))>l_threshold ? 1.0 : (progress*progress*progress);\n }\n else{\n m = dist <= r && luminance(getFromColor(p))<l_threshold ? 1.0 : (progress*progress*progress); \n }\n return mix(getFromColor(p), getToColor(p), m); \n }\n}\n\nhalf4 main(float2 _coord) {\n vec2 _uv = _coord / _resolution;\n vec4 _c = clamp(transition(vec2(_uv.x, 1.0 - _uv.y)), 0.0, 1.0);\n return half4(_c.rgb * _c.a, _c.a);\n}\n","morph":"// morph — generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/morph.glsl\n// Author: paniq\n// License: MIT\n// Description: A crossfade in which each image is displaced by the other's colors, like a morph\n\nuniform shader _from;\nuniform shader _to;\nuniform float2 _resolution;\nuniform float progress;\nuniform float ratio;\n\nvec4 getFromColor(vec2 uv) { return vec4(unpremul(_from.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\nvec4 getToColor(vec2 uv) { return vec4(unpremul(_to.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\n\nuniform float strength; \n\nvec4 transition(vec2 p) {\n vec4 ca = getFromColor(p);\n vec4 cb = getToColor(p);\n \n vec2 oa = (((ca.rg+ca.b)*0.5)*2.0-1.0);\n vec2 ob = (((cb.rg+cb.b)*0.5)*2.0-1.0);\n vec2 oc = mix(oa,ob,0.5)*strength;\n \n float w0 = progress;\n float w1 = 1.0-w0;\n return mix(getFromColor(p+oc*w0), getToColor(p-oc*w1), progress);\n}\n\nhalf4 main(float2 _coord) {\n vec2 _uv = _coord / _resolution;\n vec4 _c = clamp(transition(vec2(_uv.x, 1.0 - _uv.y)), 0.0, 1.0);\n return half4(_c.rgb * _c.a, _c.a);\n}\n","mosaic_transition":"// mosaic_transition — generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/mosaic_transition.glsl\n// Author: YueDev\n// License: MIT\n// Description: Both images break into mosaic blocks that blend, then sharpen into the incoming image\n\nuniform shader _from;\nuniform shader _to;\nuniform float2 _resolution;\nuniform float progress;\nuniform float ratio;\n\nvec4 getFromColor(vec2 uv) { return vec4(unpremul(_from.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\nvec4 getToColor(vec2 uv) { return vec4(unpremul(_to.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\n\nuniform float mosaicNum;\n\nvec2 getMosaicUV(vec2 uv) {\n float mosaicWidth = 2.0 / mosaicNum * min(progress, 1.0 - progress);\n float mX = floor(uv.x / mosaicWidth) + 0.5;\n float mY = floor(uv.y / mosaicWidth) + 0.5;\n return vec2(mX * mosaicWidth, mY * mosaicWidth);\n}\n\nvec4 transition (vec2 uv) {\n vec2 mosaicUV = min(progress, 1.0 - progress) == 0.0 ? uv : getMosaicUV(uv);\n return mix(getFromColor(mosaicUV), getToColor(mosaicUV), progress * progress);\n}\n\nhalf4 main(float2 _coord) {\n vec2 _uv = _coord / _resolution;\n vec4 _c = clamp(transition(vec2(_uv.x, 1.0 - _uv.y)), 0.0, 1.0);\n return half4(_c.rgb * _c.a, _c.a);\n}\n","multiply_blend":"// multiply_blend — generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/multiply_blend.glsl\n// Author: Fernando Kuteken\n// License: MIT\n// Description: A crossfade through the multiplied blend of both images\n\nuniform shader _from;\nuniform shader _to;\nuniform float2 _resolution;\nuniform float progress;\nuniform float ratio;\n\nvec4 getFromColor(vec2 uv) { return vec4(unpremul(_from.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\nvec4 getToColor(vec2 uv) { return vec4(unpremul(_to.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\n\nvec4 blend(vec4 a, vec4 b) {\n return a * b;\n}\n\nvec4 transition (vec2 uv) {\n \n vec4 blended = blend(getFromColor(uv), getToColor(uv));\n \n if (progress < 0.5)\n return mix(getFromColor(uv), blended, 2.0 * progress);\n else\n return mix(blended, getToColor(uv), 2.0 * progress - 1.0);\n}\n\nhalf4 main(float2 _coord) {\n vec2 _uv = _coord / _resolution;\n vec4 _c = clamp(transition(vec2(_uv.x, 1.0 - _uv.y)), 0.0, 1.0);\n return half4(_c.rgb * _c.a, _c.a);\n}\n","old_tv_lost_signal":"// old_tv_lost_signal — generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/old_tv_lost_signal.glsl\n// Author: mernking (gitlab.com/Godswork)\n// License: MIT\n// Description: A crossfade with drifting tracking lines and tearing, like a TV losing its signal\n\nuniform shader _from;\nuniform shader _to;\nuniform float2 _resolution;\nuniform float progress;\nuniform float ratio;\n\nvec4 getFromColor(vec2 uv) { return vec4(unpremul(_from.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\nvec4 getToColor(vec2 uv) { return vec4(unpremul(_to.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\n\nfloat hash(vec2 p) {\n return fract(sin(dot(p, vec2(127.1, 311.7))) * 43758.5453);\n}\n\nvec4 transition(vec2 uv) {\n\n float p = progress;\n float strength = sin(p * 3.14159265);\n\n vec2 tv = uv;\n\n vec4 fromColor = getFromColor(tv);\n vec4 toColor = getToColor(tv);\n\n vec4 color = mix(fromColor, toColor, p);\n\n \n float lineY = floor(tv.y * 120.0);\n\n float noise = hash(vec2(lineY, p * 20.0));\n\n float line = step(0.92, noise);\n\n \n float drift =\n sin(tv.y * 30.0 + p * 10.0)\n * 0.02\n * strength;\n\n vec4 shiftedFrom = getFromColor(tv + vec2(drift, 0.0));\n vec4 shiftedTo = getToColor(tv + vec2(drift, 0.0));\n\n vec4 lineColor = mix(shiftedFrom, shiftedTo, p);\n\n \n color = mix(color, lineColor, line * strength);\n\n \n float scan =\n sin(tv.y * 900.0) * 0.03;\n\n color.rgb -= scan * strength;\n\n return color;\n}\n\nhalf4 main(float2 _coord) {\n vec2 _uv = _coord / _resolution;\n vec4 _c = clamp(transition(vec2(_uv.x, 1.0 - _uv.y)), 0.0, 1.0);\n return half4(_c.rgb * _c.a, _c.a);\n}\n","parametric_glitch":"// parametric_glitch — generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/parametric_glitch.glsl\n// Author: Yoni Maltsman @friendlyspinach\n// License: MIT\n// Description: A crossfade with glitchy horizontal bands and color shifts\n\nuniform shader _from;\nuniform shader _to;\nuniform float2 _resolution;\nuniform float progress;\nuniform float ratio;\n\nvec4 getFromColor(vec2 uv) { return vec4(unpremul(_from.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\nvec4 getToColor(vec2 uv) { return vec4(unpremul(_to.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\n\nuniform float ampx; \n\nuniform float ampy; \n\nvec4 transition (vec2 uv) {\n vec4 from = getFromColor(uv);\n vec4 to = getToColor(uv);\n float r = from.r;\n float g = from.g;\n float b = from.b;\n float sphere = r*r + g*g + b*b - 1.0; \n float spiralX = cos(sphere - uv.x/(progress + .01));\n float spiralY = sin(sphere - uv.y/(progress+.01));\n vec2 st = uv;\n st.x = fract(ampx*st.x*spiralX); \n st.y = fract(ampy*st.y*spiralY);\n vec2 diff = uv - st;\n from = getFromColor(uv + progress*diff);\n return mix(from, to, progress);\n}\n\nhalf4 main(float2 _coord) {\n vec2 _uv = _coord / _resolution;\n vec4 _c = clamp(transition(vec2(_uv.x, 1.0 - _uv.y)), 0.0, 1.0);\n return half4(_c.rgb * _c.a, _c.a);\n}\n","perlin":"// perlin — generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/perlin.glsl\n// Author: Rich Harris\n// License: MIT\n// Description: The incoming image appears through blobs of Perlin noise\n\nuniform shader _from;\nuniform shader _to;\nuniform float2 _resolution;\nuniform float progress;\nuniform float ratio;\n\nvec4 getFromColor(vec2 uv) { return vec4(unpremul(_from.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\nvec4 getToColor(vec2 uv) { return vec4(unpremul(_to.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\n\nuniform float scale; \n\nuniform float smoothness; \n\nuniform float seed; \n\nfloat random(vec2 co)\n{\n float a = seed;\n float b = 78.233;\n float c = 43758.5453;\n float dt= dot(co.xy ,vec2(a,b));\n float sn= mod(dt,3.14);\n return fract(sin(sn) * c);\n}\n\nfloat noise (in vec2 st) {\n vec2 i = floor(st);\n vec2 f = fract(st);\n\n \n float a = random(i);\n float b = random(i + vec2(1.0, 0.0));\n float c = random(i + vec2(0.0, 1.0));\n float d = random(i + vec2(1.0, 1.0));\n\n \n\n \n vec2 u = f*f*(3.0-2.0*f);\n \n\n \n return mix(a, b, u.x) +\n (c - a)* u.y * (1.0 - u.x) +\n (d - b) * u.x * u.y;\n}\n\nvec4 transition (vec2 uv) {\n vec4 from = getFromColor(uv);\n vec4 to = getToColor(uv);\n float n = noise(uv * scale);\n\n float p = mix(-smoothness, 1.0 + smoothness, progress);\n float lower = p - smoothness;\n float higher = p + smoothness;\n\n float q = smoothstep(lower, higher, n);\n\n return mix(\n from,\n to,\n 1.0 - q\n );\n}\n\nhalf4 main(float2 _coord) {\n vec2 _uv = _coord / _resolution;\n vec4 _c = clamp(transition(vec2(_uv.x, 1.0 - _uv.y)), 0.0, 1.0);\n return half4(_c.rgb * _c.a, _c.a);\n}\n","pinwheel":"// pinwheel — generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/pinwheel.glsl\n// Author: Mr Speaker\n// License: MIT\n// Description: A spinning pinwheel reveals the incoming image\n\nuniform shader _from;\nuniform shader _to;\nuniform float2 _resolution;\nuniform float progress;\nuniform float ratio;\n\nvec4 getFromColor(vec2 uv) { return vec4(unpremul(_from.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\nvec4 getToColor(vec2 uv) { return vec4(unpremul(_to.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\n\nuniform float speed; \n\nvec4 transition(vec2 uv) {\n \n vec2 p = uv.xy / vec2(1.0).xy;\n \n float circPos = atan(p.y - 0.5, p.x - 0.5) + progress * speed;\n float modPos = mod(circPos, 3.1415 / 4.);\n float signed = sign(progress - modPos);\n \n return mix(getToColor(p), getFromColor(p), step(signed, 0.5));\n \n}\n\nhalf4 main(float2 _coord) {\n vec2 _uv = _coord / _resolution;\n vec4 _c = clamp(transition(vec2(_uv.x, 1.0 - _uv.y)), 0.0, 1.0);\n return half4(_c.rgb * _c.a, _c.a);\n}\n","pixelize":"// pixelize — generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/pixelize.glsl\n// Author: gre\n// License: MIT\n// Description: Both images pixelate, crossfade, then sharpen again\n\nuniform shader _from;\nuniform shader _to;\nuniform float2 _resolution;\nuniform float progress;\nuniform float ratio;\n\nvec4 getFromColor(vec2 uv) { return vec4(unpremul(_from.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\nvec4 getToColor(vec2 uv) { return vec4(unpremul(_to.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\n\nuniform ivec2 squaresMin; \n\nuniform int steps; \n\nvec4 transition(vec2 uv) {\n float d = min(progress, 1.0 - progress);\n float dist = steps>0 ? ceil(d * float(steps)) / float(steps) : d;\n vec2 squareSize = 2.0 * dist / vec2(squaresMin);\n vec2 p = dist>0.0 ? (floor(uv / squareSize) + 0.5) * squareSize : uv;\n return mix(getFromColor(p), getToColor(p), progress);\n}\n\nhalf4 main(float2 _coord) {\n vec2 _uv = _coord / _resolution;\n vec4 _c = clamp(transition(vec2(_uv.x, 1.0 - _uv.y)), 0.0, 1.0);\n return half4(_c.rgb * _c.a, _c.a);\n}\n","polar_function":"// polar_function — generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/polar_function.glsl\n// Author: Fernando Kuteken\n// License: MIT\n// Description: A flower shape with several petals grows to reveal the incoming image\n\nuniform shader _from;\nuniform shader _to;\nuniform float2 _resolution;\nuniform float progress;\nuniform float ratio;\n\nvec4 getFromColor(vec2 uv) { return vec4(unpremul(_from.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\nvec4 getToColor(vec2 uv) { return vec4(unpremul(_to.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\n\nuniform int segments; \n\nvec4 transition (vec2 uv) {\n \n float angle = atan(uv.y - 0.5, uv.x - 0.5) - 0.5 * 3.14159265359;\n float normalized = (angle + 1.5 * 3.14159265359) * (2.0 * 3.14159265359);\n \n float radius = (cos(float(segments) * angle) + 4.0) / 4.0;\n float difference = length(uv - vec2(0.5, 0.5));\n \n if (difference > radius * progress)\n return getFromColor(uv);\n else\n return getToColor(uv);\n}\n\nhalf4 main(float2 _coord) {\n vec2 _uv = _coord / _resolution;\n vec4 _c = clamp(transition(vec2(_uv.x, 1.0 - _uv.y)), 0.0, 1.0);\n return half4(_c.rgb * _c.a, _c.a);\n}\n","powerKaleido":"// powerKaleido — generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/powerKaleido.glsl\n// Author: Boundless\n// License: MIT\n// Description: The image folds into an animated kaleidoscope before revealing the incoming one\n\nuniform shader _from;\nuniform shader _to;\nuniform float2 _resolution;\nuniform float progress;\nuniform float ratio;\n\nvec4 getFromColor(vec2 uv) { return vec4(unpremul(_from.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\nvec4 getToColor(vec2 uv) { return vec4(unpremul(_to.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\n\nconst float rad = 120.; \nconst float deg = rad / 180. * 3.14159265358979;\nuniform float scale; \nuniform float z; \nuniform float speed; \nvec2 refl(vec2 p,vec2 o,vec2 n)\n{\n\treturn 2.0*o+2.0*n*dot(p-o,n)-p;\n}\n\nvec2 rot(vec2 p, vec2 o, float a)\n{\n float s = sin(a);\n float c = cos(a);\n\treturn o + mat2(c, -s, s, c) * (p - o);\n}\n\nvec4 mainImage(vec2 uv)\n{\n float dist = scale / 10.;\n vec2 uv0 = uv;\n\tuv -= 0.5;\n uv.x *= ratio;\n uv *= z;\n uv = rot(uv, vec2(0.0), progress*speed);\n \n\tfloat theta = progress*6.+3.14159265358979/.5;\n\tfor(int iter = 0; iter < 10; iter++) {\n for(float i = 0.; i < 2. * 3.14159265358979; i+=deg) {\n\t float ts = sign(asin(cos(i))) == 1.0 ? 1.0 : 0.0;\n if(((ts == 1.0) && (uv.y-dist*cos(i) > tan(i)*(uv.x+dist*+sin(i)))) || ((ts == 0.0) && (uv.y-dist*cos(i) < tan(i)*(uv.x+dist*+sin(i))))) {\n uv = refl(vec2(uv.x+sin(i)*dist*2.,uv.y-cos(i)*dist*2.), vec2(0.,0.), vec2(cos(i),sin(i)));\n }\n }\n }\n uv += 0.5;\n uv = rot(uv, vec2(0.5), progress*-speed);\n uv -= 0.5;\n uv.x /= ratio;\n uv += 0.5;\n uv = 2.*abs(uv/2.-floor(uv/2.+0.5));\n vec2 uvMix = mix(uv,uv0,cos(progress*3.14159265358979*2.)/2.+0.5);\n vec4 color = mix(getFromColor(uvMix),getToColor(uvMix),cos((progress-1.)*3.14159265358979)/2.+0.5);\n\treturn color;\n \n}\nvec4 transition (vec2 uv) {\n vec4 color = mainImage(uv);\n return color;\n}\n\nhalf4 main(float2 _coord) {\n vec2 _uv = _coord / _resolution;\n vec4 _c = clamp(transition(vec2(_uv.x, 1.0 - _uv.y)), 0.0, 1.0);\n return half4(_c.rgb * _c.a, _c.a);\n}\n","randomNoisex":"// randomNoisex — generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/randomNoisex.glsl\n// Author: towrabbit\n// License: MIT\n// Description: The incoming image appears pixel by pixel in random noise\n\nuniform shader _from;\nuniform shader _to;\nuniform float2 _resolution;\nuniform float progress;\nuniform float ratio;\n\nvec4 getFromColor(vec2 uv) { return vec4(unpremul(_from.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\nvec4 getToColor(vec2 uv) { return vec4(unpremul(_to.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\n\nfloat random (vec2 st) {\n return fract(sin(dot(st.xy,vec2(12.9898,78.233)))*43758.5453123);\n}\nvec4 transition (vec2 uv) {\n vec4 leftSide = getFromColor(uv);\n vec4 rightSide = getToColor(uv);\n float uvz = floor(random(uv)+progress);\n return mix(leftSide,rightSide,uvz);\n}\n\nhalf4 main(float2 _coord) {\n vec2 _uv = _coord / _resolution;\n vec4 _c = clamp(transition(vec2(_uv.x, 1.0 - _uv.y)), 0.0, 1.0);\n return half4(_c.rgb * _c.a, _c.a);\n}\n","randomsquares":"// randomsquares — generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/randomsquares.glsl\n// Author: gre\n// License: MIT\n// Description: The incoming image appears in random squares\n\nuniform shader _from;\nuniform shader _to;\nuniform float2 _resolution;\nuniform float progress;\nuniform float ratio;\n\nvec4 getFromColor(vec2 uv) { return vec4(unpremul(_from.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\nvec4 getToColor(vec2 uv) { return vec4(unpremul(_to.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\n\nuniform ivec2 size; \n\nuniform float smoothness; \n \nfloat rand (vec2 co) {\n return fract(sin(dot(co.xy ,vec2(12.9898,78.233))) * 43758.5453);\n}\n\nvec4 transition(vec2 p) {\n float r = rand(floor(vec2(size) * p));\n float m = smoothstep(0.0, -smoothness, r - (progress * (1.0 + smoothness)));\n return mix(getFromColor(p), getToColor(p), m);\n}\n\nhalf4 main(float2 _coord) {\n vec2 _uv = _coord / _resolution;\n vec4 _c = clamp(transition(vec2(_uv.x, 1.0 - _uv.y)), 0.0, 1.0);\n return half4(_c.rgb * _c.a, _c.a);\n}\n","ripple":"// ripple — generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/ripple.glsl\n// Author: gre\n// License: MIT\n// Description: Ripples spread from the center while crossfading\n\nuniform shader _from;\nuniform shader _to;\nuniform float2 _resolution;\nuniform float progress;\nuniform float ratio;\n\nvec4 getFromColor(vec2 uv) { return vec4(unpremul(_from.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\nvec4 getToColor(vec2 uv) { return vec4(unpremul(_to.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\n\nuniform float amplitude; \n\nuniform float speed; \n\nvec4 transition (vec2 uv) {\n vec2 dir = uv - vec2(.5);\n float dist = length(dir);\n vec2 offset = dir * (sin(progress * dist * amplitude - progress * speed) + .5) / 30. * progress;\n return mix(\n getFromColor(uv + offset),\n getToColor(uv),\n smoothstep(0.2, 1.0, progress)\n );\n}\n\nhalf4 main(float2 _coord) {\n vec2 _uv = _coord / _resolution;\n vec4 _c = clamp(transition(vec2(_uv.x, 1.0 - _uv.y)), 0.0, 1.0);\n return half4(_c.rgb * _c.a, _c.a);\n}\n","rotateTransition":"// rotateTransition — generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/rotateTransition.glsl\n// Author: haiyoucuv\n// License: MIT\n// Description: The images spin around the center while crossfading\n\nuniform shader _from;\nuniform shader _to;\nuniform float2 _resolution;\nuniform float progress;\nuniform float ratio;\n\nvec4 getFromColor(vec2 uv) { return vec4(unpremul(_from.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\nvec4 getToColor(vec2 uv) { return vec4(unpremul(_to.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\n\nvec2 rotate2D(in vec2 uv, in float angle){\n \n return uv * mat2(cos(angle), -sin(angle), sin(angle), cos(angle));\n}\nvec4 transition (vec2 uv) {\n \n vec2 p = fract(rotate2D(uv - 0.5, progress * 3.1415926 * 2.0) + 0.5);\n\n return mix(\n getFromColor(p),\n getToColor(p),\n progress\n );\n}\n\nhalf4 main(float2 _coord) {\n vec2 _uv = _coord / _resolution;\n vec4 _c = clamp(transition(vec2(_uv.x, 1.0 - _uv.y)), 0.0, 1.0);\n return half4(_c.rgb * _c.a, _c.a);\n}\n","rotate_scale_fade":"// rotate_scale_fade — generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/rotate_scale_fade.glsl\n// Author: Fernando Kuteken\n// License: MIT\n// Description: The outgoing image spins and zooms while fading to the incoming one, over a background color\n\nuniform shader _from;\nuniform shader _to;\nuniform float2 _resolution;\nuniform float progress;\nuniform float ratio;\n\nvec4 getFromColor(vec2 uv) { return vec4(unpremul(_from.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\nvec4 getToColor(vec2 uv) { return vec4(unpremul(_to.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\n\nuniform vec2 center; \n\nuniform float rotations; \n\nuniform float scale; \n\nuniform vec4 backColor; \n\nvec4 transition (vec2 uv) {\n \n vec2 difference = uv - center;\n vec2 dir = normalize(difference);\n float dist = length(difference);\n \n float angle = 2.0 * 3.14159265359 * rotations * progress;\n \n float c = cos(angle);\n float s = sin(angle);\n \n float currentScale = mix(scale, 1.0, 2.0 * abs(progress - 0.5));\n \n vec2 rotatedDir = vec2(dir.x * c - dir.y * s, dir.x * s + dir.y * c);\n vec2 rotatedUv = center + rotatedDir * dist / currentScale;\n \n if (rotatedUv.x < 0.0 || rotatedUv.x > 1.0 ||\n rotatedUv.y < 0.0 || rotatedUv.y > 1.0)\n return backColor;\n \n return mix(getFromColor(rotatedUv), getToColor(rotatedUv), progress);\n}\n\nhalf4 main(float2 _coord) {\n vec2 _uv = _coord / _resolution;\n vec4 _c = clamp(transition(vec2(_uv.x, 1.0 - _uv.y)), 0.0, 1.0);\n return half4(_c.rgb * _c.a, _c.a);\n}\n","scale-in":"// scale-in — generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/scale-in.glsl\n// Author: haiyoucuv\n// License: MIT\n// Description: The incoming image scales in from the center while fading in\n\nuniform shader _from;\nuniform shader _to;\nuniform float2 _resolution;\nuniform float progress;\nuniform float ratio;\n\nvec4 getFromColor(vec2 uv) { return vec4(unpremul(_from.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\nvec4 getToColor(vec2 uv) { return vec4(unpremul(_to.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\n\nvec4 scale(in vec2 uv){\n uv = 0.5 + (uv - 0.5) * progress;\n return getToColor(uv);\n}\n\nvec4 transition (vec2 uv) {\n return mix(\n getFromColor(uv),\n scale(uv),\n progress\n );\n}\n\nhalf4 main(float2 _coord) {\n vec2 _uv = _coord / _resolution;\n vec4 _c = clamp(transition(vec2(_uv.x, 1.0 - _uv.y)), 0.0, 1.0);\n return half4(_c.rgb * _c.a, _c.a);\n}\n","splitSlideInHorizontal":"// splitSlideInHorizontal — generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/splitSlideInHorizontal.glsl\n// Author: OllyOllyOlly\n// License: MIT\n// Description: The incoming image slides in as two halves moving horizontally in opposite directions\n\nuniform shader _from;\nuniform shader _to;\nuniform float2 _resolution;\nuniform float progress;\nuniform float ratio;\n\nvec4 getFromColor(vec2 uv) { return vec4(unpremul(_from.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\nvec4 getToColor(vec2 uv) { return vec4(unpremul(_to.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\n\nuniform int reverse; \n\nconst vec2 boundMin = vec2(0.0, 0.0);\nconst vec2 boundMax = vec2(1.0, 1.0);\n\nbool inBounds (vec2 p) {\n return all(lessThan(boundMin, p)) && all(lessThan(p, boundMax));\n}\n\nvec4 transition (vec2 uv) {\n float modifier = (reverse != 0) ? -1.0 : 1.0;\n vec2 toP = (uv.y > 0.5) ?\n vec2((uv.x - (progress * modifier)) + modifier, uv.y) :\n vec2((uv.x + (progress * modifier)) - modifier, uv.y);\n\n vec2 fromP = uv;\n\n return inBounds(toP) ? getToColor(toP) : getFromColor(fromP);\n}\n\nhalf4 main(float2 _coord) {\n vec2 _uv = _coord / _resolution;\n vec4 _c = clamp(transition(vec2(_uv.x, 1.0 - _uv.y)), 0.0, 1.0);\n return half4(_c.rgb * _c.a, _c.a);\n}\n","splitSlideInOutHorizontal":"// splitSlideInOutHorizontal — generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/splitSlideInOutHorizontal.glsl\n// Author: OllyOllyOlly\n// License: MIT\n// Description: The halves of both images slide horizontally in opposite directions, out and in at once\n\nuniform shader _from;\nuniform shader _to;\nuniform float2 _resolution;\nuniform float progress;\nuniform float ratio;\n\nvec4 getFromColor(vec2 uv) { return vec4(unpremul(_from.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\nvec4 getToColor(vec2 uv) { return vec4(unpremul(_to.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\n\nuniform int reverse; \n\nconst vec2 boundMin = vec2(0.0, 0.0);\nconst vec2 boundMax = vec2(1.0, 1.0);\n\nbool inBounds (vec2 p) {\n return all(lessThan(boundMin, p)) && all(lessThan(p, boundMax));\n}\n\nvec4 transition (vec2 uv) {\n float modifier = (uv.y > 0.5 ? 1.0 : -1.0) * ((reverse != 0) ? -1.0 : 1.0) ;\n vec2 fromP = vec2(uv.x + (progress * modifier), uv.y);\n vec2 toP = vec2((uv.x + (progress * modifier)) - modifier, uv.y);\n\n return inBounds(fromP) ? getFromColor(fromP) : getToColor(toP);\n}\n\nhalf4 main(float2 _coord) {\n vec2 _uv = _coord / _resolution;\n vec4 _c = clamp(transition(vec2(_uv.x, 1.0 - _uv.y)), 0.0, 1.0);\n return half4(_c.rgb * _c.a, _c.a);\n}\n","splitSlideInOutVertical":"// splitSlideInOutVertical — generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/splitSlideInOutVertical.glsl\n// Author: OllyOllyOlly\n// License: MIT\n// Description: The halves of both images slide vertically in opposite directions, out and in at once\n\nuniform shader _from;\nuniform shader _to;\nuniform float2 _resolution;\nuniform float progress;\nuniform float ratio;\n\nvec4 getFromColor(vec2 uv) { return vec4(unpremul(_from.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\nvec4 getToColor(vec2 uv) { return vec4(unpremul(_to.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\n\nuniform int reverse; \n\nconst vec2 boundMin = vec2(0.0, 0.0);\nconst vec2 boundMax = vec2(1.0, 1.0);\n\nbool inBounds (vec2 p) {\n return all(lessThan(boundMin, p)) && all(lessThan(p, boundMax));\n}\n\nvec4 transition (vec2 uv) {\n float modifier = (uv.x > 0.5 ? 1.0 : -1.0) * ((reverse != 0) ? -1.0 : 1.0) ;\n vec2 fromP = vec2(uv.x, uv.y + (progress * modifier));\n vec2 toP = vec2(uv.x, (uv.y + (progress * modifier)) - modifier);\n\n return inBounds(fromP) ? getFromColor(fromP) : getToColor(toP);\n}\n\nhalf4 main(float2 _coord) {\n vec2 _uv = _coord / _resolution;\n vec4 _c = clamp(transition(vec2(_uv.x, 1.0 - _uv.y)), 0.0, 1.0);\n return half4(_c.rgb * _c.a, _c.a);\n}\n","splitSlideInVertical":"// splitSlideInVertical — generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/splitSlideInVertical.glsl\n// Author: OllyOllyOlly\n// License: MIT\n// Description: The incoming image slides in as two halves moving vertically in opposite directions\n\nuniform shader _from;\nuniform shader _to;\nuniform float2 _resolution;\nuniform float progress;\nuniform float ratio;\n\nvec4 getFromColor(vec2 uv) { return vec4(unpremul(_from.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\nvec4 getToColor(vec2 uv) { return vec4(unpremul(_to.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\n\nuniform int reverse; \n\nconst vec2 boundMin = vec2(0.0, 0.0);\nconst vec2 boundMax = vec2(1.0, 1.0);\n\nbool inBounds (vec2 p) {\n return all(lessThan(boundMin, p)) && all(lessThan(p, boundMax));\n}\n\nvec4 transition (vec2 uv) {\n float modifier = (reverse != 0) ? -1.0 : 1.0;\n vec2 p = (uv.x > 0.5) ?\n vec2(uv.x, (uv.y - (progress * modifier)) + modifier) :\n vec2(uv.x, (uv.y + (progress * modifier)) - modifier);\n\n return inBounds(p) ? getToColor(p) : getFromColor(uv);\n}\n\nhalf4 main(float2 _coord) {\n vec2 _uv = _coord / _resolution;\n vec4 _c = clamp(transition(vec2(_uv.x, 1.0 - _uv.y)), 0.0, 1.0);\n return half4(_c.rgb * _c.a, _c.a);\n}\n","splitSlideOutHorizontal":"// splitSlideOutHorizontal — generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/splitSlideOutHorizontal.glsl\n// Author: OllyOllyOlly\n// License: MIT\n// Description: The outgoing image slides out as two halves moving horizontally in opposite directions\n\nuniform shader _from;\nuniform shader _to;\nuniform float2 _resolution;\nuniform float progress;\nuniform float ratio;\n\nvec4 getFromColor(vec2 uv) { return vec4(unpremul(_from.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\nvec4 getToColor(vec2 uv) { return vec4(unpremul(_to.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\n\nuniform int reverse; \n\nconst vec2 boundMin = vec2(0.0, 0.0);\nconst vec2 boundMax = vec2(1.0, 1.0);\n\nbool inBounds (vec2 p) {\n return all(lessThan(boundMin, p)) && all(lessThan(p, boundMax));\n}\n\nvec4 transition (vec2 uv) {\n float modifier = (uv.y > 0.5 ? 1.0 : -1.0) * ((reverse != 0) ? -1.0 : 1.0) ;\n vec2 p = vec2(uv.x + (progress * modifier), uv.y);\n\n return inBounds(p) ? getFromColor(p) : getToColor(uv);\n}\n\nhalf4 main(float2 _coord) {\n vec2 _uv = _coord / _resolution;\n vec4 _c = clamp(transition(vec2(_uv.x, 1.0 - _uv.y)), 0.0, 1.0);\n return half4(_c.rgb * _c.a, _c.a);\n}\n","splitSlideOutVertical":"// splitSlideOutVertical — generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/splitSlideOutVertical.glsl\n// Author: OllyOllyOlly\n// License: MIT\n// Description: The outgoing image slides out as two halves moving vertically in opposite directions\n\nuniform shader _from;\nuniform shader _to;\nuniform float2 _resolution;\nuniform float progress;\nuniform float ratio;\n\nvec4 getFromColor(vec2 uv) { return vec4(unpremul(_from.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\nvec4 getToColor(vec2 uv) { return vec4(unpremul(_to.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\n\nuniform int reverse; \n\nconst vec2 boundMin = vec2(0.0, 0.0);\nconst vec2 boundMax = vec2(1.0, 1.0);\n\nbool inBounds (vec2 p) {\n return all(lessThan(boundMin, p)) && all(lessThan(p, boundMax));\n}\n\nvec4 transition (vec2 uv) {\n float modifier = (uv.x > 0.5 ? 1.0 : -1.0) * ((reverse != 0) ? -1.0 : 1.0) ;\n vec2 p = vec2(uv.x, uv.y + (progress * modifier));\n\n return inBounds(p) ? getFromColor(p) : getToColor(uv);\n}\n\nhalf4 main(float2 _coord) {\n vec2 _uv = _coord / _resolution;\n vec4 _c = clamp(transition(vec2(_uv.x, 1.0 - _uv.y)), 0.0, 1.0);\n return half4(_c.rgb * _c.a, _c.a);\n}\n","squareswire":"// squareswire — generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/squareswire.glsl\n// Author: gre\n// License: MIT\n// Description: Squares grow along a diagonal sweep to reveal the incoming image\n\nuniform shader _from;\nuniform shader _to;\nuniform float2 _resolution;\nuniform float progress;\nuniform float ratio;\n\nvec4 getFromColor(vec2 uv) { return vec4(unpremul(_from.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\nvec4 getToColor(vec2 uv) { return vec4(unpremul(_to.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\n\nuniform ivec2 squares;\n\nuniform vec2 direction;\n\nuniform float smoothness; \n\nconst vec2 center = vec2(0.5, 0.5);\nvec4 transition (vec2 p) {\n vec2 v = normalize(direction);\n v /= abs(v.x)+abs(v.y);\n float d = v.x * center.x + v.y * center.y;\n float offset = smoothness;\n float pr = smoothstep(-offset, 0.0, v.x * p.x + v.y * p.y - (d-0.5+progress*(1.+offset)));\n vec2 squarep = fract(p*vec2(squares));\n vec2 squaremin = vec2(pr/2.0);\n vec2 squaremax = vec2(1.0 - pr/2.0);\n float a = (1.0 - step(progress, 0.0)) * step(squaremin.x, squarep.x) * step(squaremin.y, squarep.y) * step(squarep.x, squaremax.x) * step(squarep.y, squaremax.y);\n return mix(getFromColor(p), getToColor(p), a);\n}\n\nhalf4 main(float2 _coord) {\n vec2 _uv = _coord / _resolution;\n vec4 _c = clamp(transition(vec2(_uv.x, 1.0 - _uv.y)), 0.0, 1.0);\n return half4(_c.rgb * _c.a, _c.a);\n}\n","squeeze":"// squeeze — generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/squeeze.glsl\n// Author: gre\n// License: MIT\n// Description: The outgoing image is squeezed into a line with color separation, revealing the incoming one\n\nuniform shader _from;\nuniform shader _to;\nuniform float2 _resolution;\nuniform float progress;\nuniform float ratio;\n\nvec4 getFromColor(vec2 uv) { return vec4(unpremul(_from.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\nvec4 getToColor(vec2 uv) { return vec4(unpremul(_to.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\n\nuniform float colorSeparation; \n \nvec4 transition (vec2 uv) {\n float y = 0.5 + (uv.y-0.5) / (1.0-progress);\n if (y < 0.0 || y > 1.0) {\n return getToColor(uv);\n }\n else {\n vec2 fp = vec2(uv.x, y);\n vec2 off = progress * vec2(0.0, colorSeparation);\n vec4 c = getFromColor(fp);\n vec4 cn = getFromColor(fp - off);\n vec4 cp = getFromColor(fp + off);\n return vec4(cn.r, c.g, cp.b, c.a);\n }\n}\n\nhalf4 main(float2 _coord) {\n vec2 _uv = _coord / _resolution;\n vec4 _c = clamp(transition(vec2(_uv.x, 1.0 - _uv.y)), 0.0, 1.0);\n return half4(_c.rgb * _c.a, _c.a);\n}\n","static_wipe":"// static_wipe — generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/static_wipe.glsl\n// Author: Ben Lucas\n// License: MIT\n// Description: A wipe from top to bottom with a band of TV static at its edge\n\nuniform shader _from;\nuniform shader _to;\nuniform float2 _resolution;\nuniform float progress;\nuniform float ratio;\n\nvec4 getFromColor(vec2 uv) { return vec4(unpremul(_from.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\nvec4 getToColor(vec2 uv) { return vec4(unpremul(_to.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\n\nfloat rnd (vec2 st) {\n return fract(sin(dot(st.xy,\n vec2(10,70)))*\n 12345.5453123);\n}\n\nuniform int u_transitionUpToDown; \n\nuniform float u_max_static_span; \n\nvec4 transition (vec2 uv) {\n \n\n float span = u_max_static_span*pow(sin(3.14159265359*progress),0.5);\n \n float transitionEdge = (u_transitionUpToDown != 0) ? 1.0-uv.y : uv.y;\n float mixRatio = 1.0 - step(progress, transitionEdge);\n\n vec4 transitionMix = mix(\n getFromColor(uv),\n getToColor(uv),\n mixRatio\n );\n \n float noiseEnvelope = smoothstep(progress-span, progress, transitionEdge) * (1.0 - smoothstep(progress, progress + span, transitionEdge));\n vec4 noise = vec4(vec3(rnd(uv*(1.0+progress))), 1.0);\n \n\n return mix(transitionMix, noise, noiseEnvelope);\n}\n\nhalf4 main(float2 _coord) {\n vec2 _uv = _coord / _resolution;\n vec4 _c = clamp(transition(vec2(_uv.x, 1.0 - _uv.y)), 0.0, 1.0);\n return half4(_c.rgb * _c.a, _c.a);\n}\n","swap":"// swap — generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/swap.glsl\n// Author: gre\n// License: MIT\n// Description: The two images swap places in 3D, with a floor reflection\n\nuniform shader _from;\nuniform shader _to;\nuniform float2 _resolution;\nuniform float progress;\nuniform float ratio;\n\nvec4 getFromColor(vec2 uv) { return vec4(unpremul(_from.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\nvec4 getToColor(vec2 uv) { return vec4(unpremul(_to.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\n\nuniform float reflection; \n\nuniform float perspective; \nuniform float depth; \n \nconst vec4 black = vec4(0.0, 0.0, 0.0, 1.0);\nconst vec2 boundMin = vec2(0.0, 0.0);\nconst vec2 boundMax = vec2(1.0, 1.0);\n \nbool inBounds (vec2 p) {\n return all(lessThan(boundMin, p)) && all(lessThan(p, boundMax));\n}\n \nvec2 project (vec2 p) {\n return p * vec2(1.0, -1.2) + vec2(0.0, -0.02);\n}\n \nvec4 bgColor (vec2 p, vec2 pfr, vec2 pto) {\n vec4 c = black;\n pfr = project(pfr);\n if (inBounds(pfr)) {\n c += mix(black, getFromColor(pfr), reflection * mix(1.0, 0.0, pfr.y));\n }\n pto = project(pto);\n if (inBounds(pto)) {\n c += mix(black, getToColor(pto), reflection * mix(1.0, 0.0, pto.y));\n }\n return c;\n}\n \nvec4 transition(vec2 p) {\n vec2 pfr, pto = vec2(-1.);\n \n float size = mix(1.0, depth, progress);\n float persp = perspective * progress;\n pfr = (p + vec2(-0.0, -0.5)) * vec2(size/(1.0-perspective*progress), size/(1.0-size*persp*p.x)) + vec2(0.0, 0.5);\n \n size = mix(1.0, depth, 1.-progress);\n persp = perspective * (1.-progress);\n pto = (p + vec2(-1.0, -0.5)) * vec2(size/(1.0-perspective*(1.0-progress)), size/(1.0-size*persp*(0.5-p.x))) + vec2(1.0, 0.5);\n\n if (progress < 0.5) {\n if (inBounds(pfr)) {\n return getFromColor(pfr);\n }\n if (inBounds(pto)) {\n return getToColor(pto);\n } \n }\n if (inBounds(pto)) {\n return getToColor(pto);\n }\n if (inBounds(pfr)) {\n return getFromColor(pfr);\n }\n return bgColor(p, pfr, pto);\n}\n\nhalf4 main(float2 _coord) {\n vec2 _uv = _coord / _resolution;\n vec4 _c = clamp(transition(vec2(_uv.x, 1.0 - _uv.y)), 0.0, 1.0);\n return half4(_c.rgb * _c.a, _c.a);\n}\n","tangentMotionBlur":"// tangentMotionBlur — generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/tangentMotionBlur.glsl\n// Author: chenkai\n// License: MIT\n// Description: The outgoing image is flung away along a curve with motion blur\n\nuniform shader _from;\nuniform shader _to;\nuniform float2 _resolution;\nuniform float progress;\nuniform float ratio;\n\nvec4 getFromColor(vec2 uv) { return vec4(unpremul(_from.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\nvec4 getToColor(vec2 uv) { return vec4(unpremul(_to.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\n\nfloat rand (vec2 co) {\n return fract(sin(dot(co.xy ,vec2(12.9898,78.233))) * 43758.5453);\n}\n \n\nvec4 motionBlurFrom(vec2 _st, vec2 speed) {\n vec2 texCoord = _st.xy / vec2(1.0).xy;\n vec3 color = vec3(0.0);\n float total = 0.0;\n float offset = rand(_st);\n for (float t = 0.0; t <= 20.0; t++) {\n float percent = (t + offset) / 20.0;\n float weight = 4.0 * (percent - percent * percent);\n vec2 newuv = texCoord + speed * percent;\n newuv = fract(newuv);\n color += getFromColor(newuv).rgb * weight;\n total += weight;\n }\n return vec4(color / total, 1.0);\n}\n\nvec4 motionBlurTo(vec2 _st, vec2 speed) {\n vec2 texCoord = _st.xy / vec2(1.0).xy;\n vec3 color = vec3(0.0);\n float total = 0.0;\n float offset = rand(_st);\n for (float t = 0.0; t <= 20.0; t++) {\n float percent = (t + offset) / 20.0;\n float weight = 4.0 * (percent - percent * percent);\n vec2 newuv = texCoord + speed * percent;\n newuv = fract(newuv);\n color += getToColor(newuv).rgb * weight;\n total += weight;\n }\n return vec4(color / total, 1.0);\n}\n\nfloat A(float aA1, float aA2) {\n return 1.0 - 3.0 * aA2 + 3.0 * aA1;\n}\nfloat B(float aA1, float aA2) {\n return 3.0 * aA2 - 6.0 * aA1;\n}\nfloat C(float aA1) {\n return 3.0 * aA1;\n}\nfloat GetSlope(float aT, float aA1, float aA2) {\n return 3.0 * A(aA1, aA2)*aT*aT + 2.0 * B(aA1, aA2) * aT + C(aA1);\n}\nfloat CalcBezier(float aT, float aA1, float aA2) {\n return ((A(aA1, aA2)*aT + B(aA1, aA2))*aT + C(aA1))*aT;\n}\nfloat GetTForX(float aX, float mX1, float mX2) {\n \n float aGuessT = aX;\n for (int i = 0; i < 4; ++i) {\n float currentSlope = GetSlope(aGuessT, mX1, mX2);\n if (currentSlope == 0.0) return aGuessT;\n float currentX = CalcBezier(aGuessT, mX1, mX2) - aX;\n aGuessT -= currentX / currentSlope;\n }\n return aGuessT;\n}\nfloat KeySpline(float aX, float mX1, float mY1, float mX2, float mY2) {\n if (mX1 == mY1 && mX2 == mY2) return aX; \n return CalcBezier(GetTForX(aX, mX1, mX2), mY1, mY2); \n}\n\nfloat normpdf(float x) {\n float d = x - .5;\n return exp(-20.*d*d);\n}\n\nvec2 rotateUv(vec2 uv, float angle, vec2 anchor, float zDirection) {\n uv = uv - anchor; \n float s = sin(angle);\n\tfloat c = cos(angle);\n\tmat2 m = mat2(c, -s, s, c);\n uv = m * uv;\n uv += anchor; \n return uv;\n}\n\nvec4 transition (vec2 uv) {\n \n vec2 myst = uv;\n float animationTime = progress; \n float easingTime = KeySpline(animationTime, .68,.01,.17,.98);\n float blur = normpdf(easingTime);\n float r = 0.;\n float rotation = 180./180.*3.14159;\n if (easingTime <= .5) {\n r = rotation * easingTime;\n } else {\n r = -rotation + rotation * easingTime;\n }\n\n \n vec2 mystCurrent = myst;\n mystCurrent.y *= 1./ratio;\n mystCurrent = rotateUv(mystCurrent, r, vec2(1., 0.), -1.);\n mystCurrent.y *= ratio;\n \n \n float timeInterval = 0.0167*2.0;\n if (easingTime <= .5) {\n r = rotation * (easingTime+timeInterval);\n } else {\n r = -rotation + rotation * (easingTime+timeInterval);\n }\n \n \n vec2 mystNext = myst;\n mystNext.y *= 1./ratio;\n mystNext = rotateUv(mystNext, r, vec2(1., 0.), -1.);\n mystNext.y *= ratio;\n \n \n vec2 speed = (mystNext - mystCurrent) / timeInterval * blur * 0.5;\n if (easingTime <= .5) {\n return motionBlurFrom(mystCurrent, speed);\n } else {\n return motionBlurTo(mystCurrent, speed);\n }\n}\n\nhalf4 main(float2 _coord) {\n vec2 _uv = _coord / _resolution;\n vec4 _c = clamp(transition(vec2(_uv.x, 1.0 - _uv.y)), 0.0, 1.0);\n return half4(_c.rgb * _c.a, _c.a);\n}\n","undulatingBurnOut":"// undulatingBurnOut — generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/undulatingBurnOut.glsl\n// Author: pthrasher\n// License: MIT\n// Description: A circle with a wavy edge burns out from the center to reveal the incoming image\n\nuniform shader _from;\nuniform shader _to;\nuniform float2 _resolution;\nuniform float progress;\nuniform float ratio;\n\nvec4 getFromColor(vec2 uv) { return vec4(unpremul(_from.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\nvec4 getToColor(vec2 uv) { return vec4(unpremul(_to.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\n\nuniform float smoothness; \n\nuniform vec2 center; \n\nuniform vec3 color; \n\nconst float M_PI = 3.14159265358979323846;\n\nfloat quadraticInOut(float t) {\n float p = 2.0 * t * t;\n return t < 0.5 ? p : -p + (4.0 * t) - 1.0;\n}\n\nfloat getGradient(float r, float dist) {\n float d = r - dist;\n return mix(\n smoothstep(-smoothness, 0.0, r - dist * (1.0 + smoothness)),\n -1.0 - step(0.005, d),\n step(-0.005, d) * step(d, 0.01)\n );\n}\n\nfloat getWave(vec2 p){\n vec2 _p = p - center; \n float rads = atan(_p.y, _p.x);\n float degs = degrees(rads) + 180.0;\n vec2 range = vec2(0.0, M_PI * 30.0);\n vec2 domain = vec2(0.0, 360.0);\n float ratio = (M_PI * 30.0) / 360.0;\n degs = degs * ratio;\n float x = progress;\n float magnitude = mix(0.02, 0.09, smoothstep(0.0, 1.0, x));\n float offset = mix(40.0, 30.0, smoothstep(0.0, 1.0, x));\n float ease_degs = quadraticInOut(sin(degs));\n float deg_wave_pos = (ease_degs * magnitude) * sin(x * offset);\n \n \n \n return x - max(smoothness, 0.01) * (1.0 - smoothstep(0.0, 0.1, x)) + deg_wave_pos;\n}\n\nvec4 transition(vec2 p) {\n float dist = distance(center, p);\n float m = getGradient(getWave(p), dist);\n vec4 cfrom = getFromColor(p);\n vec4 cto = getToColor(p);\n return mix(mix(cfrom, cto, m), mix(cfrom, vec4(color, 1.0), 0.75), step(m, -2.0));\n}\n\nhalf4 main(float2 _coord) {\n vec2 _uv = _coord / _resolution;\n vec4 _c = clamp(transition(vec2(_uv.x, 1.0 - _uv.y)), 0.0, 1.0);\n return half4(_c.rgb * _c.a, _c.a);\n}\n","wind":"// wind — generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/wind.glsl\n// Author: gre\n// License: MIT\n// Description: A ragged left-to-right wipe, as if the image was blown away by the wind\n\nuniform shader _from;\nuniform shader _to;\nuniform float2 _resolution;\nuniform float progress;\nuniform float ratio;\n\nvec4 getFromColor(vec2 uv) { return vec4(unpremul(_from.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\nvec4 getToColor(vec2 uv) { return vec4(unpremul(_to.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\n\nuniform float size; \n\nuniform int reversed; \n\nfloat rand (vec2 co) {\n return fract(sin(dot(co.xy ,vec2(12.9898,78.233))) * 43758.5453);\n}\n\nvec4 transition (vec2 uv) {\n float x = (reversed != 0) ? 1. - uv.x : uv.x;\n float r = rand(vec2(0, uv.y));\n float m = smoothstep(0.0, -size, x*(1.0-size) + size*r - (progress * (1.0 + size)));\n return mix(\n getFromColor(uv),\n getToColor(uv),\n m\n );\n}\n\nhalf4 main(float2 _coord) {\n vec2 _uv = _coord / _resolution;\n vec4 _c = clamp(transition(vec2(_uv.x, 1.0 - _uv.y)), 0.0, 1.0);\n return half4(_c.rgb * _c.a, _c.a);\n}\n","windowblinds":"// windowblinds — generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/windowblinds.glsl\n// Author: Fabien Benetou\n// License: MIT\n// Description: A crossfade through horizontal window blinds\n\nuniform shader _from;\nuniform shader _to;\nuniform float2 _resolution;\nuniform float progress;\nuniform float ratio;\n\nvec4 getFromColor(vec2 uv) { return vec4(unpremul(_from.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\nvec4 getToColor(vec2 uv) { return vec4(unpremul(_to.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\n\nvec4 transition (vec2 uv) {\n float t = progress;\n \n if (mod(floor(uv.y*100.*progress),2.)==0.)\n t*=2.-.5;\n \n return mix(\n getFromColor(uv),\n getToColor(uv),\n mix(t, progress, smoothstep(0.8, 1.0, progress))\n );\n}\n\nhalf4 main(float2 _coord) {\n vec2 _uv = _coord / _resolution;\n vec4 _c = clamp(transition(vec2(_uv.x, 1.0 - _uv.y)), 0.0, 1.0);\n return half4(_c.rgb * _c.a, _c.a);\n}\n","windowslice":"// windowslice — generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/windowslice.glsl\n// Author: gre\n// License: MIT\n// Description: The incoming image appears through vertical slices that widen\n\nuniform shader _from;\nuniform shader _to;\nuniform float2 _resolution;\nuniform float progress;\nuniform float ratio;\n\nvec4 getFromColor(vec2 uv) { return vec4(unpremul(_from.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\nvec4 getToColor(vec2 uv) { return vec4(unpremul(_to.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\n\nuniform float count; \n\nuniform float smoothness; \n\nvec4 transition (vec2 p) {\n float pr = smoothstep(-smoothness, 0.0, p.x - progress * (1.0 + smoothness));\n float s = step(pr, fract(count * p.x));\n return mix(getFromColor(p), getToColor(p), s);\n}\n\nhalf4 main(float2 _coord) {\n vec2 _uv = _coord / _resolution;\n vec4 _c = clamp(transition(vec2(_uv.x, 1.0 - _uv.y)), 0.0, 1.0);\n return half4(_c.rgb * _c.a, _c.a);\n}\n","wipeDown":"// wipeDown — generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/wipeDown.glsl\n// Author: Jake Nelson\n// License: MIT\n// Description: A hard-edged wipe from top to bottom\n\nuniform shader _from;\nuniform shader _to;\nuniform float2 _resolution;\nuniform float progress;\nuniform float ratio;\n\nvec4 getFromColor(vec2 uv) { return vec4(unpremul(_from.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\nvec4 getToColor(vec2 uv) { return vec4(unpremul(_to.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\n\nvec4 transition(vec2 uv) {\n vec2 p=uv.xy/vec2(1.0).xy;\n vec4 a=getFromColor(p);\n vec4 b=getToColor(p);\n return mix(a, b, step(1.0-p.y,progress));\n}\n\nhalf4 main(float2 _coord) {\n vec2 _uv = _coord / _resolution;\n vec4 _c = clamp(transition(vec2(_uv.x, 1.0 - _uv.y)), 0.0, 1.0);\n return half4(_c.rgb * _c.a, _c.a);\n}\n","wipeLeft":"// wipeLeft — generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/wipeLeft.glsl\n// Author: Jake Nelson\n// License: MIT\n// Description: A hard-edged wipe from right to left\n\nuniform shader _from;\nuniform shader _to;\nuniform float2 _resolution;\nuniform float progress;\nuniform float ratio;\n\nvec4 getFromColor(vec2 uv) { return vec4(unpremul(_from.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\nvec4 getToColor(vec2 uv) { return vec4(unpremul(_to.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\n\nvec4 transition(vec2 uv) {\n vec2 p=uv.xy/vec2(1.0).xy;\n vec4 a=getFromColor(p);\n vec4 b=getToColor(p);\n return mix(a, b, step(1.0-p.x,progress));\n}\n\nhalf4 main(float2 _coord) {\n vec2 _uv = _coord / _resolution;\n vec4 _c = clamp(transition(vec2(_uv.x, 1.0 - _uv.y)), 0.0, 1.0);\n return half4(_c.rgb * _c.a, _c.a);\n}\n","wipeRight":"// wipeRight — generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/wipeRight.glsl\n// Author: Jake Nelson\n// License: MIT\n// Description: A hard-edged wipe from left to right\n\nuniform shader _from;\nuniform shader _to;\nuniform float2 _resolution;\nuniform float progress;\nuniform float ratio;\n\nvec4 getFromColor(vec2 uv) { return vec4(unpremul(_from.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\nvec4 getToColor(vec2 uv) { return vec4(unpremul(_to.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\n\nvec4 transition(vec2 uv) {\n vec2 p=uv.xy/vec2(1.0).xy;\n vec4 a=getFromColor(p);\n vec4 b=getToColor(p);\n return mix(a, b, step(0.0+p.x,progress));\n}\n\nhalf4 main(float2 _coord) {\n vec2 _uv = _coord / _resolution;\n vec4 _c = clamp(transition(vec2(_uv.x, 1.0 - _uv.y)), 0.0, 1.0);\n return half4(_c.rgb * _c.a, _c.a);\n}\n","wipeUp":"// wipeUp — generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/wipeUp.glsl\n// Author: Jake Nelson\n// License: MIT\n// Description: A hard-edged wipe from bottom to top\n\nuniform shader _from;\nuniform shader _to;\nuniform float2 _resolution;\nuniform float progress;\nuniform float ratio;\n\nvec4 getFromColor(vec2 uv) { return vec4(unpremul(_from.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\nvec4 getToColor(vec2 uv) { return vec4(unpremul(_to.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\n\nvec4 transition(vec2 uv) {\n vec2 p=uv.xy/vec2(1.0).xy;\n vec4 a=getFromColor(p);\n vec4 b=getToColor(p);\n return mix(a, b, step(0.0+p.y,progress));\n}\n\nhalf4 main(float2 _coord) {\n vec2 _uv = _coord / _resolution;\n vec4 _c = clamp(transition(vec2(_uv.x, 1.0 - _uv.y)), 0.0, 1.0);\n return half4(_c.rgb * _c.a, _c.a);\n}\n","x_axis_translation":"// x_axis_translation — generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/x_axis_translation.glsl\n// Author: lizhongjian\n// License: MIT\n// Description: The outgoing image slides to the right, uncovering a crossfade to the incoming one\n\nuniform shader _from;\nuniform shader _to;\nuniform float2 _resolution;\nuniform float progress;\nuniform float ratio;\n\nvec4 getFromColor(vec2 uv) { return vec4(unpremul(_from.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\nvec4 getToColor(vec2 uv) { return vec4(unpremul(_to.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\n\nvec4 transition (vec2 uv) {\n vec2 newUV = uv;\n newUV.x -= progress;\n if(uv.x >= progress)\n {\n return getFromColor(newUV);\n }\n\n \n return mix(\n getFromColor(uv),\n getToColor(uv),\n progress\n );\n}\n\nhalf4 main(float2 _coord) {\n vec2 _uv = _coord / _resolution;\n vec4 _c = clamp(transition(vec2(_uv.x, 1.0 - _uv.y)), 0.0, 1.0);\n return half4(_c.rgb * _c.a, _c.a);\n}\n","zoomInOut":"// zoomInOut — generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/zoomInOut.glsl\n// Author: OllyOllyOlly\n// License: MIT\n// Description: Zooms into the outgoing image until it blurs into a flat color, then out to the incoming one\n\nuniform shader _from;\nuniform shader _to;\nuniform float2 _resolution;\nuniform float progress;\nuniform float ratio;\n\nvec4 getFromColor(vec2 uv) { return vec4(unpremul(_from.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\nvec4 getToColor(vec2 uv) { return vec4(unpremul(_to.eval(vec2(uv.x, 1.0 - uv.y) * _resolution))); }\n\nvec2 zoom(vec2 uv, float amount) {\n return 0.5 + ((uv - 0.5) * (1.0 - amount));\n}\n\nvec4 transition (vec2 uv) {\n float zoomFrom = smoothstep(0.0, 1.0, progress * 2.0);\n float zoomTo = smoothstep(0.0, 1.0, (1.0 - progress) * 2.0);\n float crossfade = smoothstep(0.4, 0.6, progress);\n return mix(\n getFromColor(zoom(uv, zoomFrom)),\n getToColor(zoom(uv, zoomTo)),\n crossfade\n );\n}\n\nhalf4 main(float2 _coord) {\n vec2 _uv = _coord / _resolution;\n vec4 _c = clamp(transition(vec2(_uv.x, 1.0 - _uv.y)), 0.0, 1.0);\n return half4(_c.rgb * _c.a, _c.a);\n}\n"};