Struct bvh::bvh::Bvh

pub struct Bvh<T: BHValue, const D: usize> {
    pub nodes: Vec<BvhNode<T, D>>,
}

The Bvh data structure. Contains the list of BvhNodes.

Fields

nodes: Vec<BvhNode<T, D>>

The list of nodes of the Bvh.

Implementations

impl<T: BHValue, const D: usize> Bvh<T, D>

pub fn build<Shape: BHShape<T, D>>(shapes: &mut [Shape]) -> Bvh<T, D>

Creates a new Bvh from the shapes slice.

pub fn build_with_executor<Shape: BHShape<T, D>>( shapes: &mut [Shape], executor: impl FnMut(BvhNodeBuildArgs<'_, Shape, T, D>, BvhNodeBuildArgs<'_, Shape, T, D>) ) -> Bvh<T, D>

Creates a new Bvh from the shapes slice. The executor parameter allows you to parallelize the build of the Bvh. Using something like rayon::join. You must call either build or build_with_executor on both arguments in order to succesfully complete the build.

pub fn traverse<'a, Shape: Bounded<T, D>>( &'a self, ray: &Ray<T, D>, shapes: &'a [Shape] ) -> Vec<&Shape>

Traverses the Bvh. Returns a subset of shapes, in which the Aabbs of the elements were hit by ray.

pub fn traverse_iterator<'bvh, 'shape, Shape: Bounded<T, D>>( &'bvh self, ray: &'bvh Ray<T, D>, shapes: &'shape [Shape] ) -> BvhTraverseIterator<'bvh, 'shape, T, D, Shape>

Creates a BvhTraverseIterator to traverse the Bvh. Returns a subset of shapes, in which the Aabbs of the elements were hit by ray.

pub fn pretty_print(&self)

Prints the Bvh in a tree-like visualization.

pub fn is_consistent<Shape: BHShape<T, D>>(&self, shapes: &[Shape]) -> bool

Checks if all children of a node have the correct parent index, and that there is no detached subtree. Also checks if the Aabb hierarchy is consistent.

pub fn assert_consistent<Shape: BHShape<T, D>>(&self, shapes: &[Shape])

where T: Display,

Assert version of is_consistent.

pub fn assert_tight_subtree(&self, node_index: usize, outer_aabb: &Aabb<T, D>)

Check that the Aabbs in the Bvh are tight, which means, that parent Aabbs are not larger than they should be. This function checks, whether the children of node node_index lie inside outer_aabb.

pub fn assert_tight(&self)

Check that the Aabbs in the Bvh are tight, which means, that parent Aabbs are not larger than they should be.

impl<T: BHValue, const D: usize> Bvh<T, D>

pub fn add_shape<Shape: BHShape<T, D>>( &mut self, shapes: &mut [Shape], new_shape_index: usize )

where T: Div<Output = T>,

Adds a shape with the given index to the BVH Significantly slower at building a BVH than the full build or rebuild option Useful for moving a small subset of nodes around in a large BVH

pub fn remove_shape<Shape: BHShape<T, D>>( &mut self, shapes: &mut [Shape], deleted_shape_index: usize, swap_shape: bool )

Removes a shape from the BVH if swap_shape is true, it swaps the shape you are removing with the last shape in the shape slice truncation of the data structure backing the shapes slice must be performed by the user

pub fn update_shapes<'a, Shape: BHShape<T, D>>( &mut self, changed_shape_indices: impl IntoIterator<Item = &'a usize> + Copy, shapes: &mut [Shape] )

Fixes bvh

impl<T: BHValue, const D: usize> Bvh<T, D>

pub fn flatten_custom<F, FNodeType>(&self, constructor: &F) -> Vec<FNodeType>

where F: Fn(&Aabb<T, D>, u32, u32, u32) -> FNodeType,

Flattens the Bvh so that it can be traversed iteratively. Constructs the flat nodes using the supplied function. This function can be used, when the flat bvh nodes should be of some particular non-default structure. The constructor is fed the following arguments in this order:

1 - &Aabb: The enclosing Aabb 2 - u32: The index of the nested node 3 - u32: The exit index 4 - u32: The shape index

Example

use bvh::aabb::{Aabb, Bounded};
use bvh::bvh::Bvh;
use nalgebra::{Point3, Vector3};
use bvh::ray::Ray;

struct CustomStruct {
    aabb: Aabb<f32,3>,
    entry_index: u32,
    exit_index: u32,
    shape_index: u32,
}

let custom_constructor = |aabb: &Aabb<f32,3>, entry, exit, shape_index| {
    CustomStruct {
        aabb: *aabb,
        entry_index: entry,
        exit_index: exit,
        shape_index: shape_index,
    }
};

let mut shapes = create_bhshapes();
let bvh = Bvh::build(&mut shapes);
let custom_flat_bvh = bvh.flatten_custom(&custom_constructor);

pub fn flatten(&self) -> FlatBvh<T, D>

Flattens the Bvh so that it can be traversed iteratively.

Example

use bvh::aabb::{Aabb, Bounded};
use bvh::bvh::Bvh;
use nalgebra::{Point3, Vector3};
use bvh::ray::Ray;

let mut shapes = create_bhshapes();
let bvh = Bvh::build(&mut shapes);
let flat_bvh = bvh.flatten();

Trait Implementations

impl<T: BHValue + Display, const D: usize> BoundingHierarchy<T, D> for Bvh<T, D>

fn build<Shape: BHShape<T, D>>(shapes: &mut [Shape]) -> Bvh<T, D>

Creates a new BoundingHierarchy from the shapes slice.

fn traverse<'a, Shape: Bounded<T, D>>( &'a self, ray: &Ray<T, D>, shapes: &'a [Shape] ) -> Vec<&Shape>

Traverses the BoundingHierarchy. Returns a subset of shapes, in which the Aabbs of the elements were hit by ray.

fn pretty_print(&self)

Prints the BoundingHierarchy in a tree-like visualization.

fn build_with_executor<Shape: BHShape<T, D>, Executor: FnMut(BvhNodeBuildArgs<'_, Shape, T, D>, BvhNodeBuildArgs<'_, Shape, T, D>)>( shapes: &mut [Shape], executor: Executor ) -> Self

Builds the bvh with a custom executor.

impl<T: Clone + BHValue, const D: usize> Clone for Bvh<T, D>

fn clone(&self) -> Bvh<T, D>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T: Debug + BHValue, const D: usize> Debug for Bvh<T, D>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.