shaders: Add drop-shadow shader

src/backend/render/mod.rs

@@ -17,6 +17,7 @@ use crate::{
         render::{
             clipped_surface::{CLIPPING_SHADER, ClippingShader},
             element::DamageElement,
+            shadow::{SHADOW_SHADER, ShadowShader},
         },
     },
     config::ScreenFilter,
@@ -84,6 +85,7 @@ pub mod animations;
 pub mod clipped_surface;
 pub mod cursor;
 pub mod element;
+pub mod shadow;
 use self::element::{AsGlowRenderer, CosmicElement};
 
 use super::kms::Timings;
@@ -414,6 +416,19 @@ pub fn init_shaders(renderer: &mut GlesRenderer) -> Result<(), GlesError> {
             UniformName::new("input_to_geo", UniformType::Matrix3x3),
         ],
     )?;
+    let shadow_shader = renderer.compile_custom_pixel_shader(
+        SHADOW_SHADER,
+        &[
+            UniformName::new("shadow_color", UniformType::_4f),
+            UniformName::new("sigma", UniformType::_1f),
+            UniformName::new("input_to_geo", UniformType::Matrix3x3),
+            UniformName::new("geo_size", UniformType::_2f),
+            UniformName::new("corner_radius", UniformType::_4f),
+            UniformName::new("window_input_to_geo", UniformType::Matrix3x3),
+            UniformName::new("window_geo_size", UniformType::_2f),
+            UniformName::new("window_corner_radius", UniformType::_4f),
+        ],
+    )?;
 
     let egl_context = renderer.egl_context();
     egl_context
@@ -428,6 +443,9 @@ pub fn init_shaders(renderer: &mut GlesRenderer) -> Result<(), GlesError> {
     egl_context
         .user_data()
         .insert_if_missing(|| ClippingShader(clipping_shader));
+    egl_context
+        .user_data()
+        .insert_if_missing(|| ShadowShader(shadow_shader));
 
     Ok(())
 }

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;
+}

src/backend/render/shadow.rs

@@ -0,0 +1,181 @@
+use std::{borrow::Borrow, cell::RefCell, collections::HashMap};
+
+use cgmath::{Matrix3, Vector2};
+use smithay::{
+    backend::renderer::{
+        element::Kind,
+        gles::{
+            GlesPixelProgram, GlesRenderer, Uniform, UniformValue, element::PixelShaderElement,
+        },
+    },
+    utils::{Coordinate, IsAlive, Point, Rectangle, Size},
+};
+
+use crate::{
+    backend::render::element::AsGlowRenderer,
+    shell::element::CosmicMappedKey,
+    utils::prelude::{Local, RectLocalExt},
+};
+
+pub static SHADOW_SHADER: &str = include_str!("./shaders/shadow.frag");
+pub struct ShadowShader(pub GlesPixelProgram);
+
+#[derive(Debug, PartialEq)]
+pub struct ShadowParameters {
+    geo: Rectangle<i32, Local>,
+    scale: f64,
+    alpha: f32,
+    radius: [u8; 4],
+}
+type ShadowCache = RefCell<HashMap<CosmicMappedKey, (ShadowParameters, PixelShaderElement)>>;
+
+impl ShadowShader {
+    pub fn get<R: AsGlowRenderer>(renderer: &R) -> GlesPixelProgram {
+        Borrow::<GlesRenderer>::borrow(renderer.glow_renderer())
+            .egl_context()
+            .user_data()
+            .get::<ShadowShader>()
+            .expect("Custom Shaders not initialized")
+            .0
+            .clone()
+    }
+
+    pub fn element<R: AsGlowRenderer>(
+        renderer: &R,
+        key: CosmicMappedKey,
+        geo: Rectangle<i32, Local>,
+        radius: [u8; 4],
+        alpha: f32,
+        scale: f64,
+    ) -> PixelShaderElement {
+        let params = ShadowParameters {
+            geo,
+            scale,
+            alpha,
+            radius,
+        };
+        let ceil = |logical: f64| (logical * scale).ceil() / scale;
+
+        let mut geo = geo.to_f64();
+        geo.loc.x = ceil(geo.loc.x);
+        geo.loc.y = ceil(geo.loc.y);
+        geo.size.w = ceil(geo.size.w);
+        geo.size.h = ceil(geo.size.h);
+
+        let user_data = Borrow::<GlesRenderer>::borrow(renderer.glow_renderer())
+            .egl_context()
+            .user_data();
+
+        user_data.insert_if_missing(|| ShadowCache::new(HashMap::new()));
+        let mut cache = user_data.get::<ShadowCache>().unwrap().borrow_mut();
+        cache.retain(|k, _| k.alive());
+
+        if cache
+            .get(&key)
+            .filter(|(old_params, _)| &params == old_params)
+            .is_none()
+        {
+            let shader = Self::get(renderer);
+
+            let softness = 30.;
+            let spread = 5.;
+            let offset = [0., 5.];
+            let color = [0., 0., 0., 0.45];
+            let radius = radius.map(|r| ceil(r as f64));
+
+            let width = softness;
+            let sigma = width / 2.;
+            let width = ceil(sigma * 3.);
+
+            let offset = Point::new(ceil(offset[0]), ceil(offset[1]));
+            let spread = ceil(spread.abs()).copysign(spread);
+            let offset = offset - Point::new(spread, spread);
+
+            let box_size = if spread >= 0. {
+                geo.size + Size::new(spread, spread).upscale(2.)
+            } else {
+                geo.size - Size::new(-spread, -spread).upscale(2.)
+            };
+
+            let win_radius = radius;
+            let radius = radius.map(|r| if r > 0. { r.saturating_add(spread) } else { 0. });
+            let shader_size = box_size + Size::from((width, width)).upscale(2.);
+            let mut shader_geo = Rectangle::new(Point::from((-width, -width)), shader_size);
+
+            let window_geo = Rectangle::new(Point::new(0., 0.) - offset - shader_geo.loc, geo.size);
+            let area_size = Vector2::new(shader_geo.size.w, shader_geo.size.h);
+            let geo_loc = Vector2::new(-shader_geo.loc.x, -shader_geo.loc.y);
+            shader_geo.loc += offset + geo.loc;
+
+            let input_to_geo = (Matrix3::from_nonuniform_scale(area_size.x, area_size.y)
+                * Matrix3::from_translation(Vector2::new(
+                    -geo_loc.x / area_size.x,
+                    -geo_loc.y / area_size.y,
+                )))
+            .cast::<f32>()
+            .unwrap();
+
+            let window_geo_loc = Vector2::new(window_geo.loc.x as f64, window_geo.loc.y as f64);
+            let window_input_to_geo = (Matrix3::from_nonuniform_scale(area_size.x, area_size.y)
+                * Matrix3::from_translation(Vector2::new(
+                    -window_geo_loc.x / area_size.x,
+                    -window_geo_loc.y / area_size.y,
+                )))
+            .cast::<f32>()
+            .unwrap();
+
+            let element = PixelShaderElement::new(
+                shader,
+                shader_geo.to_i32_up().as_logical(),
+                None,
+                alpha,
+                vec![
+                    Uniform::new("shadow_color", color),
+                    Uniform::new("sigma", sigma as f32),
+                    Uniform::new(
+                        "input_to_geo",
+                        UniformValue::Matrix3x3 {
+                            matrices: vec![*AsRef::<[f32; 9]>::as_ref(&input_to_geo)],
+                            transpose: false,
+                        },
+                    ),
+                    Uniform::new("geo_size", [box_size.w as f32, box_size.h as f32]),
+                    Uniform::new(
+                        "corner_radius",
+                        [
+                            radius[0] as f32,
+                            radius[1] as f32,
+                            radius[2] as f32,
+                            radius[3] as f32,
+                        ],
+                    ),
+                    Uniform::new(
+                        "window_input_to_geo",
+                        UniformValue::Matrix3x3 {
+                            matrices: vec![*AsRef::<[f32; 9]>::as_ref(&window_input_to_geo)],
+                            transpose: false,
+                        },
+                    ),
+                    Uniform::new(
+                        "window_geo_size",
+                        [window_geo.size.w as f32, window_geo.size.h as f32],
+                    ),
+                    Uniform::new(
+                        "window_corner_radius",
+                        [
+                            win_radius[0] as f32,
+                            win_radius[1] as f32,
+                            win_radius[2] as f32,
+                            win_radius[3] as f32,
+                        ],
+                    ),
+                ],
+                Kind::Unspecified,
+            );
+
+            cache.insert(key.clone(), (params, element));
+        }
+
+        cache.get(&key).unwrap().1.clone()
+    }
+}