forked from StrafesNET/strafe-client
120 lines
3.0 KiB
Rust
120 lines
3.0 KiB
Rust
use crate::aabb::Aabb;
|
|
|
|
//da algaritum
|
|
//lista boxens
|
|
//sort by {minx,maxx,miny,maxy,minz,maxz} (6 lists)
|
|
//find the sets that minimizes the sum of surface areas
|
|
//splitting is done when the minimum split sum of surface areas is larger than the node's own surface area
|
|
|
|
//start with bisection into octrees because a bad bvh is still 1000x better than no bvh
|
|
//sort the centerpoints on each axis (3 lists)
|
|
//bv is put into octant based on whether it is upper or lower in each list
|
|
enum BvhNodeContent{
|
|
Branch(Vec<BvhNode>),
|
|
Leaf(usize),
|
|
}
|
|
impl Default for BvhNodeContent{
|
|
fn default()->Self{
|
|
Self::Branch(Vec::new())
|
|
}
|
|
}
|
|
#[derive(Default)]
|
|
pub struct BvhNode{
|
|
content:BvhNodeContent,
|
|
aabb:Aabb,
|
|
}
|
|
|
|
impl BvhNode{
|
|
pub fn the_tester<F:FnMut(usize)>(&self,aabb:&Aabb,f:&mut F){
|
|
match &self.content{
|
|
&BvhNodeContent::Leaf(model)=>f(model),
|
|
BvhNodeContent::Branch(children)=>for child in children{
|
|
if aabb.intersects(&child.aabb){
|
|
child.the_tester(aabb,f);
|
|
}
|
|
},
|
|
}
|
|
}
|
|
}
|
|
|
|
pub fn generate_bvh(boxen:Vec<Aabb>)->BvhNode{
|
|
generate_bvh_node(boxen.into_iter().enumerate().collect())
|
|
}
|
|
|
|
fn generate_bvh_node(boxen:Vec<(usize,Aabb)>)->BvhNode{
|
|
let n=boxen.len();
|
|
if n<20{
|
|
let mut aabb=Aabb::default();
|
|
let nodes=boxen.into_iter().map(|b|{
|
|
aabb.join(&b.1);
|
|
BvhNode{
|
|
content:BvhNodeContent::Leaf(b.0),
|
|
aabb:b.1,
|
|
}
|
|
}).collect();
|
|
BvhNode{
|
|
content:BvhNodeContent::Branch(nodes),
|
|
aabb,
|
|
}
|
|
}else{
|
|
let mut octant=std::collections::HashMap::with_capacity(n);//this ids which octant the boxen is put in
|
|
let mut sort_x=Vec::with_capacity(n);
|
|
let mut sort_y=Vec::with_capacity(n);
|
|
let mut sort_z=Vec::with_capacity(n);
|
|
for (i,aabb) in boxen.iter(){
|
|
let center=aabb.center();
|
|
octant.insert(*i,0);
|
|
sort_x.push((*i,center.x()));
|
|
sort_y.push((*i,center.y()));
|
|
sort_z.push((*i,center.z()));
|
|
}
|
|
sort_x.sort_by(|tup0,tup1|tup0.1.partial_cmp(&tup1.1).unwrap());
|
|
sort_y.sort_by(|tup0,tup1|tup0.1.partial_cmp(&tup1.1).unwrap());
|
|
sort_z.sort_by(|tup0,tup1|tup0.1.partial_cmp(&tup1.1).unwrap());
|
|
let h=n/2;
|
|
let median_x=sort_x[h].1;
|
|
let median_y=sort_y[h].1;
|
|
let median_z=sort_z[h].1;
|
|
for (i,c) in sort_x{
|
|
if median_x<c{
|
|
octant.insert(i,octant[&i]+1<<0);
|
|
}
|
|
}
|
|
for (i,c) in sort_y{
|
|
if median_y<c{
|
|
octant.insert(i,octant[&i]+1<<1);
|
|
}
|
|
}
|
|
for (i,c) in sort_z{
|
|
if median_z<c{
|
|
octant.insert(i,octant[&i]+1<<2);
|
|
}
|
|
}
|
|
//generate lists for unique octant values
|
|
let mut list_list=Vec::with_capacity(8);
|
|
let mut octant_list=Vec::with_capacity(8);
|
|
for (i,aabb) in boxen.into_iter(){
|
|
let octant_id=octant[&i];
|
|
let list_id=if let Some(list_id)=octant_list.iter().position(|&id|id==octant_id){
|
|
list_id
|
|
}else{
|
|
let list_id=list_list.len();
|
|
octant_list.push(octant_id);
|
|
list_list.push(Vec::new());
|
|
list_id
|
|
};
|
|
list_list[list_id].push((i,aabb));
|
|
}
|
|
let mut aabb=Aabb::default();
|
|
let children=list_list.into_iter().map(|b|{
|
|
let node=generate_bvh_node(b);
|
|
aabb.join(&node.aabb);
|
|
node
|
|
}).collect();
|
|
BvhNode{
|
|
content:BvhNodeContent::Branch(children),
|
|
aabb,
|
|
}
|
|
}
|
|
}
|