shader_element: Store program type instead of shader

4 files changed, 56 insertions, 27 deletions

diff --git a/src/layout/focus_ring.rs b/src/layout/focus_ring.rs
index 155d3254..18b5d5ca 100644
--- a/src/layout/focus_ring.rs
+++ b/src/layout/focus_ring.rs
@@ -51,6 +51,13 @@ impl FocusRing {
         self.config = config;
     }
 
+    pub fn update_shaders(&mut self) {
+        let mut borders = self.borders.borrow_mut();
+        for elem in &mut *borders {
+            elem.damage_all();
+        }
+    }
+
     pub fn update(&mut self, win_size: Size<i32, Logical>, is_border: bool, radius: CornerRadius) {
         let width = i32::from(self.config.width);
         self.full_size = win_size + Size::from((width * 2, width * 2));
@@ -138,9 +145,9 @@ impl FocusRing {
         self.is_active = is_active;
     }
 
-    pub fn render<R: NiriRenderer>(
+    pub fn render(
         &self,
-        renderer: &mut R,
+        renderer: &mut impl NiriRenderer,
         location: Point<i32, Logical>,
         scale: Scale<f64>,
         view_size: Size<i32, Logical>,
@@ -180,18 +187,14 @@ impl FocusRing {
         } else {
             0.
         };
-        let shader = BorderRenderElement::shader(renderer);
-
+        let has_border_shader = BorderRenderElement::has_shader(renderer);
         let mut borders = self.borders.borrow_mut();
-        for elem in &mut *borders {
-            elem.update_shader(shader);
-        }
 
         let mut push = |buffer,
                         border: &mut BorderRenderElement,
                         location: Point<i32, Logical>,
                         size: Size<i32, Logical>| {
-            let elem = if border.has_shader() {
+            let elem = if has_border_shader {
                 if let Some(gradient) = gradient {
                     let gradient_area = match gradient.relative_to {
                         GradientRelativeTo::Window => full_rect,
diff --git a/src/layout/mod.rs b/src/layout/mod.rs
index 83715364..b670b9f5 100644
--- a/src/layout/mod.rs
+++ b/src/layout/mod.rs
@@ -1371,6 +1371,23 @@ impl<W: LayoutElement> Layout<W> {
         }
     }
 
+    pub fn update_shaders(&mut self) {
+        match &mut self.monitor_set {
+            MonitorSet::Normal { monitors, .. } => {
+                for mon in monitors {
+                    for ws in &mut mon.workspaces {
+                        ws.update_shaders();
+                    }
+                }
+            }
+            MonitorSet::NoOutputs { workspaces, .. } => {
+                for ws in workspaces {
+                    ws.update_shaders();
+                }
+            }
+        }
+    }
+
     pub fn update_config(&mut self, config: &Config) {
         let options = Rc::new(Options::from_config(config));
 
diff --git a/src/layout/tile.rs b/src/layout/tile.rs
index b47afc76..99b2bc57 100644
--- a/src/layout/tile.rs
+++ b/src/layout/tile.rs
@@ -142,6 +142,11 @@ impl<W: LayoutElement> Tile<W> {
         self.options = options;
     }
 
+    pub fn update_shaders(&mut self) {
+        self.border.update_shaders();
+        self.focus_ring.update_shaders();
+    }
+
     pub fn update_window(&mut self) {
         // FIXME: remove when we can get a fullscreen size right away.
         if self.fullscreen_size != Size::from((0, 0)) {
@@ -594,7 +599,7 @@ impl<W: LayoutElement> Tile<W> {
                     .map(Into::into),
             );
 
-            if let Some(shader) = ResizeRenderElement::shader(renderer) {
+            if ResizeRenderElement::has_shader(renderer) {
                 let gles_renderer = renderer.as_gles_renderer();
 
                 if let Some(texture_from) = resize.snapshot.texture(gles_renderer, scale, target) {
@@ -623,7 +628,6 @@ impl<W: LayoutElement> Tile<W> {
 
                     if let Some((texture_current, _sync_point, texture_current_geo)) = current {
                         let elem = ResizeRenderElement::new(
-                            shader,
                             area,
                             scale,
                             texture_from.clone(),
@@ -680,7 +684,7 @@ impl<W: LayoutElement> Tile<W> {
                 .fit_to(window_size.w as f32, window_size.h as f32);
 
             let clip_shader = ClippedSurfaceRenderElement::shader(renderer).cloned();
-            let border_shader = BorderRenderElement::shader(renderer).cloned();
+            let has_border_shader = BorderRenderElement::has_shader(renderer);
 
             if clip_to_geometry && clip_shader.is_some() {
                 let damage = self.rounded_corner_damage.element();
@@ -715,22 +719,19 @@ impl<W: LayoutElement> Tile<W> {
                     // the unclipped window CSD already has corners rounded to the
                     // user-provided radius, so our blocked-out rendering should match that
                     // radius.
-                    if radius != CornerRadius::default() {
-                        if let Some(shader) = border_shader.clone() {
-                            return BorderRenderElement::new(
-                                &shader,
-                                scale,
-                                elem.geometry(Scale::from(1.)).to_logical(1),
-                                Rectangle::from_loc_and_size(Point::from((0, 0)), geo.size),
-                                elem.color(),
-                                elem.color(),
-                                0.,
-                                elem.geometry(Scale::from(1.)).to_logical(1),
-                                0.,
-                                radius,
-                            )
-                            .into();
-                        }
+                    if radius != CornerRadius::default() && has_border_shader {
+                        return BorderRenderElement::new(
+                            scale,
+                            elem.geometry(Scale::from(1.)).to_logical(1),
+                            Rectangle::from_loc_and_size(Point::from((0, 0)), geo.size),
+                            elem.color(),
+                            elem.color(),
+                            0.,
+                            elem.geometry(Scale::from(1.)).to_logical(1),
+                            0.,
+                            radius,
+                        )
+                        .into();
                     }
 
                     // Otherwise, render the solid color as is.
diff --git a/src/layout/workspace.rs b/src/layout/workspace.rs
index 1aa1a02b..3205d82b 100644
--- a/src/layout/workspace.rs
+++ b/src/layout/workspace.rs
@@ -333,6 +333,14 @@ impl<W: LayoutElement> Workspace<W> {
         self.options = options;
     }
 
+    pub fn update_shaders(&mut self) {
+        for col in &mut self.columns {
+            for tile in &mut col.tiles {
+                tile.update_shaders();
+            }
+        }
+    }
+
     pub fn windows(&self) -> impl Iterator<Item = &W> + '_ {
         self.columns
             .iter()