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"};