optimizations and other improvements

Cargo.toml

@@ -1,41 +1,12 @@
-[package]
-name = "bvh"
-description = "A fast BVH using SAH"
-version = "0.6.0"
-edition = "2018"
-authors = [
-    "Sven-Hendrik Haase <[email protected]>",
-    "Alexander Dmitriev <[email protected]>"
-]
-readme = "README.md"
-repository = "https://github.com/svenstaro/bvh"
-documentation = "https://docs.rs/crate/bvh"
-keywords = ["bvh", "bounding", "volume", "sah", "aabb"]
-license = "MIT"
-
-[dependencies]
-approx = "0.5"
-rand = "0.8"
-log = "0.4"
-num = "0.4"
-glam = "0.20"
-serde = { optional = true, version = "1", features = ["derive"] }
-
-[dev-dependencies]
-proptest = "1.0"
-obj-rs = "0.7"
-float_eq = "0.7"
-criterion = "0.3"
-
-[features]
-bench = []
-# Unfortunately can't use "serde" as the feature name until https://github.com/rust-lang/cargo/issues/5565 lands
-serde_impls = ["serde", "glam/serde"]
+[workspace]
+members = ["bvh", "bvh-f64"]
 
 [profile.release]
 lto = true
 codegen-units = 1
+debug = true
 
 [profile.bench]
 lto = true
 codegen-units = 1
+debug = true

bvh-f64/Cargo.toml

@@ -0,0 +1,49 @@
+[package]
+name = "bvh-f64"
+description = "A fast dynamic BVH using SAH"
+version = "0.6.0"
+edition = "2018"
+authors = [
+    "Sven-Hendrik Haase <[email protected]>",
+    "Alexander Dmitriev <[email protected]>"
+]
+readme = "README.md"
+repository = "https://github.com/svenstaro/bvh"
+documentation = "https://docs.rs/crate/bvh"
+keywords = ["bvh", "bounding", "volume", "sah", "aabb"]
+license = "MIT"
+
+
+[lib]
+name = "bvh_f64"
+path = "../src/lib.rs"
+required-features = ["f64"]
+doctest = false
+
+[dependencies]
+approx = "0.5"
+rand = "0.8"
+log = "0.4"
+num = "0.4"
+glam = "0.20"
+rayon = "1.5.1"
+smallvec = "1.6.1"
+serde = { optional = true, version = "1", features = ["derive"] }
+
+
+[dev-dependencies]
+proptest = "1.0"
+obj-rs = "0.7"
+float_eq = "0.7"
+criterion = "0.3"
+itertools = "0.10.1"
+serde = { version = "1", features = ["derive"] }
+glam = { version = "0.20", features = ["serde"] }
+serde_json = "1"
+
+[features]
+default = ["f64"]
+bench = []
+f64 = []
+# Unfortunately can't use "serde" as the feature name until https://github.com/rust-lang/cargo/issues/5565 lands
+serde_impls = ["serde", "glam/serde"]

bvh/Cargo.toml

@@ -0,0 +1,47 @@
+[package]
+name = "bvh"
+description = "A fast dynamic BVH using SAH"
+version = "0.6.0"
+edition = "2018"
+authors = [
+    "Sven-Hendrik Haase <[email protected]>",
+    "Alexander Dmitriev <[email protected]>"
+]
+readme = "README.md"
+repository = "https://github.com/svenstaro/bvh"
+documentation = "https://docs.rs/crate/bvh"
+keywords = ["bvh", "bounding", "volume", "sah", "aabb"]
+license = "MIT"
+
+
+[lib]
+name = "bvh"
+path = "../src/lib.rs"
+required-features = []
+
+[dependencies]
+approx = "0.5"
+rand = "0.8"
+log = "0.4"
+num = "0.4"
+glam = "0.20"
+rayon = "1.5.1"
+smallvec = "1.6.1"
+serde = { optional = true, version = "1", features = ["derive"] }
+
+
+[dev-dependencies]
+proptest = "1.0"
+obj-rs = "0.7"
+float_eq = "0.7"
+criterion = "0.3"
+itertools = "0.10.1"
+serde = { version = "1", features = ["derive"] }
+glam = { version = "0.20", features = ["serde"] }
+serde_json = "1"
+
+[features]
+default = []
+bench = []
+# Unfortunately can't use "serde" as the feature name until https://github.com/rust-lang/cargo/issues/5565 lands
+serde_impls = ["serde", "glam/serde"]

examples/simple.rs

@@ -1,13 +1,15 @@
-use bvh::aabb::{Bounded, AABB};
-use bvh::bounding_hierarchy::BHShape;
-use bvh::bvh::BVH;
-use bvh::ray::Ray;
-use bvh::{Point3, Vector3};
+use bvh::{
+    aabb::{Bounded, AABB},
+    bounding_hierarchy::BHShape,
+    bvh::BVH,
+    ray::Ray,
+    Point3, Real, Vector3,
+};
 
 #[derive(Debug)]
 struct Sphere {
     position: Point3,
-    radius: f32,
+    radius: Real,
     node_index: usize,
 }
 
@@ -33,8 +35,8 @@ impl BHShape for Sphere {
 pub fn main() {
     let mut spheres = Vec::new();
     for i in 0..1000000u32 {
-        let position = Point3::new(i as f32, i as f32, i as f32);
-        let radius = (i % 10) as f32 + 1.0;
+        let position = Point3::new(i as Real, i as Real, i as Real);
+        let radius = (i % 10) as Real + 1.0;
         spheres.push(Sphere {
             position,
             radius,

src/axis.rs

@@ -1,7 +1,7 @@
 //! Axis enum for indexing three-dimensional structures.
 
 #![allow(unused)]
-use crate::{Point3, Vector3};
+use crate::{Point3, Real, Vector3};
 use std::fmt::{Display, Formatter, Result};
 use std::ops::{Index, IndexMut};
 
@@ -23,7 +23,6 @@ struct MyType<T>(T);
 /// [`Point3`] and [`Vector3`] are also indexable using `Axis`.
 ///
 /// ```
-/// extern crate bvh;
 ///
 /// use bvh::axis::Axis;
 /// use bvh::Point3;
@@ -63,19 +62,19 @@ impl Display for Axis {
 }
 
 /// Make slices indexable by `Axis`.
-impl Index<Axis> for [f32] {
-    type Output = f32;
+impl Index<Axis> for [Real] {
+    type Output = Real;
 
-    fn index(&self, axis: Axis) -> &f32 {
+    fn index(&self, axis: Axis) -> &Real {
         &self[axis as usize]
     }
 }
 
 /// Make `Point3` indexable by `Axis`.
 impl Index<Axis> for Point3 {
-    type Output = f32;
+    type Output = Real;
 
-    fn index(&self, axis: Axis) -> &f32 {
+    fn index(&self, axis: Axis) -> &Real {
         match axis {
             Axis::X => &self.x,
             Axis::Y => &self.y,
@@ -86,9 +85,9 @@ impl Index<Axis> for Point3 {
 
 /// Make `Vector3` indexable by `Axis`.
 impl Index<Axis> for MyType<Vector3> {
-    type Output = f32;
+    type Output = Real;
 
-    fn index(&self, axis: Axis) -> &f32 {
+    fn index(&self, axis: Axis) -> &Real {
         match axis {
             Axis::X => &self.0.x,
             Axis::Y => &self.0.y,
@@ -98,15 +97,15 @@ impl Index<Axis> for MyType<Vector3> {
 }
 
 /// Make slices mutably accessible by `Axis`.
-impl IndexMut<Axis> for [f32] {
-    fn index_mut(&mut self, axis: Axis) -> &mut f32 {
+impl IndexMut<Axis> for [Real] {
+    fn index_mut(&mut self, axis: Axis) -> &mut Real {
         &mut self[axis as usize]
     }
 }
 
 /// Make `Point3` mutably accessible by `Axis`.
 impl IndexMut<Axis> for Point3 {
-    fn index_mut(&mut self, axis: Axis) -> &mut f32 {
+    fn index_mut(&mut self, axis: Axis) -> &mut Real {
         match axis {
             Axis::X => &mut self.x,
             Axis::Y => &mut self.y,
@@ -117,7 +116,7 @@ impl IndexMut<Axis> for Point3 {
 
 /// Make `Vector3` mutably accessible by `Axis`.
 impl IndexMut<Axis> for MyType<Vector3> {
-    fn index_mut(&mut self, axis: Axis) -> &mut f32 {
+    fn index_mut(&mut self, axis: Axis) -> &mut Real {
         match axis {
             Axis::X => &mut self.0.x,
             Axis::Y => &mut self.0.y,
@@ -128,28 +127,29 @@ impl IndexMut<Axis> for MyType<Vector3> {
 
 #[cfg(test)]
 mod test {
-    use crate::axis::Axis;
+    use crate::{axis::Axis, Real};
     use proptest::prelude::*;
 
+    #[cfg(not(miri))]
     proptest! {
         // Test whether accessing arrays by index is the same as accessing them by `Axis`.
         #[test]
-        fn test_index_by_axis(tpl: (f32, f32, f32)) {
+        fn test_index_by_axis(tpl: (Real, Real, Real)) {
             let a = [tpl.0, tpl.1, tpl.2];
 
-            assert!((a[0] - a[Axis::X]).abs() < f32::EPSILON && (a[1] - a[Axis::Y]).abs() < f32::EPSILON && (a[2] - a[Axis::Z]).abs() < f32::EPSILON);
+            assert!((a[0] - a[Axis::X]).abs() < Real::EPSILON && (a[1] - a[Axis::Y]).abs() < Real::EPSILON && (a[2] - a[Axis::Z]).abs() < Real::EPSILON);
         }
 
         // Test whether arrays can be mutably set, by indexing via `Axis`.
         #[test]
-        fn test_set_by_axis(tpl: (f32, f32, f32)) {
+        fn test_set_by_axis(tpl: (Real, Real, Real)) {
             let mut a = [0.0, 0.0, 0.0];
 
             a[Axis::X] = tpl.0;
             a[Axis::Y] = tpl.1;
             a[Axis::Z] = tpl.2;
 
-            assert!((a[0] - tpl.0).abs() < f32::EPSILON && (a[1] - tpl.1).abs() < f32::EPSILON && (a[2] - tpl.2).abs() < f32::EPSILON);
+            assert!((a[0] - tpl.0).abs() < Real::EPSILON && (a[1] - tpl.1).abs() < Real::EPSILON && (a[2] - tpl.2).abs() < Real::EPSILON);
         }
     }
 }

src/bounding_hierarchy.rs

@@ -1,15 +1,15 @@
 //! This module defines the `BoundingHierarchy` trait.
 
 use crate::aabb::Bounded;
-use crate::ray::Ray;
+use crate::aabb::AABB;
 
 /// Describes a shape as referenced by a [`BoundingHierarchy`] leaf node.
 /// Knows the index of the node in the [`BoundingHierarchy`] it is in.
 ///
 /// [`BoundingHierarchy`]: struct.BoundingHierarchy.html
 ///
 #[allow(clippy::upper_case_acronyms)]
-pub trait BHShape: Bounded {
+pub trait BHShape: Bounded + Sync + Send {
     /// Sets the index of the referenced [`BoundingHierarchy`] node.
     ///
     /// [`BoundingHierarchy`]: struct.BoundingHierarchy.html
@@ -34,6 +34,7 @@ pub trait BoundingHierarchy {
     /// use bvh::aabb::{AABB, Bounded};
     /// use bvh::bounding_hierarchy::BoundingHierarchy;
     /// use bvh::{Point3, Vector3};
+    /// use bvh::Real;
     /// # use bvh::bounding_hierarchy::BHShape;
     /// # pub struct UnitBox {
     /// #     pub id: i32,
@@ -72,7 +73,7 @@ pub trait BoundingHierarchy {
     /// # fn create_bhshapes() -> Vec<UnitBox> {
     /// #     let mut shapes = Vec::new();
     /// #     for i in 0..1000 {
-    /// #         let position = Point3::new(i as f32, i as f32, i as f32);
+    /// #         let position = Point3::new(i as Real, i as Real, i as Real);
     /// #         shapes.push(UnitBox::new(i, position));
     /// #     }
     /// #     shapes
@@ -107,6 +108,7 @@ pub trait BoundingHierarchy {
     /// use bvh::bvh::BVH;
     /// use bvh::{Point3, Vector3};
     /// use bvh::ray::Ray;
+    /// use bvh::Real;
     /// # use bvh::bounding_hierarchy::BHShape;
     /// # pub struct UnitBox {
     /// #     pub id: i32,
@@ -145,7 +147,7 @@ pub trait BoundingHierarchy {
     /// # fn create_bvh() -> (BVH, Vec<UnitBox>) {
     /// #     let mut shapes = Vec::new();
     /// #     for i in 0..1000 {
-    /// #         let position = Point3::new(i as f32, i as f32, i as f32);
+    /// #         let position = Point3::new(i as Real, i as Real, i as Real);
     /// #         shapes.push(UnitBox::new(i, position));
     /// #     }
     /// #     let bvh = BVH::build(&mut shapes);
@@ -163,11 +165,27 @@ pub trait BoundingHierarchy {
     /// [`BoundingHierarchy`]: trait.BoundingHierarchy.html
     /// [`AABB`]: ../aabb/struct.AABB.html
     ///
-    fn traverse<'a, Shape: BHShape>(&'a self, ray: &Ray, shapes: &'a [Shape]) -> Vec<&Shape>;
+    fn traverse<'a, Shape: BHShape>(
+        &'a self,
+        test: &impl IntersectionAABB,
+        shapes: &'a [Shape],
+    ) -> Vec<&Shape>;
 
     /// Prints the [`BoundingHierarchy`] in a tree-like visualization.
     ///
     /// [`BoundingHierarchy`]: trait.BoundingHierarchy.html
     ///
     fn pretty_print(&self) {}
 }
+
+/// This trait can be implemented on anything that can intersect with an `AABB`
+/// Used to traverse the `BVH`
+///
+/// [`AABB`]: ../aabb/struct.AABB.html
+///
+/// [`BVH`]: ../bvh/struct.BVH.html
+///
+pub trait IntersectionAABB {
+    /// Returns true if there is an intersection with the given `AABB`
+    fn intersects_aabb(&self, aabb: &AABB) -> bool;
+}