shader_type canvas_item;
render_mode blend_mix;

uniform vec2 Size = vec2(540.0, 289.0);
uniform vec4 Padding = vec4(50.0, 50.0, -50, -50);
uniform vec4 Corner_Radii = vec4(2.0, 10.0, 20.0, 50.0);
uniform float Blur_Level = 2.0;
uniform sampler2D Screen : source_color, filter_linear_mipmap, hint_screen_texture;
uniform vec4 ColorParameter : source_color = vec4(0.051361, 0.170669, 0.398438, 1.000000);

uniform float antialiasing_amount = .05;
uniform float edge_thickness = .1;
uniform float edge_effect_strength = .5;
uniform float softblur_strength = .5;
uniform float softblur_blur = 5.0;

float _min(float a, float b, float c)
{
    return min(min(a, b), c);
}
float _min(float a, float b, float c, float d)
{
    return min(min(min(a, b), c), d);
}

float distance_to_edge_or_corner(float edge_pos, float pixel_pos, float corner_distance, bool is_between_corners)
{
    float edge_distance = abs(edge_pos - pixel_pos);
    float min_distance = min(corner_distance, edge_distance);
    // Don't consider the edge outside the corners, we just want the corner distance there
    return min_distance * float(is_between_corners) + corner_distance * float(!is_between_corners);
}

void fragment()
{
    // UV scaled by window size
    vec2 pos = UV * Size;

    // Corner circles
    vec2 top_left_corner = vec2(Corner_Radii.x + Padding.x, Corner_Radii.x + Padding.y);
    vec2 top_right_corner = vec2(Size.x - Corner_Radii.y - Padding.x, Corner_Radii.y + Padding.y);
    vec2 bottom_right_corner = vec2(Size.x - Corner_Radii.z - Padding.x, Size.y - Corner_Radii.z - Padding.y);
    vec2 bottom_left_corner = vec2(Corner_Radii.w + Padding.x, Size.y - Corner_Radii.w - Padding.y);

    // Distance to each circle
    float distance_to_top_left_circle = max(distance(pos, top_left_corner) - Corner_Radii.x, 0.0);
    float distance_to_top_right_circle = max(distance(pos, top_right_corner) - Corner_Radii.y, 0.0);
    float distance_to_bottom_right_corner = max(distance(pos, bottom_right_corner) - Corner_Radii.z, 0.0);
    float distance_to_bottom_left_corner = max(distance(pos, bottom_left_corner) - Corner_Radii.w, 0.0);

    // Minimum distance to any corner
    float min_distance_to_corner = _min(distance_to_top_left_circle, distance_to_top_right_circle, distance_to_bottom_left_corner, distance_to_bottom_right_corner);

    bool is_above_top_corner_centers = (UV.x < .5 && pos.y < top_left_corner.y) || (UV.x >= .5 && pos.y < top_right_corner.y);
    bool is_below_bottom_corner_centers = (UV.x < .5 && pos.y > bottom_left_corner.y) || (UV.x >= .5 && pos.y > bottom_right_corner.y);
    bool is_before_left_corner_centers = (UV.y < .5 && pos.x < top_left_corner.x) || (UV.y >= .5 && pos.x < bottom_left_corner.x);
    bool is_after_right_corner_centers = (UV.y < .5 && pos.x > top_right_corner.x) || (UV.y >= .5 && pos.x > bottom_right_corner.x);

    bool is_between_corners_vertically = !is_above_top_corner_centers && !is_below_bottom_corner_centers;
    bool is_between_corners_horizontally = !is_before_left_corner_centers && !is_after_right_corner_centers;

    float min_distance_to_corner_or_left_edge = distance_to_edge_or_corner(Padding.x, pos.x, min_distance_to_corner, is_between_corners_vertically);
    float min_distance_to_corner_or_right_edge = distance_to_edge_or_corner(Size.x - Padding.x, pos.x, min_distance_to_corner, is_between_corners_vertically);
    float min_distance_to_corner_or_top_edge = distance_to_edge_or_corner(Padding.y, pos.y, min_distance_to_corner, is_between_corners_horizontally);
    float min_distance_to_corner_or_bottom_edge = distance_to_edge_or_corner(Size.y - Padding.y, pos.y, min_distance_to_corner, is_between_corners_horizontally);

    float min_distance_to_edge_or_corner = _min(min_distance_to_corner_or_left_edge, min_distance_to_corner_or_right_edge, min_distance_to_corner_or_bottom_edge, min_distance_to_corner_or_top_edge);

    bool is_left_of_padding = pos.x < Padding.x;
    bool is_right_of_padding = pos.x > (Size.x - Padding.x);
    bool is_above_padding = pos.y < Padding.y;
    bool is_below_padding = pos.y > (Size.y - Padding.y);

    bool is_outside_padding = is_left_of_padding || is_right_of_padding || is_above_padding || is_below_padding;

    bool is_top_left_corner = pos.x < (Corner_Radii.x + Padding.x) && pos.y < (Corner_Radii.x + Padding.y);
    bool is_top_right_corner = pos.x > (Size.x - Corner_Radii.y - Padding.x) && pos.y < (Corner_Radii.y + Padding.y);
    bool is_bottom_left_corner = pos.x < (Corner_Radii.w + Padding.x) && pos.y > (Size.y - Corner_Radii.w - Padding.y);
    bool is_bottom_right_corner = pos.x > (Size.x - Corner_Radii.z - Padding.x) && pos.y > (Size.y - Corner_Radii.z - Padding.y);
    bool is_corner = is_top_left_corner || is_top_right_corner || is_bottom_left_corner || is_bottom_right_corner;

    bool is_outside = is_outside_padding || is_corner;

    vec3 outer_gradient = vec3(min_distance_to_edge_or_corner) * float(is_outside);
    float max_distance = min(Padding.x, Padding.y);
    outer_gradient = outer_gradient / max_distance;
    vec3 inverted_gradient = 1.0 - outer_gradient;

    vec2 refracted_screen_uv = log(1.0+outer_gradient.x) * edge_effect_strength + SCREEN_UV;
    vec3 tint = ColorParameter.rgb * ColorParameter.a;
    vec3 inside_window_color = textureLod(Screen, refracted_screen_uv, Blur_Level).rgb + tint;

    float antialiase_start = 1.0 - edge_thickness - antialiasing_amount;
    float antialiase_end = antialiase_start + antialiasing_amount;

    float inside_outside_transition = smoothstep(antialiase_start, antialiase_end, inverted_gradient.x);
    vec3 extra_blurry_screen = textureLod(Screen, SCREEN_UV, softblur_blur).rgb;
    COLOR.rgb = mix(extra_blurry_screen, inside_window_color, inside_outside_transition);
    float soft_blur_amount = inverted_gradient.r * softblur_strength;
    COLOR.a = max(0.0, mix(soft_blur_amount, 1.0, inside_outside_transition));
}