rocketsim 0.2.4

Simulate Rocket League games at maximum efficiency
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69

use super::{
    triangle_callback::ProcessTriangle, triangle_info_map::TriangleInfoMap,
    triangle_mesh::TriangleMesh, triangle_mesh_shape::TriangleMeshShape,
};
use crate::{
    bullet::collision::{
        dispatch::{
            internal_edge_utility::generate_internal_edge_info,
            tri_bvh_util::{NodeOverlapCallback, QuadRayNodeOverlapCallback},
        },
        shapes::{optimized_bvh::create_bvh, triangle_callback::ProcessQuadRayTriangle},
    },
    shared::{Aabb, QuadRayInfo, bvh::Tree},
};

pub struct BvhTriangleMeshShape {
    bvh: Tree,
    mesh_interface: TriangleMesh,
    triangle_info_map: TriangleInfoMap,
    pub aabb_ident_cache: Aabb,
}

impl BvhTriangleMeshShape {
    pub fn new(mesh_interface: TriangleMesh) -> Self {
        let triangle_mesh_shape = TriangleMeshShape::new(&mesh_interface);

        // pre-calculate the aabb
        let aabb_ident_cache = triangle_mesh_shape.get_ident_aabb();

        let bvh = create_bvh(&mesh_interface, triangle_mesh_shape.local_aabb);
        let triangle_info_map = generate_internal_edge_info(&bvh, &mesh_interface);

        Self {
            bvh,
            mesh_interface,
            triangle_info_map,
            aabb_ident_cache,
        }
    }

    pub const fn get_triangle_info_map(&self) -> &TriangleInfoMap {
        &self.triangle_info_map
    }

    pub const fn get_mesh_interface(&self) -> &TriangleMesh {
        &self.mesh_interface
    }

    pub fn process_all_triangles<T: ProcessTriangle>(&self, callback: &mut T, aabb: &Aabb) {
        let mut my_node_callback = NodeOverlapCallback::new(self.get_mesh_interface(), callback);
        self.bvh
            .report_aabb_overlapping_node(&mut my_node_callback, aabb);
    }

    pub fn check_overlap_with(&self, aabb: &Aabb) -> bool {
        self.bvh.check_overlap_with(aabb)
    }

    pub fn perform_quad_raycast<T: ProcessQuadRayTriangle>(
        &self,
        callback: &mut T,
        ray_info: &mut QuadRayInfo,
    ) {
        let mut my_node_callback =
            QuadRayNodeOverlapCallback::new(self.get_mesh_interface(), callback);
        self.bvh
            .report_quad_ray_overlapping_node(&mut my_node_callback, ray_info);
    }
}