Struct BvhNodeIndex

pub struct BvhNodeIndex(pub usize);

An index identifying a single BVH tree node.

The BVH stores nodes in pairs (BvhNodeWide), where each pair contains a left and right child. This index encodes both which pair and which side (left or right) in a single usize value for efficient storage and manipulation.

Encoding

The index is encoded as: (wide_node_index << 1) | is_right

• The upper bits identify the BvhNodeWide (pair of nodes)
• The lowest bit indicates left (0) or right (1)

Example

use parry3d::partitioning::BvhNodeIndex;

// Create indices for the left and right children of node pair 5
let left = BvhNodeIndex::left(5);
let right = BvhNodeIndex::right(5);

assert_eq!(left.sibling(), right);
assert_eq!(right.sibling(), left);

// Decompose to get the pair index and side
let (pair_idx, is_right) = left.decompose();
assert_eq!(pair_idx, 5);
assert_eq!(is_right, false);

See Also

• BvhNodeWide - The pair of nodes this index points into
• Bvh - The main BVH structure

Tuple Fields

0: usize

Implementations

impl BvhNodeIndex

pub fn decompose(self) -> (usize, bool)

Decomposes this index into its components.

Returns a tuple of (wide_node_index, is_right) where:

• wide_node_index is the index into the BVH’s array of BvhNodeWide pairs
• is_right is false for left child, true for right child

Returns

A tuple (usize, bool) containing the pair index and side flag.

Example

use parry3d::partitioning::BvhNodeIndex;

let left = BvhNodeIndex::left(10);
let (pair_idx, is_right) = left.decompose();

assert_eq!(pair_idx, 10);
assert_eq!(is_right, false);

See Also

• new - Construct from components

pub fn sibling(self) -> Self

Returns the sibling of this node.

If this index points to the left child of a pair, returns the right child. If this index points to the right child, returns the left child.

Returns

The BvhNodeIndex of the sibling node.

Example

use parry3d::partitioning::BvhNodeIndex;

let left = BvhNodeIndex::left(5);
let right = BvhNodeIndex::right(5);

assert_eq!(left.sibling(), right);
assert_eq!(right.sibling(), left);

pub fn left(id: u32) -> Self

Creates an index for the left child of a node pair.

Arguments

• id - The index of the BvhNodeWide pair in the BVH’s node array

Returns

A BvhNodeIndex pointing to the left child of the specified pair.

Example

use parry3d::partitioning::BvhNodeIndex;

let left_child = BvhNodeIndex::left(0);
let (pair_idx, is_right) = left_child.decompose();

assert_eq!(pair_idx, 0);
assert_eq!(is_right, false);

See Also

• right - Create index for right child
• new - Create index with explicit side

pub fn right(id: u32) -> Self

Creates an index for the right child of a node pair.

Arguments

• id - The index of the BvhNodeWide pair in the BVH’s node array

Returns

A BvhNodeIndex pointing to the right child of the specified pair.

Example

use parry3d::partitioning::BvhNodeIndex;

let right_child = BvhNodeIndex::right(0);
let (pair_idx, is_right) = right_child.decompose();

assert_eq!(pair_idx, 0);
assert_eq!(is_right, true);

See Also

• left - Create index for left child
• new - Create index with explicit side

pub fn new(id: u32, is_right: bool) -> Self

Creates a new node index from a pair ID and side flag.

Arguments

• id - The index of the BvhNodeWide pair in the BVH’s node array
• is_right - false for left child, true for right child

Returns

A BvhNodeIndex encoding both the pair and the side.

Example

use parry3d::partitioning::BvhNodeIndex;

let left = BvhNodeIndex::new(3, false);
let right = BvhNodeIndex::new(3, true);

assert_eq!(left, BvhNodeIndex::left(3));
assert_eq!(right, BvhNodeIndex::right(3));

See Also

• left - Convenience method for left child
• right - Convenience method for right child

Trait Implementations

impl Clone for BvhNodeIndex

fn clone(&self) -> BvhNodeIndex

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for BvhNodeIndex

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

Formats the value using the given formatter.

impl Default for BvhNodeIndex

fn default() -> BvhNodeIndex

Returns the “default value” for a type.

impl PartialEq for BvhNodeIndex

fn eq(&self, other: &BvhNodeIndex) -> bool

Tests for self and other values to be equal, and is used by ==.

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

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

impl Copy for BvhNodeIndex

impl Eq for BvhNodeIndex

impl StructuralPartialEq for BvhNodeIndex