shaders: Add drop-shadow shader

src/backend/render/shaders/shadow.frag

@@ -0,0 +1,139 @@
+precision highp float;
+
+uniform float alpha;
+uniform vec2 size;
+varying vec2 v_coords;
+
+#if defined(DEBUG_FLAGS)
+uniform float tint;
+#endif
+
+uniform vec4 shadow_color;
+uniform float sigma;
+
+uniform mat3 input_to_geo;
+uniform vec2 geo_size;
+uniform vec4 corner_radius;
+
+uniform mat3 window_input_to_geo;
+uniform vec2 window_geo_size;
+uniform vec4 window_corner_radius;
+
+// Taken from niri, based on: https://madebyevan.com/shaders/fast-rounded-rectangle-shadows/
+//
+// License: CC0 (http://creativecommons.org/publicdomain/zero/1.0/)
+
+// A standard gaussian function, used for weighting samples
+float gaussian(float x, float sigma) {
+    const float pi = 3.141592653589793;
+    return exp(-(x * x) / (2.0 * sigma * sigma)) / (sqrt(2.0 * pi) * sigma);
+}
+
+// This approximates the error function, needed for the gaussian integral
+vec2 erf(vec2 x) {
+    vec2 s = sign(x), a = abs(x);
+    x = 1.0 + (0.278393 + (0.230389 + 0.078108 * (a * a)) * a) * a;
+    x *= x;
+    return s - s / (x * x);
+}
+
+// Return the blurred mask along the x dimension
+float roundedBoxShadowX(float x, float y, float sigma, float corner, vec2 halfSize) {
+    float delta = min(halfSize.y - corner - abs(y), 0.0);
+    float curved = halfSize.x - corner + sqrt(max(0.0, corner * corner - delta * delta));
+    vec2 integral = 0.5 + 0.5 * erf((x + vec2(-curved, curved)) * (sqrt(0.5) / sigma));
+    return integral.y - integral.x;
+}
+
+// Return the mask for the shadow of a box from lower to upper
+float roundedBoxShadow(vec2 lower, vec2 upper, vec2 point, float sigma, float corner) {
+    // Center everything to make the math easier
+    vec2 center = (lower + upper) * 0.5;
+    vec2 halfSize = (upper - lower) * 0.5;
+    point -= center;
+
+    // The signal is only non-zero in a limited range, so don't waste samples
+    float low = point.y - halfSize.y;
+    float high = point.y + halfSize.y;
+    float start = clamp(-3.0 * sigma, low, high);
+    float end = clamp(3.0 * sigma, low, high);
+
+    // Accumulate samples (we can get away with surprisingly few samples)
+    float step = (end - start) / 4.0;
+    float y = start + step * 0.5;
+    float value = 0.0;
+    for (int i = 0; i < 4; i++) {
+        value += roundedBoxShadowX(point.x, point.y - y, sigma, corner, halfSize) * gaussian(y, sigma) * step;
+        y += step;
+    }
+
+    return value;
+}
+
+float rounding_alpha(vec2 coords, vec2 size, vec4 corner_radius) {
+    vec2 center;
+    float radius;
+
+    if (coords.x < corner_radius.w && coords.y < corner_radius.w) {
+        radius = corner_radius.w;
+        center = vec2(radius, radius);
+    } else if (size.x - corner_radius.y < coords.x && coords.y < corner_radius.y) {
+        radius = corner_radius.y;
+        center = vec2(size.x - radius, radius);
+    } else if (size.x - corner_radius.x < coords.x && size.y - corner_radius.x < coords.y) {
+        radius = corner_radius.x;
+        center = vec2(size.x - radius, size.y - radius);
+    } else if (coords.x < corner_radius.z && size.y - corner_radius.z < coords.y) {
+        radius = corner_radius.z;
+        center = vec2(radius, size.y - radius);
+    } else {
+        return 1.0;
+    }
+
+    float dist = distance(coords, center);
+    return 1.0 - smoothstep(radius - 0.5, radius + 0.5, dist);
+}
+
+void main() {
+    vec3 coords_geo = input_to_geo * vec3(v_coords, 1.0);
+    vec3 coords_window_geo = window_input_to_geo * vec3(v_coords, 1.0);
+
+    vec4 color = shadow_color;
+
+    float shadow_value;
+    if (sigma < 0.1) {
+        // With low enough sigma just draw a rounded rectangle.
+        shadow_value = rounding_alpha(coords_geo.xy, geo_size, corner_radius);
+    } else {
+        shadow_value = roundedBoxShadow(
+                vec2(0.0, 0.0),
+                geo_size,
+                coords_geo.xy,
+                sigma,
+                // FIXME: figure out how to blur with different corner radii.
+                //
+                // GTK seems to call blurring separately for the rect and for the 4 corners:
+                // https://gitlab.gnome.org/GNOME/gtk/-/blob/gtk-4-16/gsk/gpu/shaders/gskgpuboxshadow.glsl
+                corner_radius.z
+            );
+    }
+    color = color * shadow_value;
+
+    // Cut out the inside of the window geometry if requested.
+    if (window_geo_size != vec2(0.0, 0.0)) {
+        if (0.0 <= coords_window_geo.x && coords_window_geo.x <= window_geo_size.x
+                && 0.0 <= coords_window_geo.y && coords_window_geo.y <= window_geo_size.y) {
+            float alpha = rounding_alpha(coords_window_geo.xy, window_geo_size, window_corner_radius);
+            color = color * (1.0 - alpha);
+        }
+    }
+
+    color = color * alpha;
+
+    #if defined(DEBUG_FLAGS)
+    if (tint == 1.0)
+        color = vec4(0.0, 0.2, 0.0, 0.2) + color * 0.8;
+    #endif
+
+    gl_FragColor = color;
+}