diff --git a/kdtree-cli/src/main.rs b/kdtree-cli/src/main.rs index 8dda9a34..b6805ce6 100644 --- a/kdtree-cli/src/main.rs +++ b/kdtree-cli/src/main.rs @@ -4,9 +4,9 @@ use geometry::{ }; use kdtree::{ build::build_kdtree, - format::{write_tree_dot, write_tree_json, write_tree_pretty, write_tree_rust}, + format::{write_node_pretty, write_tree_dot, write_tree_json, write_tree_rust}, sah::SahCost, - KdNode, KdTree, MAX_DEPTH, + KdNode, MAX_DEPTH, }; use std::{ fs::File, @@ -89,15 +89,21 @@ fn node_cost( } } -fn tree_cost(kdtree: &KdTree, cost_traverse: f32, cost_intersect: f32, empty_factor: f32) -> f32 { - let bounding_box = geometries_bounding_box(&kdtree.geometries); +fn tree_cost( + geometries: &[Geometry], + node: &KdNode, + cost_traverse: f32, + cost_intersect: f32, + empty_factor: f32, +) -> f32 { + let bounding_box = geometries_bounding_box(geometries); node_cost( cost_traverse, cost_intersect, empty_factor, bounding_box.surface_area(), bounding_box, - kdtree.root.as_ref(), + node, ) } @@ -138,8 +144,8 @@ struct KdTreeStatistics { leaf_geometries: Statistics, } -fn statistics(tree: &KdTree) -> KdTreeStatistics { - let geometries = tree.geometries.len(); +fn statistics(geometries: &[Geometry], tree: &KdNode) -> KdTreeStatistics { + let geometries = geometries.len(); let node_count = tree.iter_nodes().map(|_| 1).sum(); let leaf_count = tree.iter_leafs().map(|_| 1).sum(); let leaf_depth = Statistics::compute(tree.iter_leafs().map(|(depth, _)| depth).collect()); @@ -195,17 +201,18 @@ fn main() { intersect_cost: args.intersect_cost, empty_factor: args.empty_factor, }; - let kdtree = build_kdtree(geometries, args.max_depth, &cost); + let kdtree = build_kdtree(&geometries, args.max_depth, &cost); let duration = Instant::now().duration_since(start_time); let duration = Duration::new(duration.as_secs() as i64, duration.as_nanos() as i32); let cost = tree_cost( + &geometries, &kdtree, args.traverse_cost, args.intersect_cost, args.empty_factor, ); - let stats = statistics(&kdtree); + let stats = statistics(&geometries, &kdtree); eprintln!("Done..."); eprintln!("Tree statistics:"); eprintln!(" Build time: {:.3}", duration); @@ -226,12 +233,12 @@ fn main() { eprintln!(" Median: {}", stats.leaf_geometries.median); if args.json { - write_tree_json(&mut io::stdout().lock(), &kdtree).unwrap(); + write_tree_json(&mut io::stdout().lock(), &geometries, &kdtree).unwrap(); } else if args.rust { - write_tree_rust(&mut io::stdout().lock(), &kdtree).unwrap(); + write_tree_rust(&mut io::stdout().lock(), &geometries, &kdtree).unwrap(); } else if args.dot { write_tree_dot(&mut io::stdout().lock(), &kdtree).unwrap(); } else { - write_tree_pretty(&mut io::stdout().lock(), &kdtree).unwrap(); + write_node_pretty(&mut io::stdout().lock(), &kdtree).unwrap(); } } diff --git a/kdtree-tester/src/bin/kdtree-reducer-cli.rs b/kdtree-tester/src/bin/kdtree-reducer-cli.rs index 5c14fc27..8a96f889 100644 --- a/kdtree-tester/src/bin/kdtree-reducer-cli.rs +++ b/kdtree-tester/src/bin/kdtree-reducer-cli.rs @@ -11,17 +11,22 @@ use rand::{rngs::SmallRng, seq::SliceRandom, SeedableRng}; use geometry::{geometry::Geometry, intersection::RayIntersection, ray::Ray, triangle::Triangle}; use kdtree::{ build::build_kdtree, format::write_tree_json, intersection::KdIntersection, sah::SahCost, - KdTree, MAX_DEPTH, + KdNode, MAX_DEPTH, }; use wavefront::obj; -fn build_test_tree(geometries: Vec) -> kdtree::KdTree { +fn build_test_tree(geometries: &[Geometry]) -> KdNode { build_kdtree(geometries, MAX_DEPTH as u32, &SahCost::default()) } -fn verify_removal(ray: &Ray, actual: &(Geometry, RayIntersection), tree: &KdTree) -> bool { - let intersection = tree.intersect(ray, 0.0..=f32::MAX).unwrap(); - let same_geometry = tree.geometries[intersection.index as usize] == actual.0; +fn verify_removal( + geometries: &[Geometry], + ray: &Ray, + actual: &(Geometry, RayIntersection), + tree: &KdNode, +) -> bool { + let intersection = tree.intersect(geometries, ray, 0.0..=f32::MAX).unwrap(); + let same_geometry = geometries[intersection.index as usize] == actual.0; let same_intersection = intersection.intersection == actual.1; same_geometry && same_intersection } @@ -36,11 +41,15 @@ fn try_removing( let mut reduced = Vec::with_capacity(geometries.len() - try_count); reduced.extend_from_slice(&geometries[0..try_index]); reduced.extend_from_slice(&geometries[try_index + try_count..]); - let tree = build_test_tree(reduced); - verify_removal(ray, actual, &tree).then_some(tree.geometries) + let tree = build_test_tree(&reduced); + verify_removal(&reduced, ray, actual, &tree).then_some(reduced) } -fn reduce_tree(seed: u64, intersection: &CheckedIntersection, geometries: Vec) -> KdTree { +fn reduce_tree( + seed: u64, + intersection: &CheckedIntersection, + geometries: Vec, +) -> (Vec, KdNode) { let actual_intersection = intersection.kdtree.as_ref().unwrap(); let actual_geometry = geometries[actual_intersection.index as usize].clone(); let actual = (actual_geometry, actual_intersection.intersection); @@ -87,7 +96,8 @@ fn reduce_tree(seed: u64, intersection: &CheckedIntersection, geometries: Vec, ) -> Option { - let indices = 0u32..self.kdtree.geometries.len() as u32; - intersect_closest_geometry(&self.kdtree.geometries, indices, ray, t_range) + let indices = 0u32..self.scene.geometries.len() as u32; + intersect_closest_geometry(&self.scene.geometries, indices, ray, t_range) } fn checked_ray_intersect( @@ -36,7 +36,9 @@ impl RayBouncer { ray: &Ray, t_range: RangeInclusive, ) -> CheckedIntersection { - let kdtree = self.kdtree.intersect(ray, t_range.clone()); + let kdtree = self + .kdtree + .intersect(&self.scene.geometries, ray, t_range.clone()); let reference = self.reference_ray_intersect(ray, t_range); CheckedIntersection { ray: *ray, diff --git a/kdtree/src/build.rs b/kdtree/src/build.rs index 27e23224..541411ea 100644 --- a/kdtree/src/build.rs +++ b/kdtree/src/build.rs @@ -4,9 +4,10 @@ use glam::Vec3; use crate::{ cell::KdCell, sah::{find_best_split, should_terminate, SahCost}, + MAX_DEPTH, }; -use super::{KdNode, KdTree}; +use super::KdNode; fn starting_box(geometries: &[Geometry]) -> KdCell { KdCell::new( @@ -40,16 +41,14 @@ fn build_helper( } } -pub fn build_kdtree(geometries: Vec, max_depth: u32, cost: &SahCost) -> KdTree { - if max_depth as usize > super::MAX_DEPTH { +pub fn build_kdtree(geometries: &[Geometry], max_depth: u32, cost: &SahCost) -> KdNode { + if max_depth as usize > MAX_DEPTH { panic!( "Max depth ({}) must be smaller than hard coded value ({}).", - max_depth, - super::MAX_DEPTH + max_depth, MAX_DEPTH ); } - let root = build_helper(&geometries, cost, max_depth, 1, starting_box(&geometries)); - KdTree { root, geometries } + *build_helper(geometries, cost, max_depth, 1, starting_box(geometries)) } #[cfg(test)] @@ -73,7 +72,7 @@ mod tests { intersect_cost: 1.0, empty_factor: 0.8, }; - let tree = build_kdtree(vec![triangle.into()], 7, &cost); + let actual = build_kdtree(&vec![triangle.into()], 7, &cost); let expected = KdNode::new_node( Aap::new_x(0.0), @@ -101,9 +100,9 @@ mod tests { ), ); assert_eq!( - tree.root, expected, + actual, *expected, "\n actual: {}\n expected: {}", - tree.root, expected + actual, *expected ); } @@ -119,7 +118,7 @@ mod tests { intersect_cost: 10.0, empty_factor: 0.8, }; - let tree = build_kdtree(vec![triangle.into()], 6, &cost); + let actual = build_kdtree(&vec![triangle.into()], 6, &cost); let expected = KdNode::new_node( Aap::new_x(0.0), @@ -135,9 +134,9 @@ mod tests { ), ); assert_eq!( - tree.root, expected, + actual, *expected, "\n actual: {}\n expected: {}", - tree.root, expected + actual, *expected ); } } diff --git a/kdtree/src/format.rs b/kdtree/src/format.rs index 3f766bc9..b730d409 100644 --- a/kdtree/src/format.rs +++ b/kdtree/src/format.rs @@ -1,4 +1,4 @@ -use crate::{KdNode, KdTree}; +use crate::KdNode; use geometry::{axis::Axis, geometry::Geometry}; use std::io::{self}; @@ -46,13 +46,6 @@ where Ok(()) } -pub fn write_tree_pretty(write: &mut W, tree: &KdTree) -> Result<(), io::Error> -where - W: io::Write, -{ - write_node_pretty(write, &tree.root) -} - pub fn write_node_rust(write: &mut W, node: &KdNode) -> Result<(), io::Error> where W: io::Write, @@ -81,15 +74,19 @@ where Ok(()) } -pub fn write_tree_rust(write: &mut W, tree: &KdTree) -> Result<(), io::Error> +pub fn write_tree_rust( + write: &mut W, + geometries: &[Geometry], + tree: &KdNode, +) -> Result<(), io::Error> where W: io::Write, { write!(write, "let geometries = ")?; - write_triangle_bracketed(write, &tree.geometries)?; + write_triangle_bracketed(write, geometries)?; writeln!(write, ";")?; write!(write, "let root = ")?; - write_node_rust(write, &tree.root)?; + write_node_rust(write, tree)?; writeln!(write, ";")?; writeln!(write, "let tree = KdTree {{ root, geometries }};")?; Ok(()) @@ -117,14 +114,18 @@ where Ok(()) } -pub fn write_tree_json(write: &mut W, tree: &KdTree) -> Result<(), io::Error> +pub fn write_tree_json( + write: &mut W, + geometries: &[Geometry], + tree: &KdNode, +) -> Result<(), io::Error> where W: io::Write, { write!(write, "{{\"triangles\": ")?; - write_triangle_bracketed(write, &tree.geometries)?; + write_triangle_bracketed(write, geometries)?; write!(write, ", \"root\": ")?; - write_node_json(write, &tree.root)?; + write_node_json(write, tree)?; writeln!(write, "}}")?; Ok(()) } @@ -156,14 +157,14 @@ where Ok(()) } -pub fn write_tree_dot(write: &mut W, tree: &KdTree) -> Result<(), io::Error> +pub fn write_tree_dot(write: &mut W, tree: &KdNode) -> Result<(), io::Error> where W: io::Write, { writeln!(write, "digraph {{")?; writeln!(write, " rankdir=\"LR\";")?; writeln!(write, " node [shape=\"box\"];")?; - write_node_dot(write, "t".to_string(), &tree.root)?; + write_node_dot(write, "t".to_string(), tree)?; writeln!(write, "}}")?; Ok(()) } diff --git a/kdtree/src/lib.rs b/kdtree/src/lib.rs index cd8dceec..c508d8da 100644 --- a/kdtree/src/lib.rs +++ b/kdtree/src/lib.rs @@ -48,6 +48,21 @@ impl KdNode { } } + #[inline] + pub fn iter_nodes(&self) -> KdTreeNodeIter { + KdTreeNodeIter { + stack: vec![(1, self)], + } + } + + #[inline] + pub fn iter_leafs(&self) -> impl Iterator)> { + self.iter_nodes().filter_map(|(depth, node)| match node { + KdNode::Leaf(indices) => Some((depth, indices)), + _ => None, + }) + } + pub fn intersect( &self, geometries: &[Geometry], @@ -122,7 +137,7 @@ impl Display for KdNode { } pub struct KdTreeNodeIter<'a> { - stack: Vec<(usize, &'a KdNode)>, + pub(crate) stack: Vec<(usize, &'a KdNode)>, } impl<'a> Iterator for KdTreeNodeIter<'a> { @@ -148,49 +163,22 @@ impl<'a> Iterator for KdTreeNodeIter<'a> { } } -pub struct KdTree { - pub root: Box, - pub geometries: Vec, -} - -impl KdTree { - #[inline] - pub fn iter_nodes(&self) -> KdTreeNodeIter<'_> { - KdTreeNodeIter { - stack: vec![(1, &self.root)], - } - } - - #[inline] - pub fn iter_leafs(&self) -> impl Iterator)> { - self.iter_nodes().filter_map(|(depth, node)| match node { - KdNode::Leaf(indices) => Some((depth, indices)), - _ => None, - }) - } - - #[inline] - pub fn intersect(&self, ray: &Ray, t_range: RangeInclusive) -> Option { - self.root.intersect(&self.geometries, ray, t_range) - } -} - #[cfg(test)] mod tests { - use geometry::{axis::Axis, intersection::RayIntersection, triangle::Triangle}; + use geometry::{ + aap::Aap, axis::Axis, intersection::RayIntersection, ray::Ray, triangle::Triangle, + }; use glam::Vec3; use super::*; #[test] - fn intersect_empty_tree() { - let tree = KdTree { - root: KdNode::empty(), - geometries: vec![], - }; + fn intersect_empty_node() { + let geometries = vec![]; + let node = KdNode::empty(); let ray = Ray::between(Vec3::new(0., 0., 0.), Vec3::new(1., 1., 1.)); - assert_eq!(tree.intersect(&ray, 0.0..=1.0), None); + assert_eq!(node.intersect(&geometries, &ray, 0.0..=1.0), None); } #[test] @@ -205,25 +193,23 @@ mod tests { v1: Vec3::new(2., 0., 1.), v2: Vec3::new(2., 2., 1.), }; - let tree = KdTree { - root: Box::new(KdNode::Node { - plane: Aap { - axis: Axis::X, - distance: 1., - }, - left: KdNode::new_leaf(vec![0, 1]), - right: KdNode::new_leaf(vec![0, 1]), - }), - geometries: vec![triangle0.into(), triangle1.into()], - }; + let geometries = vec![triangle0.into(), triangle1.into()]; + let node = Box::new(KdNode::Node { + plane: Aap { + axis: Axis::X, + distance: 1., + }, + left: KdNode::new_leaf(vec![0, 1]), + right: KdNode::new_leaf(vec![0, 1]), + }); let ray = Ray::between(Vec3::new(1., 1., -2.), Vec3::new(1., 1., 2.)); assert_eq!( - tree.intersect(&ray, 0.0..=1.0), + node.intersect(&geometries, &ray, 0.0..=1.0), Some(KdIntersection::new(0, RayIntersection::new(0.25, 0., 0.5))) ); assert_eq!( - tree.intersect(&ray.reverse(), 0.0..=1.0), + node.intersect(&geometries, &ray.reverse(), 0.0..=1.0), Some(KdIntersection::new(1, RayIntersection::new(0.25, 0., 0.5))) ); } @@ -240,23 +226,21 @@ mod tests { v1: Vec3::new(2., 0., 0.), v2: Vec3::new(2., 1., 0.), }; - let tree = KdTree { - root: KdNode::new_node( - Aap::new_x(1.0), - KdNode::new_leaf(vec![0]), - KdNode::new_leaf(vec![1]), - ), - geometries: vec![triangle0.into(), triangle1.into()], - }; + let geometries = vec![triangle0.into(), triangle1.into()]; + let node = KdNode::new_node( + Aap::new_x(1.0), + KdNode::new_leaf(vec![0]), + KdNode::new_leaf(vec![1]), + ); let ray_triangle0_v0 = Ray::between(Vec3::new(0., 0., -1.), Vec3::new(0., 0., 1.)); let ray_triangle1_v1 = Ray::between(Vec3::new(2., 0., -1.), Vec3::new(2., 0., 1.)); assert_eq!( - tree.intersect(&ray_triangle0_v0, 0.0..=1.0), + node.intersect(&geometries, &ray_triangle0_v0, 0.0..=1.0), Some(KdIntersection::new(0, RayIntersection::new(0.5, 0., 0.))) ); assert_eq!( - tree.intersect(&ray_triangle1_v1, 0.0..=1.0), + node.intersect(&geometries, &ray_triangle1_v1, 0.0..=1.0), Some(KdIntersection::new(1, RayIntersection::new(0.5, 1., 0.))) ); } @@ -273,22 +257,20 @@ mod tests { v1: Vec3::new(2., 1., -1.), v2: Vec3::new(2., 1., 1.), }; - let tree = KdTree { - root: KdNode::new_node( - Aap::new_x(1.0), - KdNode::new_leaf(vec![0]), - KdNode::new_leaf(vec![1]), - ), - geometries: vec![triangle0.into(), triangle1.into()], - }; + let geometries = vec![triangle0.into(), triangle1.into()]; + let node = KdNode::new_node( + Aap::new_x(1.0), + KdNode::new_leaf(vec![0]), + KdNode::new_leaf(vec![1]), + ); let ray = Ray::between(Vec3::new(-1., 0., 0.), Vec3::new(3., 0., 0.)); assert_eq!( - tree.intersect(&ray, 0.0..=1.0), + node.intersect(&geometries, &ray, 0.0..=1.0), Some(KdIntersection::new(0, RayIntersection::new(0.25, 0., 0.5))) ); assert_eq!( - tree.intersect(&ray.reverse(), 0.0..=1.0), + node.intersect(&geometries, &ray.reverse(), 0.0..=1.0), Some(KdIntersection::new(1, RayIntersection::new(0.25, 0., 0.5))) ); } @@ -300,22 +282,19 @@ mod tests { v1: Vec3::new(1., 0., 1.), v2: Vec3::new(0., 1., 1.), }; - let tree_left = KdTree { - root: KdNode::new_node(Aap::new_z(1.0), KdNode::new_leaf(vec![0]), KdNode::empty()), - geometries: vec![triangle.into()], - }; - let tree_right = KdTree { - root: KdNode::new_node(Aap::new_z(1.0), KdNode::empty(), KdNode::new_leaf(vec![0])), - geometries: vec![triangle.into()], - }; + let geometries = vec![triangle.into()]; + let tree_left = + KdNode::new_node(Aap::new_z(1.0), KdNode::new_leaf(vec![0]), KdNode::empty()); + let tree_right = + KdNode::new_node(Aap::new_z(1.0), KdNode::empty(), KdNode::new_leaf(vec![0])); let ray = Ray::between(Vec3::new(0., 0., 0.), Vec3::new(0., 0., 2.)); assert_eq!( - tree_left.intersect(&ray, 0.0..=1.0), + tree_left.intersect(&geometries, &ray, 0.0..=1.0), Some(KdIntersection::new(0, RayIntersection::new(0.5, 0., 0.))) ); assert_eq!( - tree_right.intersect(&ray, 0.0..=1.0), + tree_right.intersect(&geometries, &ray, 0.0..=1.0), Some(KdIntersection::new(0, RayIntersection::new(0.5, 0., 0.))) ); } @@ -327,22 +306,20 @@ mod tests { v1: Vec3::new(1., 0., 1.), v2: Vec3::new(0., 1., 1.), }; - let tree = KdTree { - root: KdNode::new_node( - Aap::new_z(1.0), - KdNode::new_node(Aap::new_z(1.0), KdNode::new_leaf(vec![0]), KdNode::empty()), - KdNode::empty(), - ), - geometries: vec![triangle.into()], - }; + let geometries = vec![triangle.into()]; + let node = KdNode::new_node( + Aap::new_z(1.0), + KdNode::new_node(Aap::new_z(1.0), KdNode::new_leaf(vec![0]), KdNode::empty()), + KdNode::empty(), + ); let ray = Ray::between(Vec3::new(0., 0., 0.), Vec3::new(0., 0., 2.)); assert_eq!( - tree.intersect(&ray, 0.0..=1.0), + node.intersect(&geometries, &ray, 0.0..=1.0), Some(KdIntersection::new(0, RayIntersection::new(0.5, 0., 0.))) ); assert_eq!( - tree.intersect(&ray.reverse(), 0.0..=1.0), + node.intersect(&geometries, &ray.reverse(), 0.0..=1.0), Some(KdIntersection::new(0, RayIntersection::new(0.5, 0., 0.))) ); } @@ -354,22 +331,20 @@ mod tests { v1: Vec3::new(1., 0., 1.), v2: Vec3::new(0., 1., 1.), }; - let tree = KdTree { - root: KdNode::new_node( - Aap::new_z(1.0), - KdNode::empty(), - KdNode::new_node(Aap::new_z(1.0), KdNode::new_leaf(vec![0]), KdNode::empty()), - ), - geometries: vec![triangle.into()], - }; + let geometries = vec![triangle.into()]; + let node = KdNode::new_node( + Aap::new_z(1.0), + KdNode::empty(), + KdNode::new_node(Aap::new_z(1.0), KdNode::new_leaf(vec![0]), KdNode::empty()), + ); let ray = Ray::between(Vec3::new(0., 0., 0.), Vec3::new(0., 0., 2.)); assert_eq!( - tree.intersect(&ray, 0.0..=1.0), + node.intersect(&geometries, &ray, 0.0..=1.0), Some(KdIntersection::new(0, RayIntersection::new(0.5, 0., 0.))) ); assert_eq!( - tree.intersect(&ray.reverse(), 0.0..=1.0), + node.intersect(&geometries, &ray.reverse(), 0.0..=1.0), Some(KdIntersection::new(0, RayIntersection::new(0.5, 0., 0.))) ); } @@ -381,21 +356,18 @@ mod tests { v1: Vec3::new(-1.0, 1.0, -1.0), v2: Vec3::new(1.0, -1.0, -1.0), }; - let root = KdNode::new_node( + let geometries = vec![triangle.into()]; + let node = KdNode::new_node( Aap::new_z(-1.0), KdNode::empty(), KdNode::new_node(Aap::new_z(-1.0), KdNode::new_leaf(vec![0]), KdNode::empty()), ); - let tree = KdTree { - geometries: vec![triangle.into()], - root, - }; let ray = Ray::new( Vec3::new(0.0, 0.0, 3.0), Vec3::new(0.06646079, 0.08247295, -0.9238795), ); - let actual = tree.intersect(&ray, 0.0..=f32::MAX); + let actual = node.intersect(&geometries, &ray, 0.0..=f32::MAX); assert_eq!( actual, @@ -417,16 +389,14 @@ mod tests { v1: Vec3::new(-1.0, -1.0, -1.0), v2: Vec3::new(-1.0, 1.0, 1.0), }; - let tree = KdTree { - root: KdNode::new_node(Aap::new_x(-1.0), KdNode::empty(), KdNode::new_leaf(vec![0])), - geometries: vec![triangle.into()], - }; + let geometries = vec![triangle.into()]; + let node = KdNode::new_node(Aap::new_x(-1.0), KdNode::empty(), KdNode::new_leaf(vec![0])); let ray = Ray::new( Vec3::new(-0.5170438, -0.4394186, -0.045965273), Vec3::new(-0.8491798, -0.1408107, -0.5089852), ); - let actual = tree.intersect(&ray, 0.0..=f32::MAX); + let actual = node.intersect(&geometries, &ray, 0.0..=f32::MAX); assert_eq!( actual, diff --git a/pathtracer-cli/src/main.rs b/pathtracer-cli/src/main.rs index 6761ffa3..30c4ec6a 100644 --- a/pathtracer-cli/src/main.rs +++ b/pathtracer-cli/src/main.rs @@ -162,7 +162,7 @@ fn main() { println!("Building kdtree..."); let kdtree = build_kdtree( - scene.geometries.clone(), + &scene.geometries, args.max_depth, &SahCost { traverse_cost: args.traverse_cost, diff --git a/pathtracer-gui/src/main.rs b/pathtracer-gui/src/main.rs index d0d40835..b4532d93 100644 --- a/pathtracer-gui/src/main.rs +++ b/pathtracer-gui/src/main.rs @@ -32,7 +32,7 @@ fn main() { println!("Building kdtree..."); let kdtree = build_kdtree( - scene.geometries.clone(), + &scene.geometries, args.max_depth, &SahCost { traverse_cost: args.traverse_cost, diff --git a/raytracer-cli/src/main.rs b/raytracer-cli/src/main.rs index 956b595d..ae030bd1 100644 --- a/raytracer-cli/src/main.rs +++ b/raytracer-cli/src/main.rs @@ -73,7 +73,7 @@ fn main() { println!("Building kdtree..."); let kdtree = build_kdtree( - scene.geometries.clone(), + &scene.geometries, args.max_depth, &SahCost { traverse_cost: args.traverse_cost, diff --git a/tracing/src/pathtracer.rs b/tracing/src/pathtracer.rs index f6566476..7c0dc74d 100644 --- a/tracing/src/pathtracer.rs +++ b/tracing/src/pathtracer.rs @@ -8,19 +8,19 @@ use crate::{ }; use geometry::ray::Ray; use glam::{UVec2, Vec3}; -use kdtree::{intersection::KdIntersection, KdTree}; +use kdtree::{intersection::KdIntersection, KdNode}; use rand::rngs::SmallRng; use scene::{camera::Pinhole, Scene}; pub struct Pathtracer { pub max_bounces: u8, pub scene: Scene, - pub kdtree: KdTree, + pub kdtree: KdNode, } impl Pathtracer { fn intersect(&self, ray: &Ray, t_range: RangeInclusive) -> Option { - self.kdtree.intersect(ray, t_range) + self.kdtree.intersect(&self.scene.geometries, ray, t_range) } fn intersect_any(&self, ray: &Ray, t_range: RangeInclusive) -> bool { diff --git a/tracing/src/raytracer.rs b/tracing/src/raytracer.rs index 3f506a52..bcec531f 100644 --- a/tracing/src/raytracer.rs +++ b/tracing/src/raytracer.rs @@ -6,18 +6,18 @@ use crate::{ }; use geometry::ray::Ray; use glam::{UVec2, Vec2, Vec3}; -use kdtree::{intersection::KdIntersection, KdTree}; +use kdtree::{intersection::KdIntersection, KdNode}; use scene::{camera::Pinhole, Scene}; pub struct Raytracer { pub scene: Scene, - pub kdtree: KdTree, + pub kdtree: KdNode, pub camera: Pinhole, } impl Raytracer { fn intersect(&self, ray: &Ray, t_range: RangeInclusive) -> Option { - self.kdtree.intersect(ray, t_range) + self.kdtree.intersect(&self.scene.geometries, ray, t_range) } fn intersect_any(&self, ray: &Ray, t_range: RangeInclusive) -> bool {