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
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120

use glam::{U16Vec3, Vec3A};

use super::{triangle_mesh::TriangleMesh, triangle_shape::TriangleShape};
use crate::shared::{
    Aabb,
    bvh::{BvhNodeType, Node, Tree},
};

struct BvhQuantization {
    min: Vec3A,
    max: Vec3A,
    scale: Vec3A,
}

impl BvhQuantization {
    fn new(aabb: Aabb) -> Self {
        const MARGIN: f32 = 1.0;
        const QUANTIZED_RANGE: f32 = 65533.0;

        let margin = Vec3A::splat(MARGIN);
        let mut result = Self {
            min: aabb.min - margin,
            max: aabb.max + margin,
            scale: Vec3A::ZERO,
        };
        result.update_scale(QUANTIZED_RANGE);

        let quantized_min = result.quantize_point(result.min, false);
        let unquantized_min = result.unquantize_point(quantized_min);
        result.min = result.min.min(unquantized_min - margin);

        let quantized_max = result.quantize_point(result.max, true);
        let unquantized_max = result.unquantize_point(quantized_max);
        result.max = result.max.max(unquantized_max + margin);
        result.update_scale(QUANTIZED_RANGE);

        result
    }

    fn update_scale(&mut self, quantized_range: f32) {
        self.scale = Vec3A::splat(quantized_range) / (self.max - self.min);
    }

    fn quantize_point(&self, point: Vec3A, is_max: bool) -> U16Vec3 {
        let value = (point - self.min) * self.scale;
        let mut result = U16Vec3::ZERO;
        for axis in 0..3 {
            result[axis] = if is_max {
                ((value[axis] + 1.0) as i32 as u16) | 1
            } else {
                (value[axis] as i32 as u16) & 0xfffe
            };
        }
        result
    }

    fn unquantize_point(&self, point: U16Vec3) -> Vec3A {
        point.as_vec3a() / self.scale + self.min
    }

    fn quantize_aabb(&self, aabb: Aabb) -> Aabb {
        Aabb {
            min: self.unquantize_point(self.quantize_point(aabb.min, false)),
            max: self.unquantize_point(self.quantize_point(aabb.max, true)),
        }
    }
}

fn update_triangle_aabb(triangle: &TriangleShape) -> Aabb {
    const MIN_AABB_DIMENSION: f32 = 0.002;
    const MIN_AABB_HALF_DIMENSION: f32 = MIN_AABB_DIMENSION / 2.0;

    let mut aabb = triangle.aabb();
    let diff = (aabb.max - aabb.min).cmplt(Vec3A::splat(MIN_AABB_DIMENSION));
    if diff.any() {
        let [x, y, z] = diff.into();

        if x {
            aabb.max.x += MIN_AABB_HALF_DIMENSION;
            aabb.min.x -= MIN_AABB_HALF_DIMENSION;
        }

        if y {
            aabb.max.y += MIN_AABB_HALF_DIMENSION;
            aabb.min.y -= MIN_AABB_HALF_DIMENSION;
        }

        if z {
            aabb.max.z += MIN_AABB_HALF_DIMENSION;
            aabb.min.z -= MIN_AABB_HALF_DIMENSION;
        }
    }

    aabb
}

pub fn create_bvh(triangles: &TriangleMesh, aabb: Aabb) -> Tree {
    let quantization = BvhQuantization::new(aabb);
    let mut leaf_nodes: Vec<_> = triangles
        .get_tris()
        .iter()
        .map(update_triangle_aabb)
        .map(|triangle_aabb| quantization.quantize_aabb(triangle_aabb))
        .enumerate()
        .map(|(triangle_idx, aabb)| Node {
            aabb,
            node_type: BvhNodeType::Leaf {
                leaf_idx: triangle_idx,
            },
        })
        .collect();

    let tree_aabb = leaf_nodes
        .iter()
        .skip(1)
        .fold(leaf_nodes[0].aabb, |bounds, leaf| {
            bounds.combine(&leaf.aabb)
        });
    Tree::build_bullet(tree_aabb, &mut leaf_nodes)
}