moved bloom into rust, more refactoring

Author: cobbal

Cargo.lock

@@ -8,7 +8,7 @@ debug = true
 
 [dependencies]
 image = "*"
-mdo = "*"
+num = "*"
 rand = "*"
 num_cpus = "*"
 byteorder = "*"

Cargo.toml

@@ -6,7 +6,7 @@ use ray::*;
 #[derive(Clone)]
 pub struct Camera {
     origin : Vec3,
-    lower_left_corner : Vec3,
+    upper_left_corner : Vec3,
     horizontal : Vec3,
     vertical : Vec3,
     u : Vec3,
@@ -36,9 +36,9 @@ pub fn camera(
 
     return Camera {
         origin: lookfrom,
-        lower_left_corner: lookfrom
+        upper_left_corner: lookfrom
             - half_width * focus_dist * &u
-            - half_height * focus_dist * &v
+            + half_height * focus_dist * &v
             - focus_dist * &w,
         horizontal: 2.0 * half_width * focus_dist * &u,
         vertical: 2.0 * half_height * focus_dist * &v,
@@ -55,9 +55,9 @@ impl Camera {
         let rd = self.lens_radius * rand_in_disk(rng);
         let offset = &self.u * rd[X] + &self.v * rd[Y];
 
-        let dir = &self.lower_left_corner
+        let dir = &self.upper_left_corner
             + s * &self.horizontal
-            + t * &self.vertical
+            - t * &self.vertical
             - &self.origin - &offset;
         let time = self.time0 + rng.gen::<f32>() * (self.time1 - self.time0);
         return ray(&self.origin + offset, dir, time);

src/camera.rs

@@ -35,6 +35,7 @@ extern crate image;
 extern crate rand;
 extern crate num_cpus;
 extern crate byteorder;
+extern crate num;
 
 fn render_overlord(base_rng : &mut Rng, render_task : RenderTask) {
     let render_task = Arc::new(render_task);
@@ -123,7 +124,7 @@ fn render_overlord(base_rng : &mut Rng, render_task : RenderTask) {
 
         if prev_samp / nsave != main_target.samples / nsave {
             main_target.write_png("trace.png");
-            main_target.write_hdr("raw.rgb");
+            // main_target.write_hdr("raw.rgb");
 
             print!("{} ", main_target.samples);
             io::stdout().flush().unwrap();
@@ -163,6 +164,7 @@ fn render_a_frame(rng : &mut Rng, task : &RenderTask, target : &mut RenderTarget
     target.samples += 1;
 }
 
+
 #[inline(never)]
 fn ray_trace(rng : &mut Rng, r0 : Ray, world : &Object) -> Vec3 {
     let mut accumulator = vec3(0.0, 0.0, 0.0);
@@ -191,8 +193,8 @@ fn ray_trace(rng : &mut Rng, r0 : Ray, world : &Object) -> Vec3 {
                                     break;
                                 }
                             }
-                            continue;
                         }
+                        continue;
                     },
                     None => {
                         break;
@@ -214,11 +216,10 @@ fn main() {
     x.hit(&r, (0.0, 1.0));
 
     let seed : RngSeed = rand::thread_rng().gen();
-    let seed = [4221229915, 2284345502, 1839295593, 2276192001];
     println!("let seed = {:?};", seed);
     let mut rng : Rng = Rng::from_seed(seed);
 
-    let task = one_weekend(&mut rng);
+    let task = the_next_week(&mut rng);
 
     render_overlord(&mut rng, task);
 }

src/main.rs

@@ -1,10 +1,18 @@
+use vec3::*;
+
 use std;
 use std::ops::{Index, IndexMut};
 use std::fs::File;
 use std::path::Path;
 use std::io::Write;
 
 use image;
+use image::{Luma};
+use image::math::utils::clamp;
+
+use num::{Float};
+
+type Image32 = image::ImageBuffer<Luma<f32>, Vec<f32>>;
 
 pub struct RenderTarget {
     pub size : (u32, u32),
@@ -14,29 +22,39 @@ pub struct RenderTarget {
 
 impl RenderTarget {
     pub fn new(size : (u32, u32)) -> RenderTarget {
-        RenderTarget{
+        RenderTarget {
             size: size,
             buf: vec![[0.0; 3]; (size.0 * size.1) as usize],
             samples: 0,
         }
     }
 
-    pub fn write_png(&self, filename : &str) {
+    #[allow(dead_code)]
+    pub fn write_png(&mut self, filename : &str) {
         let (nx, ny) = self.size;
         let ns = self.samples;
         let mut img = image::DynamicImage::new_rgb8(nx, ny);
+        let bloom = self.bloom();
 
         for y in 0..ny {
             for x in 0..nx {
                 let mut col = self[(x, y)].clone();
-                col[0] = (col[0] / ns as f64).max(0.0).min(1.0).sqrt();
-                col[1] = (col[1] / ns as f64).max(0.0).min(1.0).sqrt();
-                col[2] = (col[2] / ns as f64).max(0.0).min(1.0).sqrt();
+
+                for e in 0..3 {
+                    col[e] /= ns as f64;
+                    col[e] += bloom.get_pixel(x, y).data[0] as f64;
+                    col[e] = clamp(col[e], 0.0, 1.0);
+                    col[e] = col[e].sqrt();
+                }
+
+                // col[0] = clamp(col[0] / ns as f64, 0.0, 1.0).sqrt();
+                // col[1] = clamp(col[1] / ns as f64, 0.0, 1.0).sqrt();
+                // col[2] = clamp(col[2] / ns as f64, 0.0, 1.0).sqrt();
 
                 let ir = (255.99 * col[0]) as u8;
                 let ig = (255.99 * col[1]) as u8;
                 let ib = (255.99 * col[2]) as u8;
-                img.as_mut_rgb8().unwrap()[(x, ny - y - 1)]
+                img.as_mut_rgb8().unwrap()[(x, y)]
                     = image::Rgb([ir, ig, ib]);
             }
         }
@@ -45,19 +63,38 @@ impl RenderTarget {
     }
 
 
+    #[allow(dead_code)]
     pub fn write_hdr(&self, filename : &str) {
         let ref mut fout = File::create(&Path::new(filename)).unwrap();
 
-        let bytes = unsafe {
-        let ptr : *const u8 = std::mem::transmute(&self.buf[0][0] as *const _);
-        let len = 8 * self.size.0 * self.size.1 * 3;
-            std::slice::from_raw_parts(ptr, len as usize)
+        let bytes : &[u8] = unsafe {
+            let ptr : *const u8 = std::mem::transmute(&self.buf[0] as *const _);
+            std::slice::from_raw_parts(ptr, (8 * self.size.0 * self.size.1 * 3) as usize)
         };
 
         write!(fout, "{} {} {}\n\n",
                self.size.0, self.size.1, self.samples).unwrap();
         fout.write(bytes).unwrap();
     }
+
+    fn bloom(&mut self) -> Image32 {
+        let (nx, ny) = self.size;
+
+        let luma_matrix = vec3(0.299, 0.587, 0.114);
+
+        let lumae : Vec<f32> = self.buf.iter().map(|p| {
+            let mut l = 0.299 * p[0] + 0.587 * p[1] + 0.114 * p[2];
+            l /= self.samples as f64;
+            if l > 1.0 {
+                l as f32
+            } else {
+                0.0
+            }
+        }).collect();
+
+        let im = Image32::from_vec(nx, ny, lumae).unwrap();
+        image::imageops::blur(&im, 2.5)
+    }
 }
 
 impl Index<(u32, u32)> for RenderTarget {
@@ -66,6 +103,7 @@ impl Index<(u32, u32)> for RenderTarget {
         &self.buf[(y * self.size.0 + x) as usize]
     }
 }
+
 impl IndexMut<(u32, u32)> for RenderTarget {
     fn index_mut<'a>(&'a mut self, (x, y) : (u32, u32)) -> &'a mut [f64; 3] {
         &mut self.buf[(y * self.size.0 + x) as usize]

src/render_target.rs

@@ -96,7 +96,7 @@ pub fn one_weekend(rng : &mut Rng) -> RenderTask {
 }
 
 #[allow(dead_code)]
-pub fn the_next_week(rng : &mut Rng) -> Box<Object> {
+pub fn the_next_week(rng : &mut Rng) -> RenderTask {
     let mut list : Vec<Box<Object>> = Vec::new();
     let mut boxlist : Vec<Box<Object>> = Vec::new();
     let mut boxlist2 : Vec<Box<Object>> = Vec::new();
@@ -215,11 +215,33 @@ pub fn the_next_week(rng : &mut Rng) -> Box<Object> {
                         into_bvh(rng, boxlist2, (0.0, 1.0))));
     }
 
-    return into_bvh(rng, list, (0.0, 1.0));
+    let world = into_bvh(rng, list, (0.0, 1.0));
+
+    let size = (500, 500);
+
+    let lookfrom = ivec3(478, 278, -600);
+    let lookat = ivec3(278, 278, 0);
+    let dist_to_focus = 10.0;
+    let aperture = 0.0;
+    let vfov = 40.0;
+    let aspect = size.0 as f32 / size.1 as f32;
+
+    let camera = camera(lookfrom, lookat, vec3(0.0, 1.0, 0.0),
+           vfov, aspect,
+           aperture, dist_to_focus,
+           0.0, 1.0);
+
+
+    RenderTask {
+        world: world,
+        camera: camera,
+        target_size: size,
+        samples: 10000,
+    }
 }
 
 #[allow(dead_code)]
-pub fn simple_light(rng : &mut Rng) -> Box<Object> {
+pub fn simple_light(rng : &mut Rng) -> RenderTask {
     let noise = Arc::new(PerlinNoise::new(rng, 256));
     let ntex = PerlinTexture::new(rng, 4.0);
     let mut list : Vec<Box<Object>> = Vec::new();
@@ -253,11 +275,32 @@ pub fn simple_light(rng : &mut Rng) -> Box<Object> {
         material: light_material.clone()
     });
 
-    return into_bvh(rng, list, (0.0, 1.0));
+    let world = into_bvh(rng, list, (0.0, 1.0));
+
+    let size = (200, 200);
+
+    let lookfrom = ivec3(13, 2, 3);
+    let lookat = ivec3(0, 0, 0);
+    let dist_to_focus = 10.0;
+    let aperture = 0.1;
+    let vfov = 20.0;
+    let aspect = size.0 as f32 / size.1 as f32;
+
+    let camera = camera(lookfrom, lookat, ivec3(0, 1, 0),
+           vfov, aspect,
+           aperture, dist_to_focus,
+           0.0, 1.0);
+
+    RenderTask {
+        world: world,
+        camera: camera,
+        target_size: size,
+        samples: 1000,
+    }
 }
 
 #[allow(dead_code)]
-pub fn cornell_box(rng : &mut Rng) -> Box<Object> {
+pub fn cornell_box(rng : &mut Rng) -> RenderTask {
     let mut list : Vec<Box<Object>> = Vec::new();
 
     let red : Arc<Material> = Arc::new(Lambertian(ConstantTex(vec3(0.65, 0.05, 0.05))));
@@ -292,7 +335,7 @@ pub fn cornell_box(rng : &mut Rng) -> Box<Object> {
 
     let size = (500, 500);
 
-    let lookfrom = ivec3(478, 278, -600);
+    let lookfrom = ivec3(278, 278, -800);
     let lookat = ivec3(278, 278, 0);
     let dist_to_focus = 10.0;
     let aperture = 0.0;
@@ -304,5 +347,12 @@ pub fn cornell_box(rng : &mut Rng) -> Box<Object> {
            aperture, dist_to_focus,
            0.0, 1.0);
 
-    return into_bvh(rng, list, (0.0, 1.0));
+    let world = into_bvh(rng, list, (0.0, 1.0));
+
+    RenderTask {
+        world: world,
+        camera: camera,
+        target_size: size,
+        samples: 1000,
+    }
 }

src/tasks.rs

@@ -5,7 +5,7 @@ use random::*;
 use image;
 
 use std::sync::Arc;
-use std::cmp::{max, min};
+use image::math::utils::clamp;
 
 pub trait Texture : Send + Sync {
     fn tex_lookup(&self, uv : (f32, f32), p : &Vec3) -> Vec3;
@@ -170,9 +170,9 @@ impl Texture for ImageTexture {
         let ny = self.im.height();
 
         uv.1 = 1.0 - uv.1;
-        let i = min(max(0, (uv.0 * nx as f32) as i32) as u32, nx - 1);
-        let j = min(max(0, (uv.1 * ny as f32) as i32) as u32, ny - 1);
-        let pix = self.im.get_pixel(i, j);
+        let i = clamp((uv.0 * nx as f32) as i32, 0, nx as i32 - 1);
+        let j = clamp((uv.1 * ny as f32) as i32, 0, ny as i32 - 1);
+        let pix = self.im.get_pixel(i as u32, j as u32);
         vec3(pix[0] as f32 / 255.0,
              pix[1] as f32 / 255.0,
              pix[2] as f32 / 255.0)