thomas 0.2.4

An ECS game engine.
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

/// Where the UI element is anchored on the screen. The anchor represents where the element is positioned by default
/// when it has no offset.
#[derive(PartialEq, Eq, Debug, Hash)]
pub enum UiAnchor {
    TopLeft,
    MiddleTop,
    TopRight,
    MiddleRight,
    BottomRight,
    MiddleBottom,
    BottomLeft,
    MiddleLeft,
    Middle,
}

#[derive(PartialEq, Eq, Debug)]
pub enum Alignment {
    Left,
    Middle,
    Right,
}

/// Represents an RGB color.
#[derive(Debug, Copy, Clone, PartialEq, Eq)]
pub struct Rgb(pub u8, pub u8, pub u8);
impl Rgb {
    /// The red value of the color.
    pub fn r(&self) -> u8 {
        self.0
    }

    /// The green value of the color.
    pub fn g(&self) -> u8 {
        self.1
    }

    /// The blue value of the color.
    pub fn b(&self) -> u8 {
        self.2
    }

    pub fn white() -> Self {
        Self(255, 255, 255)
    }

    pub fn black() -> Self {
        Self(0, 0, 0)
    }

    pub fn red() -> Self {
        Self(255, 0, 0)
    }

    pub fn green() -> Self {
        Self(0, 255, 0)
    }

    pub fn blue() -> Self {
        Self(0, 0, 255)
    }

    pub fn cyan() -> Self {
        Self(0, 255, 255)
    }

    pub fn magenta() -> Self {
        Self(255, 0, 255)
    }

    pub fn yellow() -> Self {
        Self(255, 255, 0)
    }
}
impl Lerp for Rgb {
    type Item = Rgb;

    fn lerp(start: &Self::Item, target: &Self::Item, interpolation_ratio: f32) -> Self::Item {
        Rgb(
            u8::lerp(&start.r(), &target.r(), interpolation_ratio),
            u8::lerp(&start.g(), &target.g(), interpolation_ratio),
            u8::lerp(&start.b(), &target.b(), interpolation_ratio),
        )
    }
}

pub trait Lerp {
    type Item;

    fn lerp(start: &Self::Item, target: &Self::Item, interpolation_ratio: f32) -> Self::Item;
}

impl Lerp for u8 {
    type Item = u8;

    fn lerp(start: &Self::Item, target: &Self::Item, interpolation_ratio: f32) -> Self::Item {
        // Implementation inspired by https://docs.unity3d.com/ScriptReference/Vector3.Lerp.html
        // Using the formula: a + (b - a) * t
        let a = *start as f32;
        let b = *target as f32;
        let t = interpolation_ratio.clamp(0.0, 1.0);

        (a + (b - a) * t).round() as u8
    }
}