Handle zero-sized buffers internally

And default to a 0-sized buffer instead of panicking in `buffer_mut`.

Author: madsmtm

CHANGELOG.md

@@ -1,5 +1,7 @@
 # Unreleased
 
+- **Breaking:** Use `u32` instead of `NonZeroU32`, and handle zero-sized buffers internally.
+
 # 0.4.7
 
 - Fix documentation building on `docs.rs`.

README.md

@@ -68,7 +68,6 @@ To run the Android-specific example on an Android phone: `cargo apk r --example
 ## Example
 
 ```rust,no_run
-use std::num::NonZeroU32;
 use std::rc::Rc;
 use winit::event::{Event, WindowEvent};
 use winit::event_loop::{ControlFlow, EventLoop};
@@ -102,12 +101,7 @@ fn main() {
                     return;
                 };
                 let size = window.inner_size();
-                surface
-                    .resize(
-                        NonZeroU32::new(size.width).unwrap(),
-                        NonZeroU32::new(size.height).unwrap(),
-                    )
-                    .unwrap();
+                surface.resize(size.width, size.height).unwrap();
 
                 let mut buffer = surface.buffer_mut().unwrap();
                 for index in 0..(buffer.width().get() * buffer.height().get()) {

benches/buffer_mut.rs

@@ -8,7 +8,6 @@
 fn buffer_mut(c: &mut criterion::Criterion) {
     use criterion::black_box;
     use softbuffer::{Context, Surface};
-    use std::num::NonZeroU32;
     use winit::event_loop::ControlFlow;
     use winit::platform::run_on_demand::EventLoopExtRunOnDemand;
 
@@ -27,12 +26,7 @@ fn buffer_mut(c: &mut criterion::Criterion) {
             let mut surface = Surface::new(&context, &window).unwrap();
 
             let size = window.inner_size();
-            surface
-                .resize(
-                    NonZeroU32::new(size.width).unwrap(),
-                    NonZeroU32::new(size.height).unwrap(),
-                )
-                .unwrap();
+            surface.resize(size.width, size.height).unwrap();
 
             c.bench_function("buffer_mut()", |b| {
                 b.iter(|| {

examples/animation.rs

@@ -1,7 +1,6 @@
 #[cfg(not(target_family = "wasm"))]
 use rayon::prelude::*;
 use std::f64::consts::PI;
-use std::num::NonZeroU32;
 use web_time::Instant;
 use winit::event::{KeyEvent, WindowEvent};
 use winit::event_loop::{ControlFlow, EventLoop};
@@ -46,11 +45,7 @@ fn main() {
                     return;
                 };
 
-                if let (Some(width), Some(height)) =
-                    (NonZeroU32::new(size.width), NonZeroU32::new(size.height))
-                {
-                    surface.resize(width, height).unwrap();
-                }
+                surface.resize(size.width, size.height).unwrap();
             }
             WindowEvent::RedrawRequested => {
                 let Some(surface) = surface else {

examples/drm.rs

@@ -19,7 +19,6 @@ mod imple {
     use raw_window_handle::{DisplayHandle, DrmDisplayHandle, DrmWindowHandle, WindowHandle};
     use softbuffer::{Context, Surface};
 
-    use std::num::NonZeroU32;
     use std::os::unix::io::{AsFd, AsRawFd, BorrowedFd};
     use std::path::Path;
     use std::time::{Duration, Instant};
@@ -114,10 +113,7 @@ mod imple {
 
         // Resize the surface.
         let (width, height) = mode.size();
-        surface.resize(
-            NonZeroU32::new(width as u32).unwrap(),
-            NonZeroU32::new(height as u32).unwrap(),
-        )?;
+        surface.resize(width as u32, height as u32)?;
 
         // Start drawing to it.
         let start = Instant::now();

examples/fruit.rs

@@ -1,5 +1,4 @@
 use image::GenericImageView;
-use std::num::NonZeroU32;
 use winit::event::{KeyEvent, WindowEvent};
 use winit::event_loop::{ControlFlow, EventLoop};
 use winit::keyboard::{Key, NamedKey};
@@ -27,12 +26,7 @@ fn main() {
             // Intentionally only set the size of the surface once, at creation.
             // This is needed if the window chooses to ignore the size we passed in above, and for the
             // platforms softbuffer supports that don't yet extract the size from the window.
-            surface
-                .resize(
-                    NonZeroU32::new(width).unwrap(),
-                    NonZeroU32::new(height).unwrap(),
-                )
-                .unwrap();
+            surface.resize(width, height).unwrap();
             surface
         },
     )

examples/libxcb.rs

@@ -117,12 +117,7 @@ mod example {
             match event {
                 Event::Expose(_) => {
                     // Draw a width x height red rectangle.
-                    surface
-                        .resize(
-                            NonZeroU32::new(width.into()).unwrap(),
-                            NonZeroU32::new(height.into()).unwrap(),
-                        )
-                        .unwrap();
+                    surface.resize(width.into(), height.into()).unwrap();
                     let mut buffer = surface.buffer_mut().unwrap();
                     buffer.fill(RED);
                     buffer.present().unwrap();

examples/rectangle.rs

@@ -1,6 +1,5 @@
 use raw_window_handle::{HasDisplayHandle, HasWindowHandle};
 use softbuffer::Buffer;
-use std::num::NonZeroU32;
 use winit::event::{ElementState, KeyEvent, WindowEvent};
 use winit::event_loop::{ControlFlow, EventLoop};
 use winit::keyboard::{Key, NamedKey};
@@ -59,12 +58,8 @@ fn main() {
                     return;
                 };
 
-                if let (Some(width), Some(height)) =
-                    (NonZeroU32::new(size.width), NonZeroU32::new(size.height))
-                {
-                    // Resize surface
-                    surface.resize(width, height).unwrap();
-                }
+                // Resize surface
+                surface.resize(size.width, size.height).unwrap();
             }
             WindowEvent::RedrawRequested => {
                 let Some(surface) = surface else {

examples/winit.rs

@@ -1,4 +1,3 @@
-use std::num::NonZeroU32;
 use winit::event::{KeyEvent, WindowEvent};
 use winit::event_loop::{ControlFlow, EventLoop};
 use winit::keyboard::{Key, NamedKey};
@@ -33,11 +32,7 @@ pub(crate) fn entry(event_loop: EventLoop<()>) {
                     return;
                 };
 
-                if let (Some(width), Some(height)) =
-                    (NonZeroU32::new(size.width), NonZeroU32::new(size.height))
-                {
-                    surface.resize(width, height).unwrap();
-                }
+                surface.resize(size.width, size.height).unwrap();
             }
             WindowEvent::RedrawRequested => {
                 let Some(surface) = surface else {

examples/winit_multithread.rs

@@ -4,8 +4,8 @@ mod util;
 
 #[cfg(not(target_family = "wasm"))]
 pub mod ex {
-    use std::num::NonZeroU32;
     use std::sync::{mpsc, Arc, Mutex};
+    use winit::dpi::PhysicalSize;
     use winit::event::{KeyEvent, WindowEvent};
     use winit::event_loop::{ControlFlow, EventLoop, OwnedDisplayHandle};
     use winit::keyboard::{Key, NamedKey};
@@ -16,20 +16,20 @@ pub mod ex {
     type Surface = softbuffer::Surface<OwnedDisplayHandle, Arc<Window>>;
 
     fn render_thread(
-        do_render: mpsc::Receiver<(Arc<Mutex<Surface>>, NonZeroU32, NonZeroU32)>,
+        do_render: mpsc::Receiver<(Arc<Mutex<Surface>>, PhysicalSize<u32>)>,
         done: mpsc::Sender<()>,
     ) {
         loop {
             tracing::info!("waiting for render...");
-            let Ok((surface, width, height)) = do_render.recv() else {
+            let Ok((surface, size)) = do_render.recv() else {
                 tracing::info!("main thread destroyed");
                 break;
             };
 
             // Perform the rendering.
             let mut surface = surface.lock().unwrap();
             tracing::info!("resizing...");
-            surface.resize(width, height).unwrap();
+            surface.resize(size.width, size.height).unwrap();
 
             let mut buffer = surface.buffer_mut().unwrap();
             for y in 0..buffer.height() {
@@ -96,13 +96,9 @@ pub mod ex {
 
                     let size = window.inner_size();
                     tracing::info!("got size: {size:?}");
-                    if let (Some(width), Some(height)) =
-                        (NonZeroU32::new(size.width), NonZeroU32::new(size.height))
-                    {
-                        // Start the render and then finish it.
-                        start_render.send((surface.clone(), width, height)).unwrap();
-                        finish_render.recv().unwrap();
-                    }
+                    // Start the render and then finish it.
+                    start_render.send((surface.clone(), size)).unwrap();
+                    finish_render.recv().unwrap();
                 }
                 WindowEvent::CloseRequested
                 | WindowEvent::KeyboardInput {