Enum bvh::bvh::BvhNode

pub enum BvhNode<T: BHValue, const D: usize> {
    Leaf {
        parent_index: usize,
        shape_index: usize,
    },
    Node {
        parent_index: usize,
        child_l_index: usize,
        child_l_aabb: Aabb<T, D>,
        child_r_index: usize,
        child_r_aabb: Aabb<T, D>,
    },
}

The BvhNode enum that describes a node in a Bvh. It’s either a leaf node and references a shape (by holding its index) or a regular node that has two child nodes. The non-leaf node stores the Aabbs of its children.

Variants

Leaf

Fields

parent_index: usize

The node’s parent.

shape_index: usize

The shape contained in this leaf.

Leaf node.

Node

Fields

parent_index: usize

The node’s parent.

child_l_index: usize

Index of the left subtree’s root node.

child_l_aabb: Aabb<T, D>

The convex hull of the shapes’ Aabb’s in child_l.

child_r_index: usize

Index of the right subtree’s root node.

child_r_aabb: Aabb<T, D>

The convex hull of the shapes’ Aabb’s in child_r.

Inner node.

Implementations

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

pub fn build<S: BHShape<T, D>>(args: BvhNodeBuildArgs<'_, S, T, D>)

Builds a BvhNode recursively using SAH partitioning.

pub fn build_with_executor<S: BHShape<T, D>>( args: BvhNodeBuildArgs<'_, S, T, D>, executor: impl FnMut(BvhNodeBuildArgs<'_, S, T, D>, BvhNodeBuildArgs<'_, S, T, D>) )

Builds a BvhNode with a custom executor function using SAH partitioning.

pub fn traverse_recursive( nodes: &[BvhNode<T, D>], node_index: usize, ray: &Ray<T, D>, indices: &mut Vec<usize> )

Traverses the Bvh recursively and returns all shapes whose Aabb is intersected by the given Ray.

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

pub fn parent(&self) -> usize

Returns the index of the parent node.

pub fn parent_mut(&mut self) -> &mut usize

Returns a mutable reference to the parent node index.

pub fn child_l(&self) -> usize

Returns the index of the left child node.

pub fn child_l_mut(&mut self) -> &mut usize

Returns the index of the left child node.

pub fn child_l_aabb(&self) -> Aabb<T, D>

Returns the Aabb of the right child node.

pub fn child_l_aabb_mut(&mut self) -> &mut Aabb<T, D>

Returns a mutable reference to the Aabb of the left child node.

pub fn child_r(&self) -> usize

Returns the index of the right child node.

pub fn child_r_mut(&mut self) -> &mut usize

Returns the index of the right child node.

pub fn child_r_aabb(&self) -> Aabb<T, D>

Returns the Aabb of the right child node.

pub fn child_r_aabb_mut(&mut self) -> &mut Aabb<T, D>

Returns a mutable reference to the Aabb of the right child node.

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

Gets the Aabb for a BvhNode. Returns the shape’s Aabb for leaves, and the joined Aabb of the two children’s Aabb’s for non-leaves.

pub fn shape_index(&self) -> Option<usize>

Returns the index of the shape contained within the node if is a leaf, or None if it is an interior node.

pub fn shape_index_mut(&mut self) -> Option<&mut usize>

Returns the index of the shape contained within the node if is a leaf, or None if it is an interior node.

impl<T: BHValue + Float, const D: usize> BvhNode<T, D>

pub fn flatten_custom<F, FNodeType>( &self, nodes: &[BvhNode<T, D>], vec: &mut Vec<FNodeType>, next_free: usize, constructor: &F ) -> usize

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

Flattens the Bvh, so that it can be traversed in an iterative manner. This method constructs custom flat nodes using the constructor.

Trait Implementations

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

fn clone(&self) -> BvhNode<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 BvhNode<T, D>

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

Formats the value using the given formatter.

impl<T: BHValue, const D: usize> PartialEq for BvhNode<T, D>

fn eq(&self, other: &BvhNode<T, D>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T: Copy + BHValue, const D: usize> Copy for BvhNode<T, D>