⚡ Prepare asyncness

Creating a bunch of futures that when completed get the buffers copied
to the screen buffer updating the screen as it gets done.

It's a bit overkill to create a future per row but it can be changed
later.

Moved hsv_to_rgb to utils. Don't even think it will be needed later.

3 files changed, 79 insertions, 44 deletions

diff --git a/racer-tracer/Cargo.toml b/racer-tracer/Cargo.toml
index e764f79..a147cfe 100644
--- a/racer-tracer/Cargo.toml
+++ b/racer-tracer/Cargo.toml
@@ -8,3 +8,4 @@ edition = "2021"
 minifb = "0.23"
 tokio = { version = "1.14.0", features = ["macros", "rt", "rt-multi-thread"] }
 thiserror = "1"
+futures = "0.3"
diff --git a/racer-tracer/src/main.rs b/racer-tracer/src/main.rs
index 959ea0a..a35773b 100644
--- a/racer-tracer/src/main.rs
+++ b/racer-tracer/src/main.rs
@@ -1,50 +1,21 @@
 #[macro_use]
 mod error;
+mod util;
 
+use std::vec::Vec;
+
+use futures::{select, stream::FuturesUnordered, stream::StreamExt};
 use minifb::{Key, Window, WindowOptions};
 
-fn hsv_to_rgb(H: f64, S: f64, V: f64) -> u32 {
-    let s: f64 = S / 100.0;
-    let v: f64 = V / 100.0;
-    let C: f64 = s * v;
-    let mut A: f64 = H / 60.0;
-    A %= 2.0f64;
-    let X: f64 = C * (1f64 - (A - 1f64).abs());
-    let m: f64 = v - C;
+async fn raytrace(row: usize, width: usize) -> Result<(usize, Vec<u32>), error::TracerError> {
+    let mut buffer: Vec<u32> = vec![0; width];
 
-    let mut r: f64;
-    let mut g: f64;
-    let mut b: f64;
-    if H >= 0.0 && H < 60.0 {
-        r = C;
-        g = X;
-        b = 0.0;
-    } else if H >= 60.0 && H < 120.0 {
-        r = X;
-        g = C;
-        b = 0.0;
-    } else if H >= 120.0 && H < 180.0 {
-        r = 0.0;
-        g = C;
-        b = X;
-    } else if H >= 180.0 && H < 240.0 {
-        r = 0.0;
-        g = X;
-        b = C;
-    } else if H >= 240.0 && H < 300.0 {
-        r = X;
-        g = 0.0;
-        b = C;
-    } else {
-        r = C;
-        g = 0.0;
-        b = X;
+    // TODO: Trace geometry
+    for i in 0..buffer.len() {
+        buffer[i as usize] = util::hsv_to_rgb(((row as u32 + i as u32) % 360) as f64, 100.0, 100.0);
     }
 
-    let red: u32 = ((r + m) * 255.0) as u32;
-    let green: u32 = ((g + m) * 255.0) as u32;
-    let blue: u32 = ((b + m) * 255.0) as u32;
-    ((red as u32) << 16) | ((green as u32) << 8) | blue as u32
+    Ok((row, buffer))
 }
 
 async fn run(width: usize, height: usize) -> Result<(), error::TracerError> {
@@ -53,12 +24,32 @@ async fn run(width: usize, height: usize) -> Result<(), error::TracerError> {
         .expect("Unable to create window");
     window.limit_update_rate(Some(std::time::Duration::from_micros(16600)));
 
-    let mut count = 1;
+    let mut futs = FuturesUnordered::new();
+    // One future per row is a bit high.
+    // Could do something less spammy.
+    for h in 0..height {
+        futs.push(raytrace(h, width));
+    }
+
+    let mut complete = false;
     while window.is_open() && !window.is_key_down(Key::Escape) {
-        count = (count + 1) % 360;
-        let color = hsv_to_rgb(count as f64, 100.0, 100.0);
-        for i in screen_buffer.iter_mut() {
-            *i = color;
+        if !complete {
+            for _ in 1..50 {
+                select! {
+                    res = futs.select_next_some() => {
+                        let row_buffer = res.expect("Expected to get data");
+                        let start = row_buffer.0 * width;
+                        let end = start + width;
+                        screen_buffer[start..end].copy_from_slice(row_buffer.1.as_slice());
+                    },
+                    complete => {
+                        if !complete {
+                            println!("Completed!");
+                        }
+                        complete = true;
+                    },
+                }
+            }
         }
 
         window
diff --git a/racer-tracer/src/util.rs b/racer-tracer/src/util.rs
new file mode 100644
index 0000000..e223c67
--- /dev/null
+++ b/racer-tracer/src/util.rs
@@ -0,0 +1,43 @@
+pub fn hsv_to_rgb(h: f64, s: f64, v: f64) -> u32 {
+    let s: f64 = s / 100.0;
+    let v: f64 = v / 100.0;
+    let c: f64 = s * v;
+    let mut a: f64 = h / 60.0;
+    a %= 2.0f64;
+    let x: f64 = c * (1f64 - (a - 1f64).abs());
+    let m: f64 = v - c;
+
+    let r: f64;
+    let g: f64;
+    let b: f64;
+    if (0.0..60.0).contains(&h) {
+        r = c;
+        g = x;
+        b = 0.0;
+    } else if (60.0..120.0).contains(&h) {
+        r = x;
+        g = c;
+        b = 0.0;
+    } else if (120.0..180.0).contains(&h) {
+        r = 0.0;
+        g = c;
+        b = x;
+    } else if (180.0..240.0).contains(&h) {
+        r = 0.0;
+        g = x;
+        b = c;
+    } else if (240.0..300.0).contains(&h) {
+        r = x;
+        g = 0.0;
+        b = c;
+    } else {
+        r = c;
+        g = 0.0;
+        b = x;
+    }
+
+    let red: u32 = ((r + m) * 255.0) as u32;
+    let green: u32 = ((g + m) * 255.0) as u32;
+    let blue: u32 = ((b + m) * 255.0) as u32;
+    ((red as u32) << 16) | ((green as u32) << 8) | blue as u32
+}