rocketsim 0.2.0

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

use glam::Vec4;

use crate::{
    bullet::collision::shapes::{
        triangle_callback::{ProcessQuadRayTriangle, ProcessTriangle},
        triangle_mesh::TriangleMesh,
        triangle_shape::TriangleShape,
    },
    shared::bvh::{ProcessNode, ProcessQuadRayNode},
};

pub struct NodeOverlapCallback<'a, T: ProcessTriangle> {
    tris: &'a [TriangleShape],
    callback: &'a mut T,
}

impl<'a, T: ProcessTriangle> NodeOverlapCallback<'a, T> {
    pub fn new(mesh_interface: &'a TriangleMesh, callback: &'a mut T) -> Self {
        Self {
            tris: mesh_interface.get_tris(),
            callback,
        }
    }
}

impl<T: ProcessTriangle> ProcessNode for NodeOverlapCallback<'_, T> {
    fn process_node(&mut self, node_triangle_idx: usize) {
        self.callback
            .process_triangle(&self.tris[node_triangle_idx], node_triangle_idx);
    }
}

pub struct QuadRayNodeOverlapCallback<'a, T: ProcessQuadRayTriangle> {
    tris: &'a [TriangleShape],
    callback: &'a mut T,
}

impl<'a, T: ProcessQuadRayTriangle> QuadRayNodeOverlapCallback<'a, T> {
    pub fn new(mesh_interface: &'a TriangleMesh, callback: &'a mut T) -> Self {
        Self {
            tris: mesh_interface.get_tris(),
            callback,
        }
    }
}

impl<T: ProcessQuadRayTriangle> ProcessQuadRayNode for QuadRayNodeOverlapCallback<'_, T> {
    fn process_node(&mut self, triangle_idx: usize, active_mask: u8, lambda_max: &mut Vec4) {
        self.callback
            .process_node(&self.tris[triangle_idx], active_mask, lambda_max);
    }
}