diff options
Diffstat (limited to 'src/render_helpers/shaders')
| -rw-r--r-- | src/render_helpers/shaders/mod.rs | 24 | ||||
| -rw-r--r-- | src/render_helpers/shaders/shadow.frag | 142 |
2 files changed, 166 insertions, 0 deletions
diff --git a/src/render_helpers/shaders/mod.rs b/src/render_helpers/shaders/mod.rs index 91ba32d1..ddc58cdb 100644 --- a/src/render_helpers/shaders/mod.rs +++ b/src/render_helpers/shaders/mod.rs @@ -11,6 +11,7 @@ use super::shader_element::ShaderProgram; pub struct Shaders { pub border: Option<ShaderProgram>, + pub shadow: Option<ShaderProgram>, pub clipped_surface: Option<GlesTexProgram>, pub resize: Option<ShaderProgram>, pub custom_resize: RefCell<Option<ShaderProgram>>, @@ -21,6 +22,7 @@ pub struct Shaders { #[derive(Debug, Clone, Copy)] pub enum ProgramType { Border, + Shadow, Resize, Close, Open, @@ -53,6 +55,26 @@ impl Shaders { }) .ok(); + let shadow = ShaderProgram::compile( + renderer, + include_str!("shadow.frag"), + &[ + 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), + ], + &[], + ) + .map_err(|err| { + warn!("error compiling shadow shader: {err:?}"); + }) + .ok(); + let clipped_surface = renderer .compile_custom_texture_shader( include_str!("clipped_surface.frag"), @@ -76,6 +98,7 @@ impl Shaders { Self { border, + shadow, clipped_surface, resize, custom_resize: RefCell::new(None), @@ -121,6 +144,7 @@ impl Shaders { pub fn program(&self, program: ProgramType) -> Option<ShaderProgram> { match program { ProgramType::Border => self.border.clone(), + ProgramType::Shadow => self.shadow.clone(), ProgramType::Resize => self .custom_resize .borrow() diff --git a/src/render_helpers/shaders/shadow.frag b/src/render_helpers/shaders/shadow.frag new file mode 100644 index 00000000..3912d71f --- /dev/null +++ b/src/render_helpers/shaders/shadow.frag @@ -0,0 +1,142 @@ +precision highp float; + +#if defined(DEBUG_FLAGS) +uniform float niri_tint; +#endif + +uniform float niri_alpha; +uniform float niri_scale; + +uniform vec2 niri_size; +varying vec2 niri_v_coords; + +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; + +// 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.x && coords.y < corner_radius.x) { + radius = corner_radius.x; + 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.z < coords.x && size.y - corner_radius.z < coords.y) { + radius = corner_radius.z; + center = vec2(size.x - radius, size.y - radius); + } else if (coords.x < corner_radius.w && size.y - corner_radius.w < coords.y) { + radius = corner_radius.w; + center = vec2(radius, size.y - radius); + } else { + return 1.0; + } + + float dist = distance(coords, center); + float half_px = 0.5 / niri_scale; + return 1.0 - smoothstep(radius - half_px, radius + half_px, dist); +} + +void main() { + vec3 coords_geo = input_to_geo * vec3(niri_v_coords, 1.0); + vec3 coords_window_geo = window_input_to_geo * vec3(niri_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.x + ); + } + 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 * niri_alpha; + +#if defined(DEBUG_FLAGS) + if (niri_tint == 1.0) + color = vec4(0.0, 0.2, 0.0, 0.2) + color * 0.8; +#endif + + gl_FragColor = color; +} |