Crate obvhs 

BVH Construction and Traversal Library

• PLOC BVH2 builder with Parallel Reinsertion and spatial pre-splits.
• CWBVH An eight-way compressed wide BVH8 builder. Each BVH Node is compressed so that it takes up only 80 bytes per node.
• Tools for dynamically updating and optimizing the BVH2. (Added in 0.3)
• CPU traversal for both BVH2 and CWBVH (SIMD traversal, intersecting 4 nodes at a time)
• For GPU traversal example, see the Tray Racing benchmark

OBVHS optionally uses rayon to parallelize building.

Example

use glam::*;
use obvhs::{
    cwbvh::builder::build_cwbvh_from_tris,
    ray::{Ray, RayHit},
    test_util::geometry::{icosphere, PLANE},
    triangle::Triangle,
    BvhBuildParams,
};
use std::time::Duration;


// Build a scene with an icosphere and a plane
// BVH primitives do not need to be triangles, the BVH builder is only concerned with AABBs.
// (With the exception of optional precise triangle aabb splitting)
let mut tris: Vec<Triangle> = Vec::new();
tris.extend(icosphere(1));
tris.extend(PLANE);

// Build the BVH.
// build_cwbvh_from_tris is just a helper that can build from BvhBuildParams and the
// respective presets. Feel free to copy the contents of build_cwbvh_from_tris or
// build_cwbvh. They are very straightforward. If you don't want to use Triangles as the
// primitive, use  build_cwbvh instead. build_cwbvh_from_tris just adds support for
// splitting tris.
let bvh = build_cwbvh_from_tris(
    &tris,
    BvhBuildParams::medium_build(),
    &mut Duration::default(),
);

// Create a new ray
let ray = Ray::new_inf(vec3a(0.1, 0.1, 4.0), vec3a(0.0, 0.0, -1.0));

// Traverse the BVH, finding the closest hit.
let mut ray_hit = RayHit::none();
if bvh.ray_traverse(ray, &mut ray_hit, |ray, id| {
    // Use primitive_indices to look up the original primitive id.
    // (Could reorder tris per bvh.primitive_indices to avoid this lookup, see
    // cornell_box_cwbvh example)
    tris[bvh.primitive_indices[id] as usize].intersect(ray)
}) {
    println!(
        "Hit Triangle {}",
        bvh.primitive_indices[ray_hit.primitive_id as usize]
    );
    println!("Distance to hit: {}", ray_hit.t);
} else {
    println!("Miss");
}

Modules

aabb

An Axis-Aligned Bounding Box (AABB) represented by its minimum and maximum points.

bvh2

A binary BVH

cwbvh

An eight-way compressed wide BVH8 builder.

faststack

Stack data structures implemented on the stack or heap

ploc

PLOC (Parallel, Locally Ordered Clustering) BVH 2 Builder.

ray

A ray in 3D space.

rt_triangle

Triangle types optimized for ray intersection performance.

splits

Split large triangles into multiple smaller Aabbs.

test_util

Meshes, generators, sampling functions, etc.. for basic testing & examples.

triangle

Triangle representation in 3D space.

Macros

fast_stack

Creates a stack- or heap-allocated stack based on runtime size.

traverse

Traverse a CwBvh with custom node and primitive intersections. I really didn’t want to use a macro but it seems like everything else using closures/yielding is slower given both generic node and primitive traversal.

Structs

BvhBuildParams

General build parameters for Bvh2 & CwBvh

Traits

Boundable

A trait for types that can be bounded by an axis-aligned bounding box (AABB). Used in Bvh2/CwBvh validation.

Transformable

A trait for types that can have a matrix transform applied. Primarily for testing/examples.