refactor: Add clamp_rect utility

Author: madsmtm

src/backends/wayland/mod.rs

@@ -260,7 +260,8 @@ impl BufferInterface for BufferImpl<'_> {
             self.surface.damage(0, 0, i32::MAX, i32::MAX);
         } else {
             for rect in damage {
-                // Damage that falls outside the surface is ignored.
+                // Damage that falls outside the surface is ignored, so we don't need to clamp the
+                // rect manually.
                 // https://wayland.freedesktop.org/docs/html/apa.html#protocol-spec-wl_surface
                 let x = to_i32_saturating(rect.x);
                 let y = to_i32_saturating(rect.y);

src/backends/web.rs

@@ -337,7 +337,7 @@ impl BufferInterface for BufferImpl<'_> {
             .expect("Must set size of surface before calling `present_with_damage()`");
 
         let union_damage = if let Some(rect) = util::union_damage(damage) {
-            rect
+            util::clamp_rect(rect, buffer_width, buffer_height)
         } else {
             return Ok(());
         };
@@ -359,9 +359,7 @@ impl BufferInterface for BufferImpl<'_> {
 
         debug_assert_eq!(
             bitmap.len(),
-            union_damage.width.get().min(buffer_width.get()) as usize
-                * union_damage.height.get().min(buffer_height.get()) as usize
-                * 4
+            union_damage.width.get() as usize * union_damage.height.get() as usize * 4
         );
 
         #[cfg(target_feature = "atomics")]
@@ -384,29 +382,31 @@ impl BufferInterface for BufferImpl<'_> {
             let array = Uint8Array::new_with_length(bitmap.len() as u32);
             array.copy_from(&bitmap);
             let array = Uint8ClampedArray::new(&array);
-            ImageDataExt::new(array, union_damage.width.get().min(buffer_width.get()))
+            ImageDataExt::new(array, union_damage.width.get())
                 .map(JsValue::from)
                 .map(ImageData::unchecked_from_js)
         };
         #[cfg(not(target_feature = "atomics"))]
         let result = ImageData::new_with_u8_clamped_array(
             wasm_bindgen::Clamped(&bitmap),
-            union_damage.width.get().min(buffer_width.get()),
+            union_damage.width.get(),
         );
         // This should only throw an error if the buffer we pass's size is incorrect.
         let image_data = result.unwrap();
 
         for rect in damage {
+            let rect = util::clamp_rect(*rect, buffer_width, buffer_height);
+
             // This can only throw an error if `data` is detached, which is impossible.
             self.canvas
                 .put_image_data(
                     &image_data,
-                    union_damage.x.min(buffer_width.get()).into(),
-                    union_damage.y.min(buffer_height.get()).into(),
+                    union_damage.x.into(),
+                    union_damage.y.into(),
                     (rect.x - union_damage.x).into(),
                     (rect.y - union_damage.y).into(),
-                    rect.width.get().min(buffer_width.get()).into(),
-                    rect.height.get().min(buffer_height.get()).into(),
+                    rect.width.get().into(),
+                    rect.height.get().into(),
                 )
                 .unwrap();
         }

src/backends/win32.rs

@@ -3,7 +3,7 @@
 //! This module converts the input buffer into a bitmap and then stretches it to the window.
 
 use crate::backend_interface::*;
-use crate::{Rect, SoftBufferError};
+use crate::{util, Rect, SoftBufferError};
 use raw_window_handle::{HasDisplayHandle, HasWindowHandle, RawWindowHandle};
 
 use std::io;
@@ -273,21 +273,26 @@ impl BufferInterface for BufferImpl<'_> {
 
     fn present_with_damage(self, damage: &[Rect]) -> Result<(), SoftBufferError> {
         unsafe {
-            for rect in damage.iter().copied() {
+            for rect in damage {
+                let rect = util::clamp_rect(
+                    *rect,
+                    self.buffer.width.try_into().unwrap(),
+                    self.buffer.height.try_into().unwrap(),
+                );
                 let x = to_i32_saturating(rect.x);
                 let y = to_i32_saturating(rect.y);
                 let width = to_i32_saturating(rect.width.get());
                 let height = to_i32_saturating(rect.height.get());
 
                 Gdi::BitBlt(
                     self.dc.0,
-                    x.min(self.buffer.width.get()),
-                    y.min(self.buffer.height.get()),
-                    width.min(self.buffer.width.get()),
-                    height.min(self.buffer.height.get()),
+                    x,
+                    y,
+                    width,
+                    height,
                     self.buffer.dc,
-                    x.min(self.buffer.width.get()),
-                    y.min(self.buffer.height.get()),
+                    x,
+                    y,
                     Gdi::SRCCOPY,
                 );
             }

src/backends/x11.rs

@@ -469,6 +469,11 @@ impl BufferInterface for BufferImpl<'_> {
                     damage
                         .iter()
                         .try_for_each(|rect| {
+                            let rect = util::clamp_rect(
+                                *rect,
+                                surface_width.into(),
+                                surface_height.into(),
+                            );
                             let src_x = to_u16_saturating(rect.x);
                             let src_y = to_u16_saturating(rect.y);
                             let dst_x = to_i16_saturating(rect.x);
@@ -482,12 +487,12 @@ impl BufferInterface for BufferImpl<'_> {
                                     self.gc,
                                     surface_width.get(),
                                     surface_height.get(),
-                                    src_x.min(surface_width.get()),
-                                    src_y.min(surface_height.get()),
-                                    width.min(surface_width.get()),
-                                    height.min(surface_height.get()),
-                                    dst_x.min(surface_width.get() as i16),
-                                    dst_y.min(surface_height.get() as i16),
+                                    src_x,
+                                    src_y,
+                                    width,
+                                    height,
+                                    dst_x,
+                                    dst_y,
                                     self.depth,
                                     xproto::ImageFormat::Z_PIXMAP.into(),
                                     false,

src/util.rs

@@ -43,6 +43,22 @@ pub(crate) fn union_damage(damage: &[Rect]) -> Option<Rect> {
     })
 }
 
+/// Clamp the damage rectangle to be within the given bounds.
+pub(crate) fn clamp_rect(rect: Rect, width: NonZeroU32, height: NonZeroU32) -> Rect {
+    // The positions of the edges of the rectangle.
+    let left = rect.x.min(width.get());
+    let top = rect.y.min(height.get());
+    let right = rect.x.saturating_add(rect.width.get()).min(width.get());
+    let bottom = rect.y.saturating_add(rect.height.get()).min(height.get());
+
+    Rect {
+        x: left,
+        y: top,
+        width: NonZeroU32::new(right - left).expect("rect ended up being zero-sized"),
+        height: NonZeroU32::new(bottom - top).expect("rect ended up being zero-sized"),
+    }
+}
+
 /// A wrapper around a `Vec` of pixels that doesn't print the whole buffer on `Debug`.
 #[derive(PartialEq, Eq, Hash, Clone)]
 pub(crate) struct PixelBuffer(pub Vec<u32>);