Added benchmarks and lib.rs

Cargo.toml

@@ -15,4 +15,9 @@ timer = "0.2.0"
 winit = "0.26.1"
 winit_input_helper = "0.12.0"
 
+[dev-dependencies]
+bencher = "0.1.5"
 
+[[bench]]
+name = "benches"
+harness = false

benches/benches.rs

@@ -0,0 +1,78 @@
+use bencher::Bencher;
+use pixels::Pixels;
+use pixels::SurfaceTexture;
+use rand::Rng;
+
+#[macro_use]
+extern crate bencher;
+
+use purple_rain::draw;
+use purple_rain::Drop;
+use winit::event_loop::EventLoop;
+use winit::window::WindowBuilder;
+
+pub const WIDTH: u32 = 400;
+pub const HEIGHT: u32 = 300;
+
+fn ten_drops(bench: &mut Bencher) {
+    let event_loop = EventLoop::new();
+    let window = WindowBuilder::new()
+        .with_visible(false)
+        .build(&event_loop)
+        .unwrap();
+
+    window.set_visible(false);
+    let mut pixels = {
+        let window_size = window.inner_size();
+        let surface_texture = SurfaceTexture::new(window_size.width, window_size.height, &window);
+        Pixels::new(WIDTH, HEIGHT, surface_texture)
+    }
+    .unwrap();
+
+    let mut drops = Vec::new();
+    let mut rng = rand::thread_rng();
+    for _i in 0..200 {
+        drops.push(Drop {
+            x: (rng.gen_range(0..WIDTH as i32)),
+            y: (rng.gen_range(0..HEIGHT as i32)),
+            z: (rng.gen_range(1..20)),
+        })
+    }
+
+    bench.iter(|| {
+        draw(&mut drops, pixels.get_frame());
+    })
+}
+
+fn one_hundred_drops(bench: &mut Bencher) {
+    let event_loop = EventLoop::new();
+    let window = WindowBuilder::new()
+        .with_visible(false)
+        .build(&event_loop)
+        .unwrap();
+
+    window.set_visible(false);
+    let mut pixels = {
+        let window_size = window.inner_size();
+        let surface_texture = SurfaceTexture::new(window_size.width, window_size.height, &window);
+        Pixels::new(WIDTH, HEIGHT, surface_texture)
+    }
+    .unwrap();
+
+    let mut drops = Vec::new();
+    let mut rng = rand::thread_rng();
+    for _i in 0..2000 {
+        drops.push(Drop {
+            x: (rng.gen_range(0..WIDTH as i32)),
+            y: (rng.gen_range(0..HEIGHT as i32)),
+            z: (rng.gen_range(1..20)),
+        })
+    }
+
+    bench.iter(|| {
+        draw(&mut drops, pixels.get_frame());
+    })
+}
+
+benchmark_group!(drops, ten_drops, one_hundred_drops);
+benchmark_main!(drops);

src/lib.rs

@@ -0,0 +1,44 @@
+
+pub const WIDTH: u32 = 400;
+pub const HEIGHT: u32 = 300;
+
+pub fn draw(drops: &mut Vec<Drop>, frame: &mut [u8]) {
+    let pixels = frame.chunks_exact_mut(4);
+    for pixel in pixels {
+        pixel.copy_from_slice(&[0xd3, 0xb7, 0xf7, 0xff]);
+    }
+
+    drops.iter_mut().for_each(|d| d.update());
+
+    for drop in drops {
+        let mut drawn = false;
+        for y in drop.y..(drop.y + drop.z) {
+            for x in drop.x..(drop.x + drop.z/4) {
+                let res = (y * (WIDTH as i32) * 4 + x * 4).try_into();
+                if res.is_ok() {
+                    let i = res.unwrap();
+
+                    if i < frame.len() {
+                        drawn = true;
+                        frame[i..i + 4].copy_from_slice(&[207, 100, 219, 0xff]);
+                    }
+                }
+            }
+        }
+        if !drawn {
+            drop.y = -drop.z;
+        }
+    }
+}
+
+pub struct Drop {
+    pub x: i32,
+    pub y: i32,
+    pub z: i32,
+}
+
+impl Drop {
+    fn update(&mut self) {
+        self.y += std::cmp::max(self.z/4, 1);
+    }
+}

src/main.rs

@@ -11,8 +11,7 @@ use winit::{
 };
 use winit_input_helper::WinitInputHelper;
 
-const WIDTH: u32 = 400;
-const HEIGHT: u32 = 300;
+use purple_rain::*;
 
 fn main() {
     env_logger::init();
@@ -84,43 +83,3 @@ fn main() {
     });
 }
 
-fn draw(drops: &mut Vec<Drop>, frame: &mut [u8]) {
-    let pixels = frame.chunks_exact_mut(4);
-    for pixel in pixels {
-        pixel.copy_from_slice(&[0xd3, 0xb7, 0xf7, 0xff]);
-    }
-
-    drops.iter_mut().for_each(|d| d.update());
-
-    for drop in drops {
-        let mut drawn = false;
-        for y in drop.y..(drop.y + drop.z) {
-            for x in drop.x..(drop.x + drop.z/4) {
-                let res = (y * (WIDTH as i32) * 4 + x * 4).try_into();
-                if res.is_ok() {
-                    let i = res.unwrap();
-
-                    if i < frame.len() {
-                        drawn = true;
-                        frame[i..i + 4].copy_from_slice(&[207, 100, 219, 0xff]);
-                    }
-                }
-            }
-        }
-        if !drawn {
-            drop.y = -drop.z;
-        }
-    }
-}
-
-struct Drop {
-    x: i32,
-    y: i32,
-    z: i32,
-}
-
-impl Drop {
-    fn update(&mut self) {
-        self.y += std::cmp::max(self.z/4, 1);
-    }
-}