Struct BvhNodeWide

#[repr(C, align(64))]
pub struct BvhNodeWide { /* private fields */ }

A pair of tree nodes forming a 2-wide BVH node.

The BVH uses a memory layout where nodes are stored in pairs (left and right children) to improve cache coherency and enable SIMD optimizations. This structure represents a single entry in the BVH’s node array.

Node Validity

Both left and right are guaranteed to be valid except for one special case:

• Single leaf tree: Only left is valid, right is zeroed
• All other cases: Both left and right are valid (tree has at least 2 leaves)

Memory Layout

In 3D with f32 precision and SIMD enabled, this structure is:

• Size: 64 bytes (cache line aligned)
• Alignment: 64 bytes (matches typical CPU cache lines)
• This alignment improves performance by reducing cache misses

Example

use parry3d::partitioning::{Bvh, BvhBuildStrategy};
use parry3d::bounding_volume::Aabb;
use nalgebra::Point3;

let aabbs = vec![
    Aabb::new(Point3::origin(), Point3::new(1.0, 1.0, 1.0)),
    Aabb::new(Point3::new(2.0, 0.0, 0.0), Point3::new(3.0, 1.0, 1.0)),
    Aabb::new(Point3::new(4.0, 0.0, 0.0), Point3::new(5.0, 1.0, 1.0)),
];

let bvh = Bvh::from_leaves(BvhBuildStrategy::default(), &aabbs);

// Access the root node's children
// The BVH stores nodes as BvhNodeWide pairs internally
assert_eq!(bvh.leaf_count(), 3);

See Also

• BvhNode - Individual node in the pair
• Bvh - The main BVH structure

Implementations

impl BvhNodeWide

pub fn zeros() -> Self

Creates a new BvhNodeWide with both children zeroed out.

This is primarily used internally during BVH construction and should rarely be needed in user code.

Example

use parry3d::partitioning::BvhNodeWide;

let node_wide = BvhNodeWide::zeros();
assert_eq!(node_wide.leaf_count(), 0);

pub fn as_array(&self) -> [&BvhNode; 2]

Returns the two nodes as an array of references.

This is useful for accessing the left or right node by index (0 or 1 respectively) instead of by name. Index 0 is the left node, index 1 is the right node.

Example

use parry3d::partitioning::{Bvh, BvhBuildStrategy};
use parry3d::bounding_volume::{Aabb, BoundingVolume};
use nalgebra::Point3;

let aabbs = vec![
    Aabb::new(Point3::origin(), Point3::new(1.0, 1.0, 1.0)),
    Aabb::new(Point3::new(2.0, 0.0, 0.0), Point3::new(3.0, 1.0, 1.0)),
];

let bvh = Bvh::from_leaves(BvhBuildStrategy::default(), &aabbs);
// The root AABB should contain both leaves
assert!(bvh.root_aabb().contains(&aabbs[0]));
assert!(bvh.root_aabb().contains(&aabbs[1]));

See Also

• as_array_mut - Mutable version

pub fn as_array_mut(&mut self) -> [&mut BvhNode; 2]

Returns the two nodes as an array of mutable references.

This is useful for modifying the left or right node by index (0 or 1 respectively) instead of by name. Index 0 is the left node, index 1 is the right node.

Example

use parry3d::partitioning::BvhNodeWide;
use nalgebra::Vector3;

let mut node_wide = BvhNodeWide::zeros();
let nodes = node_wide.as_array_mut();

// Scale both nodes by 2.0
let scale = Vector3::new(2.0, 2.0, 2.0);
nodes[0].scale(&scale);
nodes[1].scale(&scale);

See Also

• as_array - Immutable version

pub fn merged(&self, my_id: u32) -> BvhNode

Merges both child nodes to create their parent node.

The parent’s AABB will be the union of both children’s AABBs, and the parent’s leaf count will be the sum of both children’s leaf counts. The my_id parameter becomes the parent’s children field, pointing back to this BvhNodeWide.

Arguments

• my_id - The index of this BvhNodeWide in the BVH’s node array

Returns

A new BvhNode representing the parent of both children.

pub fn leaf_count(&self) -> u32

Returns the total number of leaves contained in both child nodes.

This is the sum of the leaf counts of the left and right children. For leaf nodes, the count is 1. For internal nodes, it’s the sum of their descendants.

Returns

The total number of leaves in the subtrees rooted at both children.

Trait Implementations

impl Clone for BvhNodeWide

fn clone(&self) -> BvhNodeWide

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for BvhNodeWide

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

Formats the value using the given formatter.

impl Copy for BvhNodeWide