#version 150
#define float2 vec2
#define float3 vec3
#define float4 vec4












uniform Push
{
   vec4 OutputSize;
   vec4 OriginalSize;
   vec4 SourceSize;
   uint FrameCount;
   float aspect_x;
   float aspect_y;
   float integer_scale;
   float overscale;
   float border_zoom;
   float border_speed;
   float effect;
   float scanline_toggle;
   float interp_toggle;
   float THICKNESS;
   float DARKNESS;
   float OS_MASK_TOP;
   float OS_MASK_BOTTOM;
   float OS_MASK_LEFT;
   float OS_MASK_RIGHT;
}params;

layout(std140) uniform UBO
{
   mat4 MVP;
}global;

#pragma parametereffect¡1.01.07.01.0
#pragma parameteraspect_x¡64.01.0256.1.0
#pragma parameteraspect_y¡49.01.0256.1.0
#pragma parameterinteger_scale¡1.00.01.01.0
#pragma parameteroverscale¡0.00.01.01.0
#pragma parameterborder_zoom¡8.00.516.00.5
#pragma parameterborder_speed¡0.50.5100.5
#pragma parameterinterp_toggle¡0.00.01.01.0
#pragma parameterscanline_toggle¡0.00.01.01.0
#pragma parameterTHICKNESS¡2.01.012.01.0
#pragma parameterDARKNESS¡0.350.01.00.05
#pragma parameterOS_MASK_TOP¡0.00.01.00.005
#pragma parameterOS_MASK_BOTTOM¡0.00.01.00.005
#pragma parameterOS_MASK_LEFT¡0.00.01.00.005
#pragma parameterOS_MASK_RIGHT¡0.00.01.00.005

layout(location = 0) in vec2 border_coord;
layout(location = 1) in vec2 screen_coord;
layout(location = 0) out vec4 FragColor;
uniform sampler2D Source;
uniform sampler2D Original;
uniform sampler2D iChannel0;

vec4 fractal_tiling(vec2 iResolution, vec2 fragCoord)
{
    vec2 pos = 256.0 * fragCoord . xy / iResolution . x + params . FrameCount /(15.0 / params . border_speed);

    vec3 col = vec3(0.0);
    for(int i = 0;i < 6;i ++)
    {
        vec2 a = floor(pos);
        vec2 b = fract(pos);

        vec4 w = fract((sin(a . x * 7.0 + 31.0 * a . y + 0.01 * params . FrameCount /(15.0 / params . border_speed))+ vec4(0.035, 0.01, 0.0, 0.7))* 13.545317);

        col += w . xyz *
               smoothstep(0.45, 0.55, w . w)*
               sqrt(16.0 * b . x * b . y *(1.0 - b . x)*(1.0 - b . y));

        pos /= 2.0;
        col /= 2.0;
    }

    col = pow(2.5 * col, vec3(1.0, 1.0, 0.7));

    return vec4(col, 1.0);
}

vec4 bubbles(vec2 iResolution, vec2 fragCoord)
{
 vec2 uv = - 1.0 + 2.0 * fragCoord . xy / iResolution . xy;
 uv . x *= iResolution . x / iResolution . y;


 vec3 color = vec3(0.8 + 0.2 * uv . y);


 for(int i = 0;i < 20;i ++)
 {

  float pha = sin(float(i)* 546.13 + 1.0)* 0.5 + 0.5;
  float siz = pow(sin(float(i)* 651.74 + 5.0)* 0.5 + 0.5, 4.0);
  float pox = sin(float(i)* 321.55 + 4.1)* iResolution . x / iResolution . y;


  float rad = 0.1 + 0.5 * siz;
  vec2 pos = vec2(pox, - 1.0 *(- 1.0 - rad +(2.0 + 2.0 * rad)* mod(pha + 0.1 *(params . FrameCount /(15.0 / params . border_speed))*(0.2 + 0.8 * siz), 1.0)));
  float dis = length(uv - pos);
  vec3 col = mix(vec3(0.94, 0.3, 0.0), vec3(0.1, 0.4, 0.8), 0.5 + 0.5 * sin(float(i)* 1.2 + 1.9));



  float f = length(uv - pos)/ rad;
  f = sqrt(clamp(1.0 - f * f, 0.0, 1.0));
  color -= col . zyx *(1.0 - smoothstep(rad * 0.95, rad, dis))* f;
 }


 color *= sqrt(1.5 - 0.5 * length(uv));

 return vec4(color, 1.0);
}

vec4 hexagon(vec2 p)
{
 vec2 q = vec2(p . x * 2.0 * 0.5773503, p . y + p . x * 0.5773503);

 vec2 pi = floor(q);
 vec2 pf = fract(q);

 float v = mod(pi . x + pi . y, 3.0);

 float ca = step(1.0, v);
 float cb = step(2.0, v);
 vec2 ma = step(pf . xy, pf . yx);


 float e = dot(ma, 1.0 - pf . yx + ca *(pf . x + pf . y - 1.0)+ cb *(pf . yx - 2.0 * pf . xy));


 p = vec2(q . x + floor(0.5 + p . y / 1.5), 4.0 * p . y / 3.0)* 0.5 + 0.5;
 float f = length((fract(p)- 0.5)* vec2(1.0, 0.85));

 return vec4(pi + ca - cb * ma, e, f);
}

float hash(vec2 p)
{
 float n = dot(p, vec2(127.1, 311.7));
 return fract(sin(n)* 43758.5453);
}

float hash1(float n)
{
 return fract(sin(n)* 43758.5453);
}

vec2 hash2(vec2 p)
{
 p = vec2(dot(p, vec2(127.1, 311.7)), dot(p, vec2(269.5, 183.3)));
 return fract(sin(p)* 43758.5453);
}

float noise(in vec3 x)
{
    vec3 p = floor(x);
    vec3 f = fract(x);
 f = f * f *(3.0 - 2.0 * f);
 vec2 uv =(p . xy + vec2(37.0, 17.0)* p . z)+ f . xy;
 vec2 rg = texture(iChannel0,(uv + 0.5)/ 32.0, - 1.0). yx;
 return mix(rg . x, rg . y, f . z);
}

vec4 hexagons_bg(vec2 coord, vec2 output_size, float frame_count)
{
    vec2 uv = coord;
 vec2 pos =(- output_size . xy + 8.0 *(coord * output_size . xy))/ output_size . y;
 float timer = frame_count * 0.05 * params . border_speed;


 pos *= 1.0 + 0.9 * length(pos);


 vec4 h = hexagon(8.0 * pos + 0.5 * timer);
 float n = noise(vec3(0.3 * h . xy + timer * 0.1, timer));
 vec3 col = 0.15 + 0.15 * hash(h . xy + 1.2)* vec3(1.0);
 col *= smoothstep(0.10, 0.11, h . z);
 col *= smoothstep(0.10, 0.11, h . w);
 col *= 1.0 + 0.15 * sin(40.0 * h . z);
 col *= 0.75 + 0.5 * h . z * n;


 h = hexagon(6.0 * pos + 0.6 * timer);
 n = noise(vec3(0.3 * h . xy + timer * 0.1, timer));
 vec3 colb = 0.9 + 0.8 * sin(hash(h . xy)* 1.5 + 2.0 + vec3(0.0, 1.0, 1.0));
 colb *= smoothstep(0.10, 0.11, h . z);
 colb *= 1.0 + 0.15 * sin(40.0 * h . z);
 colb *= 0.75 + 0.5 * h . z * n;

 h = hexagon(6.0 *(pos + 0.1 * vec2(- 1.3, 1.0))+ 0.6 * timer);
    col *= 1.0 - 0.8 * smoothstep(0.45, 0.451, noise(vec3(0.3 * h . xy + timer * 0.1, timer)));

 col = mix(col, colb, smoothstep(0.45, 0.451, n));


 col *= pow(16.0 * uv . x *(1.0 - uv . x)* uv . y *(1.0 - uv . y), 0.1);
 return vec4(col, 1.0);
}

vec4 voronoi_1(in vec2 x, float w, float frame_count)
{
    vec2 n = floor(x);
    vec2 f = fract(x);

 vec4 m = vec4(8.0, 0.0, 0.0, 0.0);
    for(int j = - 1;j <= 2;j ++)
    for(int i = - 1;i <= 2;i ++)
    {
        vec2 g = vec2(float(i), float(j));
        vec2 o = vec2(hash(n + g));


        o = 0.5 + 0.5 * sin(0.01 * frame_count + 6.2831 * o);


  float d = length(g - f + o);


  vec3 col = 0.5 + 0.5 * sin(hash1(dot(n + g, vec2(7.0, 113.0)))* 2.5 + 3.5 + vec3(2.0, 3.0, 0.0));
  float h = smoothstep(0.0, 1.0, 0.5 + 0.5 *(m . x - d)/ w);

     m . x = mix(m . x, d, h)- h *(1.0 - h)* w /(1.0 + 3.0 * w);
  m . yzw = mix(m . yzw, col, h)- h *(1.0 - h)* w /(1.0 + 3.0 * w);
    }

 return m;
}

vec4 voronoi_smooth(vec2 texture_size, float frame_count, vec2 uv)
{
    vec2 p = uv * vec2(2.0, 1.0);

 float k = 2.0 + 70.0 * pow(0.5 + 0.5 * sin(0.25 * 6.2831 * 0.03 * frame_count), 4.0);
 k = 0.5 - 0.5 * cos(0.25 * 6.2831 * 0.01 * frame_count);
    vec4 c = voronoi_1(6.0 * p, k, frame_count);

    vec3 col = c . yzw;

 col *= 1.0 - 0.8 * c . x * step(p . y, 0.33);
 col *= mix(c . x, 1.0, step(p . y, 0.66));

 col *= smoothstep(0.005, 0.007, abs(p . y - 0.33));
 col *= smoothstep(0.005, 0.007, abs(p . y - 0.66));

 return vec4(col, 1.0);
}

vec4 voronoi_2(in vec2 x, float mode, float timer)
{
    vec2 n = floor(x);
    vec2 f = fract(x);

 vec3 m = vec3(8.0);
 float m2 = 8.0;
    for(int j = - 1;j <= 2;j ++)
    for(int i = - 1;i <= 2;i ++)
    {
        vec2 g = vec2(float(i), float(j));
        vec2 o = hash2(n + g);


        o = 0.5 + 0.5 * sin(timer + 6.2831 * o);

  vec2 r = g - f + o;


  vec2 d0 = vec2(sqrt(dot(r, r)), 1.0);

  vec2 d1 = vec2(0.71 *(abs(r . x)+ abs(r . y)), 1.0);

  vec2 d2 = vec2(max(abs(r . x)* 0.866025 + r . y * 0.5, - r . y),
            step(0.0, 0.5 * abs(r . x)+ 0.866025 * r . y)*(1.0 + step(0.0, r . x)));

  vec2 d = d0;
  if(mode < 3.0)d = mix(d2, d0, fract(mode));
  if(mode < 2.0)d = mix(d1, d2, fract(mode));
  if(mode < 1.0)d = mix(d0, d1, fract(mode));

        if(d . x < m . x)
        {
   m2 = m . x;
            m . x = d . x;
            m . y = hash1(dot(n + g, vec2(7.0, 113.0)));
   m . z = d . y;
        }
  else if(d . x < m2)
  {
   m2 = d . x;
  }

    }
    return vec4(m, m2 - m . x);
}

vec4 voronoi_metrics(vec2 texture_size, float frame_count, vec2 uv)
{
 float mode = 2.0;


    vec2 p = - uv . xy / texture_size . xx;
    vec4 c = voronoi_2(8.0 * p, mode, frame_count / 4.0);

    vec3 col = 0.5 + 0.5 * sin(c . y * 2.5 + vec3(1.5, 1.0, 1.0));
    col *= sqrt(clamp(1.0 - c . x, 0.0, 1.0));
 col *= clamp(0.5 +(1.0 - c . z / 2.0)* 0.5, 0.0, 1.0);
 col *= 0.4 + 0.6 * sqrt(clamp(4.0 * c . w, 0.0, 1.0));


    return vec4(col, 1.0);
}

vec4 colorgrid(vec2 texture_size, float frame_count, vec2 uv)
{
    vec2 px = 1000.0 *(- texture_size . xy + 2.0 * params . border_zoom * uv)/ texture_size . y / 5.0;

    float id = 0.5 + 0.5 * cos(frame_count * 0.01 * params . border_speed + sin(dot(floor(px + 0.5), vec2(113.1, 17.81)))* 43758.545);

    vec3 co = 0.5 + 0.5 * cos(frame_count * 0.01 + 3.5 * id + vec3(0.0, 1.57, 3.14));

    vec2 pa = smoothstep(0.0, 0.2, id *(0.5 + 0.5 * cos(6.2831 * px)));

 return vec4(co * pa . x * pa . y, 1.0);
}

vec4 shiny_iterations(vec2 texture_size, float frame_count, vec2 uv)
{
 vec2 pc = uv * 5.0;

 vec2 pa = pc + vec2(0.04, 0.0);
 vec2 pb = pc + vec2(0.0, 0.04);


 vec2 zc = pc;
 vec3 fc = vec3(0.0, 0.0, 0.0);
 for(int i = 0;i < 8;i ++)
 {

  zc += cos(zc . yx + cos(zc . yx + cos(zc . yx + frame_count * 0.01 * params . border_speed)));


  float d = dot(zc - pc, zc - pc);
  fc . x += 1.0 /(1.0 + d);
  fc . y += d;
  fc . z += sin(atan(zc . x - pc . x, zc . y - pc . y));
 }
 fc /= 8.0;
 vec3 sc = fc;

 vec2 za = pa;
 vec3 fa = vec3(0.0, 0.0, 0.0);
  for(int j = 0;j < 8;j ++)
 {

  za += cos(za . yx + cos(za . yx + cos(za . yx + frame_count * 0.01 * params . border_speed)));


  float d = dot(za - pa, za - pa);
  fa . x += 1.0 /(1.0 + d);
  fa . y += d;
  fa . z += sin(atan(zc . x - pc . x, zc . y - pc . y));
 }
 fa /= 8.0;
 vec3 sa = fa;

 vec2 zb = pb;
 vec3 fb = vec3(0.0, 0.0, 0.0);
  for(int k = 0;k < 8;k ++)
 {

  zb += cos(zb . yx + cos(zb . yx + cos(zb . yx + frame_count * 0.01 * params . border_speed)));


  float d = dot(zb - pb, zb - pb);
  fb . x += 1.0 /(1.0 + d);
  fb . y += d;
  fb . z += sin(atan(zc . x - pc . x, zc . y - pc . y));
 }
 fb /= 8.0;
 vec3 sb = fb;


 vec3 col = mix(vec3(0.08, 0.02, 0.15), vec3(0.6, 1.1, 1.6), sc . x);
 col = mix(col, col . zxy, smoothstep(- 0.5, 0.5, cos(0.01 * frame_count * 0.5)));
 col *= 0.15 * sc . y;
 col += 0.4 * abs(sc . z)- 0.1;


 vec3 nor = normalize(vec3(sa . x - sc . x, 0.01, sb . x - sc . x));
 float dif = clamp(0.5 + 0.5 * dot(nor, vec3(0.5773, 0.5773, 0.5773)), 0.0, 1.0);
 col *= 1.0 + 0.7 * dif * col;
 col += 0.3 * pow(nor . y, 128.0);


 col *= 1.0 - 0.1 * length(pc);
 return vec4(col, 1.0);
}

vec4 scanlines(vec4 frame, vec2 coord, vec2 texture_size, vec2
 video_size, vec2 output_size)
{
 float lines = fract(coord . y * texture_size . y);
 float scale_factor = floor((output_size . y / video_size . y)+ 0.4999);
    float lightness = 1.0 - params . DARKNESS;
 return(params . scanline_toggle > 0.5 &&(lines <(1.0 / scale_factor * params . THICKNESS)))
  ? frame * vec4(lightness, lightness, lightness, lightness): frame;
}

vec2 interp_coord(vec2 coord, vec2 texture_size)
{
 vec2 p = coord . xy;
 p = p * texture_size . xy + vec2(0.5, 0.5);
 vec2 i = floor(p);
 vec2 f = p - i;

 f = f * f * f * f *(f *(f *(- 20.0 * f + vec2(70.0, 70.0))- vec2(84.0, 84.0))+ vec2(35.0, 35.0));
 p = i + f;
 p =(p - vec2(0.5, 0.5))* 1.0 / texture_size;
 return p;
}

vec4 border(vec2 screen_coord, vec2 border_coord, vec2 texture_size, vec2 video_size,
 vec2 output_size, float frame_count, sampler2D decal)
{
 vec4 background;
 if(params . effect == 1.0)background = hexagons_bg(border_coord *(2.0 / params . border_zoom), output_size . xy, frame_count);
 else if(params . effect == 2.0)background = voronoi_smooth(texture_size, frame_count, border_coord);
 else if(params . effect == 3.0)background = colorgrid(texture_size, frame_count * 6.0, border_coord / vec2(output_size . y / output_size . x, 1.0));
 else if(params . effect == 4.0)background = shiny_iterations(texture_size, frame_count, border_coord);
 else if(params . effect == 5.0)background = bubbles(texture_size . xy, border_coord / vec2(output_size . y / output_size . x, 1.0)*(15.0 * params . border_zoom));
 else if(params . effect == 6.0)background = voronoi_metrics(texture_size, frame_count / 10 * params . border_speed, border_coord * 75.0 * params . border_zoom);
 else background = fractal_tiling(texture_size . xy, border_coord / vec2(output_size . y / output_size . x, 1.0)*(30.0 * params . border_zoom));

 vec2 coord =(params . interp_toggle < 0.5)? screen_coord : interp_coord(screen_coord, texture_size);
 vec4 frame = texture(decal, coord);
 frame = scanlines(frame, coord * 1.0001, texture_size, video_size, output_size);
 vec2 fragcoord =(coord . xy);
 if(fragcoord . x < 1.0 - params . OS_MASK_RIGHT && fragcoord . x > 0.0 + params . OS_MASK_LEFT &&
  fragcoord . y < 1.0 - params . OS_MASK_BOTTOM && fragcoord . y > 0.0 + params . OS_MASK_TOP)
   return frame;

 else return background;
}

void main()
{
 FragColor = border(screen_coord, border_coord, params . SourceSize . xy, params . SourceSize . xy,
  params . OutputSize . xy, float(params . FrameCount), Source);
}