//////////////////////////////////////////////////////////////////////////////////////////
//          )                                                   (                       //
//       ( /(   (  (               )    (       (  (  (         )\ )    (  (            //
//       )\()) ))\ )(   (         (     )\ )    )\))( )\  (    (()/( (  )\))(  (        //
//      ((_)\ /((_|()\  )\ )      )\  '(()/(   ((_)()((_) )\ )  ((_)))\((_)()\ )\       //
//      | |(_|_))( ((_)_(_/(    _((_))  )(_))  _(()((_|_)_(_/(  _| |((_)(()((_|(_)      //
//      | '_ \ || | '_| ' \))  | '  \()| || |  \ V  V / | ' \)) _` / _ \ V  V (_-<      //
//      |_.__/\_,_|_| |_||_|   |_|_|_|  \_, |   \_/\_/|_|_||_|\__,_\___/\_/\_//__/      //
//                                 |__/                                                 //
//////////////////////////////////////////////////////////////////////////////////////////

// SPDX-FileCopyrightText: Justin Garza <JGarza9788@gmail.com>
// SPDX-License-Identifier: GPL-3.0-or-later

// The content from common.glsl is automatically prepended to each shader effect. This
// provides the standard input:

// vec2  iTexCoord:     Texture coordinates for retrieving the window input color.
// bool  uIsFullscreen: True if the window is maximized or in fullscreen mode.
// bool  uForOpening:   True if a window-open animation is ongoing, false otherwise.
// float uProgress:     A value which transitions from 0 to 1 during the animation.
// float uDuration:     The duration of the current animation in seconds.
// vec2  uSize:         The size of uTexture in pixels.
// float uPadding:      The empty area around the actual window (e.g. where the shadow
//                      is drawn). For now, this will only be set on GNOME.

// Furthermore, there are two global methods for reading the window input color and
// setting the shader output color. Both methods assume straight alpha:

// vec4 getInputColor(vec2 coords)
// void setOutputColor(vec4 outColor)

// The width of the fading effect is loaded from the settings.
uniform float uColorSpeed;
uniform bool uRandomColorOffset;
uniform float uColorOffset;
uniform float uColorSaturation;
uniform float uFadeOut;
uniform float uBlur;
uniform vec2 uSeed;

/*
this controls the end shape
-5.0 large Star
-3.0 Star
1.0 Dimond
2.0 Circle
3.0 Squircle
5.0 Square
*/
uniform float uEdgeShape;

// the size of the edge color
uniform float uEdgeSize;

// soft <--> hard
uniform float uEdgeHardness;

// A simple blur function
vec4 blur(vec2 uv, float radius, float samples) {
  vec4 color = vec4(0.0);

  const float tau        = 6.28318530718;
  const float directions = 15.0;

  for (float d = 0.0; d < tau; d += tau / directions) {
    for (float s = 0.0; s < 1.0; s += 1.0 / samples) {
      vec2 offset = vec2(cos(d), sin(d)) * radius * (1.0 - s) / uSize;
      color += getInputColor(uv + offset);
    }
  }

  return color / samples / directions;
}

void main() {

  // This gradually dissolves from [1..0] from the outside to the center. We
  // switch the direction for opening and closing.
  float progress = uForOpening ? uProgress : 1.0 - uProgress;

  // adjusting for Gnome
  if (uPadding > 0.0) {
    progress = remap(progress, 0.0, ((uSize.x - (uPadding * 2.0)) / uSize.x), 0.0, 1.0);
  }

  // Get the color from the window texture.
  vec4 oColor = getInputColor(iTexCoord.st);

  // Calculate the aspect ratio of the render area
  float aspect = uSize.x / uSize.y;

  // standard uv
  vec2 uv = iTexCoord.st;

  // tuv is for when progress is near 0
  vec2 tuv = uv;
  tuv -= 0.5;       // Shift UV coordinates to center (from [-0.5 to 0.5])
  tuv.x *= aspect;  // Scale x-coordinate to match aspect ratio
  tuv += 0.5;       // Shift UV coordinates back (from [0 to 1])

  // mixing the UVs
  uv = mix(tuv, uv, easeOutExpo(progress));

  // this controls the shape
  // -1.0 would be a diamond-ish
  // 0.0 would be a rounded diamond
  // 1.0 would be a circle
  // 2.0  will be sqircle
  // 1000.0 will be very square
  float p = mix(uEdgeShape, 1000.0, easeInExpo(progress));

  // this will be used later to make a mask
  float m =
    mix(0.0, 1.0,
        clamp(pow(abs(uv.x - 0.5) * 2.0, p) + pow(abs(uv.y - 0.5) * 2.0, p), 0.0, 1.0));

  // this calculates the edge of the effect
  float edge = abs(m - progress);
  float e    = mix(0.0, uEdgeSize, 1.0 - progress);
  edge       = remap(edge, 0.0, e, 0.0, 1.0);
  edge       = clamp(edge, 0.0, 1.0);
  edge       = 1.0 - edge;

  // this is the mask
  float mask = (m > progress) ? 0.0 : 1.0;

  // we need two of these
  float mask0 = mix(mask, mask + edge, 1.0 - uEdgeHardness);
  float mask1 = mix(edge, edge * mask, uEdgeHardness);

  // calculate color
  vec3 color = cos(progress * uColorSpeed + uv.xyx + vec3(0, 2, 4)).xyz;
  // coloroffset
  float colorOffset = (uRandomColorOffset) ? hash12(uSeed) : uColorOffset;
  color             = offsetHue(color, colorOffset + 0.10);
  // clamp and saturate
  color = clamp(color * uColorSaturation, vec3(0.0), vec3(1.0));

  // save this for later
  float oColorAlpha = oColor.a;

  // blur-ify
  if (uBlur > 0.0) {
    // used for blur later ...
    // calculate this before saturating it
    float b = (color.r + color.g + color.b) / 3.0;

    oColor = blur(iTexCoord.st, b * uBlur * mask1, 7.0);
  }

  // apply masks and colors
  oColor.a *= mask0;

  // i was doing this to try to adjust for light mode
  //  i don;t like the way these make the effect look
  //       ...maybe a toggle for it later
  /*
  float oColorPercent = (oColor.r + oColor.g + oColor.b)/3.0;
  oColor.r = mix(oColor.r , 1.0 - oColor.r, mask1 * oColorPercent);
  oColor.g = mix(oColor.g , 1.0 - oColor.g, mask1 * oColorPercent);
  oColor.b = mix(oColor.b , 1.0 - oColor.b, mask1 * oColorPercent);
  // --or
  oColor.r = mix(oColor.r , 0.0, mask1 * oColorPercent);
  oColor.g = mix(oColor.g , 0.0, mask1 * oColorPercent);
  oColor.b = mix(oColor.b , 0.0, mask1 * oColorPercent);
  */

  oColor += mask1 * vec4(color.rgb, 1.0);
  oColor.a *= oColorAlpha;

  // i want to fade out the last ~10% of the animation
  float lastfade = remap(progress, 0.0, uFadeOut, 0.0, 1.0);
  lastfade       = clamp(lastfade, 0.0, 1.0);
  lastfade       = easeInSine(lastfade);

  // apply the lastfade
  oColor.a *= lastfade;

  setOutputColor(oColor);
}