/*
 *  SPDX-FileCopyrightText: 2020 Arjen Hiemstra <ahiemstra@heimr.nl>
 *  SPDX-FileCopyrightText: 2025 iaom <zhangpengfei@kylinos.cn>
 *
 *  SPDX-License-Identifier: LGPL-2.0-or-later
 */

#version 440

#extension GL_GOOGLE_include_directive: enable
#include "sdf.glsl"
// See sdf.glsl for the SDF related functions.

// This shader renders a rectangle with rounded corners and a shadow below it.
// In addition it renders a border around it.

#include "uniforms.glsl"

layout(location = 0) in lowp vec2 uv;
layout(location = 0) out lowp vec4 out_color;

const lowp float minimum_shadow_radius = 0.05;

void main()
{
    // Scaling factor that is the inverse of the amount of scaling applied to the geometry.
    lowp float inverse_scale = 1.0 / (1.0 + ubuf.size + length(ubuf.offset) * 2.0);

    // Correction factor to round the corners of a larger shadow.
    // We want to account for size in regards to shadow radius, so that a larger shadow is
    // more rounded, but only if we are not already rounding the corners due to corner radius.
    lowp vec4 size_factor = 0.5 * (minimum_shadow_radius / max(ubuf.radius, minimum_shadow_radius));
    lowp vec4 shadow_radius = ubuf.radius + ubuf.size * size_factor;

    lowp vec4 col = vec4(0.0);

    // Calculate the shadow's distance field.
    lowp float shadow = sdf_rounded_rectangle(uv - ubuf.offset * 2.0 * inverse_scale, ubuf.aspect * inverse_scale, shadow_radius * inverse_scale);
    // Render it, interpolating the color over the distance.
    col = mix(col, ubuf.shadowColor * sign(ubuf.size), 1.0 - smoothstep(-ubuf.size * 0.5, ubuf.size * 0.5, shadow));

    // Scale corrected corner radius
    lowp vec4 corner_radius = ubuf.radius * inverse_scale;

    // Calculate the outer rectangle distance field and render it.
    lowp float outer_rect = sdf_rounded_rectangle(uv, ubuf.aspect * inverse_scale, corner_radius);

    col = sdf_render(outer_rect, col, ubuf.borderColor);

    // The inner rectangle distance field is the outer reduced by twice the border size.
    lowp float inner_rect = outer_rect + (ubuf.borderWidth * inverse_scale) * 2.0;

    // Finally, render the inner rectangle with gradient support.
    if (ubuf.pureColor) {
        col = sdf_render(inner_rect, col, ubuf.color);
    } else {
        // 计算渐变方向
        vec2 dir = normalize(vec2(cos(ubuf.angle), sin(ubuf.angle)) / ubuf.aspect);
        // 转换到矩形本地坐标系
        vec2 rectUV = uv / (ubuf.aspect * inverse_scale);
        // 计算渐变插值因子
        float t = clamp((dot(rectUV, dir) + 1.0) / 2.0, 0.0, 1.0);
        // 混合颜色
        vec4 gradientColor = mix(ubuf.startColor, ubuf.endColor, t);

        col = sdf_render(inner_rect, col, gradientColor);
    }

    out_color = col * ubuf.opacity;
}