nightshade 0.8.0

A cross-platform data-oriented 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
105

use super::{TextMesh, TextProperties};
use nalgebra_glm::Vec2;

#[derive(Clone, Copy, Debug, PartialEq, Default, serde::Serialize, serde::Deserialize)]
pub enum HudAnchor {
    TopLeft,
    TopCenter,
    TopRight,
    CenterLeft,
    #[default]
    Center,
    CenterRight,
    BottomLeft,
    BottomCenter,
    BottomRight,
}

#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
pub struct HudText {
    pub text_index: usize,
    pub properties: TextProperties,
    pub font_index: usize,
    pub position: Vec2,
    pub anchor: HudAnchor,
    pub dirty: bool,
    #[serde(skip)]
    pub cached_mesh: Option<TextMesh>,
}

impl Default for HudText {
    fn default() -> Self {
        Self {
            text_index: 0,
            properties: TextProperties::default(),
            font_index: 0,
            position: Vec2::zeros(),
            anchor: HudAnchor::default(),
            dirty: true,
            cached_mesh: None,
        }
    }
}

impl HudText {
    pub fn new(text_index: usize) -> Self {
        Self {
            text_index,
            properties: TextProperties::default(),
            font_index: 0,
            position: Vec2::zeros(),
            anchor: HudAnchor::default(),
            dirty: true,
            cached_mesh: None,
        }
    }

    pub fn with_properties(mut self, properties: TextProperties) -> Self {
        self.properties = properties;
        self.dirty = true;
        self
    }

    pub fn with_font(mut self, font_index: usize) -> Self {
        self.font_index = font_index;
        self.dirty = true;
        self
    }

    pub fn with_position(mut self, position: Vec2) -> Self {
        self.position = position;
        self
    }

    pub fn with_anchor(mut self, anchor: HudAnchor) -> Self {
        self.anchor = anchor;
        self
    }

    pub fn set_text_index(&mut self, text_index: usize) {
        self.text_index = text_index;
        self.dirty = true;
    }

    pub fn set_position(&mut self, position: Vec2) {
        self.position = position;
    }

    pub fn set_anchor(&mut self, anchor: HudAnchor) {
        self.anchor = anchor;
    }

    pub fn set_font_index(&mut self, font_index: usize) {
        self.font_index = font_index;
        self.dirty = true;
    }

    pub fn set_properties(&mut self, properties: TextProperties) {
        self.properties = properties;
        self.dirty = true;
    }

    pub fn get_bounds(&self) -> Option<Vec2> {
        self.cached_mesh.as_ref().map(|mesh| mesh.bounds)
    }
}