rtiow: add support to send rendering output to https://github.com/Tom94/tev

Add debugging hit DebugHit.
Move some color helpers from mandelbrot to colors mod.
Implement Texture trait for [f32;3]

rtiow/Cargo.toml

@@ -1,4 +1,5 @@
 [workspace]
+resolver = "2"
 
 members = [
   "noise_explorer",
@@ -10,3 +11,5 @@ members = [
 [profile.release]
 debug = true
 
+[profile.dev]
+opt-level = 3 

rtiow/renderer/Cargo.toml

@@ -23,17 +23,20 @@ num_cpus = "1.15.0"
 rand = "0.8.5"
 serde = "1.0.152"
 serde_derive = "1.0.152"
-serde_json = "1.0.91"
+serde_json = "1.0.93"
 structopt = "0.2.18"
 vec3 = {path = "../vec3"}
 stl = {path = "../../../stl"}
 strum = { version = "0.24.1", features = ["derive"] }
 strum_macros = "0.24.3"
+thiserror = "1.0.38"
+tev_client = "0.5.2"
 #stl = {git = "https://git-private.z.xinu.tv/wathiede/stl"}
 
 [dev-dependencies]
 criterion = "0.4"
 pretty_assertions = "1.3.0"
+proptest = "1.1.0"
 
 [features]
 profile = ["cpuprofiler"]

rtiow/renderer/src/aabb.rs

@@ -33,15 +33,23 @@ impl fmt::Debug for AABB {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         write!(
             f,
-            "AABB: <{} - {}> Vol: {}",
+            "AABB: <{} - {}> Vol: {} Area: {}",
             self.bounds[0],
             self.bounds[1],
-            self.volume()
+            self.volume(),
+            self.area()
         )
     }
 }
 
 impl AABB {
+    // Create AABB with min = f32::MAX and max = -f32::MAX. It is expected the caller will use grow to create
+    // a vaild AABB.
+    pub fn infinite() -> AABB {
+        AABB {
+            bounds: [Vec3::from(f32::MAX), Vec3::from(f32::MIN)],
+        }
+    }
     pub fn new<V: Into<Vec3>>(min: V, max: V) -> AABB {
         let min: Vec3 = min.into();
         let max: Vec3 = max.into();
@@ -51,10 +59,35 @@ impl AABB {
         AABB { bounds: [min, max] }
     }
 
+    pub fn area(&self) -> f32 {
+        if self.max().x == f32::MIN || self.min().x == f32::MAX {
+            return 0.;
+        }
+        let e = self.max() - self.min();
+        let v = e.x * e.y + e.y * e.z + e.z * e.x;
+        if v.is_finite() {
+            v
+        } else {
+            0.
+        }
+    }
     pub fn volume(&self) -> f32 {
-        (self.min().x - self.max().x).abs()
+        if self.max().x == f32::MIN || self.min().x == f32::MAX {
+            return 0.;
+        }
+        let v = (self.min().x - self.max().x).abs()
             * (self.min().y - self.max().y).abs()
-            * (self.min().z - self.max().z).abs()
+            * (self.min().z - self.max().z).abs();
+        if v.is_finite() {
+            v
+        } else {
+            0.
+        }
+    }
+
+    pub fn grow(&mut self, v: Vec3) {
+        self.bounds[0] = vec3::min(self.bounds[0], v);
+        self.bounds[1] = vec3::max(self.bounds[1], v);
     }
 
     pub fn longest_axis(&self) -> usize {
@@ -86,10 +119,14 @@ impl AABB {
     // TODO(wathiede): implement branchless https://tavianator.com/cgit/dimension.git/tree/libdimension/bvh/bvh.c#n194
 
     pub fn hit(&self, r: Ray, t_min: f32, t_max: f32) -> bool {
+        self.hit_simd(r, t_min, t_max).is_some()
+    }
+
+    pub fn hit_distance(&self, r: Ray, t_min: f32, t_max: f32) -> Option<f32> {
         self.hit_simd(r, t_min, t_max)
     }
 
-    pub fn hit_naive(&self, r: Ray, t_min: f32, t_max: f32) -> bool {
+    pub fn hit_naive(&self, r: Ray, t_min: f32, t_max: f32) -> Option<f32> {
         let mut t_min = t_min;
         let mut t_max = t_max;
         for axis in 0..3 {
@@ -100,13 +137,13 @@ impl AABB {
             t_min = t0.max(t_min);
             t_max = t1.min(t_max);
             if t_max <= t_min {
-                return false;
+                return None;
             }
         }
-        true
+        Some(t_min)
     }
 
-    pub fn hit2(&self, r: Ray, t_min: f32, t_max: f32) -> bool {
+    pub fn hit2(&self, r: Ray, t_min: f32, t_max: f32) -> Option<f32> {
         let mut t_min = t_min;
         let mut t_max = t_max;
         for axis in 0..3 {
@@ -122,13 +159,13 @@ impl AABB {
             t_min = max(t0, t_min);
             t_max = min(t1, t_max);
             if t_max <= t_min {
-                return false;
+                return None;
             }
         }
-        true
+        Some(t_min)
     }
 
-    pub fn hit_precompute(&self, r: Ray, t0: f32, t1: f32) -> bool {
+    pub fn hit_precompute(&self, r: Ray, t0: f32, t1: f32) -> Option<f32> {
         // TODO(wathiede): this has bugs.
         let mut t_min = (self.bounds[r.sign[0]].x - r.origin.x) * r.inv_direction.x;
         let mut t_max = (self.bounds[1 - r.sign[0]].x - r.origin.x) * r.inv_direction.x;
@@ -136,7 +173,7 @@ impl AABB {
         let t_y_max = (self.bounds[1 - r.sign[0]].y - r.origin.y) * r.inv_direction.y;
 
         if t_min > t_y_max || t_y_min > t_max {
-            return false;
+            return None;
         }
 
         if t_y_min > t_min {
@@ -149,7 +186,7 @@ impl AABB {
         let t_z_min = (self.bounds[r.sign[2]].z - r.origin.z) * r.inv_direction.z;
         let t_z_max = (self.bounds[1 - r.sign[2]].z - r.origin.z) * r.inv_direction.z;
         if t_min > t_z_max || t_z_min > t_max {
-            return false;
+            return None;
         }
         if t_z_min > t_min {
             t_min = t_z_min;
@@ -157,10 +194,14 @@ impl AABB {
         if t_z_max < t_max {
             t_max = t_z_max;
         }
-        t_min < t1 && t_max > t0
+        if t_min < t1 && t_max > t0 {
+            Some(t_min)
+        } else {
+            None
+        }
     }
 
-    pub fn hit_simd(&self, r: Ray, t_min: f32, t_max: f32) -> bool {
+    pub fn hit_simd(&self, r: Ray, t_min: f32, t_max: f32) -> Option<f32> {
         #[cfg(target_arch = "x86_64")]
         unsafe {
             use std::arch::x86_64::*;
@@ -177,14 +218,18 @@ impl AABB {
             let vmin4: (f32, f32, f32, f32) = std::mem::transmute(vmin4);
             let tmax = min(min(vmax4.0, min(vmax4.1, vmax4.2)), t_max);
             let tmin = max(max(vmin4.0, max(vmin4.1, vmin4.2)), t_min);
-            tmin <= tmax
+            if tmin <= tmax {
+                Some(tmin)
+            } else {
+                None
+            }
         }
         #[cfg(target_arch = "aarch64")]
         // TODO(wathiede): add NEON implementation.
         self.hit2(r, t_min, t_max)
     }
 
-    pub fn hit_fast(&self, r: Ray, _t_min: f32, _t_max: f32) -> bool {
+    pub fn hit_fast(&self, r: Ray, _t_min: f32, _t_max: f32) -> Option<f32> {
         let b = self;
         let mut t1 = (b.min()[0] - r.origin[0]) * 1. / r.direction[0];
         let mut t2 = (b.max()[0] - r.origin[0]) * 1. / r.direction[0];
@@ -200,7 +245,11 @@ impl AABB {
             tmax = tmax.min(t1.max(t2));
         }
 
-        tmax > tmin.max(0.0)
+        if tmax > tmin.max(0.0) {
+            Some(tmin)
+        } else {
+            None
+        }
     }
 }
 
@@ -222,6 +271,13 @@ pub fn surrounding_box(box0: &AABB, box1: &AABB) -> AABB {
 mod tests {
     use super::*;
 
+    #[test]
+    fn infinite() {
+        let bb = AABB::infinite();
+        assert_eq!(bb.area(), 0.);
+        assert_eq!(bb.volume(), 0.);
+    }
+
     macro_rules! hit_test {
         ($($name:ident,)*) => {
             $(
@@ -238,74 +294,74 @@ mod tests {
                     fn hit_front() {
                         let bb = test_bb();
                         let r = Ray::new([-2., 0., 0.], [1., 0., 0.], 0.5);
-                        assert!(bb.$name(r, T_MIN, T_MAX));
+                        assert!(bb.$name(r, T_MIN, T_MAX).is_some());
                     }
                     #[test]
                     fn hit_back() {
                         let bb = test_bb();
                         let r = Ray::new([2., 0., 0.], [-1., 0., 0.], 0.5);
-                        assert!(bb.$name(r, T_MIN, T_MAX));
+                        assert!(bb.$name(r, T_MIN, T_MAX).is_some());
                     }
                     #[test]
                     fn hit_top() {
                         let bb = test_bb();
                         let r = Ray::new([0., 2., 0.], [0., -1., 0.], 0.5);
-                        assert!(bb.$name(r, T_MIN, T_MAX));
+                        assert!(bb.$name(r, T_MIN, T_MAX).is_some());
                     }
                     #[test]
                     fn hit_bottom() {
                         let bb = test_bb();
                         let r = Ray::new([0., -2., 0.], [0., 1., 0.], 0.5);
-                        assert!(bb.$name(r, T_MIN, T_MAX));
+                        assert!(bb.$name(r, T_MIN, T_MAX).is_some());
                     }
                     #[test]
                     fn hit_left() {
                         let bb = test_bb();
                         let r = Ray::new([0., 0., -2.], [0., 0., 1.], 0.5);
-                        assert!(bb.$name(r, T_MIN, T_MAX));
+                        assert!(bb.$name(r, T_MIN, T_MAX).is_some());
                     }
                     #[test]
                     fn hit_right() {
                         let bb = test_bb();
                         let r = Ray::new([0., 0., 2.], [0., 0., -1.], 0.5);
-                        assert!(bb.$name(r, T_MIN, T_MAX));
+                        assert!(bb.$name(r, T_MIN, T_MAX).is_some());
                     }
 
                     #[test]
                     fn miss_front() {
                         let bb = test_bb();
                         let r = Ray::new([0., 1.1, -1.1], [0., -1., 0.], 0.5);
-                        assert!(!bb.$name(r, T_MIN, T_MAX));
+                        assert_eq!(bb.$name(r, T_MIN, T_MAX), None);
                     }
                     #[test]
                     fn miss_back() {
                         let bb = test_bb();
                         let r = Ray::new([0., 1.1, 1.1], [0., -1., 0.], 0.5);
-                        assert!(!bb.$name(r, T_MIN, T_MAX));
+                        assert_eq!(bb.$name(r, T_MIN, T_MAX), None);
                     }
                     #[test]
                     fn miss_top() {
                         let bb = test_bb();
                         let r = Ray::new([0., 1.1, -1.1], [0., 0., 1.], 0.5);
-                        assert!(!bb.$name(r, T_MIN, T_MAX));
+                        assert_eq!(bb.$name(r, T_MIN, T_MAX), None);
                     }
                     #[test]
                     fn miss_bottom() {
                         let bb = test_bb();
                         let r = Ray::new([0., -1.1, -1.1], [0., 0., 1.], 0.5);
-                        assert!(!bb.$name(r, T_MIN, T_MAX));
+                        assert_eq!(bb.$name(r, T_MIN, T_MAX), None);
                     }
                     #[test]
                     fn miss_left() {
                         let bb = test_bb();
                         let r = Ray::new([-1.1, 0., -1.1], [0., 0., 1.], 0.5);
-                        assert!(!bb.$name(r, T_MIN, T_MAX));
+                        assert_eq!(bb.$name(r, T_MIN, T_MAX), None);
                     }
                     #[test]
                     fn miss_right() {
                         let bb = test_bb();
                         let r = Ray::new([1.1, 0., -1.1], [0., 0., 1.], 0.5);
-                        assert!(!bb.$name(r, T_MIN, T_MAX));
+                        assert_eq!(bb.$name(r, T_MIN, T_MAX), None);
                     }
                 }
             )*
@@ -314,8 +370,8 @@ mod tests {
 
     hit_test! {
         hit_naive,
-        hit2,
-        hit_fast,
         hit_simd,
+        hit_fast,
+        hit2,
     }
 }

rtiow/renderer/src/bvh_triangles.rs

@@ -3,6 +3,7 @@
 use std::f32::EPSILON;
 use std::fmt;
 
+use log::info;
 use stl::STL;
 
 use crate::{
@@ -16,18 +17,24 @@ use crate::{
 #[derive(Debug, PartialEq)]
 struct BVHNode {
     aabb: AABB,
-    left_child: usize,
+    // When tri_count==0, left_first holds the left child's index in bvh_nodes. When >0 left_first
-    first_prim: usize,
+    // holds the index for the first triangle in triangles.
-    prim_count: usize,
+    left_first: u32,
+    tri_count: u32,
 }
 
 impl BVHNode {
     fn is_leaf(&self) -> bool {
-        self.prim_count > 0
+        self.tri_count > 0
+    }
+
+    fn cost(&self) -> f32 {
+        let area = self.aabb.area();
+        self.tri_count as f32 * area
     }
 }
 
-#[derive(PartialEq)]
+#[derive(Clone, PartialEq)]
 pub struct Triangle {
     centroid: Vec3,
     verts: [Vec3; 3],
@@ -47,10 +54,17 @@ where
     M: Material,
 {
     pub triangles: Vec<Triangle>,
+    triangle_index: Vec<usize>,
     material: M,
     bvh_nodes: Vec<BVHNode>,
 }
 
+#[derive(Debug, Default)]
+struct Bin {
+    bounds: AABB,
+    tri_count: usize,
+}
+
 impl<M> fmt::Debug for BVHTriangles<M>
 where
     M: Material,
@@ -79,11 +93,11 @@ where
             }
             let n = &self.bvh_nodes[i];
             if n.is_leaf() {
-                for t_idx in n.first_prim..(n.first_prim + n.prim_count) {
+                for t_idx in n.left_first..(n.left_first + n.tri_count) {
                     if f.alternate() {
                         write!(f, "\t")?;
                     }
-                    write!(f, "{:?} ", self.triangles[t_idx])?;
+                    write!(f, "{:?} ", self.triangles[t_idx as usize])?;
                     if f.alternate() {
                         writeln!(f)?;
                     }
@@ -94,20 +108,30 @@ where
     }
 }
 
+#[derive(Debug)]
+struct SplitCost {
+    pos: f32,
+    axis: usize,
+    cost: f32,
+}
+
 const ROOT_NODE_IDX: usize = 0;
 impl<M> BVHTriangles<M>
 where
     M: Material,
 {
-    pub fn new(stl: &STL, material: M) -> BVHTriangles<M> {
+    pub fn new(stl: &STL, material: M, scale_factor: f32) -> BVHTriangles<M> {
+        let now = std::time::Instant::now();
+
+        assert_eq!(std::mem::size_of::<BVHNode>(), 32);
         let div3 = 1. / 3.;
         let triangles: Vec<_> = stl
             .triangles
             .iter()
             .map(|t| {
-                let v0 = t.verts[0];
+                let v0 = t.verts[0] * scale_factor;
-                let v1 = t.verts[1];
+                let v1 = t.verts[1] * scale_factor;
-                let v2 = t.verts[2];
+                let v2 = t.verts[2] * scale_factor;
                 let centroid = (v0 + v1 + v2) * div3;
                 Triangle {
                     centroid,
@@ -115,15 +139,61 @@ where
                 }
             })
             .collect();
+        let triangle_index = (0..triangles.len()).collect();
 
         let n = 2 * triangles.len() - 2;
         let bvh_nodes = Vec::with_capacity(n);
         let mut bvh = BVHTriangles {
             triangles,
+            triangle_index,
             bvh_nodes,
             material,
         };
         bvh.build_bvh();
+        info!(
+            "BVHTriangles build time {:0.3}s",
+            now.elapsed().as_secs_f32()
+        );
+        struct Stats {
+            nodes: usize,
+            leafs: usize,
+            min_tris: u32,
+            max_tris: u32,
+        }
+        impl Default for Stats {
+            fn default() -> Self {
+                Stats {
+                    nodes: 0,
+                    leafs: 0,
+                    min_tris: u32::MAX,
+                    max_tris: u32::MIN,
+                }
+            }
+        }
+        let stats = bvh.bvh_nodes.iter().fold(Stats::default(), |mut stats, n| {
+            stats.nodes += 1;
+            if n.is_leaf() {
+                stats.leafs += 1;
+                stats.min_tris = n.tri_count.min(stats.min_tris);
+                stats.max_tris = n.tri_count.max(stats.max_tris);
+            }
+            stats
+        });
+        info!("BVHTriangles build stats:");
+        info!("  Nodes:   {}", stats.nodes);
+        info!("  Leaves:  {}", stats.leafs);
+        info!("  Tris:    {}", bvh.triangles.len());
+        info!("  Min Tri: {}", stats.min_tris);
+        info!("  Max Tri: {}", stats.max_tris);
+        info!("  Avg Tri: {}", bvh.triangles.len() / stats.leafs);
+        info!("  Predict: {}", bvh.bvh_nodes.capacity());
+        info!("  Actual:  {}", bvh.bvh_nodes.len());
+        info!(
+            "  Savings:  {} bytes",
+            (bvh.bvh_nodes.capacity() - bvh.bvh_nodes.len()) * std::mem::size_of::<BVHNode>()
+        );
+        bvh.bvh_nodes.shrink_to_fit();
+        //dbg!(&bvh);
         bvh
     }
 
@@ -131,9 +201,8 @@ where
         // assign all triangles to root node
         let root = BVHNode {
             aabb: AABB::default(),
-            left_child: 0,
+            left_first: 0,
-            first_prim: 0,
+            tri_count: self.triangles.len() as u32,
-            prim_count: self.triangles.len(),
         };
         self.bvh_nodes.push(root);
         self.update_node_bounds(ROOT_NODE_IDX);
@@ -144,8 +213,9 @@ where
         let node = &mut self.bvh_nodes[node_idx];
         let mut aabb_min: Vec3 = f32::MAX.into();
         let mut aabb_max: Vec3 = f32::MIN.into();
-        for i in node.first_prim..(node.first_prim + node.prim_count) {
+        for i in node.left_first..(node.left_first + node.tri_count) {
-            let leaf_tri = &self.triangles[i];
+            let leaf_tri_idx = self.triangle_index[i as usize];
+            let leaf_tri = &self.triangles[leaf_tri_idx];
             aabb_min = vec3::min(aabb_min, leaf_tri.verts[0]);
             aabb_min = vec3::min(aabb_min, leaf_tri.verts[1]);
             aabb_min = vec3::min(aabb_min, leaf_tri.verts[2]);
@@ -155,116 +225,212 @@ where
         }
         node.aabb = AABB::new(aabb_min, aabb_max);
     }
+
+    fn find_best_split_plane(&self, node: &BVHNode) -> SplitCost {
+        let mut best = SplitCost {
+            pos: 0.,
+            cost: f32::MAX,
+            axis: usize::MAX,
+        };
+
+        for axis in 0..3 {
+            let mut bounds_min = f32::MAX;
+            let mut bounds_max = f32::MIN;
+
+            for i in 0..node.tri_count {
+                let triangle = &self.triangles[self.triangle_index[(node.left_first + i) as usize]];
+                bounds_min = bounds_min.min(triangle.centroid[axis]);
+                bounds_max = bounds_max.max(triangle.centroid[axis]);
+            }
+
+            if bounds_min == bounds_max {
+                continue;
+            }
+
+            const NUM_BINS: usize = 8;
+            let mut bins: Vec<_> = (0..NUM_BINS)
+                .map(|_| Bin {
+                    bounds: AABB::infinite(),
+                    tri_count: 0,
+                })
+                .collect();
+            let scale = bins.len() as f32 / (bounds_max - bounds_min);
+            // populate the bins
+            for i in 0..node.tri_count {
+                let triangle = &self.triangles[self.triangle_index[(node.left_first + i) as usize]];
+                let bin_idx = (triangle.centroid[axis] - bounds_min) * scale;
+                let bin_idx = (bins.len() - 1).min(bin_idx as usize);
+
+                bins[bin_idx].tri_count += 1;
+                bins[bin_idx].bounds.grow(triangle.verts[0]);
+                bins[bin_idx].bounds.grow(triangle.verts[1]);
+                bins[bin_idx].bounds.grow(triangle.verts[2]);
+            }
+
+            // gather data for the 7 planes between the 8 bins
+            let mut left_area: Vec<_> = (0..bins.len() - 1).map(|_| 0.).collect();
+            let mut right_area: Vec<_> = (0..bins.len() - 1).map(|_| 0.).collect();
+            let mut left_count: Vec<_> = (0..bins.len() - 1).map(|_| 0).collect();
+            let mut right_count: Vec<_> = (0..bins.len() - 1).map(|_| 0).collect();
+            let mut left_box = AABB::infinite();
+            let mut right_box = AABB::infinite();
+            let mut left_sum = 0;
+            let mut right_sum = 0;
+            for i in 0..(bins.len() - 1) {
+                left_sum += bins[i].tri_count;
+                left_count[i] = left_sum;
+                left_box.grow(bins[i].bounds.min());
+                left_box.grow(bins[i].bounds.max());
+                left_area[i] = left_box.area();
+
+                right_sum += bins[bins.len() - 1 - i].tri_count;
+                right_count[bins.len() - 2 - i] = right_sum;
+                right_box.grow(bins[bins.len() - 1 - i].bounds.min());
+                right_box.grow(bins[bins.len() - 1 - i].bounds.max());
+                right_area[bins.len() - 2 - i] = right_box.area();
+            }
+
+            let scale = (bounds_max - bounds_min) / bins.len() as f32;
+            // calculate SAH cost for the 7 planes
+            for i in 0..(bins.len() - 1) {
+                let plane_cost =
+                    left_count[i] as f32 * left_area[i] + right_count[i] as f32 * right_area[i];
+                if plane_cost < best.cost {
+                    best.axis = axis;
+                    best.pos = bounds_min + scale * (i as f32 + 1.);
+                    best.cost = plane_cost;
+                }
+            }
+        }
+        best
+    }
+
     fn subdivide(&mut self, idx: usize) {
-        // Early out if we're down to just 2 or less triangles
+        let (left_first, tri_count, left_count, i) = {
-        if self.bvh_nodes[idx].prim_count <= 2 {
+            let node = &self.bvh_nodes[idx];
+            let split = self.find_best_split_plane(&node);
+            let no_split_cost = node.cost();
+            // Stop subdividing if it isn't getting any better.
+            if split.cost >= no_split_cost {
                 return;
             }
-        let (first_prim, prim_count, left_count, i) = {
-            let node = &self.bvh_nodes[idx];
-
-            // Compute split plane and position.
-            let extent = node.aabb.max() - node.aabb.min();
-            let axis = node.aabb.longest_axis();
-            let split_pos = node.aabb.min()[axis] + extent[axis] * 0.5;
 
             // Split the group in two halves.
-            let mut i = node.first_prim as isize;
+            let mut i = node.left_first as isize;
-            let mut j = i + node.prim_count as isize - 1;
+            let mut j = i + node.tri_count as isize - 1;
             while i <= j {
-                if self.triangles[i as usize].centroid[axis] < split_pos {
+                if self.triangles[self.triangle_index[i as usize]].centroid[split.axis] < split.pos
+                {
                     i += 1;
                 } else {
-                    self.triangles.swap(i as usize, j as usize);
+                    self.triangles.swap(
+                        self.triangle_index[i as usize],
+                        self.triangle_index[j as usize],
+                    );
                     j -= 1;
                 }
             }
 
             // Create child nodes for each half.
-            let left_count = i as usize - node.first_prim;
+            let left_count = i as u32 - node.left_first;
-            if left_count == 0 || left_count == node.prim_count {
+            if left_count == 0 || left_count == node.tri_count {
                 return;
             }
-            (node.first_prim, node.prim_count, left_count, i)
+            (node.left_first, node.tri_count, left_count, i)
         };
 
         // create child nodes
-        let left_child_idx = self.bvh_nodes.len();
+        let left_child_idx = self.bvh_nodes.len() as u32;
-        let right_child_idx = left_child_idx + 1;
+        let right_child_idx = left_child_idx + 1 as u32;
         let left = BVHNode {
             aabb: AABB::default(),
-            left_child: 0,
+            left_first,
-            first_prim: first_prim,
+            tri_count: left_count as u32,
-            prim_count: left_count,
         };
         let right = BVHNode {
             aabb: AABB::default(),
-            left_child: 0,
+            left_first: i as u32,
-            first_prim: i as usize,
+            tri_count: (tri_count - left_count) as u32,
-            prim_count: prim_count - left_count,
         };
         self.bvh_nodes.push(left);
         self.bvh_nodes.push(right);
         let node = &mut self.bvh_nodes[idx];
-        node.left_child = left_child_idx;
+        node.left_first = left_child_idx;
-        node.prim_count = 0;
+        node.tri_count = 0;
 
         // Recurse
-        self.update_node_bounds(left_child_idx);
+        self.update_node_bounds(left_child_idx as usize);
-        self.update_node_bounds(right_child_idx);
+        self.subdivide(left_child_idx as usize);
-        self.subdivide(left_child_idx);
+        self.update_node_bounds(right_child_idx as usize);
-        self.subdivide(right_child_idx);
+        self.subdivide(right_child_idx as usize);
     }
 
-    fn intersect_bvh(&self, r: Ray, node_idx: usize, t_min: f32, t_max: f32) -> Option<HitRecord> {
+    fn intersect_bvh(&self, r: Ray, t_min: f32, t_max: f32) -> Option<HitRecord> {
-        let node = &self.bvh_nodes[node_idx];
+        let mut node = &self.bvh_nodes[ROOT_NODE_IDX];
-        if !node.aabb.hit(r, t_min, t_max) {
+        let mut stack = Vec::with_capacity(2);
-            return None;
+        let mut nearest = None;
-        }
+        loop {
-        //dbg!(&self);
-
             if node.is_leaf() {
-            return self
+                let canditate = (node.left_first..(node.left_first + node.tri_count))
-                .triangles
+                    // Map from idx to Triangle
-                .iter()
+                    .map(|idx| &self.triangles[self.triangle_index[idx as usize]])
-                .map(|tri| {
+                    // Try to hit all triangles for this node, filtering out misses.
-                    if let Some(RayTriangleResult { t, p }) = intersect_tri(r, tri) {
+                    .filter_map(|tri| intersect_tri(r, &tri))
-                        // We don't support UV (yet?).
+                    // Find the nearest hit (if any).
-                        let uv = (0.5, 0.5);
-                        let v0 = tri.verts[0];
-                        let v1 = tri.verts[1];
-                        let v2 = tri.verts[2];
-
-                        let v0v1 = v1 - v0;
-                        let v0v2 = v2 - v0;
-                        let normal = cross(v0v1, v0v2).unit_vector();
-                        //println!("hit triangle {tri:?}");
-                        Some(HitRecord {
-                            t,
-                            uv,
-                            p,
-                            normal,
-                            material: &self.material,
-                        })
-                    } else {
-                        None
-                    }
-                })
-                .filter_map(|hr| hr)
                     .min_by(|a, b| a.t.partial_cmp(&b.t).unwrap());
+
+                // merge candidate with nearest.
+                nearest = match (&canditate, &nearest) {
+                    (Some(_), None) => canditate,
+                    (None, Some(_)) => nearest,
+                    (Some(c), Some(n)) => {
+                        //info!("merging {c:#?} and {n:#?}");
+                        if c.t < n.t {
+                            canditate
                         } else {
-            let r1 = self.intersect_bvh(r, node.left_child, t_min, t_max);
+                            nearest
-            let r2 = self.intersect_bvh(r, node.left_child + 1, t_min, t_max);
-            // Merge results, if both hit, take the one closest to the ray origin (smallest t
-            // value).
-            match (&r1, &r2) {
-                (Some(_), None) => return r1,
-                (None, Some(_)) => return r2,
-                (None, None) => (),
-                (Some(rp1), Some(rp2)) => return if rp1.t < rp2.t { r1 } else { r2 },
                         }
                     }
-        None
+                    (None, None) => None,
+                };
+                if stack.is_empty() {
+                    break;
+                }
+                node = stack.pop().unwrap();
+                continue;
+            }
+
+            let child1 = &self.bvh_nodes[node.left_first as usize];
+            let child2 = &self.bvh_nodes[node.left_first as usize + 1];
+            let dist1 = child1.aabb.hit_distance(r, t_min, t_max);
+            let dist2 = child2.aabb.hit_distance(r, t_min, t_max);
+            // Swap c1/c2 & d1/d2 based on d1/d2.
+            let (child1, child2, dist1, dist2) = match (dist1, dist2) {
+                (Some(d1), Some(d2)) if d1 > d2 => (child2, child1, dist2, dist1),
+                (None, Some(_)) => (child2, child1, dist2, dist1),
+                _ => (child1, child2, dist1, dist2),
+            };
+
+            // dist1/child1 should now be the nearest hit.
+
+            // If we missed dist1/child1, then we implicitly missed dist2/child2, so pop a child
+            // from the stack or exit the function.
+            if dist1.is_none() {
+                if stack.is_empty() {
+                    break;
+                }
+                node = stack.pop().unwrap();
+            } else {
+                // We hit child1, so process it next.
+                node = child1;
+                // If we also hit child2 save it on the stack so we can process it later.
+                if dist2.is_some() {
+                    stack.push(child2);
+                }
+            }
+        }
+        nearest
+            .and_then(|rtr: RayTriangleResult| Some(rtr.hit_record_with_material(&self.material)))
     }
 }
 
@@ -326,6 +492,7 @@ fn intersect_tri(r: Ray, tri: &Triangle) -> Option<RayTriangleResult> {
         return Some(RayTriangleResult {
             t,
             p: r.point_at_parameter(t),
+            tri: tri.clone(),
         });
     }
     None
@@ -336,17 +503,41 @@ where
     M: Material,
 {
     fn hit(&self, r: Ray, t_min: f32, t_max: f32) -> Option<HitRecord> {
-        self.intersect_bvh(r, 0, t_min, t_max)
+        self.intersect_bvh(r, t_min, t_max)
     }
 
     fn bounding_box(&self, _t_min: f32, _t_max: f32) -> Option<AABB> {
-        Some(self.bvh_nodes[0].aabb)
+        Some(self.bvh_nodes[ROOT_NODE_IDX].aabb)
     }
 }
 
+#[derive(Debug)]
 struct RayTriangleResult {
     t: f32,
     p: Vec3,
+    tri: Triangle,
+}
+
+impl RayTriangleResult {
+    fn hit_record_with_material<'m>(self, material: &'m dyn Material) -> HitRecord<'m> {
+        // We don't support UV (yet?).
+        let uv = (0.5, 0.5);
+        let v0 = self.tri.verts[0];
+        let v1 = self.tri.verts[1];
+        let v2 = self.tri.verts[2];
+
+        let v0v1 = v1 - v0;
+        let v0v2 = v2 - v0;
+        let normal = cross(v0v1, v0v2).unit_vector();
+        //println!("hit triangle {tri:?}");
+        HitRecord {
+            t: self.t,
+            uv,
+            p: self.p,
+            normal,
+            material,
+        }
+    }
 }
 
 #[cfg(test)]
@@ -361,67 +552,13 @@ mod tests {
         texture::ConstantTexture,
     };
     use pretty_assertions::assert_eq;
+    use proptest::prelude::*;
     use std::{
         io::{BufReader, Cursor},
         sync::Arc,
     };
     use stl::STL;
 
-    /*
-        #[test]
-        fn build_bvh() {
-            let stl_triangles: Vec<_> = (0..4)
-                .flat_map(|y| {
-                    (0..2).map(move |x| {
-                        let x = x as f32;
-                        let y = y as f32;
-                        stl::Triangle {
-                            normal: [1., 0., 0.].into(),
-                            verts: [
-                                [2. * x + 0., 2. * y + 0., 0.].into(),
-                                [2. * x + 1., 2. * y + 0., 0.].into(),
-                                [2. * x + 1., 2. * y + 1., 0.].into(),
-                            ],
-                            attr: 0,
-                        }
-                    })
-                })
-                .collect();
-            let stl = STL {
-                header: [0; 80],
-                triangles: stl_triangles,
-            };
-            /*
-            let mut bvh_triangles: Vec<_> = stl_triangles
-            .iter()
-            .map(|tri| {
-            let div3 = 1. / 3.;
-            let v0 = tri.verts[0];
-            let v1 = tri.verts[1];
-            let v2 = tri.verts[2];
-            let centroid = (v0 + v1 + v2) * div3;
-            Triangle {
-            centroid,
-            verts: tri.verts,
-            }
-            })
-            .collect();
-            bvh_triangles.sort_by(|a, b| a.centroid.y.partial_cmp(&b.centroid.y).unwrap());
-            let material = Lambertian::new(ConstantTexture::new([0., 0., 0.]));
-            let bvh_nodes = Default::default();
-            let want = BVHTriangles {
-            triangles: bvh_triangles,
-            bvh_nodes,
-            material,
-            };
-            */
-            let material = Lambertian::new(ConstantTexture::new([0., 0., 0.]));
-            let bvh = BVHTriangles::new(&stl, material);
-            dbg!(&bvh);
-            assert_eq!(bvh.bvh_nodes.len(), 2 * bvh.triangles.len() - 2);
-        }
-    */
-
     #[test]
     fn compare_cuboid() {
         let c = Cuboid::new(
@@ -479,7 +616,6 @@ mod tests {
                 })
             })
             .collect();
-        // These currently differ between STL and cuboid.
         if false {
             // Outward in at an angle.
             let sqrt2 = 2f32.sqrt();
@@ -491,8 +627,6 @@ mod tests {
             ]);
         }
 
-        // TODO(wathiede): proptest this, it's still not perfectly equal when rendering.
-
         for r in rays.into_iter() {
             let c_hit = c
                 .hit(r, 0., f32::MAX)
@@ -516,4 +650,62 @@ mod tests {
             );
         }
     }
+
+    proptest! {
+        // TODO(wathiede): make this work.
+        //#[test]
+        fn compare_cuboid_proptest(
+            ox in -20.0f32..40.0,
+            oy in -20.0f32..40.0,
+            oz in -20.0f32..40.0,
+            dx in -1.0f32..1.0,
+            dy in -1.0f32..1.0,
+            dz in -1.0f32..1.0,
+        ) {
+            let r = Ray::new([ox,oy,oz].into(), Vec3::new(dx, dy, dz).unit_vector(), 0.5);
+            let c = Cuboid::new(
+                [0., 0., 0.].into(),
+                [20., 20., 20.].into(),
+                Arc::new(Dielectric::new(1.5)),
+            );
+            let stl_cube = STL::parse(
+                BufReader::new(Cursor::new(include_bytes!("../stls/cube.stl"))),
+                false,
+            )
+                .expect("failed to parse cube");
+
+            let s = BVHTriangles::new(
+                &stl_cube,
+                Dielectric::new(1.5),
+                //Metal::new(Vec3::new(0.8, 0.8, 0.8), 0.2),
+                //Lambertian::new(ConstantTexture::new(Vec3::new(1.0, 0.2, 0.2))),
+            );
+
+            let c_hit = c .hit(r, 0., f32::MAX);
+            let s_hit = s .hit(r, 0., f32::MAX);
+
+            match (c_hit, s_hit) {
+                (Some(_), None)=>assert!(false, "hit cuboid but not STL"),
+                (None, Some(_))=>assert!(false, "hit STL but not cuboid"),
+                (Some(c_hit), Some(s_hit))=> {
+                    assert!(
+                        (c_hit.t - s_hit.t).abs() < 0.00001,
+                        "{r:?} [t] c_hit: {c_hit:#?}, s_hit: {s_hit:#?}"
+                    );
+                    // uv isn't valid for BVHTriangles.
+                    // assert_eq!( c_hit.uv, s_hit.uv, "{i}: [uv] c_hit: {c_hit:?}, s_hit: {s_hit:?}");
+                    assert_eq!(
+                        c_hit.p, s_hit.p,
+                        "{r:?}: [p] c_hit: {c_hit:#?}, s_hit: {s_hit:#?}"
+                    );
+                    assert_eq!(
+                        c_hit.normal, s_hit.normal,
+                        "{r:?}: [normal] c_hit: {c_hit:?}, s_hit: {s_hit:?}"
+                    );
+                },
+                // It's okay if they both miss.
+                (None,None)=>(),
+            }
+        }
+    }
 }

rtiow/renderer/src/camera.rs

@@ -18,6 +18,7 @@ fn random_in_unit_disk() -> Vec3 {
     }
 }
 
+#[derive(Debug)]
 pub struct Camera {
     origin: Vec3,
     lower_left_corner: Vec3,

rtiow/renderer/src/colors.rs

@@ -0,0 +1,46 @@
+use rand::{self, Rng};
+
+use crate::vec3::Vec3;
+
+// HSV values in [0..1]
+// returns [r, g, b] values from 0 to 255
+//From https://martin.ankerl.com/2009/12/09/how-to-create-random-colors-programmatically/
+pub fn hsv_to_rgb(h: f32, s: f32, v: f32) -> Vec3 {
+    let h_i = (h * 6.) as i32;
+    let f = h * 6. - h_i as f32;
+    let p = v * (1. - s);
+    let q = v * (1. - f * s);
+    let t = v * (1. - (1. - f) * s);
+    match h_i {
+        0 => Vec3::new(v, t, p),
+        1 => Vec3::new(q, v, p),
+        2 => Vec3::new(p, v, t),
+        3 => Vec3::new(p, q, v),
+        4 => Vec3::new(t, p, v),
+        5 => Vec3::new(v, p, q),
+        _ => panic!("Unknown H value {}", h_i),
+    }
+}
+
+pub fn generate_rainbow(num: usize) -> Vec<Vec3> {
+    (0..num)
+        .map(|n| {
+            let h = n as f32 / num as f32;
+            hsv_to_rgb(h, 0.99, 0.99)
+        })
+        .collect()
+}
+pub fn generate_palette(num: usize) -> Vec<Vec3> {
+    let mut rng = rand::thread_rng();
+    let mut random = || rng.gen();
+    // use golden ratio
+    let golden_ratio_conjugate = 0.618_034;
+    let mut h = random();
+    (0..num)
+        .map(|_| {
+            h += golden_ratio_conjugate;
+            h %= 1.0;
+            hsv_to_rgb(h, 0.99, 0.99)
+        })
+        .collect()
+}

rtiow/renderer/src/debug_hit.rs

@@ -0,0 +1,44 @@
+use crate::{
+    aabb::AABB,
+    hitable::{Hit, HitRecord},
+    material::Lambertian,
+    ray::Ray,
+};
+
+#[derive(Debug)]
+pub struct DebugHit<H>
+where
+    H: Hit,
+{
+    hitable: H,
+    material: Lambertian<[f32; 3]>,
+}
+
+impl<H> DebugHit<H>
+where
+    H: Hit,
+{
+    pub fn new(hitable: H) -> DebugHit<H>
+where {
+        DebugHit {
+            hitable,
+            material: Lambertian::new([0.2, 0.2, 0.2]),
+        }
+    }
+}
+
+impl<H> Hit for DebugHit<H>
+where
+    H: Hit,
+{
+    fn hit(&self, r: Ray, t_min: f32, t_max: f32) -> Option<HitRecord> {
+        if let Some(hit) = self.hitable.hit(r, t_min, t_max) {
+            return Some(HitRecord { t: hit.t, ..hit });
+        }
+        None
+    }
+
+    fn bounding_box(&self, t_min: f32, t_max: f32) -> Option<AABB> {
+        self.hitable.bounding_box(t_min, t_max)
+    }
+}

rtiow/renderer/src/lib.rs

@@ -2,8 +2,10 @@ pub mod aabb;
 pub mod bvh;
 pub mod bvh_triangles;
 pub mod camera;
+pub mod colors;
 pub mod constant_medium;
 pub mod cuboid;
+pub mod debug_hit;
 pub mod flip_normals;
 pub mod glowybox;
 pub mod hitable;
@@ -14,6 +16,7 @@ pub mod material;
 pub mod moving_sphere;
 pub mod noise;
 pub mod output;
+pub mod parser;
 pub mod ray;
 pub mod rect;
 pub mod renderer;

rtiow/renderer/src/material.rs

@@ -52,7 +52,7 @@ impl Material for Box<dyn Material> {
     }
 }
 
-#[derive(Debug)]
+#[derive(Clone, Debug)]
 pub struct Isotropic<T>
 where
     T: Texture,
@@ -83,7 +83,7 @@ where
     }
 }
 
-#[derive(Debug)]
+#[derive(Clone, Debug)]
 pub struct Lambertian<T>
 where
     T: Texture,
@@ -115,7 +115,7 @@ where
     }
 }
 
-#[derive(Debug)]
+#[derive(Clone, Debug)]
 pub struct Metal {
     albedo: Vec3,
     fuzzy: f32,
@@ -170,7 +170,7 @@ fn schlick(cosine: f32, ref_idx: f32) -> f32 {
     r0 + (1. - r0) * (1. - cosine).powf(5.)
 }
 
-#[derive(Debug)]
+#[derive(Clone, Debug)]
 pub struct Dielectric {
     ref_idx: f32,
 }

rtiow/renderer/src/output.rs

@@ -2,6 +2,7 @@ use std::{
     collections::HashMap,
     fs::File,
     io::BufWriter,
+    net::TcpStream,
     path::Path,
     sync::{Arc, Mutex},
     time,
@@ -9,9 +10,9 @@ use std::{
 
 use chrono::Local;
 use image;
-use lazy_static::lazy_static;
 use log::info;
 use serde_derive::Serialize;
+use tev_client::{PacketCreateImage, PacketUpdateImage, TevClient};
 
 use crate::{renderer::Scene, vec3::Vec3};
 
@@ -24,10 +25,6 @@ pub const ADAPTIVE_DEPTH: &str = "adaptive_depth";
 // Grey scale showing rays cast per pixel.
 pub const RAYS_PER_PIXEL: &str = "rays_per_pixel";
 
-lazy_static! {
-    static ref DEBUGGER: Arc<Mutex<Debugger>> = Arc::new(Mutex::new(Debugger::new()));
-}
-
 #[derive(Serialize)]
 struct ImageMetadata {
     name: String,
@@ -74,65 +71,86 @@ impl Image {
     }
 }
 
-struct Debugger {
+pub struct OutputManager {
-    images: HashMap<String, (ImageType, Image)>,
+    images: Arc<Mutex<HashMap<String, (ImageType, Image)>>>,
+    tev_client: Option<Arc<Mutex<TevClient>>>,
 }
 
-impl Debugger {
+impl OutputManager {
-    fn new() -> Debugger {
+    pub fn new(tev_addr: &Option<String>) -> std::io::Result<OutputManager> {
-        Debugger {
+        let tev_client = if let Some(addr) = tev_addr {
-            images: HashMap::new(),
+            Some(Arc::new(Mutex::new(TevClient::wrap(TcpStream::connect(
-        }
+                addr,
-    }
+            )?))))
+        } else {
+            None
+        };
+        Ok(OutputManager {
+            images: Arc::new(Mutex::new(HashMap::new())),
+            tev_client,
+        })
     }
 
-pub fn register_image(name: String, dimensions: (usize, usize), it: ImageType) {
+    pub fn register_image(&self, name: String, dimensions: (usize, usize), it: ImageType) {
-    let mut debugger = DEBUGGER.lock().unwrap();
+        let mut images = self.images.lock().unwrap();
-    debugger
+        images.insert(name.clone(), (it, Image::new(dimensions.0, dimensions.1)));
-        .images
+        self.tev_client.clone().map(|c| {
-        .insert(name, (it, Image::new(dimensions.0, dimensions.1)));
+            c.lock().unwrap().send(PacketCreateImage {
+                image_name: &name,
+                grab_focus: false,
+                width: dimensions.0 as u32,
+                height: dimensions.1 as u32,
+                channel_names: &["R", "G", "B"],
+            })
+        });
     }
 
-pub fn set_pixel(name: &str, x: usize, y: usize, pixel: Vec3) {
+    pub fn set_pixel(&self, name: &str, x: usize, y: usize, pixel: Vec3) {
-    let mut debugger = DEBUGGER.lock().unwrap();
+        let mut images = self.images.lock().unwrap();
-    let (_it, img) = debugger
+        let (_it, img) = images
-        .images
             .get_mut(name)
             .unwrap_or_else(|| panic!("couldn't find image named '{}'", name));
         let y_inv = img.h - y - 1;
         img.put_pixel(x, y_inv, pixel);
+        self.tev_client.clone().map(|c| {
+            c.lock().unwrap().send(PacketUpdateImage {
+                image_name: &name,
+                grab_focus: false,
+                channel_names: &["R", "G", "B"],
+                channel_offsets: &[0, 1, 2],
+                channel_strides: &[0, 0, 0],
+                x: x as u32,
+                y: y_inv as u32,
+                width: 1,
+                height: 1,
+                data: &[pixel.x, pixel.y, pixel.z],
+            })
+        });
     }
 
-pub fn set_pixel_grey(name: &str, x: usize, y: usize, grey: f32) {
+    pub fn set_pixel_grey(&self, name: &str, x: usize, y: usize, grey: f32) {
-    let mut debugger = DEBUGGER.lock().unwrap();
+        let mut images = self.images.lock().unwrap();
-    let (_it, img) = debugger
+        let (_it, img) = images
-        .images
             .get_mut(name)
             .unwrap_or_else(|| panic!("couldn't find image named '{}'", name));
         let y_inv = img.h - y - 1;
         img.put_pixel(x, y_inv, [grey, grey, grey].into());
     }
-
-trait ImageSaver {
-    fn save<Q>(&self, path: Q) -> std::io::Result<()>
-    where
-        Q: AsRef<Path> + Sized;
-}
-
     pub fn write_images<P: AsRef<Path>>(
+        &self,
         scene: &Scene,
         render_time: time::Duration,
         output_dir: P,
     ) -> std::io::Result<()> {
         let output_dir: &Path = output_dir.as_ref();
-    let debugger = DEBUGGER.lock().unwrap();
         let now = Local::now();
+        let images = self.images.lock().unwrap();
         // Write out images in consistent order.
-    let mut names = debugger.images.keys().collect::<Vec<_>>();
+        let mut names = images.keys().collect::<Vec<_>>();
         names.sort();
         let mut image_metadata = Vec::new();
         for name in &names {
-        let (it, img) = debugger.images.get(*name).unwrap();
+            let (it, img) = images.get(*name).unwrap();
             let image = format!("{}.png", name);
             let binary = format!("{}.json", name);
             let ratio = img.w as f32 / img.h as f32;
@@ -203,7 +221,10 @@ pub fn write_images<P: AsRef<Path>>(
                     )?;
                 }
                 ImageType::Grey01 | ImageType::GreyNormalized => {
-                serde_json::ser::to_writer(f, &img.pix.iter().map(|v| v.x).collect::<Vec<f32>>())?;
+                    serde_json::ser::to_writer(
+                        f,
+                        &img.pix.iter().map(|v| v.x).collect::<Vec<f32>>(),
+                    )?;
                 }
             };
         }
@@ -220,3 +241,10 @@ pub fn write_images<P: AsRef<Path>>(
         )?;
         Ok(())
     }
+}
+
+trait ImageSaver {
+    fn save<Q>(&self, path: Q) -> std::io::Result<()>
+    where
+        Q: AsRef<Path> + Sized;
+}

rtiow/renderer/src/parser.rs

@@ -0,0 +1,206 @@
+use crate::{
+    bvh_triangles::BVHTriangles,
+    camera::Camera,
+    cuboid::Cuboid,
+    hitable::Hit,
+    hitable_list::HitableList,
+    material::{Dielectric, DiffuseLight, Isotropic, Lambertian, Material, Metal},
+    renderer::Scene,
+    sphere::Sphere,
+    texture::{EnvMap, Texture},
+};
+use chrono::IsoWeek;
+use serde::Deserialize;
+use std::{collections::HashMap, fs::File, io::BufReader, path::PathBuf, sync::Arc};
+use stl::STL;
+use thiserror::Error;
+use vec3::Vec3;
+
+#[derive(Debug, Deserialize)]
+pub struct Config {
+    scene: SceneConfig,
+    camera: CameraConfig,
+    materials: Vec<MaterialConfig>,
+    hitables: Vec<HitableConfig>,
+    envmap: Option<EnvMapConfig>,
+}
+
+#[derive(Error, Debug)]
+pub enum ConfigError {
+    #[error("failed to load image")]
+    ImageError(#[from] image::ImageError),
+    #[error("failed to parser STL")]
+    STLError(#[from] stl::ParseError),
+    #[error("I/O error")]
+    IOError(#[from] std::io::Error),
+    #[error("duplication material named '{0}'")]
+    DuplicateMaterial(String),
+    #[error("unkown material named '{0}'")]
+    UnknownMaterial(String),
+}
+
+impl TryFrom<Config> for Scene {
+    type Error = ConfigError;
+
+    fn try_from(c: Config) -> Result<Scene, Self::Error> {
+        let mut materials = HashMap::new();
+        for mc in c.materials {
+            let v: Arc<dyn Material> = match mc.material {
+                Materials::Metal { albedo, fuzzy } => Arc::new(Metal::new(albedo, fuzzy)),
+                Materials::Dielectric { ref_idx } => Arc::new(Dielectric::new(ref_idx)),
+                Materials::DiffuseLight { texture } => Arc::new(DiffuseLight::new(texture)),
+                Materials::Isotropic { texture } => Arc::new(Isotropic::new(texture)),
+                Materials::Lambertian { texture } => Arc::new(Lambertian::new(texture)),
+            };
+            if materials.insert(mc.name.clone(), v).is_some() {
+                return Err(ConfigError::DuplicateMaterial(mc.name));
+            }
+        }
+
+        let hitables: Result<Vec<Box<dyn Hit>>, Self::Error> = c
+            .hitables
+            .into_iter()
+            .map(|hc| -> Result<Box<dyn Hit>, Self::Error> {
+                match hc.hitable {
+                    Hitables::Sphere { center, radius } => Ok(Box::new(Sphere::new(
+                        center,
+                        radius,
+                        Arc::clone(
+                            materials
+                                .get(&hc.material_name)
+                                .ok_or(ConfigError::UnknownMaterial(hc.material_name))?,
+                        ),
+                    ))),
+                    Hitables::Cuboid { min, max } => Ok(Box::new(Cuboid::new(
+                        min.into(),
+                        max.into(),
+                        Arc::clone(
+                            materials
+                                .get(&hc.material_name)
+                                .ok_or(ConfigError::UnknownMaterial(hc.material_name))?,
+                        ),
+                    ))),
+                    Hitables::STL { path, scale } => {
+                        let r = BufReader::new(File::open(path)?);
+                        let stl = STL::parse(r, false)?;
+                        Ok(Box::new(BVHTriangles::new(
+                            &stl,
+                            Arc::clone(
+                                materials
+                                    .get(&hc.material_name)
+                                    .ok_or(ConfigError::UnknownMaterial(hc.material_name))?,
+                            ),
+                            scale.unwrap_or(1.),
+                        )))
+                    }
+                }
+            })
+            .collect();
+        let hitables = hitables?;
+
+        let world: Box<dyn Hit> = Box::new(HitableList::new(hitables));
+        let mut env_map: Option<EnvMap> = None;
+
+        if let Some(em) = c.envmap {
+            let im = image::open(em.path)?.into_rgb();
+            env_map = Some(EnvMap::new(im));
+        };
+
+        let camera = make_camera(&c.camera, c.scene.width, c.scene.height);
+
+        let scene = Scene {
+            world,
+            camera,
+            env_map,
+            subsamples: c.scene.subsamples.unwrap_or(8),
+            adaptive_subsampling: c.scene.adaptive_subsampling,
+            num_threads: c.scene.num_threads,
+            width: c.scene.width,
+            height: c.scene.height,
+            global_illumination: c.scene.global_illumination.unwrap_or(true),
+        };
+        Ok(scene)
+    }
+}
+
+fn make_camera(cfg: &CameraConfig, width: usize, height: usize) -> Camera {
+    Camera::new(
+        cfg.lookfrom.into(),
+        cfg.lookat.into(),
+        Vec3::new(0., 1., 0.),
+        cfg.fov,
+        width as f32 / height as f32,
+        cfg.aperture,
+        cfg.focus_dist,
+        cfg.time_min,
+        cfg.time_max,
+    )
+}
+
+#[derive(Debug, Deserialize)]
+struct SceneConfig {
+    subsamples: Option<usize>,
+    adaptive_subsampling: Option<f32>,
+    num_threads: Option<usize>,
+    width: usize,
+    height: usize,
+    global_illumination: Option<bool>,
+}
+
+#[derive(Debug, Deserialize)]
+#[serde(tag = "type")]
+struct HitableConfig {
+    material_name: String,
+    #[serde(flatten)]
+    hitable: Hitables,
+}
+
+#[derive(Debug, Deserialize)]
+#[serde(tag = "type")]
+enum Hitables {
+    #[serde(rename = "sphere")]
+    Sphere { center: [f32; 3], radius: f32 },
+    #[serde(rename = "cuboid")]
+    Cuboid { min: [f32; 3], max: [f32; 3] },
+    #[serde(rename = "stl")]
+    STL { path: PathBuf, scale: Option<f32> },
+}
+
+#[derive(Debug, Deserialize)]
+struct MaterialConfig {
+    name: String,
+    #[serde(flatten)]
+    material: Materials,
+}
+
+#[derive(Debug, Deserialize)]
+#[serde(tag = "type")]
+enum Materials {
+    #[serde(rename = "metal")]
+    Metal { albedo: [f32; 3], fuzzy: f32 },
+    #[serde(rename = "dielectric")]
+    Dielectric { ref_idx: f32 },
+    // TODO(wathiede): these all take Textures, for now, only support RGB
+    #[serde(rename = "diffuse_light")]
+    DiffuseLight { texture: [f32; 3] },
+    #[serde(rename = "isotropic")]
+    Isotropic { texture: [f32; 3] },
+    #[serde(rename = "lambertian")]
+    Lambertian { texture: [f32; 3] },
+}
+
+#[derive(Debug, Deserialize)]
+pub struct CameraConfig {
+    lookfrom: [f32; 3],
+    lookat: [f32; 3],
+    fov: f32,
+    aperture: f32,
+    focus_dist: f32,
+    time_min: f32,
+    time_max: f32,
+}
+
+#[derive(Debug, Deserialize)]
+struct EnvMapConfig {
+    path: PathBuf,
+}

rtiow/renderer/src/renderer.rs

@@ -1,4 +1,5 @@
 use std::{
+    collections::HashMap,
     fmt,
     ops::{AddAssign, Range},
     path::{Path, PathBuf},
@@ -8,7 +9,7 @@ use std::{
         Arc, Mutex,
     },
     thread,
-    time::{self, Instant},
+    time::{Duration, Instant},
 };
 
 use core_affinity;
@@ -22,8 +23,9 @@ use crate::{
     camera::Camera,
     hitable::Hit,
     human,
-    material::Lambertian,
+    material::{Lambertian, Material},
     output,
+    output::OutputManager,
     ray::Ray,
     scenes,
     sphere::Sphere,
@@ -99,15 +101,26 @@ pub struct Opt {
     /// Select scene to render.
     #[structopt(long = "model")]
     pub model: Option<Model>,
+    /// Toml config describing scene.
+    #[structopt(long = "config")]
+    pub config: Option<PathBuf>,
     /// Path to store pprof profile data, i.e. /tmp/cpuprofile.pprof
     #[structopt(long = "pprof", parse(from_os_str))]
     pub pprof: Option<PathBuf>,
     /// Use acceleration data structure, may be BVH or kd-tree depending on scene.
     #[structopt(long = "use_accel")]
     pub use_accel: bool,
+    /// Host:port of running tev instance.
+    #[structopt(long = "tev_addr")]
+    pub tev_addr: Option<String>,
 
     /// Output directory
-    #[structopt(parse(from_os_str), default_value = "/tmp/tracer")]
+    #[structopt(
+        short = "o",
+        long = "output",
+        parse(from_os_str),
+        default_value = "/tmp/tracer"
+    )]
     pub output: PathBuf,
 }
 
@@ -126,11 +139,13 @@ pub fn opt_hash(opt: &Opt) -> String {
 }
 
 // TODO(wathiede): implement the skips and then the renderer could use json as an input file type.
-#[derive(Serialize)]
+#[derive(Debug, Serialize)]
 #[serde(rename_all = "camelCase")]
 pub struct Scene {
     #[serde(skip)]
     pub world: Box<dyn Hit>,
+    //#[serde(skip)]
+    //pub materials: HashMap<String, Box<dyn Material>>,
     #[serde(skip)]
     pub camera: Camera,
     pub subsamples: usize,
@@ -235,6 +250,7 @@ fn trace_pixel_adaptive(
     x_range: Range<f32>,
     y_range: Range<f32>,
     scene: &Scene,
+    output: &OutputManager,
 ) -> (Vec3, usize) {
     let w = scene.width as f32;
     let h = scene.height as f32;
@@ -249,7 +265,7 @@ fn trace_pixel_adaptive(
         &scene.env_map,
     );
     if depth == 0 {
-        output::set_pixel(output::ADAPTIVE_DEPTH, x, y, [1., 0., 0.].into());
+        output.set_pixel(output::ADAPTIVE_DEPTH, x, y, [1., 0., 0.].into());
         return (center, rays);
     }
     // t = top
@@ -291,6 +307,7 @@ fn trace_pixel_adaptive(
             x_range.start..x_mid,
             y_range.start..y_mid,
             scene,
+            output,
         );
         let tr = trace_pixel_adaptive(
             depth - 1,
@@ -300,6 +317,7 @@ fn trace_pixel_adaptive(
             x_mid..x_range.end,
             y_range.start..y_mid,
             scene,
+            output,
         );
         let bl = trace_pixel_adaptive(
             depth - 1,
@@ -309,6 +327,7 @@ fn trace_pixel_adaptive(
             x_range.start..x_mid,
             y_mid..y_range.end,
             scene,
+            output,
         );
         let br = trace_pixel_adaptive(
             depth - 1,
@@ -318,13 +337,14 @@ fn trace_pixel_adaptive(
             x_mid..x_range.end,
             y_mid..y_range.end,
             scene,
+            output,
         );
         let pixel = (tl.0 + tr.0 + bl.0 + br.0) / 4.;
         let rays = tl.1 + tr.1 + bl.1 + br.1;
         (pixel, rays)
     } else {
         if depth == MAX_ADAPTIVE_DEPTH {
-            output::set_pixel(output::ADAPTIVE_DEPTH, x, y, [0., 1., 0.].into());
+            output.set_pixel(output::ADAPTIVE_DEPTH, x, y, [0., 1., 0.].into());
         }
         (corners, rays)
     }
@@ -363,13 +383,13 @@ fn progress(
     start_time: Instant,
     last_stat: &RenderStats,
     current_stat: &RenderStats,
-    time_diff: time::Duration,
+    time_diff: Duration,
     pixel_total: usize,
 ) -> String {
     let human = human::Formatter::new();
     let pixel_diff = current_stat.pixels - last_stat.pixels;
     let ray_diff = current_stat.rays - last_stat.rays;
-    let now = time::Instant::now();
+    let now = Instant::now();
     let start_diff = now - start_time;
     let ratio = current_stat.pixels as f32 / pixel_total as f32;
     let percent = ratio * 100.;
@@ -390,6 +410,7 @@ fn progress(
 enum Request {
     Pixel { x: usize, y: usize },
     Line { width: usize, y: usize },
+    // TODO(wathiede): add Cohort that does 4x4 or 8x8 pixel chunks.
 }
 
 enum Response {
@@ -406,7 +427,7 @@ enum Response {
     },
 }
 
-fn render_pixel(scene: &Scene, x: usize, y: usize) -> (Vec3, usize) {
+fn render_pixel(scene: &Scene, x: usize, y: usize, output: &OutputManager) -> (Vec3, usize) {
     let (pixel, rays) = if let Some(threshold) = scene.adaptive_subsampling {
         trace_pixel_adaptive(
             MAX_ADAPTIVE_DEPTH,
@@ -416,6 +437,7 @@ fn render_pixel(scene: &Scene, x: usize, y: usize) -> (Vec3, usize) {
             0.0..1.0,
             0.0..1.0,
             scene,
+            output,
         )
     } else {
         let (pixel, rays) = (0..scene.subsamples)
@@ -424,7 +446,7 @@ fn render_pixel(scene: &Scene, x: usize, y: usize) -> (Vec3, usize) {
                 ([0., 0., 0.].into(), 0),
                 |(p1, r1): (Vec3, usize), (p2, r2): (Vec3, usize)| ((p1 + p2), (r1 + r2)),
             );
-        output::set_pixel_grey(output::RAYS_PER_PIXEL, x, y, rays as f32);
+        output.set_pixel_grey(output::RAYS_PER_PIXEL, x, y, rays as f32);
         (pixel / scene.subsamples as f32, rays)
     };
     // Gamma correct, use gamma 2 correction, which is 1/gamma where gamma=2 which is 1/2 or
@@ -440,6 +462,7 @@ fn render_worker(
     scene: &Scene,
     input_chan: Arc<Mutex<Receiver<Request>>>,
     output_chan: &SyncSender<Response>,
+    output: &OutputManager,
 ) {
     loop {
         let job = { input_chan.lock().unwrap().recv() };
@@ -454,7 +477,7 @@ fn render_worker(
                     let batch = false;
                     if batch {
                         let (pixels, rays): (Vec<Vec3>, Vec<usize>) = (0..width)
-                            .map(|x| render_pixel(scene, x, y))
+                            .map(|x| render_pixel(scene, x, y, output))
                             .collect::<Vec<(_, _)>>()
                             .into_iter()
                             .unzip();
@@ -471,7 +494,7 @@ fn render_worker(
                             .expect("failed to send pixel response");
                     } else {
                         (0..width).for_each(|x| {
-                            let (pixel, rays) = render_pixel(scene, x, y);
+                            let (pixel, rays) = render_pixel(scene, x, y, output);
                             output_chan
                                 .send(Response::Pixel {
                                     x,
@@ -485,7 +508,7 @@ fn render_worker(
                 }
                 Request::Pixel { x, y } => {
                     trace!("tid {} x {} y {}", tid, x, y);
-                    let (pixel, rays) = render_pixel(scene, x, y);
+                    let (pixel, rays) = render_pixel(scene, x, y, output);
                     output_chan
                         .send(Response::Pixel {
                             x,
@@ -500,7 +523,17 @@ fn render_worker(
     }
 }
 
-pub fn render(scene: Scene, output_dir: &Path) -> std::result::Result<(), std::io::Error> {
+/*
+lazy_static! {
+    static ref DEBUGGER: Arc<Mutex<OutputManager>> = Arc::new(Mutex::new(OutputManager::new()));
+}
+*/
+
+pub fn render(
+    scene: Scene,
+    output_dir: &Path,
+    tev_addr: &Option<String>,
+) -> std::result::Result<(), std::io::Error> {
     // Default to half the cores to disable hyperthreading.
     let num_threads = scene.num_threads.unwrap_or_else(|| num_cpus::get() / 2);
     let (pixel_req_tx, pixel_req_rx) = sync_channel(2 * num_threads);
@@ -516,20 +549,23 @@ pub fn render(scene: Scene, output_dir: &Path) -> std::result::Result<(), std::i
     } else {
         core_ids
     };
+    let output = output::OutputManager::new(tev_addr)?;
+    let output = Arc::new(output);
+
     info!("Creating {} render threads", core_ids.len());
-    output::register_image(
+    output.register_image(
         output::MAIN_IMAGE.to_string(),
         (scene.width, scene.height),
         output::ImageType::RGB01,
     );
     if scene.adaptive_subsampling.is_some() {
-        output::register_image(
+        output.register_image(
             output::ADAPTIVE_DEPTH.to_string(),
             (scene.width, scene.height),
             output::ImageType::RGB01,
         );
     }
-    output::register_image(
+    output.register_image(
         output::RAYS_PER_PIXEL.to_string(),
         (scene.width, scene.height),
         output::ImageType::GreyNormalized,
@@ -543,9 +579,10 @@ pub fn render(scene: Scene, output_dir: &Path) -> std::result::Result<(), std::i
             let s = sync::Arc::clone(&scene);
             let pixel_req_rx = pixel_req_rx.clone();
             let pixel_resp_tx = pixel_resp_tx.clone();
+            let output = sync::Arc::clone(&output);
             thread::spawn(move || {
                 core_affinity::set_for_current(id);
-                render_worker(i, &s, pixel_req_rx, &pixel_resp_tx);
+                render_worker(i, &s, pixel_req_rx, &pixel_resp_tx, &output);
             })
         })
         .collect::<Vec<_>>();
@@ -576,31 +613,31 @@ pub fn render(scene: Scene, output_dir: &Path) -> std::result::Result<(), std::i
     info!("Rendering with {} subsamples", scene.subsamples);
 
     let pixel_total = scene.width * scene.height;
-    let mut last_time = time::Instant::now();
+    let mut last_time = Instant::now();
     let mut last_stat: RenderStats = Default::default();
     let mut current_stat: RenderStats = Default::default();
-    let start_time = time::Instant::now();
+    let render_start_time = Instant::now();
     for resp in pixel_resp_rx {
         match resp {
             Response::Pixel { x, y, pixel, rs } => {
                 current_stat += rs;
-                output::set_pixel(output::MAIN_IMAGE, x, y, pixel);
+                output.set_pixel(output::MAIN_IMAGE, x, y, pixel);
             }
             Response::Line { y, pixels, rs } => {
                 current_stat += rs;
                 for (x, pixel) in pixels.iter().enumerate() {
-                    output::set_pixel(output::MAIN_IMAGE, x, y, *pixel);
+                    output.set_pixel(output::MAIN_IMAGE, x, y, *pixel);
                 }
             }
         }
 
-        let now = time::Instant::now();
+        let now = Instant::now();
         let time_diff = now - last_time;
-        if time_diff > time::Duration::from_secs(1) {
+        if time_diff > Duration::from_secs(5) {
             println!(
                 "{}",
                 progress(
-                    start_time,
+                    render_start_time,
                     &last_stat,
                     &current_stat,
                     time_diff,
@@ -614,12 +651,12 @@ pub fn render(scene: Scene, output_dir: &Path) -> std::result::Result<(), std::i
     for thr in handles {
         thr.join().expect("thread join");
     }
-    let time_diff = time::Instant::now() - start_time;
+    let time_diff = Instant::now() - render_start_time;
     println!(
-        "Runtime {} seconds {}",
+        "Render {} seconds {}",
         time_diff.as_secs_f32(),
         progress(
-            start_time,
+            render_start_time,
             &Default::default(),
             &current_stat,
             time_diff,
@@ -627,5 +664,5 @@ pub fn render(scene: Scene, output_dir: &Path) -> std::result::Result<(), std::i
         )
     );
 
-    output::write_images(&scene, time_diff, output_dir)
+    output.write_images(&scene, time_diff, output_dir)
 }

rtiow/renderer/src/scale.rs

@@ -2,7 +2,6 @@ use crate::{
     aabb::AABB,
     hitable::{Hit, HitRecord},
     ray::Ray,
-    vec3::Vec3,
 };
 
 #[derive(Debug)]
@@ -11,21 +10,15 @@ where
     H: Hit,
 {
     hitable: H,
-    scale: Vec3,
+    scale: f32,
 }
 
 impl<H> Scale<H>
 where
     H: Hit,
 {
-    pub fn new<V>(hitable: H, scale: V) -> Scale<H>
+    pub fn new(hitable: H, scale: f32) -> Scale<H> {
-    where
+        Scale { hitable, scale }
-        V: Into<Vec3>,
-    {
-        Scale {
-            hitable,
-            scale: scale.into(),
-        }
     }
 }
 
@@ -38,6 +31,7 @@ where
         if let Some(rec) = self.hitable.hit(moved_r, t_min, t_max) {
             return Some(HitRecord {
                 p: rec.p * self.scale,
+                t: rec.t * self.scale,
                 ..rec
             });
         }

rtiow/renderer/src/scenes/book.rs

@@ -52,6 +52,7 @@ pub fn new(opt: &Opt) -> Scene {
         height: opt.height,
         global_illumination: true,
         env_map: Some(EnvMap::new(skybox)),
+        ..Default::default()
     }
 }
 

rtiow/renderer/src/scenes/dragon.rs

@@ -1,6 +1,6 @@
 use std::{
+    f32::consts::PI,
     io::{BufReader, Cursor},
-    sync::Arc,
 };
 
 use stl::STL;
@@ -8,21 +8,23 @@ use stl::STL;
 use crate::{
     bvh_triangles::BVHTriangles,
     camera::Camera,
-    cuboid::Cuboid,
+    colors::generate_rainbow,
     hitable::Hit,
     hitable_list::HitableList,
     kdtree::KDTree,
-    material::{Dielectric, Lambertian},
+    material::{Lambertian, Metal},
     renderer::{Opt, Scene},
+    rotate::RotateY,
     scale::Scale,
     sphere::Sphere,
     texture::{ConstantTexture, EnvMap},
+    translate::Translate,
     vec3::Vec3,
 };
 
 pub fn new(opt: &Opt) -> Scene {
-    let lookfrom = Vec3::new(0., 40., -100.);
+    let lookfrom = Vec3::new(0., 80., 80.);
-    let lookat = Vec3::new(0., 10., 0.);
+    let lookat = Vec3::new(0., 0., 0.);
     let dist_to_focus = 10.0;
     let aperture = 0.0;
     let time_min = 0.;
@@ -38,6 +40,10 @@ pub fn new(opt: &Opt) -> Scene {
         time_min,
         time_max,
     );
+    //let dragon_material = Dielectric::new(1.5);
+    let dragon_material = Metal::new(Vec3::new(0.6, 0.6, 0.6), 0.0);
+    //let dragon_material = Lambertian::new(ConstantTexture::new(Vec3::new(1.0, 1.0, 0.2)));
+
     let ground_color = if opt.use_accel {
         ConstantTexture::new(Vec3::new(1.0, 0.4, 0.4))
     } else {
@@ -45,58 +51,50 @@ pub fn new(opt: &Opt) -> Scene {
     };
 
     let stl_cube = STL::parse(
-        BufReader::new(Cursor::new(include_bytes!(
+        BufReader::new(Cursor::new(include_bytes!("../../stls/dragon.stl"))),
-                    "../../stls/cube.stl"
-                    //"../../stls/stanford_dragon-lowres.stl" //"../../stls/stanford_dragon.stl"
-        ))),
         false,
     )
     .expect("failed to parse cube");
     let _light_size = 50.;
     let _light_height = 200.;
-    let objects: Vec<Box<dyn Hit>> = vec![
+    let sphere_radius = 5.;
-        // Light from above - white
+    let circle_radius = 40.;
+    let num_spheres = 16;
+    let palette = generate_rainbow(num_spheres);
+    let spheres: Vec<Box<dyn Hit>> = (0..num_spheres)
+        .map(|i| (i, i as f32, num_spheres as f32))
+        .map(|(idx, idx_f, n)| (idx, idx_f * 2. * PI / n))
+        .map(|(idx, rad)| -> Box<dyn Hit> {
+            let x = circle_radius * rad.cos();
+            let y = 4. * sphere_radius;
+            let z = circle_radius * rad.sin();
+            let c = palette[idx];
+            Box::new(Sphere::new(
+                [x, y, z],
+                sphere_radius,
+                Lambertian::new(ConstantTexture::new(c)),
+            ))
+        })
+        .collect();
+    let mut objects: Vec<Box<dyn Hit>> = vec![
+        Box::new(Sphere::new(
+            Vec3::new(0., 0.1, -0.5),
+            0.1,
+            Lambertian::new([0., 1., 1.]),
+        )),
         // Earth sized sphere
-        Box::new(Sphere::new(
+        //Box::new(Sphere::new( Vec3::new(0., -10000., 0.), 10000., Lambertian::new(ground_color),)),
-            Vec3::new(0., -10000., 0.),
-            10000.,
-            Lambertian::new(ground_color),
-        )),
-        // Blue sphere
-        Box::new(Sphere::new(
-            Vec3::new(0., 20., 40.),
-            20.,
-            Lambertian::new(ConstantTexture::new(Vec3::new(0.2, 0.2, 1.))),
-        )),
-        Box::new(Sphere::new(
-            Vec3::new(40., 20., 40.),
-            20.,
-            //Metal::new(Vec3::new(0.8, 0.8, 0.8), 0.2),
-            Lambertian::new(ConstantTexture::new(Vec3::new(0.2, 1.0, 0.2))),
-        )),
-        Box::new(Sphere::new(
-            Vec3::new(-40., 20., 40.),
-            20.,
-            //Metal::new(Vec3::new(0.8, 0.8, 0.8), 0.2),
-            Lambertian::new(ConstantTexture::new(Vec3::new(1.0, 0.2, 0.2))),
-        )),
         // STL Mesh
-        Box::new(Scale::new(
+        Box::new(crate::debug_hit::DebugHit::new(RotateY::new(
-            BVHTriangles::new(
+            Translate::new(
-                &stl_cube,
+                BVHTriangles::new(&stl_cube, dragon_material, 250.),
-                Dielectric::new(1.5),
+                [0., -10., 0.],
-                //Metal::new(Vec3::new(0.8, 0.8, 0.8), 0.2),
-                //Lambertian::new(ConstantTexture::new(Vec3::new(1.0, 0.2, 0.2))),
             ),
-            1.,
+            180.,
-            //250.,
+        ))),
-        )),
-        Box::new(Cuboid::new(
-            [-20., 0., 0.].into(),
-            [0., 20., 20.].into(),
-            Arc::new(Dielectric::new(1.5)),
-        )),
     ];
+    objects.extend(spheres);
+
     let world: Box<dyn Hit> = if opt.use_accel {
         Box::new(KDTree::new(objects, time_min, time_max))
     } else {

rtiow/renderer/src/scenes/spheramid.rs

@@ -112,5 +112,6 @@ pub fn new(opt: &Opt) -> Scene {
         height: opt.height,
         global_illumination: true,
         env_map: Some(EnvMap::new(skybox)),
+        ..Default::default()
     }
 }

rtiow/renderer/src/scenes/stltest.rs

@@ -12,10 +12,11 @@ use crate::{
     hitable::Hit,
     hitable_list::HitableList,
     kdtree::KDTree,
-    material::{Dielectric, Lambertian},
+    material::{Dielectric, Lambertian, Metal},
     renderer::{Opt, Scene},
     sphere::Sphere,
     texture::{ConstantTexture, EnvMap},
+    translate::Translate,
     vec3::Vec3,
 };
 
@@ -43,13 +44,20 @@ pub fn new(opt: &Opt) -> Scene {
         ConstantTexture::new(Vec3::new(0.4, 0.4, 0.4))
     };
 
+    let glass = Dielectric::new(1.5);
+    let metal = Metal::new(Vec3::new(0.8, 0.8, 0.8), 0.2);
+    let red = Lambertian::new(ConstantTexture::new(Vec3::new(1.0, 0.2, 0.2)));
+
+    //let box_material = glass;
+    let _ = glass;
+    let _ = metal;
+    let _ = red;
+
     let stl_cube = STL::parse(
         BufReader::new(Cursor::new(include_bytes!("../../stls/cube.stl"))),
         false,
     )
     .expect("failed to parse cube");
-    let _light_size = 50.;
-    let _light_height = 200.;
     let objects: Vec<Box<dyn Hit>> = vec![
         // Light from above - white
         // Earth sized sphere
@@ -58,6 +66,11 @@ pub fn new(opt: &Opt) -> Scene {
             10000.,
             Lambertian::new(ground_color),
         )),
+        Box::new(Sphere::new(
+            Vec3::new(0., 20., -40.),
+            10.,
+            Lambertian::new(ConstantTexture::new(Vec3::new(1., 0.2, 1.))),
+        )),
         // Blue sphere
         Box::new(Sphere::new(
             Vec3::new(0., 20., 40.),
@@ -77,16 +90,15 @@ pub fn new(opt: &Opt) -> Scene {
             Lambertian::new(ConstantTexture::new(Vec3::new(1.0, 0.2, 0.2))),
         )),
         // STL Mesh
-        Box::new(BVHTriangles::new(
+        Box::new(Translate::new(
-            &stl_cube,
+            BVHTriangles::new(&stl_cube, glass, 1.),
-            Dielectric::new(1.5),
+            [0., 10., 0.],
-            //Metal::new(Vec3::new(0.8, 0.8, 0.8), 0.2),
-            //Lambertian::new(ConstantTexture::new(Vec3::new(1.0, 0.2, 0.2))),
         )),
+        //Box::new(BVHTriangles::new(&stl_cube, box_material.clone())),
         Box::new(Cuboid::new(
             [-20., 0., 0.].into(),
             [0., 20., 20.].into(),
-            Arc::new(Dielectric::new(1.5)),
+            Arc::new(red),
         )),
     ];
     let world: Box<dyn Hit> = if opt.use_accel {

rtiow/renderer/src/texture/constant.rs

@@ -1,6 +1,6 @@
 use crate::{texture::Texture, vec3::Vec3};
 
-#[derive(Debug, PartialEq)]
+#[derive(Clone, Debug, PartialEq)]
 pub struct ConstantTexture {
     color: Vec3,
 }

rtiow/renderer/src/texture/mandelbrot.rs

@@ -1,48 +1,12 @@
 #![allow(clippy::many_single_char_names)]
-use rand::{self, Rng};
 
-use crate::{texture::Texture, vec3::Vec3};
+use crate::{colors::generate_palette, texture::Texture, vec3::Vec3};
 
 #[derive(Debug)]
 pub struct Mandelbrot {
     palette: Vec<Vec3>,
 }
 
-// HSV values in [0..1]
-// returns [r, g, b] values from 0 to 255
-//From https://martin.ankerl.com/2009/12/09/how-to-create-random-colors-programmatically/
-fn hsv_to_rgb(h: f32, s: f32, v: f32) -> Vec3 {
-    let h_i = (h * 6.) as i32;
-    let f = h * 6. - h_i as f32;
-    let p = v * (1. - s);
-    let q = v * (1. - f * s);
-    let t = v * (1. - (1. - f) * s);
-    match h_i {
-        0 => Vec3::new(v, t, p),
-        1 => Vec3::new(q, v, p),
-        2 => Vec3::new(p, v, t),
-        3 => Vec3::new(p, q, v),
-        4 => Vec3::new(t, p, v),
-        5 => Vec3::new(v, p, q),
-        _ => panic!("Unknown H value {}", h_i),
-    }
-}
-
-fn generate_palette(num: usize) -> Vec<Vec3> {
-    let mut rng = rand::thread_rng();
-    let mut random = || rng.gen();
-    // use golden ratio
-    let golden_ratio_conjugate = 0.618_034;
-    let mut h = random();
-    (0..num)
-        .map(|_| {
-            h += golden_ratio_conjugate;
-            h %= 1.0;
-            hsv_to_rgb(h, 0.99, 0.99)
-        })
-        .collect()
-}
-
 impl Default for Mandelbrot {
     fn default() -> Self {
         Mandelbrot {

rtiow/renderer/src/texture/mod.rs

@@ -29,6 +29,12 @@ impl Texture for Box<dyn Texture> {
     }
 }
 
+impl Texture for [f32; 3] {
+    fn value(&self, u: f32, v: f32, p: Vec3) -> Vec3 {
+        (*self).into()
+    }
+}
+
 #[cfg(test)]
 mod test {
     use super::*;

rtiow/renderer/stls/dragon.stl

@@ -0,0 +1 @@
+stanford_dragon.stl

rtiow/tracer/Cargo.toml

@@ -3,12 +3,15 @@ name = "tracer"
 version = "0.1.0"
 authors = ["Bill Thiede <git@xinu.tv>"]
 edition = "2021"
+default-run = "tracer"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
+anyhow = "1.0.69"
 log = "0.4.17"
 renderer = { path = "../renderer" }
 stderrlog = "0.4.3"
 structopt = "0.2.18"
 strum = "0.24.1"
+toml = "0.7.2"

rtiow/tracer/configs/test.toml

@@ -0,0 +1,74 @@
+[scene]
+width = 768
+height = 512
+subsamples = 100
+
+[camera]
+lookfrom = [0.0, 50.0, 100.0]
+lookat = [0.0, 10.0, 0.0]
+fov = 45
+aperture = 0.0
+focus_dist = 10.0
+time_min = 0.0
+time_max = 1.0
+
+[[materials]]
+name = "light1"
+type = "isotropic"
+texture = [20, 10, 10]
+[[materials]]
+name = "yellow"
+type = "isotropic"
+texture = [1, 1, 0]
+[[materials]]
+name = "magenta"
+type = "lambertian"
+texture = [1, 0, 1]
+[[materials]]
+name = "green"
+type = "diffuse_light"
+texture = [0, 1, 0]
+[[materials]]
+name = "metal"
+type = "metal"
+albedo = [1, 1, 1]
+fuzzy = 0
+[[materials]]
+name = "glass"
+type = "dielectric"
+ref_idx = 1.5
+
+
+[[hitables]]
+type = "sphere"
+center = [-30.0, 0.0, 0.0]
+radius = 10
+material_name = "yellow"
+[[hitables]]
+type = "sphere"
+center = [30.0, 0.0, 0.0]
+radius = 10
+material_name = "green"
+[[hitables]]
+type = "sphere"
+center = [0.0, -10.0, 0.0]
+radius = 10
+material_name = "metal"
+[[hitables]]
+type = "sphere"
+center = [0.0, 0.0, -30.0]
+radius = 10
+material_name = "magenta"
+[[hitables]]
+type = "stl"
+path = "/net/nasx.h.xinu.tv/x/3dprint/stl/stanford_dragon.stl"
+scale = 200
+material_name = "glass"
+#[[hitables]]
+#type = "sphere"
+#center = [0.0, 50.0, -100.0]
+#radius = 10
+#material_name = "light1"
+
+[envmap]
+path = "/home/wathiede/src/xinu.tv/raytracers/rtiow/renderer/images/52681723945_e1d94d3df9_6k.jpg"

rtiow/tracer/src/main.rs

@@ -1,12 +1,16 @@
 #![warn(unused_extern_crates)]
-use std::fs;
+use std::{fs, time::Instant};
 
+use anyhow::Result;
 #[cfg(feature = "profile")]
 use cpuprofiler::PROFILER;
 use log::info;
 use structopt::StructOpt;
 
-use renderer::renderer::{render, Model, Opt};
+use renderer::{
+    parser::Config,
+    renderer::{render, Model, Opt},
+};
 use strum::VariantNames;
 
 #[cfg(not(feature = "profile"))]
@@ -35,19 +39,36 @@ impl MockProfiler {
 #[cfg(not(feature = "profile"))]
 static PROFILER: MockProfiler = MockProfiler {};
 
-fn main() -> Result<(), std::io::Error> {
+fn main() -> Result<()> {
+    let start_time = Instant::now();
     stderrlog::new()
         .verbosity(3)
         .timestamp(stderrlog::Timestamp::Millisecond)
         .init()
         .unwrap();
     let opt = Opt::from_args();
-    if opt.model.is_none() {
+    if opt.model.is_none() && opt.config.is_none() {
-        eprintln!("--model should be one of {:?}", Model::VARIANTS);
+        eprintln!(
+            "--config <path> or --model should be one of {:?}",
+            Model::VARIANTS
+        );
         return Ok(());
     }
-    info!("{:?}", opt);
+    if opt.model.is_some() && opt.config.is_some() {
-    let scene = opt.model.as_ref().unwrap().scene(&opt);
+        eprintln!("only specify one of --config or --model");
+        return Ok(());
+    }
+    info!("{:#?}", opt);
+    let scene = match (&opt.model, &opt.config) {
+        (Some(model), None) => model.scene(&opt),
+        (None, Some(config)) => {
+            let s = std::fs::read_to_string(config)?;
+            let cfg: Config = toml::from_str(&s)?;
+            println!("{:#?}", cfg);
+            cfg.try_into()?
+        }
+        _ => unreachable!(),
+    };
     fs::create_dir_all(&opt.output)?;
     if opt.pprof.is_some() && !cfg!(feature = "profile") {
         panic!("profiling disabled at compile time, but -pprof specified");
@@ -59,11 +80,13 @@ fn main() -> Result<(), std::io::Error> {
             .start(pprof_path.to_str().unwrap().as_bytes())
             .unwrap();
     }
-    let res = render(scene, &opt.output);
+    let res = render(scene, &opt.output, &opt.tev_addr);
     if let Some(pprof_path) = &opt.pprof {
         info!("Saving pprof to {}", pprof_path.to_string_lossy());
         PROFILER.lock().unwrap().stop().unwrap();
     }
 
-    res
+    let time_diff = Instant::now() - start_time;
+    info!("Total runtime {} seconds", time_diff.as_secs_f32());
+    Ok(res?)
 }