FlatBVH and BoundingHierarchy trait

src/bounding_hierarchy.rs

@@ -5,11 +5,10 @@ use nalgebra::{
 };
 use num::{Float, FromPrimitive, Signed};
 
-use crate::aabb::Bounded;
+use crate::aabb::{AabbIntersection, Bounded};
 #[cfg(feature = "rayon")]
 use crate::bvh::rayon_executor;
 use crate::bvh::BvhNodeBuildArgs;
-use crate::ray::Ray;
 
 /// Encapsulates the required traits for the value type used in the Bvh.
 pub trait BHValue:
@@ -240,9 +239,9 @@ pub trait BoundingHierarchy<T: BHValue, const D: usize> {
     /// [`BoundingHierarchy`]: trait.BoundingHierarchy.html
     /// [`Aabb`]: ../aabb/struct.Aabb.html
     ///
-    fn traverse<'a, Shape: BHShape<T, D>>(
+    fn traverse<'a, Query: AabbIntersection<T, D>, Shape: BHShape<T, D>>(
         &'a self,
-        ray: &Ray<T, D>,
+        query: &Query,
         shapes: &'a [Shape],
     ) -> Vec<&'a Shape>;
 
@@ -258,12 +257,12 @@ impl<T: BHValue, const D: usize, H: BoundingHierarchy<T, D>> BoundingHierarchy<T
         Box::new(H::build(shapes))
     }
 
-    fn traverse<'a, Shape: BHShape<T, D>>(
+    fn traverse<'a, Query: AabbIntersection<T, D>, Shape: BHShape<T, D>>(
         &'a self,
-        ray: &Ray<T, D>,
+        query: &Query,
         shapes: &'a [Shape],
     ) -> Vec<&'a Shape> {
-        H::traverse(self, ray, shapes)
+        H::traverse(self, query, shapes)
     }
 
     fn build_with_executor<

src/bvh/bvh_impl.rs

@@ -410,12 +410,12 @@ impl<T: BHValue + std::fmt::Display, const D: usize> BoundingHierarchy<T, D> for
         Bvh::build(shapes)
     }
 
-    fn traverse<'a, Shape: Bounded<T, D>>(
+    fn traverse<'a, Query: AabbIntersection<T, D>, Shape: Bounded<T, D>>(
         &'a self,
-        ray: &Ray<T, D>,
+        query: &Query,
         shapes: &'a [Shape],
     ) -> Vec<&'a Shape> {
-        self.traverse(ray, shapes)
+        self.traverse(query, shapes)
     }
 
     fn pretty_print(&self) {

src/flat_bvh.rs

@@ -1,8 +1,7 @@
 //! This module exports methods to flatten the [`Bvh`] into a [`FlatBvh`] and traverse it iteratively.
-use crate::aabb::{Aabb, Bounded};
+use crate::aabb::{Aabb, AabbIntersection, Bounded};
 use crate::bounding_hierarchy::{BHShape, BHValue, BoundingHierarchy};
 use crate::bvh::{Bvh, BvhNode};
-use crate::ray::Ray;
 
 use num::Float;
 
@@ -382,7 +381,11 @@ impl<T: BHValue + std::fmt::Display, const D: usize> BoundingHierarchy<T, D> for
     /// let flat_bvh = FlatBvh::build(&mut shapes);
     /// let hit_shapes = flat_bvh.traverse(&ray, &shapes);
     /// ```
-    fn traverse<'a, B: Bounded<T, D>>(&'a self, ray: &Ray<T, D>, shapes: &'a [B]) -> Vec<&'a B> {
+    fn traverse<'a, Q: AabbIntersection<T, D>, B: Bounded<T, D>>(
+        &'a self,
+        query: &Q,
+        shapes: &'a [B],
+    ) -> Vec<&'a B> {
         let mut hit_shapes = Vec::new();
         let mut index = 0;
 
@@ -396,13 +399,13 @@ impl<T: BHValue + std::fmt::Display, const D: usize> BoundingHierarchy<T, D> for
             if node.entry_index == u32::MAX {
                 // If the entry_index is MAX_UINT32, then it's a leaf node.
                 let shape = &shapes[node.shape_index as usize];
-                if ray.intersects_aabb(&shape.aabb()) {
+                if query.intersects_aabb(&shape.aabb()) {
                     hit_shapes.push(shape);
                 }
 
                 // Exit the current node.
                 index = node.exit_index as usize;
-            } else if ray.intersects_aabb(&node.aabb) {
+            } else if query.intersects_aabb(&node.aabb) {
                 // If entry_index is not MAX_UINT32 and the Aabb test passes, then
                 // proceed to the node in entry_index (which goes down the bvh branch).
                 index = node.entry_index as usize;

src/ray/ray_impl.rs

@@ -356,7 +356,7 @@ mod tests {
 
 impl<T: BHValue, const D: usize> AabbIntersection<T, D> for Ray<T, D> {
     fn intersects_aabb(&self, aabb: &Aabb<T, D>) -> bool {
-        self.intersects_aabb(&aabb)
+        self.intersects_aabb(aabb)
     }
 }