Handle zero-sized buffers internally

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

Author: madsmtm

CHANGELOG.md

@@ -1,6 +1,7 @@
 # Unreleased
 
 - **Breaking:** Remove generic type parameters `D` and `W` from `Buffer<'_>` struct.
+- **Breaking:** Use `u32` instead of `NonZeroU32`, and handle zero-sized buffers internally.
 
 # 0.4.7
 

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() * buffer.height()) {

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/raytracing/main.rs

@@ -3,7 +3,6 @@
 //! Note that this is quite slow, you probably don't want to do realtime CPU raytracing in practice.
 //!
 //! [Ray Tracing in One Weekend]: https://raytracing.github.io/books/RayTracingInOneWeekend.html
-use std::num::NonZeroU32;
 use winit::event::{DeviceEvent, ElementState, KeyEvent, WindowEvent};
 use winit::event_loop::EventLoop;
 use winit::keyboard::{Key, KeyCode, NamedKey, PhysicalKey};
@@ -32,10 +31,7 @@ fn main() {
         move |_elwt, window| {
             let mut surface = softbuffer::Surface::new(&context, window.clone()).unwrap();
             surface
-                .resize(
-                    NonZeroU32::new(window.inner_size().width).unwrap(),
-                    NonZeroU32::new(window.inner_size().height).unwrap(),
-                )
+                .resize(window.inner_size().width, window.inner_size().height)
                 .unwrap();
             let game = Game::new();
             (surface, game)
@@ -53,11 +49,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, game)) = surface else {

examples/rectangle.rs

@@ -1,5 +1,4 @@
 use softbuffer::Buffer;
-use std::num::NonZeroU32;
 use winit::event::{ElementState, KeyEvent, WindowEvent};
 use winit::event_loop::{ControlFlow, EventLoop};
 use winit::keyboard::{Key, NamedKey};
@@ -58,12 +57,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 {