Enum BvhBuildStrategy

pub enum BvhBuildStrategy {
    Binned,
    Ploc,
}

The strategy for one-time build of the BVH tree.

This enum controls which algorithm is used when constructing a BVH from scratch. Different strategies offer different trade-offs between construction speed and final tree quality (measured by ray-casting performance and other query efficiency).

Strategy Comparison

• Binned: Fast construction with good overall quality. Best for general-purpose use.
• PLOC: Slower construction but produces higher quality trees. Best when ray-casting performance is critical and construction time is less important.

Performance Notes

• Neither strategy is currently parallelized, though PLOC is designed to support parallelization.
• Tree quality affects query performance: better trees mean fewer node visits during traversals.
• For dynamic scenes with frequent updates, choose based on initial construction performance.

Example

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

// Create some AABBs for objects in the scene
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(0.0, 2.0, 0.0), Point3::new(1.0, 3.0, 1.0)),
];

// Use binned strategy for general purpose (default)
let bvh_binned = Bvh::from_leaves(BvhBuildStrategy::Binned, &aabbs);
assert_eq!(bvh_binned.leaf_count(), 3);

// Use PLOC strategy for ray-casting heavy applications
let bvh_ploc = Bvh::from_leaves(BvhBuildStrategy::Ploc, &aabbs);
assert_eq!(bvh_ploc.leaf_count(), 3);

See Also

• Bvh::from_leaves - Construct a BVH using a specific strategy
• Bvh::from_iter - Construct a BVH from an iterator

Variants

Binned

The tree is built using the binned strategy.

This implements the strategy from “On fast Construction of SAH-based Bounding Volume Hierarchies” by Ingo Wald. It uses binning to quickly approximate the Surface Area Heuristic (SAH) cost function, resulting in fast construction times with good tree quality.

Recommended for: General-purpose usage, dynamic scenes, initial prototyping.

Ploc

The tree is built using the Locally-Ordered Clustering technique.

This implements the strategy from “Parallel Locally-Ordered Clustering for Bounding Volume Hierarchy Construction” by Meister and Bittner. It produces higher quality trees at the cost of slower construction. The algorithm is designed for parallelization but the current implementation is sequential.

Recommended for: Ray-casting heavy workloads, static scenes, when query performance is more important than construction time.

Trait Implementations

impl Clone for BvhBuildStrategy

fn clone(&self) -> BvhBuildStrategy

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for BvhBuildStrategy

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

Formats the value using the given formatter.

impl Default for BvhBuildStrategy

fn default() -> BvhBuildStrategy

Returns the “default value” for a type.

impl PartialEq for BvhBuildStrategy

fn eq(&self, other: &BvhBuildStrategy) -> 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 BvhBuildStrategy

impl Eq for BvhBuildStrategy

impl StructuralPartialEq for BvhBuildStrategy