seperated binaries for window and cli

Cargo.toml

@@ -9,6 +9,10 @@ edition = "2021"
 name = "blackhole"
 path = "src/bin/blackhole/main.rs"
 
+[[bin]]
+name = "blackhole-cli"
+path = "src/bin/blackhole/main-cli.rs"
+
 [dependencies]
 png = "0.17"
 cgmath = { version = "0.18", features = ["swizzle"] }

src/bin/blackhole/main-cli.rs

@@ -0,0 +1,106 @@
+use std::fs::File;
+use std::io::BufWriter;
+
+use cgmath::{InnerSpace, Vector3};
+
+use clap::Parser;
+
+use blackhole::filter::BlackmanHarrisFilter;
+use blackhole::framebuffer::{FrameBuffer, Pixel};
+
+mod args;
+mod gl_wrapper;
+mod renderer;
+mod scene_loader;
+mod shaders;
+
+use args::Args;
+use blackhole::frame::{Frame, Region};
+use renderer::{RenderMode, Renderer};
+use scene_loader::SceneLoader;
+
+fn main() {
+    // clion needs help in trait annotation
+    let args = <Args as Parser>::parse();
+
+    let mut fb = FrameBuffer::new(args.width, args.height);
+
+    let loader = SceneLoader::new();
+
+    let scene = loader.load_path(args.scene);
+
+    let scene = match scene {
+        Ok(v) => v,
+        Err(e) => {
+            eprintln!("Could not read scene description: {e}");
+            std::process::exit(-1);
+        }
+    };
+
+    let mut renderer = Renderer {
+        mode: args.mode,
+        samples: args.samples,
+        threads: args.threads,
+        filter: Box::new(BlackmanHarrisFilter::new(1.5)),
+        frame: Frame {
+            width: args.width,
+            height: args.height,
+            region: Region::Whole,
+        },
+        ..Default::default()
+    };
+
+    renderer.render(&scene, &mut fb);
+
+    post_process(&mut fb, &args.mode);
+
+    write_out(fb, args.width as u32, args.height as u32);
+}
+
+fn post_process(fb: &mut FrameBuffer, mode: &RenderMode) {
+    let luminance_base = Vector3::new(0.2126, 0.7152, 0.0722);
+
+    match mode {
+        RenderMode::Shaded => {
+            for pixel in fb.buffer_mut() {
+                let luminance = Vector3::new(pixel.r, pixel.g, pixel.b).dot(luminance_base);
+
+                let new_luminance = luminance / (luminance + 1.0);
+
+                let tonemapped = Pixel::new(
+                    pixel.r * (new_luminance / luminance),
+                    pixel.g * (new_luminance / luminance),
+                    pixel.b * (new_luminance / luminance),
+                    pixel.a,
+                );
+
+                let new_pixel = Pixel::new(
+                    tonemapped.r.powf(1.0 / 2.2),
+                    tonemapped.g.powf(1.0 / 2.2),
+                    tonemapped.b.powf(1.0 / 2.2),
+                    pixel.a,
+                );
+
+                *pixel = new_pixel;
+            }
+        }
+        RenderMode::Samples | RenderMode::Normal => {}
+    }
+}
+
+fn write_out(fb: FrameBuffer, width: u32, height: u32) {
+    let buf = unsafe {
+        assert_eq!(std::mem::size_of::<Pixel>(), 4 * std::mem::size_of::<f32>());
+
+        fb.as_f32_slice()
+    };
+
+    let mapped = buf.iter().map(|e| (e * 255.0) as u8).collect::<Vec<_>>();
+
+    let file = File::create("out.png").unwrap();
+    let writer = BufWriter::new(file);
+    let mut encoder = png::Encoder::new(writer, width, height);
+    encoder.set_color(png::ColorType::Rgba);
+    let mut writer = encoder.write_header().unwrap();
+    writer.write_image_data(&mapped).unwrap();
+}

src/bin/blackhole/main.rs

@@ -1,26 +1,26 @@
 use std::ffi::CString;
-use std::fs::File;
-use std::io::BufWriter;
 use std::num::NonZeroU32;
 use std::sync::{Arc, RwLock};
 
-use cgmath::{InnerSpace, Vector3};
-
 use clap::Parser;
+
 use glutin::config::{Config, ConfigTemplateBuilder};
 use glutin::context::{ContextApi, ContextAttributesBuilder, Version};
 use glutin::display::GetGlDisplay;
 use glutin::prelude::*;
 use glutin::surface::{Surface, SurfaceAttributesBuilder, WindowSurface};
+
 use glutin_winit::DisplayBuilder;
+
 use raw_window_handle::HasRawWindowHandle;
+
 use winit::dpi::{PhysicalSize, Size};
 use winit::event::{Event, WindowEvent};
 use winit::event_loop::{ControlFlow, EventLoop};
 use winit::window::{Window, WindowBuilder};
 
 use blackhole::filter::BlackmanHarrisFilter;
-use blackhole::framebuffer::{FrameBuffer, Pixel};
+use blackhole::framebuffer::FrameBuffer;
 
 mod args;
 mod gl_wrapper;
@@ -57,34 +57,16 @@ fn main() {
         }
     };
 
-    /*let region = Region::Window {
-        x_min: 499,
-        y_min: 700,
-        x_max: 500,
-        y_max: 701,
-    };
-    let region = Region::Window {
-        x_min: 450,
-        y_min: 650,
-        x_max: 550,
-        y_max: 750,
-    };*/
-    let region = Region::Whole;
-
-    let frame = Frame {
-        width: args.width,
-        height: args.height,
-        region,
-    };
-
     let mut renderer = Renderer {
         mode: args.mode,
         samples: args.samples,
         threads: args.threads,
-        max_steps: 2 << 16,
-        max_depth: 16,
         filter: Box::new(BlackmanHarrisFilter::new(1.5)),
-        frame,
+        frame: Frame {
+            width: args.width,
+            height: args.height,
+            region: Region::Whole,
+        },
         ..Default::default()
     };
 
@@ -216,60 +198,6 @@ fn main() {
             _ => (),
         }
     });
-
-    /*renderer.render(&scene, &mut fb, |src| {});
-
-    post_process(&mut fb, &args.mode);
-
-    write_out(fb, args.width as u32, args.height as u32);*/
-}
-
-fn post_process(fb: &mut FrameBuffer, mode: &RenderMode) {
-    let luminance_base = Vector3::new(0.2126, 0.7152, 0.0722);
-
-    match mode {
-        RenderMode::Shaded => {
-            for pixel in fb.buffer_mut() {
-                let luminance = Vector3::new(pixel.r, pixel.g, pixel.b).dot(luminance_base);
-
-                let new_luminance = luminance / (luminance + 1.0);
-
-                let tonemapped = Pixel::new(
-                    pixel.r * (new_luminance / luminance),
-                    pixel.g * (new_luminance / luminance),
-                    pixel.b * (new_luminance / luminance),
-                    pixel.a,
-                );
-
-                let new_pixel = Pixel::new(
-                    tonemapped.r.powf(1.0 / 2.2),
-                    tonemapped.g.powf(1.0 / 2.2),
-                    tonemapped.b.powf(1.0 / 2.2),
-                    pixel.a,
-                );
-
-                *pixel = new_pixel;
-            }
-        }
-        RenderMode::Samples | RenderMode::Normal => {}
-    }
-}
-
-fn write_out(fb: FrameBuffer, width: u32, height: u32) {
-    let buf = unsafe {
-        assert_eq!(std::mem::size_of::<Pixel>(), 4 * std::mem::size_of::<f32>());
-
-        fb.as_f32_slice()
-    };
-
-    let mapped = buf.iter().map(|e| (e * 255.0) as u8).collect::<Vec<_>>();
-
-    let file = File::create("out.png").unwrap();
-    let writer = BufWriter::new(file);
-    let mut encoder = png::Encoder::new(writer, width, height);
-    encoder.set_color(png::ColorType::Rgba);
-    let mut writer = encoder.write_header().unwrap();
-    writer.write_image_data(&mapped).unwrap();
 }
 
 pub struct GlWindow {

src/bin/blackhole/renderer.rs

@@ -11,7 +11,7 @@ use std::sync::atomic::{AtomicUsize, Ordering};
 use std::sync::mpsc::{Receiver, Sender};
 use std::sync::{Arc, RwLock};
 
-use blackhole::filter::PixelFilter;
+use blackhole::filter::{BlackmanHarrisFilter, PixelFilter};
 use blackhole::frame::{Frame, Region};
 use blackhole::framebuffer::{FrameBuffer, Pixel};
 use blackhole::material::MaterialResult;
@@ -502,6 +502,25 @@ impl Renderer {
     }
 }
 
+impl Default for Renderer {
+    fn default() -> Self {
+        Self {
+            mode: RenderMode::Samples,
+            samples: 128,
+            threads: 0,
+            max_steps: 2 << 16,
+            max_depth: 16,
+            frame: Frame {
+                width: 1280,
+                height: 720,
+                region: Region::Whole,
+            },
+            filter: Box::new(BlackmanHarrisFilter::new(1.5)),
+            scaling: Default::default(),
+        }
+    }
+}
+
 pub enum RenderInMsg {
     Resize(u32, u32),
     Restart,
@@ -541,4 +560,4 @@ impl Default for Scaling {
     fn default() -> Self {
         Self::X1
     }
-}
+}