shura 0.6.0

A fast cross-plattform 2D component-based game framework
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

use crate::{Isometry, Vector, Vertex};

#[derive(Debug, Clone, Copy)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
/// Simple Axis-aligned minimum bounding box collision detection
pub struct AABB {
    pub min: Vector<f32>,
    pub max: Vector<f32>,
}

impl AABB {
    pub const fn new(min: Vector<f32>, max: Vector<f32>) -> Self {
        Self { min, max }
    }

    pub fn center(&self) -> Vector<f32> {
        (self.min + self.max) / 2.0
    }

    pub fn half_extents(&self) -> Vector<f32> {
        (self.max - self.min) / 2.0
    }

    pub fn dim(&self) -> Vector<f32> {
        self.max - self.min
    }

    pub fn from_center(center: Vector<f32>, half_extents: Vector<f32>) -> Self {
        let min = center - half_extents;
        let max = center + half_extents;
        Self::new(min, max)
    }

    pub fn from_vertices(vertices: &[Vertex]) -> Self {
        let mut min_x = vertices[0].pos.x;
        let mut max_x = vertices[0].pos.x;
        let mut min_y = vertices[0].pos.y;
        let mut max_y = vertices[0].pos.y;
        for i in 1..vertices.len() {
            let v = vertices[i];
            if v.pos.x < min_x {
                min_x = v.pos.x;
            }
            if v.pos.x > max_x {
                max_x = v.pos.x;
            }

            if v.pos.y < min_y {
                min_y = v.pos.y;
            }
            if v.pos.y > max_y {
                max_y = v.pos.y;
            }
        }

        return Self {
            min: Vector::new(min_x, min_y),
            max: Vector::new(max_x, max_y),
        };
    }

    pub fn with_translation(&self, translation: Vector<f32>) -> Self {
        let mut model_aabb = self.clone();
        model_aabb.min += translation;
        model_aabb.max += translation;
        return model_aabb;
    }

    pub fn with_position(&self, position: Isometry<f32>) -> Self {
        let mut model_aabb = self.clone();
        model_aabb.min += position.translation.vector;
        model_aabb.max += position.translation.vector;

        if position.rotation.angle() != 0.0 {
            let delta = model_aabb.min - position.translation.vector;
            model_aabb.min = position.translation.vector + position.rotation * delta;

            let delta = model_aabb.max - position.translation.vector;
            model_aabb.max = position.translation.vector + position.rotation * delta;

            let mut xs = [
                model_aabb.min.x,
                model_aabb.min.x,
                model_aabb.max.x,
                model_aabb.max.x,
            ];
            xs.sort_by(|a, b| a.partial_cmp(b).unwrap());
            let mut ys = [
                model_aabb.min.y,
                model_aabb.min.y,
                model_aabb.max.y,
                model_aabb.max.y,
            ];
            ys.sort_by(|a, b| a.partial_cmp(b).unwrap());

            model_aabb.min = Vector::new(*xs.first().unwrap(), *ys.first().unwrap());
            model_aabb.max = Vector::new(*xs.last().unwrap(), *ys.last().unwrap());
        }

        return model_aabb;
    }

    pub fn contains_point(&self, point: &Vector<f32>) -> bool {
        point.x >= self.min.x
            && point.x <= self.max.x
            && point.y >= self.min.y
            && point.y <= self.max.y
    }

    pub fn intersects(&self, other: &AABB) -> bool {
        self.min.x <= other.max.x
            && self.max.x >= other.min.x
            && self.min.y <= other.max.y
            && self.max.y >= other.min.y
    }
}