monolith

public

Star0

Fork 0

Watch0

23 commits 1 branch 0 tags 0 releases1.5 MiB

Commit `96db497859dc`

tarball

atagen <boss@atagen.co>2026-10-16 11:42 UTC

9 files changed+305-38

render-vk, monolith: route spawn and close through a transition shader

Spawning windows and closing ghosts are drawn by an effect pipeline whose effect() function receives the transition kind and progress, so custom shaders later only replace that function. The built-in effect fades windows in and out. Subsurfaces and popups of a spawning window fade with the same progress through plain alpha, since only the root surface goes through the shader.

Modified file: crates/monolith/src/anim.rs+35 additions−1 deletions@@ -6,7 +6,7 @@ use monolith_config::{Animation, AnimationStyle};
 use monolith_layout::{OutputId, Rect, WindowId};
 use monolith_motion::{CubicBezier, Edges, Position, Timeline, group_initial_slope};
 use monolith_planner::{Config as PlanConfig, Plan, Style};
-use monolith_render_vk::VulkanTexture;
+use monolith_render_vk::{Effect, Transition, VulkanTexture};
 use smithay::utils::{Logical, Rectangle, Transform};
 use std::collections::HashMap;
 
@@ -17,6 +17,7 @@ pub struct Animator {
     tracks: HashMap<OutputId, Track>,
     glides: HashMap<WindowId, Glide>,
     ghosts: Vec<Ghost>,
+    spawns: HashMap<WindowId, u64>,
 }
 
 /// A closed tiled window that stays in its output's plan, shrinking to
@@ -30,6 +31,7 @@ pub struct Ghost {
     pub transform: Transform,
     /// Window geometry inside the buffer.
     pub geometry: Rectangle<i32, Logical>,
+    pub born: u64,
 }
 
 struct Track {
@@ -56,6 +58,7 @@ impl Animator {
             tracks: HashMap::new(),
             glides: HashMap::new(),
             ghosts: Vec::new(),
+            spawns: HashMap::new(),
         }
     }
 
@@ -201,13 +204,44 @@ impl Animator {
         &self.ghosts
     }
 
+    pub fn spawned(&mut self, id: WindowId, now: u64) {
+        if self.phase_ns() > 0 {
+            self.spawns.insert(id, now);
+        }
+    }
+
+    /// The transition effect on a window, lasting one phase from its spawn.
+    pub fn effect(&self, id: WindowId, now: u64) -> Option<Effect> {
+        let start = *self.spawns.get(&id)?;
+        self.progress(start, now).map(|progress| Effect {
+            kind: Transition::Spawn,
+            progress,
+        })
+    }
+
+    pub fn ghost_effect(&self, g: &Ghost, now: u64) -> Effect {
+        Effect {
+            kind: Transition::Close,
+            progress: self.progress(g.born, now).unwrap_or(1.0),
+        }
+    }
+
+    fn progress(&self, start: u64, now: u64) -> Option<f32> {
+        let p = now.saturating_sub(start) as f64 / self.phase_ns() as f64;
+        (p < 1.0).then_some(p as f32)
+    }
+
     pub fn active(&self, now: u64) -> bool {
         self.tracks.values().any(|t| t.timeline.end_ns() > now)
             || self.glides.values().any(|g| g.timeline.end_ns() > now)
+            || !self.spawns.is_empty()
     }
 
     pub fn prune(&mut self, now: u64) {
         self.glides.retain(|_, g| g.timeline.end_ns() > now);
+        let phase = self.phase_ns();
+        self.spawns
+            .retain(|_, start| now.saturating_sub(*start) < phase);
         let tracks = &self.tracks;
         self.ghosts.retain(|g| {
             tracks

Modified file: crates/monolith/src/scene.rs+141 additions−11 deletions@@ -3,15 +3,17 @@
 
 use crate::anim::Animator;
 use monolith_layout::{Layout, Rect, WindowId};
-use monolith_render_vk::{VulkanRenderer, VulkanTexture};
+use monolith_render_vk::{Effect, VulkanFrame, VulkanRenderer, VulkanTexture};
 use smithay::backend::renderer::element::surface::WaylandSurfaceRenderElement;
 use smithay::backend::renderer::element::texture::TextureRenderElement;
 use smithay::backend::renderer::element::utils::CropRenderElement;
-use smithay::backend::renderer::element::{AsRenderElements, Id, Kind};
+use smithay::backend::renderer::element::{AsRenderElements, Element, Id, Kind, RenderElement};
+use smithay::backend::renderer::utils::CommitCounter;
 use smithay::backend::renderer::utils::with_renderer_surface_state;
-use smithay::backend::renderer::{ContextId, Renderer};
+use smithay::backend::renderer::{ContextId, Renderer, Texture};
 use smithay::desktop::Window;
-use smithay::utils::{Logical, Physical, Point, Rectangle, Scale, Size, Transform};
+use smithay::utils::user_data::UserDataMap;
+use smithay::utils::{Buffer, Logical, Physical, Point, Rectangle, Scale, Size, Transform};
 use std::collections::HashMap;
 
 smithay::backend::renderer::element::render_elements! {
@@ -19,6 +21,7 @@ smithay::backend::renderer::element::render_elements! {
     Surface=WaylandSurfaceRenderElement<VulkanRenderer>,
     Cropped=CropRenderElement<WaylandSurfaceRenderElement<VulkanRenderer>>,
     Texture=TextureRenderElement<VulkanTexture>,
+    Effect=EffectElement,
 }
 
 /// Elements for every output, front to back.
@@ -64,10 +67,9 @@ pub fn build(
     let mut out = Vec::new();
     for (id, r) in tiled.into_iter().chain(above).rev() {
         if let Some(window) = windows.get(&id) {
-            window_elements(&mut out, renderer, window, r);
+            window_elements(&mut out, renderer, window, r, anim.effect(id, now));
         }
     }
-    let context = renderer.context_id();
     for (g, r) in ghosts.into_iter().rev() {
         let Some((at, size)) = pixels(r) else {
             continue;
@@ -76,15 +78,15 @@ pub fn build(
             g.geometry.loc.to_f64(),
             (f64::from(size.0), f64::from(size.1)).into(),
         );
-        out.push(texture(
-            &context,
+        out.push(Draw::Effect(EffectElement::new(
             &g.texture,
             g.scale,
             g.transform,
             src,
             at,
             size,
-        ));
+            anim.ghost_effect(g, now),
+        )));
     }
     out
 }
@@ -92,14 +94,25 @@ pub fn build(
 /// Draws `window` filling `r`. A buffer bigger than `r` is cropped, and one
 /// smaller has its last row and column stretched over the rest, so a resize
 /// in flight never shows a scaled or missing client.
-fn window_elements(out: &mut Vec<Draw>, renderer: &mut VulkanRenderer, window: &Window, r: Rect) {
+fn window_elements(
+    out: &mut Vec<Draw>,
+    renderer: &mut VulkanRenderer,
+    window: &Window,
+    r: Rect,
+    effect: Option<Effect>,
+) {
     let Some(((x, y), (w, h))) = pixels(r) else {
         return;
     };
     let geo = window.geometry();
     let loc = Point::<i32, Physical>::from((x - geo.loc.x, y - geo.loc.y));
+    let alpha = effect.map_or(1.0, |e| e.progress);
     let elems: Vec<WaylandSurfaceRenderElement<VulkanRenderer>> =
-        window.render_elements(renderer, loc, Scale::from(1.0), 1.0);
+        window.render_elements(renderer, loc, Scale::from(1.0), alpha);
+    if let Some(effect) = effect {
+        effect_elements(out, renderer, window, elems, ((x, y), (w, h)), effect);
+        return;
+    }
     if (w, h) == (geo.size.w, geo.size.h) {
         out.extend(elems.into_iter().map(Draw::Surface));
         return;
@@ -182,3 +195,120 @@ fn texture(
         Kind::Unspecified,
     ))
 }
+
+/// A window in a spawn transition. Its root surface goes through the effect
+/// shader, clamped to fill its rect, and its subsurfaces and popups fade with it.
+fn effect_elements(
+    out: &mut Vec<Draw>,
+    renderer: &mut VulkanRenderer,
+    window: &Window,
+    elems: Vec<WaylandSurfaceRenderElement<VulkanRenderer>>,
+    (at, size): ((i32, i32), (i32, i32)),
+    effect: Effect,
+) {
+    let Some(root) = window.toplevel().map(|t| t.wl_surface().clone()) else {
+        return;
+    };
+    let root_id = Id::from_wayland_resource(&root);
+    let crop = Rectangle::new(at.into(), size.into());
+    let context = renderer.context_id();
+    let root_tex = with_renderer_surface_state(&root, |s| {
+        s.texture::<VulkanTexture>(context.clone())
+            .cloned()
+            .map(|t| (t, s.buffer_scale(), s.buffer_transform()))
+    })
+    .flatten();
+    out.extend(
+        elems
+            .into_iter()
+            .filter(|e| root_tex.is_none() || *e.id() != root_id)
+            .filter_map(|e| CropRenderElement::from_element(e, 1.0, crop))
+            .map(Draw::Cropped),
+    );
+    if let Some((tex, scale, transform)) = root_tex {
+        let geo = window.geometry();
+        let src = Rectangle::new(
+            geo.loc.to_f64(),
+            (f64::from(size.0), f64::from(size.1)).into(),
+        );
+        out.push(Draw::Effect(EffectElement::new(
+            &tex, scale, transform, src, at, size, effect,
+        )));
+    }
+}
+
+/// A texture drawn through the transition hook in the effect shader.
+pub struct EffectElement {
+    id: Id,
+    texture: VulkanTexture,
+    src: Rectangle<f64, Buffer>,
+    geometry: Rectangle<i32, Physical>,
+    transform: Transform,
+    effect: Effect,
+}
+
+impl EffectElement {
+    fn new(
+        texture: &VulkanTexture,
+        scale: i32,
+        transform: Transform,
+        src: Rectangle<f64, Logical>,
+        at: (i32, i32),
+        size: (i32, i32),
+        effect: Effect,
+    ) -> Self {
+        let bounds = texture.size().to_logical(scale, transform).to_f64();
+        Self {
+            id: Id::new(),
+            texture: texture.clone(),
+            src: src.to_buffer(f64::from(scale), transform, &bounds),
+            geometry: Rectangle::new(at.into(), size.into()),
+            transform,
+            effect,
+        }
+    }
+}
+
+impl Element for EffectElement {
+    fn id(&self) -> &Id {
+        &self.id
+    }
+
+    fn current_commit(&self) -> CommitCounter {
+        CommitCounter::default()
+    }
+
+    fn src(&self) -> Rectangle<f64, Buffer> {
+        self.src
+    }
+
+    fn geometry(&self, _scale: Scale<f64>) -> Rectangle<i32, Physical> {
+        self.geometry
+    }
+
+    fn transform(&self) -> Transform {
+        self.transform
+    }
+}
+
+impl RenderElement<VulkanRenderer> for EffectElement {
+    fn draw(
+        &self,
+        frame: &mut VulkanFrame<'_, '_>,
+        src: Rectangle<f64, Buffer>,
+        dst: Rectangle<i32, Physical>,
+        damage: &[Rectangle<i32, Physical>],
+        _opaque_regions: &[Rectangle<i32, Physical>],
+        _cache: Option<&UserDataMap>,
+    ) -> Result<(), monolith_render_vk::Error> {
+        frame.render_effect(
+            &self.texture,
+            src,
+            dst,
+            damage,
+            self.transform,
+            1.0,
+            self.effect,
+        )
+    }
+}

Modified file: crates/monolith/src/state.rs+2 additions@@ -210,6 +210,7 @@ impl State {
             self.layout.scratchpad_add(id, name);
         }
         self.windows.insert(id, window);
+        self.anim.spawned(id, now_ns());
         if self.layout.visible(id) {
             self.layout.focus(id);
         }
@@ -271,6 +272,7 @@ impl State {
                 scale,
                 transform,
                 geometry: window.geometry(),
+                born: now_ns(),
             });
         }
     }

Modified file: crates/render-vk/build.rs+1−1

@@ -4,7 +4,7 @@ use std::process::Command;

44 fn main() {

55 let out = PathBuf::from(std::env::var("OUT_DIR").expect("OUT_DIR"));

66 println!("cargo:rerun-if-changed=shaders");

7- for name in ["quad.vert", "solid.frag", "texture.frag"] {

7+ for name in ["quad.vert", "solid.frag", "texture.frag", "effect.frag"] {

88 let status = Command::new("glslangValidator")

99 .args(["-V", "--target-env", "vulkan1.3", "-o"])

1010 .arg(out.join(format!("{name}.spv")))

Added file: crates/render-vk/shaders/effect.frag+27 additions@@ -0,0 +1,27 @@
+#version 450
+#extension GL_GOOGLE_include_directive : require
+#include "push.glsl"
+
+layout(set = 0, binding = 0) uniform sampler2D tex;
+layout(location = 0) in vec2 v_uv;
+layout(location = 0) out vec4 out_color;
+
+const int MOVE = 0;
+const int SPAWN = 1;
+const int CLOSE = 2;
+
+// The transition hook. Custom shaders will replace this function.
+vec4 effect(vec4 color, vec2 uv, float progress, int kind) {
+    if (kind == SPAWN) {
+        return color * progress;
+    }
+    if (kind == CLOSE) {
+        return color * (1.0 - progress);
+    }
+    return color;
+}
+
+void main() {
+    vec4 color = texture(tex, v_uv) * pc.color.a;
+    out_color = effect(color, v_uv, pc.effect.x, int(pc.effect.y));
+}

Modified file: crates/render-vk/shaders/push.glsl+1

@@ -5,4 +5,5 @@ layout(push_constant) uniform Push {

55 vec4 color;

66 vec4 dst;

77 vec2 uv[4];

8+ vec4 effect;

89 } pc;

Modified file: crates/render-vk/src/frame.rs+89 additions−24 deletions@@ -90,6 +90,70 @@ impl<'frame, 'buffer> VulkanFrame<'frame, 'buffer> {
             .collect()
     }
 
+    /// Draws a texture through the transition hook in `shaders/effect.frag`.
+    #[expect(clippy::too_many_arguments)]
+    pub fn render_effect(
+        &mut self,
+        texture: &VulkanTexture,
+        src: Rectangle<f64, Buffer>,
+        dst: Rectangle<i32, Physical>,
+        damage: &[Rectangle<i32, Physical>],
+        src_transform: Transform,
+        alpha: f32,
+        effect: Effect,
+    ) -> Result<(), Error> {
+        let params = [effect.progress, effect.kind as u32 as f32, 0.0, 0.0];
+        self.draw_texture(
+            texture,
+            src,
+            dst,
+            damage,
+            src_transform,
+            alpha,
+            Kind::Effect,
+            params,
+        )
+    }
+
+    #[expect(clippy::too_many_arguments)]
+    fn draw_texture(
+        &mut self,
+        texture: &VulkanTexture,
+        src: Rectangle<f64, Buffer>,
+        dst: Rectangle<i32, Physical>,
+        damage: &[Rectangle<i32, Physical>],
+        src_transform: Transform,
+        alpha: f32,
+        kind: Kind,
+        effect: [f32; 4],
+    ) -> Result<(), Error> {
+        if !Arc::ptr_eq(&texture.0.shared, self.renderer.shared()) {
+            return Err(Error::ForeignTexture);
+        }
+        if dst.size.w <= 0 || dst.size.h <= 0 || Arc::ptr_eq(&texture.0, &self.target.0) {
+            return Ok(());
+        }
+        let scissors = self.scissors(dst, damage);
+        if scissors.is_empty() {
+            return Ok(());
+        }
+        let uvs = texture_uvs(src, dst.size, texture.size(), src_transform);
+        let (fb, uv) = to_framebuffer(dst, uvs, self.output, self.transform);
+        let push = Push {
+            dst: self.ndc(fb),
+            uv,
+            color: [1.0, 1.0, 1.0, alpha],
+            effect,
+        };
+        self.ops.push(Op::Draw {
+            kind,
+            texture: Some(texture.clone()),
+            push,
+            scissors,
+        });
+        Ok(())
+    }
+
     fn ndc(&self, r: Rectangle<i32, Physical>) -> [f32; 4] {
         let fb = self.fb_size();
         let (w, h) = (fb.w as f32, fb.h as f32);
@@ -136,6 +200,7 @@ impl Frame for VulkanFrame<'_, '_> {
             dst: self.ndc(fb),
             uv: [[0.0; 2]; 4],
             color: color.components(),
+            effect: [0.0; 4],
         };
         self.ops.push(Op::Draw {
             kind: Kind::Solid,
@@ -156,30 +221,16 @@ impl Frame for VulkanFrame<'_, '_> {
         src_transform: Transform,
         alpha: f32,
     ) -> Result<(), Error> {
-        if !Arc::ptr_eq(&texture.0.shared, self.renderer.shared()) {
-            return Err(Error::ForeignTexture);
-        }
-        if dst.size.w <= 0 || dst.size.h <= 0 || Arc::ptr_eq(&texture.0, &self.target.0) {
-            return Ok(());
-        }
-        let scissors = self.scissors(dst, damage);
-        if scissors.is_empty() {
-            return Ok(());
-        }
-        let uvs = texture_uvs(src, dst.size, texture.size(), src_transform);
-        let (fb, uv) = to_framebuffer(dst, uvs, self.output, self.transform);
-        let push = Push {
-            dst: self.ndc(fb),
-            uv,
-            color: [1.0, 1.0, 1.0, alpha],
-        };
-        self.ops.push(Op::Draw {
-            kind: Kind::Texture,
-            texture: Some(texture.clone()),
-            push,
-            scissors,
-        });
-        Ok(())
+        self.draw_texture(
+            texture,
+            src,
+            dst,
+            damage,
+            src_transform,
+            alpha,
+            Kind::Texture,
+            [0.0; 4],
+        )
     }
 
     fn transformation(&self) -> Transform {
@@ -199,3 +250,17 @@ impl Frame for VulkanFrame<'_, '_> {
         self.renderer.submit(self.target, ops)
     }
 }
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum Transition {
+    Move = 0,
+    Spawn = 1,
+    Close = 2,
+}
+
+/// A window transition for the effect shader, with `progress` in [0, 1].
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub struct Effect {
+    pub kind: Transition,
+    pub progress: f32,
+}

Modified file: crates/render-vk/src/lib.rs+1−1

@@ -16,6 +16,6 @@ mod transform;

1616

1717 pub use dmabuf::VulkanAllocator;

1818 pub use error::Error;

19-pub use frame::VulkanFrame;

19+pub use frame::{Effect, Transition, VulkanFrame};

2020 pub use image::{VulkanImage, VulkanMapping, VulkanTarget, VulkanTexture};

2121 pub use renderer::VulkanRenderer;

Modified file: crates/render-vk/src/pipeline.rs+8 additions@@ -13,6 +13,8 @@ pub(crate) struct Push {
     pub color: [f32; 4],
     pub dst: [f32; 4],
     pub uv: [[f32; 2]; 4],
+    /// Transition progress and kind, read only by `shaders/effect.frag`.
+    pub effect: [f32; 4],
 }
 
 impl Push {
@@ -25,6 +27,7 @@ impl Push {
 pub(crate) enum Kind {
     Solid,
     Texture,
+    Effect,
 }
 
 pub(crate) struct Pipelines {
@@ -34,12 +37,14 @@ pub(crate) struct Pipelines {
     vert: vk::ShaderModule,
     solid: vk::ShaderModule,
     texture: vk::ShaderModule,
+    effect: vk::ShaderModule,
     cache: HashMap<(vk::Format, Kind), vk::Pipeline>,
 }
 
 const QUAD_VERT: &[u8] = include_bytes!(concat!(env!("OUT_DIR"), "/quad.vert.spv"));
 const SOLID_FRAG: &[u8] = include_bytes!(concat!(env!("OUT_DIR"), "/solid.frag.spv"));
 const TEXTURE_FRAG: &[u8] = include_bytes!(concat!(env!("OUT_DIR"), "/texture.frag.spv"));
+const EFFECT_FRAG: &[u8] = include_bytes!(concat!(env!("OUT_DIR"), "/effect.frag.spv"));
 
 impl Pipelines {
     pub fn new(shared: &Arc<Shared>) -> Result<Self, Error> {
@@ -83,6 +88,7 @@ impl Pipelines {
             vert: module(QUAD_VERT)?,
             solid: module(SOLID_FRAG)?,
             texture: module(TEXTURE_FRAG)?,
+            effect: module(EFFECT_FRAG)?,
             cache: HashMap::new(),
         })
     }
@@ -95,6 +101,7 @@ impl Pipelines {
         let frag = match kind {
             Kind::Solid => self.solid,
             Kind::Texture => self.texture,
+            Kind::Effect => self.effect,
         };
         let stages = [
             vk::PipelineShaderStageCreateInfo::default()
@@ -162,6 +169,7 @@ impl Drop for Pipelines {
             d.destroy_shader_module(self.vert, None);
             d.destroy_shader_module(self.solid, None);
             d.destroy_shader_module(self.texture, None);
+            d.destroy_shader_module(self.effect, None);
             d.destroy_pipeline_layout(self.layout, None);
             d.destroy_descriptor_set_layout(self.set_layout, None);
         }

monolith

Commit 96db497859dc

Commit `96db497859dc`