metal: track per-framebuffer damage

src/damage.rs

@@ -1,14 +1,19 @@
 use {
     crate::{
         async_engine::AsyncEngine,
+        fixed::Fixed,
+        ifs::wl_output::WlOutputGlobal,
         rect::{Rect, Region},
         renderer::renderer_base::RendererBase,
         state::State,
         theme::Color,
         time::Time,
-        utils::{asyncevent::AsyncEvent, errorfmt::ErrorFmt, timer::TimerFd},
+        utils::{
+            asyncevent::AsyncEvent, errorfmt::ErrorFmt, timer::TimerFd, transform_ext::TransformExt,
+        },
     },
     isnt::std_1::primitive::IsntSliceExt,
+    jay_config::video::Transform,
     std::{
         cell::{Cell, RefCell},
         collections::VecDeque,
@@ -56,6 +61,9 @@ pub async fn visualize_damage(state: Rc<State>) {
 fn damage_all(state: &State) {
     for connector in state.connectors.lock().values() {
         if connector.connected.get() {
+            let damage = &mut *connector.damage.borrow_mut();
+            damage.clear();
+            damage.push(connector.damage_intersect.get());
             connector.damage();
         }
     }
@@ -126,10 +134,7 @@ impl DamageVisualizer {
         self.color.set(color);
     }
 
-    pub fn render(&self, cursor_rect: &Rect, renderer: &mut RendererBase<'_>) {
-        if !self.enabled.get() {
-            return;
-        }
+    fn trim(&self) {
         let now = self.eng.now();
         let entries = &mut *self.entries.borrow_mut();
         let decay = self.decay.get();
@@ -140,6 +145,16 @@ impl DamageVisualizer {
                 break;
             }
         }
+    }
+
+    pub fn render(&self, cursor_rect: &Rect, renderer: &mut RendererBase<'_>) {
+        if !self.enabled.get() {
+            return;
+        }
+        self.trim();
+        let now = self.eng.now();
+        let entries = &*self.entries.borrow();
+        let decay = self.decay.get();
         let base_color = self.color.get();
         let mut used = Region::empty();
         let dx = -cursor_rect.x1();
@@ -156,4 +171,129 @@ impl DamageVisualizer {
             }
         }
     }
+
+    pub fn copy_damage(&self, output: &WlOutputGlobal) {
+        if !self.enabled.get() {
+            return;
+        }
+        self.trim();
+        let entries = &*self.entries.borrow();
+        let pos = output.pos.get();
+        for entry in entries {
+            if entry.rect.intersects(&pos) {
+                output.add_damage_area(&entry.rect);
+            }
+        }
+    }
+}
+
+#[derive(Copy, Clone, Debug)]
+pub struct DamageMatrix {
+    transform: Transform,
+    mx: f64,
+    my: f64,
+    dx: f64,
+    dy: f64,
+    smear: i32,
+}
+
+impl Default for DamageMatrix {
+    fn default() -> Self {
+        Self {
+            transform: Default::default(),
+            mx: 1.0,
+            my: 1.0,
+            dx: 0.0,
+            dy: 0.0,
+            smear: 0,
+        }
+    }
+}
+
+impl DamageMatrix {
+    pub fn apply(&self, dx: i32, dy: i32, rect: Rect) -> Rect {
+        let x1 = rect.x1() - self.smear;
+        let x2 = rect.x2() + self.smear;
+        let y1 = rect.y1() - self.smear;
+        let y2 = rect.y2() + self.smear;
+        let [x1, y1, x2, y2] = match self.transform {
+            Transform::None => [x1, y1, x2, y2],
+            Transform::Rotate90 => [-y2, x1, -y1, x2],
+            Transform::Rotate180 => [-x2, -y2, -x1, -y1],
+            Transform::Rotate270 => [y1, -x2, y2, -x1],
+            Transform::Flip => [-x2, y1, -x1, y2],
+            Transform::FlipRotate90 => [y1, x1, y2, x2],
+            Transform::FlipRotate180 => [x1, -y2, x2, -y1],
+            Transform::FlipRotate270 => [-y2, -x2, -y1, -x1],
+        };
+        let x1 = (x1 as f64 * self.mx + self.dx).floor() as i32 + dx;
+        let y1 = (y1 as f64 * self.my + self.dy).floor() as i32 + dy;
+        let x2 = (x2 as f64 * self.mx + self.dx).ceil() as i32 + dx;
+        let y2 = (y2 as f64 * self.my + self.dy).ceil() as i32 + dy;
+        Rect::new(x1, y1, x2, y2).unwrap()
+    }
+
+    pub fn new(
+        transform: Transform,
+        legacy_scale: i32,
+        buffer_width: i32,
+        buffer_height: i32,
+        viewport: Option<[Fixed; 4]>,
+        dst_width: i32,
+        dst_height: i32,
+    ) -> DamageMatrix {
+        let mut buffer_width = buffer_width as f64;
+        let mut buffer_height = buffer_height as f64;
+        let dst_width = dst_width as f64;
+        let dst_height = dst_height as f64;
+
+        let mut mx = 1.0;
+        let mut my = 1.0;
+        if legacy_scale != 1 {
+            let scale_inv = 1.0 / (legacy_scale as f64);
+            mx = scale_inv;
+            my = scale_inv;
+            buffer_width *= scale_inv;
+            buffer_height *= scale_inv;
+        }
+        let (mut buffer_width, mut buffer_height) =
+            transform.maybe_swap((buffer_width, buffer_height));
+        let (mut dx, mut dy) = match transform {
+            Transform::None => (0.0, 0.0),
+            Transform::Rotate90 => (buffer_width, 0.0),
+            Transform::Rotate180 => (buffer_width, buffer_height),
+            Transform::Rotate270 => (0.0, buffer_height),
+            Transform::Flip => (buffer_width, 0.0),
+            Transform::FlipRotate90 => (0.0, 0.0),
+            Transform::FlipRotate180 => (0.0, buffer_height),
+            Transform::FlipRotate270 => (buffer_width, buffer_height),
+        };
+        if let Some([x, y, w, h]) = viewport {
+            dx -= x.to_f64();
+            dy -= y.to_f64();
+            buffer_width = w.to_f64();
+            buffer_height = h.to_f64();
+        }
+        let mut smear = false;
+        if dst_width != buffer_width {
+            let scale = dst_width / buffer_width;
+            mx *= scale;
+            dx *= scale;
+            smear |= dst_width > buffer_width;
+        }
+        if dst_height != buffer_height {
+            let scale = dst_height / buffer_height;
+            my *= scale;
+            dy *= scale;
+            smear |= dst_height > buffer_height;
+        }
+        DamageMatrix {
+            transform,
+            mx,
+            my,
+            dx,
+            dy,
+            smear: smear as _,
+        }
+    }
 }