Struct Bvh2Converter 

pub struct Bvh2Converter<'a> {
    pub bvh2: &'a Bvh2,
    pub nodes: Vec<CwBvhNode>,
    pub primitive_indices: Vec<u32>,
    pub decisions: Vec<Decision>,
    pub order_children_during_build: bool,
    pub include_exact_node_aabbs: bool,
    pub exact_node_aabbs: Option<Vec<Aabb>>,
    /* private fields */
}

Convert a bvh2 to CwBvh

Fields

bvh2: &'a Bvh2

nodes: Vec<CwBvhNode>

primitive_indices: Vec<u32>

decisions: Vec<Decision>

order_children_during_build: bool

include_exact_node_aabbs: bool

exact_node_aabbs: Option<Vec<Aabb>>

Implementations

impl<'a> Bvh2Converter<'a>

pub fn new( bvh2: &'a Bvh2, order_children: bool, include_exact_node_aabbs: bool, ) -> Self

Initialize the Bvh2 to CwBvh converter.

pub fn convert_to_cwbvh(&mut self)

Convert the bvh2 to CwBvh

pub fn convert_to_cwbvh_impl( &mut self, node_index_bvh8: usize, node_index_bvh2: usize, )

pub fn calculate_cost(&mut self, max_prims_per_leaf: u32)

Fill cost table for bvh2 -> bvh8 conversion

pub fn calculate_cost_impl( &mut self, node_index: usize, max_prims_per_leaf: u32, _current_depth: i32, ) -> u32

pub fn get_children( &mut self, node_index: usize, children: &mut [u32; 8], child_count: &mut u32, i: usize, )

pub fn order_children( &mut self, node_index: usize, children: &mut [u32; 8], child_count: usize, )

Arrange child nodes in Morton order according to their centroids so that the order in which the intersected children are traversed can be determined by the ray octant.