notation_bevy_utils 0.4.2

Fun notation - bevy utils
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
121
122
123
124
125
126
127
128
129
130

use bevy::prelude::*;
use std::fmt::Display;

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum LayoutHAnchor {
    Left,
    Center,
    Right,
}
impl Display for LayoutHAnchor {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{:?}", self)
    }
}
impl Default for LayoutHAnchor {
    fn default() -> Self {
        Self::Left
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum LayoutVAnchor {
    Top,
    Center,
    Bottom,
}
impl Display for LayoutVAnchor {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{:?}", self)
    }
}
impl Default for LayoutVAnchor {
    fn default() -> Self {
        Self::Top
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub struct LayoutAnchor {
    pub v: LayoutVAnchor,
    pub h: LayoutHAnchor,
}
impl Display for LayoutAnchor {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}{}", self.v, self.h)
    }
}
impl LayoutHAnchor {
    pub fn opposite(&self) -> Self {
        match self {
            Self::Left => Self::Right,
            Self::Center => Self::Center,
            Self::Right => Self::Left,
        }
    }
    pub fn factor(&self) -> f32 {
        match self {
            Self::Center => 0.0,
            Self::Left => -0.5,
            Self::Right => 0.5,
        }
    }
}
impl LayoutVAnchor {
    pub fn opposite(&self) -> Self {
        match self {
            Self::Top => Self::Bottom,
            Self::Center => Self::Center,
            Self::Bottom => Self::Top,
        }
    }
    pub fn factor(&self) -> f32 {
        match self {
            Self::Center => 0.0,
            Self::Top => 0.5,
            Self::Bottom => -0.5,
        }
    }
}
impl LayoutAnchor {
    pub fn new(v: LayoutVAnchor, h: LayoutHAnchor) -> Self {
        Self { h, v }
    }
    pub fn opposite(&self) -> Self {
        Self::new(self.v.opposite(), self.h.opposite())
    }
    pub fn factor(&self) -> Vec2 {
        Vec2::new(self.h.factor(), self.v.factor())
    }
    pub const ROOT: Self = Self {
        v: LayoutVAnchor::Center,
        h: LayoutHAnchor::Center,
    };
    pub const CENTER: Self = Self {
        v: LayoutVAnchor::Center,
        h: LayoutHAnchor::Center,
    };
    pub const LEFT: Self = Self {
        v: LayoutVAnchor::Center,
        h: LayoutHAnchor::Left,
    };
    pub const RIGHT: Self = Self {
        v: LayoutVAnchor::Center,
        h: LayoutHAnchor::Right,
    };
    pub const TOP: Self = Self {
        v: LayoutVAnchor::Top,
        h: LayoutHAnchor::Center,
    };
    pub const TOP_LEFT: Self = Self {
        v: LayoutVAnchor::Top,
        h: LayoutHAnchor::Left,
    };
    pub const TOP_RIGHT: Self = Self {
        v: LayoutVAnchor::Top,
        h: LayoutHAnchor::Right,
    };
    pub const BOTTOM: Self = Self {
        v: LayoutVAnchor::Bottom,
        h: LayoutHAnchor::Center,
    };
    pub const BOTTOM_LEFT: Self = Self {
        v: LayoutVAnchor::Bottom,
        h: LayoutHAnchor::Left,
    };
    pub const BOTTOM_RIGHT: Self = Self {
        v: LayoutVAnchor::Bottom,
        h: LayoutHAnchor::Right,
    };
}