Remove unnecessary generics from Buffer

This should make it more ergonomic to pass around.

Author: madsmtm

CHANGELOG.md

@@ -1,5 +1,7 @@
 # Unreleased
 
+- **Breaking:** Remove generic type parameters `D` and `W` from `Buffer<'_>` struct.
+
 # 0.4.7
 
 - Fix documentation building on `docs.rs`.

examples/raytracing/game.rs

@@ -2,7 +2,6 @@ use std::time::{Duration, Instant};
 
 use rand::rngs::SmallRng;
 use rand::{Rng, SeedableRng};
-use raw_window_handle::{HasDisplayHandle, HasWindowHandle};
 use softbuffer::Buffer;
 
 use crate::camera::Camera;
@@ -44,21 +43,13 @@ impl Game {
         }
     }
 
-    pub fn draw(
-        &self,
-        buffer: &mut Buffer<'_, impl HasDisplayHandle, impl HasWindowHandle>,
-        scale_factor: f32,
-    ) {
+    pub fn draw(&self, buffer: &mut Buffer<'_>, scale_factor: f32) {
         self.draw_scene(buffer, scale_factor);
         self.draw_ui(buffer, scale_factor);
     }
 
     /// Draw the 3D scene.
-    fn draw_scene(
-        &self,
-        buffer: &mut Buffer<'_, impl HasDisplayHandle, impl HasWindowHandle>,
-        scale_factor: f32,
-    ) {
+    fn draw_scene(&self, buffer: &mut Buffer<'_>, scale_factor: f32) {
         // Raytracing is expensive, so we only do it once every 4x4 pixel.
         //
         // FIXME(madsmtm): Avoid the need for this once we can do hardware scaling.
@@ -130,11 +121,7 @@ impl Game {
     }
 
     /// Draw a simple example UI on top of the scene.
-    fn draw_ui(
-        &self,
-        buffer: &mut Buffer<'_, impl HasDisplayHandle, impl HasWindowHandle>,
-        scale_factor: f32,
-    ) {
+    fn draw_ui(&self, buffer: &mut Buffer<'_>, scale_factor: f32) {
         struct Rect {
             left: f32,
             right: f32,

examples/rectangle.rs

@@ -1,4 +1,3 @@
-use raw_window_handle::{HasDisplayHandle, HasWindowHandle};
 use softbuffer::Buffer;
 use std::num::NonZeroU32;
 use winit::event::{ElementState, KeyEvent, WindowEvent};
@@ -7,7 +6,7 @@ use winit::keyboard::{Key, NamedKey};
 
 mod util;
 
-fn redraw(buffer: &mut Buffer<'_, impl HasDisplayHandle, impl HasWindowHandle>, flag: bool) {
+fn redraw(buffer: &mut Buffer<'_>, flag: bool) {
     let width = buffer.width().get();
     let height = buffer.height().get();
     for y in 0..height {

src/backend_dispatch.rs

@@ -76,7 +76,7 @@ macro_rules! make_dispatch {
 
         impl<D: HasDisplayHandle, W: HasWindowHandle> SurfaceInterface<D, W> for SurfaceDispatch<D, W> {
             type Context = ContextDispatch<D>;
-            type Buffer<'a> = BufferDispatch<'a, D, W> where Self: 'a;
+            type Buffer<'a> = BufferDispatch<'a> where Self: 'a;
 
             fn new(window: W, display: &Self::Context) -> Result<Self, InitError<W>>
             where
@@ -108,7 +108,7 @@ macro_rules! make_dispatch {
                 }
             }
 
-            fn buffer_mut(&mut self) -> Result<BufferDispatch<'_, D, W>, SoftBufferError> {
+            fn buffer_mut(&mut self) -> Result<BufferDispatch<'_>, SoftBufferError> {
                 match self {
                     $(
                         $(#[$attr])*
@@ -138,14 +138,14 @@ macro_rules! make_dispatch {
             }
         }
 
-        pub(crate) enum BufferDispatch<'a, $dgen, $wgen> {
+        pub(crate) enum BufferDispatch<'a> {
             $(
                 $(#[$attr])*
                 $name($buffer_inner),
             )*
         }
 
-        impl<'a, D: HasDisplayHandle, W: HasWindowHandle> BufferInterface for BufferDispatch<'a, D, W> {
+        impl BufferInterface for BufferDispatch<'_> {
             #[inline]
             fn width(&self) -> NonZeroU32 {
                 match self {
@@ -214,7 +214,7 @@ macro_rules! make_dispatch {
             }
         }
 
-        impl<D: fmt::Debug, W: fmt::Debug> fmt::Debug for BufferDispatch<'_, D, W> {
+        impl fmt::Debug for BufferDispatch<'_> {
             fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
                 match self {
                     $(
@@ -232,7 +232,7 @@ macro_rules! make_dispatch {
 make_dispatch! {
     <D, W> =>
     #[cfg(target_os = "android")]
-    Android(D, backends::android::AndroidImpl<D, W>, backends::android::BufferImpl<'a, D, W>),
+    Android(D, backends::android::AndroidImpl<D, W>, backends::android::BufferImpl<'a>),
     #[cfg(all(
         feature = "x11",
         not(any(
@@ -243,7 +243,7 @@ make_dispatch! {
             target_os = "windows"
         ))
     ))]
-    X11(std::sync::Arc<backends::x11::X11DisplayImpl<D>>, backends::x11::X11Impl<D, W>, backends::x11::BufferImpl<'a, D, W>),
+    X11(std::sync::Arc<backends::x11::X11DisplayImpl<D>>, backends::x11::X11Impl<D, W>, backends::x11::BufferImpl<'a>),
     #[cfg(all(
         feature = "wayland",
         not(any(
@@ -254,7 +254,7 @@ make_dispatch! {
             target_os = "windows"
         ))
     ))]
-    Wayland(std::sync::Arc<backends::wayland::WaylandDisplayImpl<D>>, backends::wayland::WaylandImpl<D, W>, backends::wayland::BufferImpl<'a, D, W>),
+    Wayland(std::sync::Arc<backends::wayland::WaylandDisplayImpl<D>>, backends::wayland::WaylandImpl<D, W>, backends::wayland::BufferImpl<'a>),
     #[cfg(all(
         feature = "kms",
         not(any(
@@ -265,13 +265,13 @@ make_dispatch! {
             target_os = "windows"
         ))
     ))]
-    Kms(std::sync::Arc<backends::kms::KmsDisplayImpl<D>>, backends::kms::KmsImpl<D, W>, backends::kms::BufferImpl<'a, D, W>),
+    Kms(std::sync::Arc<backends::kms::KmsDisplayImpl<D>>, backends::kms::KmsImpl<D, W>, backends::kms::BufferImpl<'a>),
     #[cfg(target_os = "windows")]
-    Win32(D, backends::win32::Win32Impl<D, W>, backends::win32::BufferImpl<'a, D, W>),
+    Win32(D, backends::win32::Win32Impl<D, W>, backends::win32::BufferImpl<'a>),
     #[cfg(target_vendor = "apple")]
-    CoreGraphics(D, backends::cg::CGImpl<D, W>, backends::cg::BufferImpl<'a, D, W>),
+    CoreGraphics(D, backends::cg::CGImpl<D, W>, backends::cg::BufferImpl<'a>),
     #[cfg(target_family = "wasm")]
-    Web(backends::web::WebDisplayImpl<D>, backends::web::WebImpl<D, W>, backends::web::BufferImpl<'a, D, W>),
+    Web(backends::web::WebDisplayImpl<D>, backends::web::WebImpl<D, W>, backends::web::BufferImpl<'a>),
     #[cfg(target_os = "redox")]
-    Orbital(D, backends::orbital::OrbitalImpl<D, W>, backends::orbital::BufferImpl<'a, D, W>),
+    Orbital(D, backends::orbital::OrbitalImpl<D, W>, backends::orbital::BufferImpl<'a>),
 }

src/backends/android.rs

@@ -25,7 +25,7 @@ pub struct AndroidImpl<D, W> {
 impl<D: HasDisplayHandle, W: HasWindowHandle> SurfaceInterface<D, W> for AndroidImpl<D, W> {
     type Context = D;
     type Buffer<'a>
-        = BufferImpl<'a, D, W>
+        = BufferImpl<'a>
     where
         Self: 'a;
 
@@ -76,7 +76,7 @@ impl<D: HasDisplayHandle, W: HasWindowHandle> SurfaceInterface<D, W> for Android
             })
     }
 
-    fn buffer_mut(&mut self) -> Result<BufferImpl<'_, D, W>, SoftBufferError> {
+    fn buffer_mut(&mut self) -> Result<BufferImpl<'_>, SoftBufferError> {
         let native_window_buffer = self.native_window.lock(None).map_err(|err| {
             SoftBufferError::PlatformError(
                 Some("Failed to lock ANativeWindow".to_owned()),
@@ -104,7 +104,6 @@ impl<D: HasDisplayHandle, W: HasWindowHandle> SurfaceInterface<D, W> for Android
         Ok(BufferImpl {
             native_window_buffer,
             buffer: util::PixelBuffer(buffer),
-            marker: PhantomData,
         })
     }
 
@@ -115,16 +114,15 @@ impl<D: HasDisplayHandle, W: HasWindowHandle> SurfaceInterface<D, W> for Android
 }
 
 #[derive(Debug)]
-pub struct BufferImpl<'a, D: ?Sized, W> {
+pub struct BufferImpl<'a> {
     native_window_buffer: NativeWindowBufferLockGuard<'a>,
     buffer: util::PixelBuffer,
-    marker: PhantomData<(&'a D, &'a W)>,
 }
 
 // TODO: Move to NativeWindowBufferLockGuard?
-unsafe impl<'a, D, W> Send for BufferImpl<'a, D, W> {}
+unsafe impl Send for BufferImpl<'_> {}
 
-impl<'a, D: HasDisplayHandle, W: HasWindowHandle> BufferInterface for BufferImpl<'a, D, W> {
+impl BufferInterface for BufferImpl<'_> {
     fn width(&self) -> NonZeroU32 {
         NonZeroU32::new(self.native_window_buffer.width() as u32).unwrap()
     }

src/backends/cg.rs

@@ -127,7 +127,7 @@ impl<D, W> Drop for CGImpl<D, W> {
 impl<D: HasDisplayHandle, W: HasWindowHandle> SurfaceInterface<D, W> for CGImpl<D, W> {
     type Context = D;
     type Buffer<'a>
-        = BufferImpl<'a, D, W>
+        = BufferImpl<'a>
     where
         Self: 'a;
 
@@ -258,29 +258,27 @@ impl<D: HasDisplayHandle, W: HasWindowHandle> SurfaceInterface<D, W> for CGImpl<
         Ok(())
     }
 
-    fn buffer_mut(&mut self) -> Result<BufferImpl<'_, D, W>, SoftBufferError> {
+    fn buffer_mut(&mut self) -> Result<BufferImpl<'_>, SoftBufferError> {
         Ok(BufferImpl {
             buffer: util::PixelBuffer(vec![0; self.width * self.height]),
             width: self.width,
             height: self.height,
             color_space: &self.color_space,
             layer: &mut self.layer,
-            _phantom: PhantomData,
         })
     }
 }
 
 #[derive(Debug)]
-pub struct BufferImpl<'a, D, W> {
+pub struct BufferImpl<'a> {
     width: usize,
     height: usize,
     color_space: &'a CGColorSpace,
     buffer: util::PixelBuffer,
     layer: &'a mut SendCALayer,
-    _phantom: PhantomData<(D, W)>,
 }
 
-impl<D: HasDisplayHandle, W: HasWindowHandle> BufferInterface for BufferImpl<'_, D, W> {
+impl BufferInterface for BufferImpl<'_> {
     fn width(&self) -> NonZeroU32 {
         NonZeroU32::new(self.width as u32).unwrap()
     }

src/backends/kms.rs

@@ -13,7 +13,6 @@ use raw_window_handle::{HasDisplayHandle, HasWindowHandle, RawDisplayHandle, Raw
 
 use std::collections::HashSet;
 use std::fmt;
-use std::marker::PhantomData;
 use std::num::NonZeroU32;
 use std::os::unix::io::{AsFd, BorrowedFd};
 use std::sync::Arc;
@@ -95,7 +94,7 @@ struct Buffers {
 }
 
 /// The buffer implementation.
-pub(crate) struct BufferImpl<'a, D: ?Sized, W: ?Sized> {
+pub(crate) struct BufferImpl<'a> {
     /// The mapping of the dump buffer.
     mapping: DumbMapping<'a>,
 
@@ -119,11 +118,9 @@ pub(crate) struct BufferImpl<'a, D: ?Sized, W: ?Sized> {
 
     /// Age of the back buffer.
     back_age: &'a mut u8,
-
-    _phantom: PhantomData<(&'a D, &'a W)>,
 }
 
-impl<D: ?Sized + fmt::Debug, W: ?Sized + fmt::Debug> fmt::Debug for BufferImpl<'_, D, W> {
+impl fmt::Debug for BufferImpl<'_> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         // FIXME: Derive instead once `DumbMapping` impls `Debug`.
         f.debug_struct("BufferImpl").finish_non_exhaustive()
@@ -146,7 +143,7 @@ struct SharedBuffer {
 impl<D: HasDisplayHandle + ?Sized, W: HasWindowHandle> SurfaceInterface<D, W> for KmsImpl<D, W> {
     type Context = Arc<KmsDisplayImpl<D>>;
     type Buffer<'a>
-        = BufferImpl<'a, D, W>
+        = BufferImpl<'a>
     where
         Self: 'a;
 
@@ -252,7 +249,7 @@ impl<D: HasDisplayHandle + ?Sized, W: HasWindowHandle> SurfaceInterface<D, W> fo
     }
     */
 
-    fn buffer_mut(&mut self) -> Result<BufferImpl<'_, D, W>, SoftBufferError> {
+    fn buffer_mut(&mut self) -> Result<BufferImpl<'_>, SoftBufferError> {
         // Map the dumb buffer.
         let set = self
             .buffer
@@ -287,7 +284,6 @@ impl<D: HasDisplayHandle + ?Sized, W: HasWindowHandle> SurfaceInterface<D, W> fo
             device: self.display.device.clone(),
             front_age,
             back_age,
-            _phantom: PhantomData,
         })
     }
 }
@@ -308,7 +304,7 @@ impl<D: ?Sized, W: ?Sized> Drop for KmsImpl<D, W> {
     }
 }
 
-impl<D: ?Sized, W: ?Sized> BufferInterface for BufferImpl<'_, D, W> {
+impl BufferInterface for BufferImpl<'_> {
     fn width(&self) -> NonZeroU32 {
         self.size.0
     }

src/backends/orbital.rs

@@ -80,7 +80,7 @@ impl<D: HasDisplayHandle, W: HasWindowHandle> OrbitalImpl<D, W> {
 impl<D: HasDisplayHandle, W: HasWindowHandle> SurfaceInterface<D, W> for OrbitalImpl<D, W> {
     type Context = D;
     type Buffer<'a>
-        = BufferImpl<'a, D, W>
+        = BufferImpl<'a>
     where
         Self: 'a;
 
@@ -116,7 +116,7 @@ impl<D: HasDisplayHandle, W: HasWindowHandle> SurfaceInterface<D, W> for Orbital
         Ok(())
     }
 
-    fn buffer_mut(&mut self) -> Result<BufferImpl<'_, D, W>, SoftBufferError> {
+    fn buffer_mut(&mut self) -> Result<BufferImpl<'_>, SoftBufferError> {
         let (window_width, window_height) = window_size(self.window_fd());
         let pixels = if self.width as usize == window_width && self.height as usize == window_height
         {
@@ -137,7 +137,6 @@ impl<D: HasDisplayHandle, W: HasWindowHandle> SurfaceInterface<D, W> for Orbital
             height: self.height,
             presented: &mut self.presented,
             pixels,
-            _phantom: PhantomData,
         })
     }
 }
@@ -149,16 +148,15 @@ enum Pixels {
 }
 
 #[derive(Debug)]
-pub struct BufferImpl<'a, D, W> {
+pub struct BufferImpl<'a> {
     window_fd: usize,
     width: u32,
     height: u32,
     presented: &'a mut bool,
     pixels: Pixels,
-    _phantom: PhantomData<(D, W)>,
 }
 
-impl<D: HasDisplayHandle, W: HasWindowHandle> BufferInterface for BufferImpl<'_, D, W> {
+impl BufferInterface for BufferImpl<'_> {
     fn width(&self) -> NonZeroU32 {
         NonZeroU32::new(self.width as u32).unwrap()
     }