Add Buffer::width and Buffer::height

CHANGELOG.md

@@ -2,6 +2,7 @@
 
 - Update to `objc2` 0.6.0.
 - Bump MSRV to Rust 1.71.
+- Added `Buffer::width` and `Buffer::height`.
 
 # 0.4.6
 

src/backend_dispatch.rs

@@ -124,6 +124,26 @@ macro_rules! make_dispatch {
         }
 
         impl<'a, D: HasDisplayHandle, W: HasWindowHandle> BufferInterface for BufferDispatch<'a, D, W> {
+            #[inline]
+            fn width(&self) -> usize {
+                match self {
+                    $(
+                        $(#[$attr])*
+                        Self::$name(inner) => inner.width(),
+                    )*
+                }
+            }
+
+            #[inline]
+            fn height(&self) -> usize {
+                match self {
+                    $(
+                        $(#[$attr])*
+                        Self::$name(inner) => inner.height(),
+                    )*
+                }
+            }
+
             #[inline]
             fn pixels(&self) -> &[u32] {
                 match self {

src/backend_interface.rs

@@ -35,6 +35,8 @@ pub(crate) trait SurfaceInterface<D: HasDisplayHandle + ?Sized, W: HasWindowHand
 }
 
 pub(crate) trait BufferInterface {
+    fn width(&self) -> usize;
+    fn height(&self) -> usize;
     fn pixels(&self) -> &[u32];
     fn pixels_mut(&mut self) -> &mut [u32];
     fn age(&self) -> u8;

src/backends/android.rs

@@ -123,6 +123,14 @@ pub struct BufferImpl<'a, D: ?Sized, W> {
 unsafe impl<'a, D, W> Send for BufferImpl<'a, D, W> {}
 
 impl<'a, D: HasDisplayHandle, W: HasWindowHandle> BufferInterface for BufferImpl<'a, D, W> {
+    fn width(&self) -> usize {
+        self.native_window_buffer.width()
+    }
+
+    fn height(&self) -> usize {
+        self.native_window_buffer.height()
+    }
+
     #[inline]
     fn pixels(&self) -> &[u32] {
         &self.buffer

src/backends/cg.rs

@@ -269,6 +269,14 @@ pub struct BufferImpl<'a, D, W> {
 }
 
 impl<D: HasDisplayHandle, W: HasWindowHandle> BufferInterface for BufferImpl<'_, D, W> {
+    fn width(&self) -> usize {
+        self.imp.width
+    }
+
+    fn height(&self) -> usize {
+        self.imp.height
+    }
+
     #[inline]
     fn pixels(&self) -> &[u32] {
         &self.buffer

src/backends/kms.rs

@@ -293,6 +293,14 @@ impl<D: ?Sized, W: ?Sized> Drop for KmsImpl<D, W> {
 }
 
 impl<D: ?Sized, W: ?Sized> BufferInterface for BufferImpl<'_, D, W> {
+    fn width(&self) -> usize {
+        self.size.0.get() as usize
+    }
+
+    fn height(&self) -> usize {
+        self.size.1.get() as usize
+    }
+
     #[inline]
     fn pixels(&self) -> &[u32] {
         bytemuck::cast_slice(self.mapping.as_ref())

src/backends/orbital.rs

@@ -191,6 +191,14 @@ pub struct BufferImpl<'a, D, W> {
 }
 
 impl<D: HasDisplayHandle, W: HasWindowHandle> BufferInterface for BufferImpl<'_, D, W> {
+    fn width(&self) -> usize {
+        self.imp.width as usize
+    }
+
+    fn height(&self) -> usize {
+        self.imp.height as usize
+    }
+
     #[inline]
     fn pixels(&self) -> &[u32] {
         match &self.pixels {

src/backends/wayland/mod.rs

@@ -263,6 +263,14 @@
 }
 
 impl<D: HasDisplayHandle + ?Sized, W: HasWindowHandle> BufferInterface for BufferImpl<'_, D, W> {
+    fn width(&self) -> usize {
+        self.stack.member().width
+    }
+
+    fn height(&self) -> usize {
+        self.stack.member().height
+    }
+
     #[inline]
     fn pixels(&self) -> &[u32] {
         self.stack.member()

src/backends/web.rs

@@ -377,6 +377,22 @@ pub struct BufferImpl<'a, D, W> {
 }
 
 impl<D: HasDisplayHandle, W: HasWindowHandle> BufferInterface for BufferImpl<'_, D, W> {
+    fn width(&self) -> usize {
+        self.imp
+            .size
+            .expect("must set size of surface before calling `width()` on the buffer")
+            .0
+            .get() as usize
+    }
+
+    fn height(&self) -> usize {
+        self.imp
+            .size
+            .expect("must set size of surface before calling `height()` on the buffer")
+            .1
+            .get() as usize
+    }
+
     fn pixels(&self) -> &[u32] {
         &self.imp.buffer
     }

src/backends/win32.rs

@@ -284,6 +284,14 @@ impl<D: HasDisplayHandle, W: HasWindowHandle> SurfaceInterface<D, W> for Win32Im
 pub struct BufferImpl<'a, D, W>(&'a mut Win32Impl<D, W>);
 
 impl<D: HasDisplayHandle, W: HasWindowHandle> BufferInterface for BufferImpl<'_, D, W> {
+    fn width(&self) -> usize {
+        self.0.buffer.as_ref().unwrap().width.get() as usize
+    }
+
+    fn height(&self) -> usize {
+        self.0.buffer.as_ref().unwrap().height.get() as usize
+    }
+
     #[inline]
     fn pixels(&self) -> &[u32] {
         self.0.buffer.as_ref().unwrap().pixels()

src/backends/x11.rs

@@ -388,6 +388,14 @@ pub struct BufferImpl<'a, D: ?Sized, W: ?Sized>(&'a mut X11Impl<D, W>);
 impl<D: HasDisplayHandle + ?Sized, W: HasWindowHandle + ?Sized> BufferInterface
     for BufferImpl<'_, D, W>
 {
+    fn width(&self) -> usize {
+        self.0.size.unwrap().0.get() as usize
+    }
+
+    fn height(&self) -> usize {
+        self.0.size.unwrap().1.get() as usize
+    }
+
     #[inline]
     fn pixels(&self) -> &[u32] {
         // SAFETY: We called `finish_wait` on the buffer, so it is safe to call `buffer()`.

src/lib.rs

@@ -205,6 +205,28 @@ pub struct Buffer<'a, D, W> {
 }
 
 impl<D: HasDisplayHandle, W: HasWindowHandle> Buffer<'_, D, W> {
+    /// The amount of pixels wide the buffer is.
+    pub fn width(&self) -> usize {
+        let width = self.buffer_impl.width();
+        debug_assert_eq!(
+            width * self.buffer_impl.height(),
+            self.len(),
+            "buffer must be sized correctly"
+        );
+        width
+    }
+
+    /// The amount of pixels tall the buffer is.
+    pub fn height(&self) -> usize {
+        let height = self.buffer_impl.height();
+        debug_assert_eq!(
+            height * self.buffer_impl.width(),
+            self.len(),
+            "buffer must be sized correctly"
+        );
+        height
+    }
+
     /// `age` is the number of frames ago this buffer was last presented. So if the value is
     /// `1`, it is the same as the last frame, and if it is `2`, it is the same as the frame
     /// before that (for backends using double buffering). If the value is `0`, it is a new