(&self.handle).await {
54 | Ok(true) => (),
55 | Ok(false) => warn!(handle = ?self.handle, "Could not destroy portal session"),
56 | Err(err) => error!(?err, "Failed to destroy portal session"),
57 | }
58 |
59 | if let Some(on_destroy) = self.on_destroy.take() {
60 | let data = self.data.lock().unwrap();
61 | on_destroy(&*data);
62 | }
63 | }
64 |
65 | /// Emitted when a session is closed.
66 | ///
67 | /// The content of details is specified by the interface creating the session.
68 | #[zbus(signal)]
69 | pub async fn closed(
70 | &self,
71 | _emitter: &SignalEmitter<'_>,
72 | details: HashMap<&str, zvariant::Value<'_>>,
73 | ) -> zbus::Result<()>;
74 | }
75 |
76 | /// A single portal request.
77 | pub struct Request {
78 | handle: zvariant::OwnedObjectPath,
79 | }
80 |
81 | impl Request {
82 | /// Create a new XDG desktop portal request.
83 | pub fn new(handle: P) -> Self
84 | where
85 | P: Into,
86 | {
87 | Self {
88 | handle: handle.into(),
89 | }
90 | }
91 | }
92 |
93 | #[zbus::interface(name = "org.freedesktop.impl.portal.Request")]
94 | impl Request {
95 | /// Closes the portal request to which this object refers and ends all related user interaction
96 | /// (dialogs, etc).
97 | pub async fn close(&mut self, #[zbus(object_server)] object_server: &zbus::ObjectServer) {
98 | match object_server.remove::(&self.handle).await {
99 | Ok(true) => (),
100 | Ok(false) => warn!(handle = ?self.handle, "Could not destroy portal request"),
101 | Err(err) => error!(?err, "Failed to destroy portal request"),
102 | }
103 | }
104 | }
105 |
106 | /// A result from a portal request.
107 | #[derive(
108 | Debug,
109 | Clone,
110 | Copy,
111 | PartialEq,
112 | Eq,
113 | serde_repr::Deserialize_repr,
114 | serde_repr::Serialize_repr,
115 | zvariant::Type,
116 | )]
117 | #[repr(u32)]
118 | pub enum PortalResponse {
119 | Success,
120 | Cancelled,
121 | Error,
122 | }
123 |
--------------------------------------------------------------------------------
/src/profiling.rs:
--------------------------------------------------------------------------------
1 | #![allow(unused_macros)]
2 | #![allow(unused_imports)]
3 |
4 | macro_rules! profile_function {
5 | () => {
6 | let _tracy_span = tracy_client::span!();
7 | };
8 | ($data:expr) => {
9 | let _location = $crate::tracy_client::span_location!();
10 | let _tracy_span = $crate::tracy_client::Client::running()
11 | .expect("function_scope! without a running tracy_client::Client")
12 | .span(_location, 0);
13 | _tracy_span.emit_text($data);
14 | };
15 | }
16 | pub(crate) use profile_function;
17 |
18 | /// Profiling macro for feature "profile-with-puffin"
19 | macro_rules! profile_scope {
20 | // Note: literal patterns provided as an optimization since they can skip an allocation.
21 | ($name:literal) => {
22 | // Note: callstack_depth is 0 since this has significant overhead
23 | let _tracy_span = ::tracy_client::span!($name, 0);
24 | };
25 | ($name:literal, $data:expr) => {
26 | // Note: callstack_depth is 0 since this has significant overhead
27 | let _tracy_span = ::tracy_client::span!($name, 0);
28 | _tracy_span.emit_text($data);
29 | };
30 | ($name:expr) => {
31 | let _function_name = {
32 | struct S;
33 | let type_name = core::any::type_name::();
34 | &type_name[..type_name.len() - 3]
35 | };
36 | let _tracy_span = ::tracy_client::Client::running()
37 | .expect("scope! without a running tracy_client::Client")
38 | // Note: callstack_depth is 0 since this has significant overhead
39 | .span_alloc(Some($name), _function_name, file!(), line!(), 0);
40 | };
41 | ($name:expr, $data:expr) => {
42 | let _function_name = {
43 | struct S;
44 | let type_name = core::any::type_name::();
45 | &type_name[..type_name.len() - 3]
46 | };
47 | let _tracy_span = ::tracy_client::Client::running()
48 | .expect("scope! without a running tracy_client::Client")
49 | // Note: callstack_depth is 0 since this has significant overhead
50 | .span_alloc(Some($name), _function_name, file!(), line!(), 0);
51 | _tracy_span.emit_text($data);
52 | };
53 | }
54 | pub(crate) use profile_scope;
55 |
--------------------------------------------------------------------------------
/src/protocols/mod.rs:
--------------------------------------------------------------------------------
1 | pub mod output_management;
2 | pub mod screencopy;
3 |
--------------------------------------------------------------------------------
/src/renderer/data.rs:
--------------------------------------------------------------------------------
1 | use smithay::backend::renderer::gles::{ffi, Capability, GlesFrame, GlesRenderer};
2 |
3 | /// Extra renderer data used for custom drawing with gles FFI.
4 | ///
5 | /// [`GlesRenderer`] creates these, but keeps them private, so we create our own.
6 | pub struct RendererData {
7 | pub vbos: [u32; 2],
8 | }
9 |
10 | impl RendererData {
11 | pub fn init(renderer: &mut GlesRenderer) {
12 | let capabilities = renderer.capabilities();
13 | let vertices: &[ffi::types::GLfloat] = if capabilities.contains(&Capability::Instancing) {
14 | &INSTANCED_VERTS
15 | } else {
16 | &TRIANGLE_VERTS
17 | };
18 |
19 | let this = renderer
20 | .with_context(|gl| unsafe {
21 | let mut vbos = [0; 2];
22 | gl.GenBuffers(vbos.len() as i32, vbos.as_mut_ptr());
23 | gl.BindBuffer(ffi::ARRAY_BUFFER, vbos[0]);
24 | gl.BufferData(
25 | ffi::ARRAY_BUFFER,
26 | std::mem::size_of_val(vertices) as isize,
27 | vertices.as_ptr() as *const _,
28 | ffi::STATIC_DRAW,
29 | );
30 | gl.BindBuffer(ffi::ARRAY_BUFFER, vbos[1]);
31 | gl.BufferData(
32 | ffi::ARRAY_BUFFER,
33 | (std::mem::size_of::() * OUTPUT_VERTS.len()) as isize,
34 | OUTPUT_VERTS.as_ptr() as *const _,
35 | ffi::STATIC_DRAW,
36 | );
37 | gl.BindBuffer(ffi::ARRAY_BUFFER, 0);
38 |
39 | Self { vbos }
40 | })
41 | .unwrap();
42 |
43 | renderer
44 | .egl_context()
45 | .user_data()
46 | .insert_if_missing(|| this);
47 | }
48 |
49 | pub fn get(renderer: &mut GlesRenderer) -> &Self {
50 | renderer.egl_context().user_data().get().unwrap()
51 | }
52 |
53 | pub fn get_from_frame<'a>(frame: &'a mut GlesFrame<'_, '_>) -> &'a Self {
54 | frame.egl_context().user_data().get().unwrap()
55 | }
56 | }
57 |
58 | /// Vertices for instanced rendering.
59 | static INSTANCED_VERTS: [ffi::types::GLfloat; 8] = [
60 | 1.0, 0.0, // top right
61 | 0.0, 0.0, // top left
62 | 1.0, 1.0, // bottom right
63 | 0.0, 1.0, // bottom left
64 | ];
65 |
66 | /// Vertices for rendering individual triangles.
67 | const MAX_RECTS_PER_DRAW: usize = 10;
68 | const TRIANGLE_VERTS: [ffi::types::GLfloat; 12 * MAX_RECTS_PER_DRAW] = triangle_verts();
69 | const fn triangle_verts() -> [ffi::types::GLfloat; 12 * MAX_RECTS_PER_DRAW] {
70 | let mut verts = [0.; 12 * MAX_RECTS_PER_DRAW];
71 | let mut i = 0;
72 | loop {
73 | // Top Left.
74 | verts[i * 12] = 0.0;
75 | verts[i * 12 + 1] = 0.0;
76 |
77 | // Bottom left.
78 | verts[i * 12 + 2] = 0.0;
79 | verts[i * 12 + 3] = 1.0;
80 |
81 | // Bottom right.
82 | verts[i * 12 + 4] = 1.0;
83 | verts[i * 12 + 5] = 1.0;
84 |
85 | // Top left.
86 | verts[i * 12 + 6] = 0.0;
87 | verts[i * 12 + 7] = 0.0;
88 |
89 | // Bottom right.
90 | verts[i * 12 + 8] = 1.0;
91 | verts[i * 12 + 9] = 1.0;
92 |
93 | // Top right.
94 | verts[i * 12 + 10] = 1.0;
95 | verts[i * 12 + 11] = 0.0;
96 |
97 | i += 1;
98 | if i == MAX_RECTS_PER_DRAW {
99 | break;
100 | }
101 | }
102 | verts
103 | }
104 |
105 | /// Vertices for output rendering.
106 | static OUTPUT_VERTS: [ffi::types::GLfloat; 8] = [
107 | -1.0, 1.0, // top right
108 | -1.0, -1.0, // top left
109 | 1.0, 1.0, // bottom right
110 | 1.0, -1.0, // bottom left
111 | ];
112 |
--------------------------------------------------------------------------------
/src/renderer/extra_damage.rs:
--------------------------------------------------------------------------------
1 | // From https://github.com/Yalter/Niri licensed under GPL-v3.0
2 | // Thank you very much.
3 | use smithay::backend::renderer::element::{Element, Id, RenderElement};
4 | use smithay::backend::renderer::utils::CommitCounter;
5 | use smithay::backend::renderer::Renderer;
6 | use smithay::utils::{Buffer, Logical, Physical, Point, Rectangle, Scale, Size};
7 |
8 | #[derive(Debug, Clone)]
9 | pub struct ExtraDamage {
10 | id: Id,
11 | commit: CommitCounter,
12 | geometry: Rectangle,
13 | }
14 |
15 | impl ExtraDamage {
16 | pub fn new(size: Size) -> Self {
17 | Self {
18 | id: Id::new(),
19 | commit: Default::default(),
20 | geometry: Rectangle::from_size(size),
21 | }
22 | }
23 |
24 | pub fn set_size(&mut self, size: Size) {
25 | if self.geometry.size == size {
26 | return;
27 | }
28 |
29 | self.geometry.size = size;
30 | self.commit.increment();
31 | }
32 |
33 | pub fn with_location(mut self, location: Point) -> Self {
34 | self.geometry.loc = location;
35 | self
36 | }
37 | }
38 |
39 | impl Default for ExtraDamage {
40 | fn default() -> Self {
41 | Self::new(Size::default())
42 | }
43 | }
44 |
45 | impl Element for ExtraDamage {
46 | fn id(&self) -> &Id {
47 | &self.id
48 | }
49 |
50 | fn current_commit(&self) -> CommitCounter {
51 | self.commit
52 | }
53 |
54 | fn src(&self) -> Rectangle {
55 | Rectangle::new((0., 0.).into(), (1., 1.).into())
56 | }
57 |
58 | fn geometry(&self, scale: Scale) -> Rectangle {
59 | self.geometry.to_physical_precise_round(scale)
60 | }
61 | }
62 |
63 | impl RenderElement for ExtraDamage {
64 | fn draw(
65 | &self,
66 | _frame: &mut R::Frame<'_, '_>,
67 | _src: Rectangle,
68 | _dst: Rectangle,
69 | _damage: &[Rectangle],
70 | _or: &[Rectangle],
71 | ) -> Result<(), R::Error> {
72 | Ok(())
73 | }
74 | }
75 |
--------------------------------------------------------------------------------
/src/renderer/pixel_shader_element.rs:
--------------------------------------------------------------------------------
1 | use smithay::backend::renderer::element::{Element, Id, Kind, RenderElement};
2 | use smithay::backend::renderer::gles::element::PixelShaderElement;
3 | use smithay::backend::renderer::gles::{GlesError, GlesPixelProgram, Uniform};
4 | use smithay::backend::renderer::glow::{GlowFrame, GlowRenderer};
5 | use smithay::backend::renderer::utils::{CommitCounter, DamageSet};
6 | use smithay::utils::{Buffer, Logical, Physical, Point, Rectangle, Scale, Transform};
7 |
8 | #[cfg(feature = "udev-backend")]
9 | use crate::backend::udev::{UdevFrame, UdevRenderError, UdevRenderer};
10 |
11 | #[derive(Debug)]
12 | pub struct FhtPixelShaderElement(PixelShaderElement, Option>);
13 |
14 | impl FhtPixelShaderElement {
15 | /// Create a new [`FhtPixelShaderElement`].
16 | ///
17 | /// See [`PixelShaderElement::new`]
18 | pub fn new(
19 | program: GlesPixelProgram,
20 | geometry: Rectangle,
21 | alpha: f32,
22 | additional_uniforms: Vec>,
23 | damage: Option<&[Rectangle]>,
24 | kind: Kind,
25 | ) -> Self {
26 | let inner =
27 | PixelShaderElement::new(program, geometry, None, alpha, additional_uniforms, kind);
28 | Self(inner, damage.map(DamageSet::from_slice))
29 | }
30 | }
31 |
32 | impl Element for FhtPixelShaderElement {
33 | fn id(&self) -> &Id {
34 | self.0.id()
35 | }
36 |
37 | fn current_commit(&self) -> CommitCounter {
38 | self.0.current_commit()
39 | }
40 |
41 | fn src(&self) -> Rectangle {
42 | self.0.src()
43 | }
44 |
45 | fn geometry(&self, scale: Scale) -> Rectangle {
46 | self.0.geometry(scale)
47 | }
48 |
49 | fn location(&self, scale: Scale) -> Point {
50 | self.geometry(scale).loc
51 | }
52 |
53 | fn transform(&self) -> Transform {
54 | Transform::Normal
55 | }
56 |
57 | fn damage_since(
58 | &self,
59 | scale: Scale,
60 | commit: Option,
61 | ) -> smithay::backend::renderer::utils::DamageSet {
62 | match &self.1 {
63 | // If we have custom damage, use that. Otherwise pixel shader element uses full
64 | // area. FIXME: Maybe avoid the allocation, but this should live on the stack
65 | Some(damage) => DamageSet::from_iter(
66 | damage
67 | .iter()
68 | .copied()
69 | .map(|rect| rect.to_physical_precise_round(scale)),
70 | ),
71 | None => self.0.damage_since(scale, commit),
72 | }
73 | }
74 |
75 | fn opaque_regions(
76 | &self,
77 | scale: Scale,
78 | ) -> smithay::backend::renderer::utils::OpaqueRegions {
79 | self.0.opaque_regions(scale)
80 | }
81 |
82 | fn alpha(&self) -> f32 {
83 | self.0.alpha()
84 | }
85 |
86 | fn kind(&self) -> Kind {
87 | self.0.kind()
88 | }
89 | }
90 |
91 | impl RenderElement for FhtPixelShaderElement {
92 | fn draw(
93 | &self,
94 | frame: &mut GlowFrame<'_, '_>,
95 | src: Rectangle,
96 | dst: Rectangle,
97 | damage: &[Rectangle],
98 | opaque_regions: &[Rectangle],
99 | ) -> Result<(), GlesError> {
100 | >::draw(
101 | &self.0,
102 | frame,
103 | src,
104 | dst,
105 | damage,
106 | opaque_regions,
107 | )
108 | }
109 |
110 | fn underlying_storage(
111 | &self,
112 | _: &mut GlowRenderer,
113 | ) -> Option {
114 | None // pixel shader elements can't be scanned out.
115 | }
116 | }
117 |
118 | #[cfg(feature = "udev-backend")]
119 | impl<'a> RenderElement> for FhtPixelShaderElement {
120 | fn draw(
121 | &self,
122 | frame: &mut UdevFrame<'a, '_, '_>,
123 | src: Rectangle,
124 | dst: Rectangle,
125 | damage: &[Rectangle],
126 | opaque_regions: &[Rectangle],
127 | ) -> Result<(), UdevRenderError> {
128 | >::draw(
129 | &self.0,
130 | frame.as_mut(),
131 | src,
132 | dst,
133 | damage,
134 | opaque_regions,
135 | )
136 | .map_err(UdevRenderError::Render)
137 | }
138 |
139 | fn underlying_storage(
140 | &self,
141 | _: &mut UdevRenderer<'a>,
142 | ) -> Option {
143 | None // pixel shader elements can't be scanned out.
144 | }
145 | }
146 |
--------------------------------------------------------------------------------
/src/renderer/rounded_element/shader_.frag:
--------------------------------------------------------------------------------
1 | //_DEFINES_
2 |
3 | #if defined(EXTERNAL)
4 | #extension GL_OES_EGL_image_external : require
5 | #endif
6 |
7 | precision mediump float;
8 | #if defined(EXTERNAL)
9 | uniform samplerExternalOES tex;
10 | #else
11 | uniform sampler2D tex;
12 | #endif
13 |
14 | uniform float alpha;
15 | varying vec2 v_coords;
16 |
17 | #if defined(DEBUG_FLAGS)
18 | uniform float tint;
19 | #endif
20 |
21 | uniform vec2 size;
22 | uniform float radius;
23 |
24 | float rounded_box(vec2 center, vec2 size, float radius) {
25 | return length(max(abs(center) - size + radius, 0.0)) - radius;
26 | }
27 |
28 | void main() {
29 | vec2 center = size / 2.0;
30 | vec2 location = v_coords * size;
31 |
32 | float distance = rounded_box(location - center, size / 2.0, radius);
33 | vec4 mix_color;
34 | if (distance > 1.0) {
35 | mix_color = vec4(0);
36 | } else {
37 | mix_color = texture2D(tex, v_coords);
38 | }
39 |
40 | #if defined(NO_ALPHA)
41 | mix_color = vec4(mix_color.rgb, 1.0) * alpha;
42 | #else
43 | mix_color = mix_color * alpha;
44 | #endif
45 |
46 | #if defined(DEBUG_FLAGS)
47 | if (tint == 1.0)
48 | mix_color = vec4(0.0, 0.3, 0.0, 0.2) + mix_color * 0.8;
49 | #endif
50 |
51 | gl_FragColor = mix_color;
52 | }
53 |
54 | // vim: ft=glsl
55 |
--------------------------------------------------------------------------------
/src/renderer/shaders/blur-down.frag:
--------------------------------------------------------------------------------
1 | #version 100
2 |
3 | //_DEFINES_
4 |
5 | #if defined(EXTERNAL)
6 | #extension GL_OES_EGL_image_external : require
7 | #endif
8 |
9 | precision mediump float;
10 | #if defined(EXTERNAL)
11 | uniform samplerExternalOES tex;
12 | #else
13 | uniform sampler2D tex;
14 | #endif
15 |
16 | varying vec2 v_coords;
17 | uniform float radius;
18 | uniform vec2 half_pixel;
19 |
20 | void main() {
21 | vec2 uv = v_coords * 2.0;
22 |
23 | vec4 sum = texture2D(tex, uv) * 4.0;
24 | sum += texture2D(tex, uv - half_pixel.xy * radius);
25 | sum += texture2D(tex, uv + half_pixel.xy * radius);
26 | sum += texture2D(tex, uv + vec2(half_pixel.x, -half_pixel.y) * radius);
27 | sum += texture2D(tex, uv - vec2(half_pixel.x, -half_pixel.y) * radius);
28 |
29 | gl_FragColor = sum / 8.0;
30 | }
31 |
32 |
--------------------------------------------------------------------------------
/src/renderer/shaders/blur-finish.frag:
--------------------------------------------------------------------------------
1 | // Implementation from pinnacle-comp/pinnacle (GPL-3.0)
2 | // Thank you very much!
3 | #version 100
4 |
5 | //_DEFINES_
6 |
7 | #if defined(EXTERNAL)
8 | #extension GL_OES_EGL_image_external : require
9 | #endif
10 |
11 | precision mediump float;
12 | #if defined(EXTERNAL)
13 | uniform samplerExternalOES tex;
14 | #else
15 | uniform sampler2D tex;
16 | #endif
17 |
18 | uniform float alpha;
19 | varying vec2 v_coords;
20 |
21 | #if defined(DEBUG_FLAGS)
22 | uniform float tint;
23 | #endif
24 |
25 | uniform vec4 geo;
26 | uniform float corner_radius;
27 | uniform float noise;
28 |
29 | float rounding_alpha(vec2 coords, vec2 size, float radius) {
30 | vec2 center;
31 |
32 | if (coords.x < corner_radius && coords.y < corner_radius) {
33 | center = vec2(radius);
34 | } else if (size.x - corner_radius < coords.x && coords.y < corner_radius) {
35 | center = vec2(size.x - radius, radius);
36 | } else if (size.x - corner_radius < coords.x && size.y - corner_radius < coords.y) {
37 | center = size - vec2(radius);
38 | } else if (coords.x < corner_radius && size.y - corner_radius < coords.y) {
39 | center = vec2(radius, size.y - radius);
40 | } else {
41 | return 1.0;
42 | }
43 |
44 | float dist = distance(coords, center);
45 | return 1.0 - smoothstep(radius - 0.5, radius + 0.5, dist);
46 | }
47 |
48 | // Noise function copied from hyprland.
49 | // I like the effect it gave, can be tweaked further
50 | float hash(vec2 p) {
51 | vec3 p3 = fract(vec3(p.xyx) * 727.727); // wysi :wink: :wink:
52 | p3 += dot(p3, p3.xyz + 33.33);
53 | return fract((p3.x + p3.y) * p3.z);
54 | }
55 |
56 | void main() {
57 |
58 | // Sample the texture.
59 | vec4 color = texture2D(tex, v_coords);
60 |
61 | #if defined(NO_ALPHA)
62 | color = vec4(color.rgb, 1.0);
63 | #endif
64 |
65 | // This shader exists to make blur rounding correct.
66 | //
67 | // Since we are scr-ing a texture that is the size of the output, the v_coords are always
68 | // relative to the output. This corresponds to gl_FragCoord.
69 | vec2 size = geo.zw;
70 | vec2 loc = gl_FragCoord.xy - geo.xy;
71 |
72 | // Add noise fx
73 | // This can be used to achieve a glass look
74 | float noiseHash = hash(loc / size);
75 | float noiseAmount = (mod(noiseHash, 1.0) - 0.5);
76 | color.rgb += noiseAmount * noise;
77 |
78 | // Apply corner rounding inside geometry.
79 | color *= rounding_alpha(loc, size, corner_radius);
80 |
81 |
82 | // Apply final alpha and tint.
83 | color *= alpha;
84 | #if defined(DEBUG_FLAGS)
85 | if (tint == 1.0)
86 | color = vec4(0.0, 0.2, 0.0, 0.2) + color * 0.8;
87 | #endif
88 |
89 | gl_FragColor = color;
90 | }
91 |
92 | // vim: ft=glsl
93 |
--------------------------------------------------------------------------------
/src/renderer/shaders/blur-up.frag:
--------------------------------------------------------------------------------
1 | #version 100
2 |
3 | //_DEFINES_
4 |
5 | #if defined(EXTERNAL)
6 | #extension GL_OES_EGL_image_external : require
7 | #endif
8 |
9 | precision mediump float;
10 | #if defined(EXTERNAL)
11 | uniform samplerExternalOES tex;
12 | #else
13 | uniform sampler2D tex;
14 | #endif
15 |
16 | varying vec2 v_coords;
17 | uniform vec2 half_pixel;
18 | uniform float radius;
19 |
20 | void main() {
21 | vec2 uv = v_coords / 2.0;
22 |
23 | vec4 sum = texture2D(tex, uv + vec2(-half_pixel.x * 2.0, 0.0) * radius);
24 | sum += texture2D(tex, uv + vec2(-half_pixel.x, half_pixel.y) * radius) * 2.0;
25 | sum += texture2D(tex, uv + vec2(0.0, half_pixel.y * 2.0) * radius);
26 | sum += texture2D(tex, uv + vec2(half_pixel.x, half_pixel.y) * radius) * 2.0;
27 | sum += texture2D(tex, uv + vec2(half_pixel.x * 2.0, 0.0) * radius);
28 | sum += texture2D(tex, uv + vec2(half_pixel.x, -half_pixel.y) * radius) * 2.0;
29 | sum += texture2D(tex, uv + vec2(0.0, -half_pixel.y * 2.0) * radius);
30 | sum += texture2D(tex, uv + vec2(-half_pixel.x, -half_pixel.y) * radius) * 2.0;
31 |
32 | gl_FragColor = sum / 12.0;
33 | }
34 |
35 |
--------------------------------------------------------------------------------
/src/renderer/shaders/border.frag:
--------------------------------------------------------------------------------
1 | precision mediump float;
2 |
3 | uniform vec4 v_start_color;
4 | uniform vec4 v_end_color;
5 | uniform float v_gradient_angle;
6 | uniform float corner_radius;
7 | uniform float thickness;
8 |
9 | uniform vec2 size;
10 | uniform float alpha;
11 | varying vec2 v_coords;
12 |
13 | float rounding_alpha(vec2 coords, vec2 size, float radius)
14 | {
15 | vec2 center;
16 |
17 | if (coords.x < corner_radius && coords.y < corner_radius)
18 | {
19 | center = vec2(radius);
20 | }
21 | else if (size.x - corner_radius < coords.x && coords.y < corner_radius)
22 | {
23 | center = vec2(size.x - radius, radius);
24 | }
25 | else if (size.x - corner_radius < coords.x && size.y - corner_radius < coords.y)
26 | {
27 | center = size - vec2(radius);
28 | }
29 | else if (coords.x < corner_radius && size.y - corner_radius < coords.y)
30 | {
31 | center = vec2(radius, size.y - radius);
32 | }
33 | else
34 | {
35 | return 1.0;
36 | }
37 |
38 | float dist = distance(coords, center);
39 | return 1.0 - smoothstep(radius - 0.5, radius + 0.5, dist);
40 | }
41 |
42 | // Gradient color calculation from here
43 | // https://www.shadertoy.com/view/Mt2XDK
44 | vec4 get_pixel_color()
45 | {
46 | vec2 origin = vec2(0.5);
47 | vec2 uv = v_coords - origin;
48 |
49 | float angle = radians(90.0) - radians(v_gradient_angle) + atan(uv.x, uv.y);
50 |
51 | float uv_len = length(uv);
52 | uv = vec2(cos(angle) * uv_len, sin(angle) * uv_len) + origin;
53 |
54 | return mix(v_start_color, v_end_color, smoothstep(0.0, 1.0, uv.x));
55 | }
56 |
57 | void main()
58 | {
59 | vec2 loc = v_coords * size;
60 | // First rounding pass is for outside radius
61 | vec4 color = get_pixel_color();
62 | color *= rounding_alpha(loc, size, corner_radius);
63 |
64 | if (thickness > 0.0)
65 | {
66 | // Second pass: inner rounding
67 | loc -= vec2(thickness);
68 | vec2 inner_size = size - vec2(thickness * 2.0);
69 |
70 | // Only apply rounding when we are inside
71 | if (0.0 <= loc.x && loc.x <= inner_size.x && 0.0 <= loc.y && loc.y <= inner_size.y)
72 | {
73 | float inner_radius = max(corner_radius - thickness, 0.0);
74 | color = color * (1.0 - rounding_alpha(loc, inner_size, inner_radius));
75 | }
76 | }
77 |
78 | gl_FragColor = color * alpha;
79 | }
80 |
81 | // vim: ft=glsl
82 |
--------------------------------------------------------------------------------
/src/renderer/shaders/box-shadow.frag:
--------------------------------------------------------------------------------
1 | precision mediump float;
2 |
3 | uniform vec4 shadow_color;
4 | uniform float blur_sigma;
5 | uniform float corner_radius;
6 |
7 | uniform vec2 size;
8 | uniform float alpha;
9 | varying vec2 v_coords;
10 |
11 | // The shader code is from here
12 | // https://madebyevan.com/shaders/fast-rounded-rectangle-shadows/
13 |
14 | // A standard gaussian function, used for weighting samples
15 | float gaussian(float x, float sigma)
16 | {
17 | const float pi = 3.141592653589793;
18 | return exp(-(x * x) / (2.0 * sigma * sigma)) / (sqrt(2.0 * pi) * sigma);
19 | }
20 |
21 | // This approximates the error function, needed for the gaussian integral
22 | vec2 erf(vec2 x)
23 | {
24 | vec2 s = sign(x), a = abs(x);
25 | x = 1.0 + (0.278393 + (0.230389 + 0.078108 * (a * a)) * a) * a;
26 | x *= x;
27 | return s - s / (x * x);
28 | }
29 |
30 | // Return the blurred mask along the x dimension
31 | float rounded_box_shadow_x(float x, float y, float sigma, float corner, vec2 halfSize)
32 | {
33 | float delta = min(halfSize.y - corner - abs(y), 0.0);
34 | float curved = halfSize.x - corner + sqrt(max(0.0, corner * corner - delta * delta));
35 | vec2 integral = 0.5 + 0.5 * erf((x + vec2(-curved, curved)) * (sqrt(0.5) / sigma));
36 | return integral.y - integral.x;
37 | }
38 |
39 | // Return the mask for the shadow of a box from lower to upper
40 | float rounded_box_shadow(vec2 lower, vec2 upper, vec2 point, float sigma, float corner)
41 | {
42 | // Center everything to make the math easier
43 | vec2 center = (lower + upper) * 0.5;
44 | vec2 halfSize = (upper - lower) * 0.5;
45 | point -= center;
46 |
47 | // The signal is only non-zero in a limited range, so don't waste samples
48 | float low = point.y - halfSize.y;
49 | float high = point.y + halfSize.y;
50 | float start = clamp(-3.0 * sigma, low, high);
51 | float end = clamp(3.0 * sigma, low, high);
52 |
53 | // Accumulate samples (we can get away with surprisingly few samples)
54 | float step = (end - start) / 4.0;
55 | float y = start + step * 0.5;
56 | float value = 0.0;
57 | for (int i = 0; i < 4; i++)
58 | {
59 | value += rounded_box_shadow_x(point.x, point.y - y, sigma, corner, halfSize) * gaussian(y, sigma) * step;
60 | y += step;
61 | }
62 |
63 | return value;
64 | }
65 |
66 | // per-pixel "random" number between 0 and 1
67 | float random()
68 | {
69 | return fract(sin(dot(vec2(12.9898, 78.233), gl_FragCoord.xy)) * 43758.5453);
70 | }
71 |
72 | // simple rounded box sdf to check that we are inside
73 | // https://iquilezles.org/articles/distfunctions2d/
74 | float rounded_box_sdf(vec2 pos, vec4 rect, float corner_radius)
75 | {
76 | vec2 half_size = (rect.zw) * 0.5;
77 | vec2 q = abs(pos - rect.xy - half_size) - half_size + corner_radius;
78 | return min(max(q.x, q.y), 0.0) + length(max(q, 0.0)) - corner_radius;
79 | }
80 |
81 | void main()
82 | {
83 | // the shader's element size will always fit the blur sigma / 2
84 | vec4 rect = vec4(vec2(blur_sigma), size.x - (2. * blur_sigma), size.y - (2. * blur_sigma));
85 | vec2 pos = v_coords * size;
86 | if (rounded_box_sdf(pos, rect, corner_radius) < 0.0)
87 | discard; // we dont draw the shadow *inside* the rectangle
88 |
89 | // First rounding pass is for outside radius
90 | float frag_alpha = shadow_color.a;
91 | frag_alpha *= rounded_box_shadow(rect.xy, rect.xy + rect.zw, v_coords * size, blur_sigma / 2., corner_radius);
92 | frag_alpha += (random() - 0.5) / 128.0;
93 |
94 | gl_FragColor = vec4(shadow_color.xyz * frag_alpha, frag_alpha) * alpha;
95 | }
96 |
97 | // vim: ft=glsl
98 |
--------------------------------------------------------------------------------
/src/renderer/shaders/mod.rs:
--------------------------------------------------------------------------------
1 | use std::borrow::BorrowMut;
2 |
3 | use smithay::backend::renderer::gles::{
4 | GlesFrame, GlesPixelProgram, GlesRenderer, GlesTexProgram, UniformName, UniformType,
5 | };
6 | use smithay::backend::renderer::glow::GlowRenderer;
7 |
8 | use super::blur::shader::BlurShaders;
9 |
10 | const BORDER_SRC: &str = include_str!("./border.frag");
11 | const BOX_SHADOW_SRC: &str = include_str!("./box-shadow.frag");
12 | const ROUNDED_WINDOW_SRC: &str = include_str!("./rounded-window.frag");
13 | const BLUR_FINISH_SRC: &str = include_str!("./blur-finish.frag");
14 | const RESIZING_TEXTURE_SRC: &str = include_str!("./resizing-texture.frag");
15 | pub(super) const BLUR_DOWN_SRC: &str = include_str!("./blur-down.frag");
16 | pub(super) const BLUR_UP_SRC: &str = include_str!("./blur-up.frag");
17 | pub(super) const VERTEX_SRC: &str = include_str!("./texture.vert");
18 |
19 | pub struct Shaders {
20 | pub border: GlesPixelProgram,
21 | pub box_shadow: GlesPixelProgram,
22 | // rounded_window => complex shader that takes into account subsurface position through
23 | // matrices, only used in src/space/tile.rs
24 | pub rounded_window: GlesTexProgram,
25 | // blur_finish => apply rounded corners and additional effects
26 | pub blur_finish: GlesTexProgram,
27 | pub resizing_texture: GlesTexProgram,
28 | pub blur: BlurShaders,
29 | }
30 |
31 | impl Shaders {
32 | pub fn init(renderer: &mut GlowRenderer) {
33 | let renderer: &mut GlesRenderer = renderer.borrow_mut();
34 |
35 | let rounded_window = renderer
36 | .compile_custom_texture_shader(
37 | ROUNDED_WINDOW_SRC,
38 | &[
39 | UniformName::new("corner_radius", UniformType::_1f),
40 | UniformName::new("geo_size", UniformType::_2f),
41 | UniformName::new("input_to_geo", UniformType::Matrix3x3),
42 | ],
43 | )
44 | .expect("Shader source should always compile!");
45 | let blur_finish = renderer
46 | .compile_custom_texture_shader(
47 | BLUR_FINISH_SRC,
48 | &[
49 | UniformName::new("corner_radius", UniformType::_1f),
50 | UniformName::new("noise", UniformType::_1f),
51 | UniformName::new("geo", UniformType::_4f),
52 | ],
53 | )
54 | .expect("Shader source should always compile!");
55 |
56 | let resizing_texture = renderer
57 | .compile_custom_texture_shader(
58 | RESIZING_TEXTURE_SRC,
59 | &[
60 | UniformName::new("corner_radius", UniformType::_1f),
61 | // the size of the window texture we sampled from
62 | UniformName::new("win_size", UniformType::_2f),
63 | UniformName::new("curr_size", UniformType::_2f),
64 | ],
65 | )
66 | .expect("Shader source should always compile!");
67 | let border = renderer
68 | .compile_custom_pixel_shader(
69 | BORDER_SRC,
70 | &[
71 | UniformName::new("v_start_color", UniformType::_4f),
72 | UniformName::new("v_end_color", UniformType::_4f),
73 | UniformName::new("v_gradient_angle", UniformType::_1f),
74 | UniformName::new("corner_radius", UniformType::_1f),
75 | UniformName::new("thickness", UniformType::_1f),
76 | ],
77 | )
78 | .expect("Shader source should always compile!");
79 | let box_shadow = renderer
80 | .compile_custom_pixel_shader(
81 | BOX_SHADOW_SRC,
82 | &[
83 | UniformName::new("shadow_color", UniformType::_4f),
84 | UniformName::new("corner_radius", UniformType::_1f),
85 | UniformName::new("blur_sigma", UniformType::_1f),
86 | ],
87 | )
88 | .expect("Shader source should always compile!");
89 | let blur = BlurShaders::compile(renderer).expect("Shader source should always compile!");
90 |
91 | let shaders = Self {
92 | border,
93 | box_shadow,
94 | rounded_window,
95 | blur_finish,
96 | resizing_texture,
97 | blur,
98 | };
99 |
100 | renderer
101 | .egl_context()
102 | .user_data()
103 | .insert_if_missing(|| shaders);
104 | }
105 |
106 | pub fn get(renderer: &GlowRenderer) -> &Self {
107 | renderer
108 | .egl_context()
109 | .user_data()
110 | .get()
111 | .expect("Shaders are initialized at startup!")
112 | }
113 |
114 | pub fn get_from_frame<'a>(frame: &'a GlesFrame<'_, '_>) -> &'a Self {
115 | frame
116 | .egl_context()
117 | .user_data()
118 | .get()
119 | .expect("Shaders are initialized at startup!")
120 | }
121 | }
122 |
--------------------------------------------------------------------------------
/src/renderer/shaders/resizing-texture.frag:
--------------------------------------------------------------------------------
1 | #version 100
2 |
3 | //_DEFINES_
4 |
5 | #if defined(EXTERNAL)
6 | #extension GL_OES_EGL_image_external : require
7 | #endif
8 |
9 | precision mediump float;
10 | #if defined(EXTERNAL)
11 | uniform samplerExternalOES tex;
12 | #else
13 | uniform sampler2D tex;
14 | #endif
15 |
16 | uniform float alpha;
17 |
18 | // the size of the window texture
19 | uniform vec2 win_size;
20 | // the size we should display with
21 | uniform vec2 curr_size;
22 | // sample coords inside curr_size
23 | varying vec2 v_coords;
24 | // The corner radius of the tile.
25 | uniform float corner_radius;
26 |
27 | #if defined(DEBUG_FLAGS)
28 | uniform float tint;
29 | #endif
30 |
31 | float rounding_alpha(vec2 coords, vec2 size, float radius)
32 | {
33 | vec2 center;
34 |
35 | if (coords.x < corner_radius && coords.y < corner_radius)
36 | {
37 | center = vec2(radius);
38 | }
39 | else if (size.x - corner_radius < coords.x && coords.y < corner_radius)
40 | {
41 | center = vec2(size.x - radius, radius);
42 | }
43 | else if (size.x - corner_radius < coords.x && size.y - corner_radius < coords.y)
44 | {
45 | center = size - vec2(radius);
46 | }
47 | else if (coords.x < corner_radius && size.y - corner_radius < coords.y)
48 | {
49 | center = vec2(radius, size.y - radius);
50 | }
51 | else
52 | {
53 | return 1.0;
54 | }
55 |
56 | float dist = distance(coords, center);
57 | return 1.0 - smoothstep(radius - 0.5, radius + 0.5, dist);
58 | }
59 |
60 | void main()
61 | {
62 | vec2 tex_coords = (v_coords * win_size) / curr_size;
63 | if (win_size.x > curr_size.x)
64 | tex_coords.x = v_coords.x;
65 | if (win_size.y > curr_size.y)
66 | tex_coords.y = v_coords.y;
67 | vec4 color = texture2D(tex, tex_coords);
68 |
69 | if (corner_radius > 0.0)
70 | color *= rounding_alpha(v_coords * curr_size, curr_size, corner_radius);
71 |
72 | #if defined(NO_ALPHA)
73 | color = vec4(color.rgb, 1.0);
74 | #endif
75 |
76 | #if defined(DEBUG_FLAGS)
77 | if (tint == 1.0)
78 | color = vec4(0.0, 0.2, 0.0, 0.2) + color * 0.8;
79 | #endif
80 |
81 | gl_FragColor = color;
82 | }
83 |
84 | // vim: ft=glsl
85 |
--------------------------------------------------------------------------------
/src/renderer/shaders/rounded-window.frag:
--------------------------------------------------------------------------------
1 | // Implementation from pinnacle-comp/pinnacle (GPL-3.0)
2 | // Thank you very much!
3 | #version 100
4 |
5 | //_DEFINES_
6 |
7 | #if defined(EXTERNAL)
8 | #extension GL_OES_EGL_image_external : require
9 | #endif
10 |
11 | precision mediump float;
12 | #if defined(EXTERNAL)
13 | uniform samplerExternalOES tex;
14 | #else
15 | uniform sampler2D tex;
16 | #endif
17 |
18 | uniform float alpha;
19 | varying vec2 v_coords;
20 |
21 | #if defined(DEBUG_FLAGS)
22 | uniform float tint;
23 | #endif
24 |
25 | uniform vec2 geo_size;
26 | uniform float corner_radius;
27 | uniform mat3 input_to_geo;
28 |
29 | float rounding_alpha(vec2 coords, vec2 size, float radius) {
30 | vec2 center;
31 |
32 | if (coords.x < corner_radius && coords.y < corner_radius) {
33 | center = vec2(radius);
34 | } else if (size.x - corner_radius < coords.x && coords.y < corner_radius) {
35 | center = vec2(size.x - radius, radius);
36 | } else if (size.x - corner_radius < coords.x && size.y - corner_radius < coords.y) {
37 | center = size - vec2(radius);
38 | } else if (coords.x < corner_radius && size.y - corner_radius < coords.y) {
39 | center = vec2(radius, size.y - radius);
40 | } else {
41 | return 1.0;
42 | }
43 |
44 | float dist = distance(coords, center);
45 | return 1.0 - smoothstep(radius - 0.5, radius + 0.5, dist);
46 | }
47 |
48 | void main() {
49 | vec3 coords_geo = input_to_geo * vec3(v_coords, 1.0);
50 |
51 | // Sample the texture.
52 | vec4 color = texture2D(tex, v_coords);
53 | #if defined(NO_ALPHA)
54 | color = vec4(color.rgb, 1.0);
55 | #endif
56 |
57 | if (coords_geo.x < 0.0 || 1.0 < coords_geo.x || coords_geo.y < 0.0 || 1.0 < coords_geo.y) {
58 | // Clip outside geometry.
59 | color = vec4(0.0);
60 | } else {
61 | // Apply corner rounding inside geometry.
62 | color = color * rounding_alpha(coords_geo.xy * geo_size, geo_size, corner_radius);
63 | }
64 |
65 | // Apply final alpha and tint.
66 | color = color * alpha;
67 |
68 | #if defined(DEBUG_FLAGS)
69 | if (tint == 1.0)
70 | color = vec4(0.0, 0.2, 0.0, 0.2) + color * 0.8;
71 | #endif
72 |
73 | gl_FragColor = color;
74 | }
75 |
76 | // vim: ft=glsl
77 |
--------------------------------------------------------------------------------
/src/renderer/shaders/texture.vert:
--------------------------------------------------------------------------------
1 |
2 | #version 100
3 |
4 | uniform mat3 matrix;
5 | uniform mat3 tex_matrix;
6 |
7 | attribute vec2 vert;
8 | attribute vec4 vert_position;
9 |
10 | varying vec2 v_coords;
11 |
12 | mat2 scale(vec2 scale_vec){
13 | return mat2(
14 | scale_vec.x, 0.0,
15 | 0.0, scale_vec.y
16 | );
17 | }
18 |
19 | void main() {
20 | vec2 vert_transform_translation = vert_position.xy;
21 | vec2 vert_transform_scale = vert_position.zw;
22 | vec3 position = vec3(vert * scale(vert_transform_scale) + vert_transform_translation, 1.0);
23 | v_coords = (tex_matrix * position).xy;
24 | gl_Position = vec4(matrix * position, 1.0);
25 | }
26 |
--------------------------------------------------------------------------------
/src/renderer/texture_element.rs:
--------------------------------------------------------------------------------
1 | use smithay::backend::renderer::element::texture::TextureRenderElement;
2 | use smithay::backend::renderer::element::{Element, Id, Kind, RenderElement};
3 | use smithay::backend::renderer::gles::{GlesError, GlesTexture};
4 | use smithay::backend::renderer::glow::{GlowFrame, GlowRenderer};
5 | #[cfg(feature = "udev-backend")]
6 | use smithay::backend::renderer::multigpu::MultiTexture;
7 | use smithay::backend::renderer::utils::CommitCounter;
8 | use smithay::backend::renderer::Texture;
9 | use smithay::utils::{Buffer, Physical, Point, Rectangle, Scale, Transform};
10 |
11 | #[cfg(feature = "udev-backend")]
12 | use crate::backend::udev::{UdevFrame, UdevRenderError, UdevRenderer};
13 |
14 | #[derive(Debug)]
15 | pub struct FhtTextureElement(pub TextureRenderElement)
16 | where
17 | E: Texture + Clone + 'static;
18 |
19 | impl From> for FhtTextureElement {
20 | fn from(value: TextureRenderElement) -> Self {
21 | Self(value)
22 | }
23 | }
24 |
25 | impl Element for FhtTextureElement {
26 | fn id(&self) -> &Id {
27 | self.0.id()
28 | }
29 |
30 | fn current_commit(&self) -> CommitCounter {
31 | self.0.current_commit()
32 | }
33 |
34 | fn src(&self) -> Rectangle {
35 | self.0.src()
36 | }
37 |
38 | fn geometry(&self, scale: Scale) -> Rectangle {
39 | self.0.geometry(scale)
40 | }
41 |
42 | fn location(&self, scale: Scale) -> Point {
43 | self.geometry(scale).loc
44 | }
45 |
46 | fn transform(&self) -> Transform {
47 | Transform::Normal
48 | }
49 |
50 | fn damage_since(
51 | &self,
52 | scale: Scale,
53 | commit: Option,
54 | ) -> smithay::backend::renderer::utils::DamageSet {
55 | self.0.damage_since(scale, commit)
56 | }
57 |
58 | fn alpha(&self) -> f32 {
59 | self.0.alpha()
60 | }
61 |
62 | fn kind(&self) -> Kind {
63 | self.0.kind()
64 | }
65 | }
66 |
67 | impl RenderElement for FhtTextureElement {
68 | fn draw(
69 | &self,
70 | frame: &mut GlowFrame<'_, '_>,
71 | src: Rectangle,
72 | dst: Rectangle,
73 | damage: &[Rectangle],
74 | opaque_regions: &[Rectangle],
75 | ) -> Result<(), GlesError> {
76 | as RenderElement>::draw(
77 | &self.0,
78 | frame,
79 | src,
80 | dst,
81 | damage,
82 | opaque_regions,
83 | )
84 | }
85 |
86 | fn underlying_storage(
87 | &self,
88 | renderer: &mut GlowRenderer,
89 | ) -> Option {
90 | self.0.underlying_storage(renderer)
91 | }
92 | }
93 |
94 | #[cfg(feature = "udev-backend")]
95 | impl<'a> RenderElement> for FhtTextureElement {
96 | fn draw(
97 | &self,
98 | frame: &mut UdevFrame<'a, '_, '_>,
99 | src: Rectangle,
100 | dst: Rectangle,
101 | damage: &[Rectangle],
102 | opaque_regions: &[Rectangle],
103 | ) -> Result<(), UdevRenderError> {
104 | as RenderElement>>::draw(
105 | &self.0,
106 | frame,
107 | src,
108 | dst,
109 | damage,
110 | opaque_regions,
111 | )
112 | }
113 |
114 | fn underlying_storage(
115 | &self,
116 | _: &mut UdevRenderer<'a>,
117 | ) -> Option {
118 | None // pixel shader elements can't be scanned out.
119 | }
120 | }
121 |
122 | #[cfg(feature = "udev-backend")]
123 | impl<'a> RenderElement> for FhtTextureElement {
124 | fn draw(
125 | &self,
126 | frame: &mut UdevFrame<'a, '_, '_>,
127 | src: Rectangle,
128 | dst: Rectangle,
129 | damage: &[Rectangle],
130 | opaque_regions: &[Rectangle],
131 | ) -> Result<(), UdevRenderError> {
132 | as RenderElement>::draw(
133 | &self.0,
134 | frame.as_mut(),
135 | src,
136 | dst,
137 | damage,
138 | opaque_regions,
139 | )
140 | .map_err(UdevRenderError::Render)
141 | }
142 |
143 | fn underlying_storage(
144 | &self,
145 | _: &mut UdevRenderer<'a>,
146 | ) -> Option {
147 | None // pixel shader elements can't be scanned out.
148 | }
149 | }
150 |
--------------------------------------------------------------------------------
/src/renderer/texture_shader_element.rs:
--------------------------------------------------------------------------------
1 | use smithay::backend::renderer::element::{Element, Id, Kind, RenderElement};
2 | use smithay::backend::renderer::gles::element::TextureShaderElement;
3 | use smithay::backend::renderer::gles::GlesError;
4 | use smithay::backend::renderer::glow::{GlowFrame, GlowRenderer};
5 | use smithay::backend::renderer::utils::CommitCounter;
6 | use smithay::utils::{Buffer, Physical, Point, Rectangle, Scale, Transform};
7 |
8 | #[cfg(feature = "udev-backend")]
9 | use crate::backend::udev::{UdevFrame, UdevRenderError, UdevRenderer};
10 |
11 | /// NewType wrapper to impl [`TextureShaderElement`] for [`UdevRenderer`]
12 | #[derive(Debug)]
13 | pub struct FhtTextureShaderElement(pub TextureShaderElement);
14 |
15 | impl From for FhtTextureShaderElement {
16 | fn from(value: TextureShaderElement) -> Self {
17 | Self(value)
18 | }
19 | }
20 |
21 | impl Element for FhtTextureShaderElement {
22 | fn id(&self) -> &Id {
23 | self.0.id()
24 | }
25 |
26 | fn current_commit(&self) -> CommitCounter {
27 | self.0.current_commit()
28 | }
29 |
30 | fn src(&self) -> Rectangle {
31 | self.0.src()
32 | }
33 |
34 | fn geometry(&self, scale: Scale) -> Rectangle {
35 | self.0.geometry(scale)
36 | }
37 |
38 | fn location(&self, scale: Scale) -> Point {
39 | self.geometry(scale).loc
40 | }
41 |
42 | fn transform(&self) -> Transform {
43 | Transform::Normal
44 | }
45 |
46 | fn damage_since(
47 | &self,
48 | scale: Scale,
49 | commit: Option,
50 | ) -> smithay::backend::renderer::utils::DamageSet {
51 | self.0.damage_since(scale, commit)
52 | }
53 |
54 | fn alpha(&self) -> f32 {
55 | self.0.alpha()
56 | }
57 |
58 | fn kind(&self) -> Kind {
59 | self.0.kind()
60 | }
61 | }
62 |
63 | impl RenderElement for FhtTextureShaderElement {
64 | fn draw(
65 | &self,
66 | frame: &mut GlowFrame<'_, '_>,
67 | src: Rectangle,
68 | dst: Rectangle,
69 | damage: &[Rectangle],
70 | opaque_regions: &[Rectangle],
71 | ) -> Result<(), GlesError> {
72 | >::draw(
73 | &self.0,
74 | frame,
75 | src,
76 | dst,
77 | damage,
78 | opaque_regions,
79 | )
80 | }
81 |
82 | fn underlying_storage(
83 | &self,
84 | renderer: &mut GlowRenderer,
85 | ) -> Option {
86 | self.0.underlying_storage(renderer)
87 | }
88 | }
89 |
90 | #[cfg(feature = "udev-backend")]
91 | impl<'a> RenderElement> for FhtTextureShaderElement {
92 | fn draw(
93 | &self,
94 | frame: &mut UdevFrame<'a, '_, '_>,
95 | src: Rectangle,
96 | dst: Rectangle,
97 | damage: &[Rectangle],
98 | opaque_regions: &[Rectangle],
99 | ) -> Result<(), UdevRenderError> {
100 | >::draw(
101 | &self.0,
102 | frame.as_mut(),
103 | src,
104 | dst,
105 | damage,
106 | opaque_regions,
107 | )
108 | .map_err(UdevRenderError::Render)
109 | }
110 |
111 | fn underlying_storage(
112 | &self,
113 | _: &mut UdevRenderer<'a>,
114 | ) -> Option {
115 | None // pixel shader elements can't be scanned out.
116 | }
117 | }
118 |
--------------------------------------------------------------------------------
/src/space/closing_tile.rs:
--------------------------------------------------------------------------------
1 | use std::time::Duration;
2 |
3 | use fht_animation::Animation;
4 | use smithay::backend::allocator::Fourcc;
5 | use smithay::backend::renderer::element::solid::SolidColorRenderElement;
6 | use smithay::backend::renderer::element::texture::{TextureBuffer, TextureRenderElement};
7 | use smithay::backend::renderer::element::utils::{
8 | Relocate, RelocateRenderElement, RescaleRenderElement,
9 | };
10 | use smithay::backend::renderer::element::{Element as _, Id, Kind};
11 | use smithay::backend::renderer::gles::GlesTexture;
12 | use smithay::backend::renderer::glow::GlowRenderer;
13 | use smithay::backend::renderer::utils::CommitCounter;
14 | use smithay::backend::renderer::Color32F;
15 | use smithay::utils::{Logical, Point, Rectangle, Scale, Transform};
16 |
17 | use super::tile::TileRenderElement;
18 | use crate::fht_render_elements;
19 | use crate::renderer::render_to_texture;
20 | use crate::renderer::texture_element::FhtTextureElement;
21 |
22 | const CLOSE_SCALE_THRESHOLD: f64 = 0.8;
23 | const FALLBACK_BUFFER_COLOR: Color32F = Color32F::new(1.0, 0.0, 0.0, 1.0);
24 |
25 | /// A representation of a closing [`Tile`](super::tile::Tile).
26 | ///
27 | /// When the tile's [`Window`](crate::window::Window) gets unmapped, or dies, the tile will have
28 | /// prepared in advance a list of render elements that constitutes the "snapshot" or the last frame
29 | /// before unmapped, used to animate a closing effect where the tile pops out.
30 | #[derive(Debug)]
31 | pub struct ClosingTile {
32 | /// The texture with the tile's render elements.
33 | ///
34 | /// If this is [`None`], a [`SolidColorBuffer`] will get rendered as a fallback.
35 | texture: Option<(TextureBuffer, Point)>,
36 | /// The last registered tile geometry.
37 | geometry: Rectangle,
38 | /// The animation.
39 | progress: Animation,
40 | }
41 |
42 | fht_render_elements! {
43 | ClosingTileRenderElement => {
44 | Texture = RelocateRenderElement>,
45 | Solid = SolidColorRenderElement,
46 | }
47 | }
48 |
49 | impl ClosingTile {
50 | pub fn new(
51 | renderer: &mut GlowRenderer,
52 | render_elements: Vec>,
53 | geometry: Rectangle,
54 | scale: Scale,
55 | animation: &super::AnimationConfig,
56 | ) -> Self {
57 | let geo = render_elements
58 | .iter()
59 | .fold(Rectangle::default(), |acc, e| acc.merge(e.geometry(scale)));
60 | let render_elements = render_elements.into_iter().rev().map(|e| {
61 | RelocateRenderElement::from_element(e, (-geo.loc.x, -geo.loc.y), Relocate::Relative)
62 | });
63 |
64 | let texture = match render_to_texture(
65 | renderer,
66 | geo.size,
67 | scale,
68 | Transform::Normal,
69 | Fourcc::Abgr8888,
70 | render_elements.into_iter(),
71 | ) {
72 | Ok((texture, _)) => {
73 | let texture = TextureBuffer::from_texture(
74 | renderer,
75 | texture,
76 | scale.x.max(scale.y) as i32,
77 | Transform::Normal,
78 | None,
79 | );
80 | Some((texture, geo.loc.to_f64().to_logical(scale).to_i32_round()))
81 | }
82 | Err(err) => {
83 | warn!(?err, "Failed to render texture for ClosingTile");
84 | None
85 | }
86 | };
87 |
88 | Self {
89 | texture,
90 | geometry,
91 | progress: Animation::new(1.0, 0.0, animation.duration).with_curve(animation.curve),
92 | }
93 | }
94 |
95 | pub fn advance_animations(&mut self, target_presentation_time: Duration) {
96 | self.progress.tick(target_presentation_time);
97 | }
98 |
99 | /// Did we finish animating the closing animation.
100 | pub fn is_finished(&self) -> bool {
101 | self.progress.is_finished()
102 | }
103 |
104 | /// Render this [`ClosingTile`].
105 | ///
106 | /// NOTE: It is up to YOU to assure that the rendered that will draw the
107 | /// [`ClosingTileRenderElement`] is the same one used to create the [`ClosingTile`].
108 | pub fn render(&self, scale: i32, alpha: f32) -> ClosingTileRenderElement {
109 | let Some((texture, offset)) = &self.texture else {
110 | return SolidColorRenderElement::new(
111 | Id::new(),
112 | self.geometry.to_physical_precise_round(scale),
113 | CommitCounter::default(),
114 | FALLBACK_BUFFER_COLOR,
115 | Kind::Unspecified,
116 | )
117 | .into();
118 | };
119 | let progress = self.progress.value();
120 |
121 | let texture: FhtTextureElement = TextureRenderElement::from_texture_buffer(
122 | Point::from((0., 0.)),
123 | texture,
124 | Some(progress.clamp(0., 1.) as f32 * alpha),
125 | None,
126 | None,
127 | Kind::Unspecified,
128 | )
129 | .into();
130 |
131 | let center = self.geometry.size.to_point().downscale(2);
132 | let origin = (center + *offset).to_physical_precise_round(scale);
133 | let rescale = progress * (1.0 - CLOSE_SCALE_THRESHOLD) + CLOSE_SCALE_THRESHOLD;
134 | let rescale = RescaleRenderElement::from_element(texture, origin, rescale);
135 |
136 | let location = (self.geometry.loc + *offset).to_physical_precise_round(scale);
137 | let relocate = RelocateRenderElement::from_element(rescale, location, Relocate::Relative);
138 | ClosingTileRenderElement::Texture(relocate)
139 | }
140 | }
141 |
--------------------------------------------------------------------------------
/src/space/decorations.rs:
--------------------------------------------------------------------------------
1 | //! Decorations rendering.
2 | //!
3 | //! This is achieved using a GlesPixelShader, nothing special otherwise.
4 |
5 | use smithay::backend::renderer::element::Kind;
6 | use smithay::backend::renderer::gles::Uniform;
7 | use smithay::utils::{Logical, Point, Rectangle, Size};
8 |
9 | use crate::renderer::pixel_shader_element::FhtPixelShaderElement;
10 | use crate::renderer::shaders::Shaders;
11 | use crate::renderer::AsGlowRenderer;
12 |
13 | pub fn draw_border(
14 | renderer: &mut impl AsGlowRenderer,
15 | scale: i32,
16 | alpha: f32,
17 | geometry: Rectangle,
18 | thickness: f64,
19 | radius: f64,
20 | color: fht_compositor_config::Color,
21 | ) -> FhtPixelShaderElement {
22 | let scaled_thickness = thickness * scale as f64;
23 | let (start_color, end_color, angle) = match color {
24 | fht_compositor_config::Color::Solid(color) => (color, color, 0.0),
25 | fht_compositor_config::Color::Gradient { start, end, angle } => (start, end, angle),
26 | };
27 |
28 | // Only draw whats needed for the border.
29 | //
30 | // XXXXXXXXXXXXXXXXXX
31 | // XXooooooooooooooXX
32 | // XooooooooooooooooX
33 | // XooooooooooooooooX
34 | // XooooooooooooooooX
35 | // XooooooooooooooooX
36 | // XXooooooooooooooXX
37 | // XXXXXXXXXXXXXXXXXX
38 | //
39 | // We leave the four patches of X at each border for corner radius
40 | // FIXME: const?
41 | let border_damage = Rectangle::from_size(geometry.size).subtract_rect(Rectangle::new(
42 | Point::from((scaled_thickness, scaled_thickness)).to_i32_round(),
43 | geometry.size
44 | - Size::from((scaled_thickness, scaled_thickness))
45 | .upscale(2.0)
46 | .to_i32_round(),
47 | ));
48 |
49 | FhtPixelShaderElement::new(
50 | Shaders::get(renderer.glow_renderer()).border.clone(),
51 | geometry,
52 | alpha,
53 | vec![
54 | Uniform::new("v_start_color", start_color),
55 | Uniform::new("v_end_color", end_color),
56 | Uniform::new("v_gradient_angle", angle),
57 | // NOTE: For some reasons we cant use f64s, we shall cast
58 | Uniform::new("thickness", scaled_thickness as f32),
59 | Uniform::new("corner_radius", radius as f32),
60 | ],
61 | Some(&border_damage),
62 | Kind::Unspecified,
63 | )
64 | }
65 |
66 | // Shadow drawing shader using the following article code:
67 | // https://madebyevan.com/shaders/fast-rounded-rectangle-shadows/
68 | pub fn draw_shadow(
69 | renderer: &mut impl AsGlowRenderer,
70 | alpha: f32,
71 | scale: i32,
72 | mut geometry: Rectangle,
73 | blur_sigma: f32,
74 | corner_radius: f32,
75 | color: [f32; 4],
76 | ) -> FhtPixelShaderElement {
77 | let scaled_blur_sigma = (blur_sigma / scale as f32).round() as i32;
78 | geometry.loc -= Point::from((scaled_blur_sigma, scaled_blur_sigma));
79 | geometry.size += Size::from((2 * scaled_blur_sigma, 2 * scaled_blur_sigma));
80 |
81 | // We only draw the shadow around the window, its pointless to damage everything, only causing
82 | // useless drawing from the GPU.
83 | //
84 | // XXXXXXXXXXXXXXXXXX
85 | // XXooooooooooooooXX
86 | // XXooooooooooooooXX
87 | // XXooooooooooooooXX
88 | // XXooooooooooooooXX
89 | // XXXXXXXXXXXXXXXXXX
90 | //
91 | // We generate the damage for the regions marked by X, relative to (0,0)
92 | // FIXME: const?
93 | let shadow_damage = Rectangle::from_size(geometry.size).subtract_rect(Rectangle::new(
94 | Point::from((scaled_blur_sigma, scaled_blur_sigma)),
95 | geometry.size - Size::from((scaled_blur_sigma, scaled_blur_sigma)).upscale(2),
96 | ));
97 |
98 | FhtPixelShaderElement::new(
99 | Shaders::get(renderer.glow_renderer()).box_shadow.clone(),
100 | geometry,
101 | alpha,
102 | vec![
103 | // NOTE: For some reasons we cant use f64s, we shall cast
104 | Uniform::new("shadow_color", color),
105 | Uniform::new("blur_sigma", blur_sigma),
106 | Uniform::new("corner_radius", corner_radius),
107 | ],
108 | Some(&shadow_damage),
109 | Kind::Unspecified,
110 | )
111 | }
112 |
--------------------------------------------------------------------------------
/src/utils/mod.rs:
--------------------------------------------------------------------------------
1 | use std::mem::MaybeUninit;
2 | use std::os::unix::process::CommandExt;
3 | use std::process::Stdio;
4 | use std::time::Duration;
5 |
6 | use smithay::reexports::rustix;
7 | use smithay::utils::{Coordinate, Point, Rectangle};
8 |
9 | #[cfg(feature = "xdg-screencast-portal")]
10 | pub mod pipewire;
11 |
12 | pub fn get_monotonic_time() -> Duration {
13 | // This does the same job as a Clock provided by smithay.
14 | // I do not understand why they decided to put on an abstraction
15 | //
16 | // We also do not use the Time structure provided by smithay since its really
17 | // annoying to work with (addition, difference, etc...)
18 | let timespec = rustix::time::clock_gettime(rustix::time::ClockId::Monotonic);
19 | Duration::new(timespec.tv_sec as u64, timespec.tv_nsec as u32)
20 | }
21 |
22 | pub fn spawn(cmd: &str) {
23 | let cmd = cmd.to_string();
24 | crate::profile_function!();
25 | let res = std::thread::Builder::new()
26 | .name("Command spawner".to_string())
27 | .spawn(move || {
28 | let mut command = std::process::Command::new("/bin/sh");
29 | command.args(["-c", &cmd]);
30 | // Disable all IO.
31 | command
32 | .stdin(Stdio::null())
33 | .stdout(Stdio::null())
34 | .stderr(Stdio::null());
35 |
36 | // Double for in order to avoid the command being a child of fht-compositor.
37 | // This will allow us to avoid creating zombie processes.
38 | //
39 | // This also lets us not waitpid from the child
40 | unsafe {
41 | command.pre_exec(|| {
42 | match libc::fork() {
43 | -1 => return Err(std::io::Error::last_os_error()),
44 | 0 => (),
45 | _ => libc::_exit(0),
46 | }
47 |
48 | if libc::setsid() == -1 {
49 | return Err(std::io::Error::last_os_error());
50 | }
51 |
52 | // Reset signal handlers.
53 | let mut signal_set = MaybeUninit::uninit();
54 | libc::sigemptyset(signal_set.as_mut_ptr());
55 | libc::sigprocmask(
56 | libc::SIG_SETMASK,
57 | signal_set.as_mut_ptr(),
58 | std::ptr::null_mut(),
59 | );
60 |
61 | Ok(())
62 | });
63 | }
64 |
65 | let mut child = match command.spawn() {
66 | Ok(child) => child,
67 | Err(err) => {
68 | warn!(?err, ?cmd, "Error spawning command");
69 | return;
70 | }
71 | };
72 |
73 | match child.wait() {
74 | Ok(status) => {
75 | if !status.success() {
76 | warn!(?status, "Child didn't exit sucessfully")
77 | }
78 | }
79 | Err(err) => {
80 | warn!(?err, "Failed to wait for child")
81 | }
82 | }
83 | });
84 |
85 | if let Err(err) = res {
86 | warn!(?err, "Failed to create command spawner for command")
87 | }
88 | }
89 |
90 | pub trait RectCenterExt {
91 | fn center(self) -> Point;
92 | }
93 |
94 | impl RectCenterExt for Rectangle {
95 | fn center(self) -> Point {
96 | self.loc + self.size.downscale(2).to_point()
97 | }
98 | }
99 |
100 | impl RectCenterExt for Rectangle {
101 | fn center(self) -> Point {
102 | self.loc + self.size.downscale(2.0).to_point()
103 | }
104 | }
105 |
--------------------------------------------------------------------------------
5 | 
6 | 
7 | 