emerald 0.3.214

A lite, fully featured 2D 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
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
131
132
133
134
135
136
137
138

use fontdue::layout::{HorizontalAlign, VerticalAlign};
use hecs::Entity;
use rapier2d::na::Vector2;
use serde::{Deserialize, Serialize};

use crate::{rendering::components::Label, AssetLoader, EmeraldError, World};

use super::Vec2f32Schema;

#[derive(Deserialize, Serialize)]
pub(crate) struct EntLabelSchema {
    pub font: Option<String>,
    pub font_size: Option<u32>,

    /// A path to the font resource file
    pub resource: Option<String>,

    #[serde(default)]
    pub z_index: f32,
    pub size: u16,
    pub text: Option<String>,
    pub offset: Option<Vec2f32Schema>,
    /// options: "bottom", "middle", "top"
    pub vertical_align: Option<String>,

    /// options: "center", "left", "right"
    pub horizontal_align: Option<String>,
}

#[derive(Deserialize, Serialize)]
pub struct FontResource {
    /// The path to the font
    pub font: String,

    /// The size of the font
    pub size: u32,
}

pub(crate) fn load_ent_label<'a>(
    loader: &mut AssetLoader<'a>,
    entity: Entity,
    world: &mut World,
    toml: &toml::Value,
) -> Result<(), EmeraldError> {
    if !toml.is_table() {
        return Err(EmeraldError::new(
            "Cannot load label from a non-table toml value.",
        ));
    }

    let schema: EntLabelSchema = toml::from_str(&toml.to_string())?;

    if (schema.font.is_none() || schema.font_size.is_none()) && schema.resource.is_none() {
        return Err(EmeraldError::new(format!("Failure loading entity {:?}: Labels require either a resource OR a (font AND font_size).", entity)));
    }

    let mut font = None;

    if let (Some(font_path), Some(font_size)) = (schema.font, schema.font_size) {
        font = Some(loader.font(font_path, font_size)?);
    } else if let Some(resource_file) = schema.resource {
        let resource_data = loader.string(resource_file)?;
        let resource: FontResource = toml::from_str(&resource_data)?;
        font = Some(loader.font(resource.font, resource.size)?);
    }

    if font.is_none() {
        return Err(EmeraldError::new(format!("Failure loading entity {:?}: Labels require either a resource OR a (font AND font_size).", entity)));
    }

    let font = font.unwrap();
    let text = schema.text.unwrap_or("".into());
    let mut label = Label::new(text, font, schema.size);
    label.z_index = schema.z_index;

    if let Some(offset) = schema.offset {
        label.offset = Vector2::new(offset.x, offset.y);
    }

    if let Some(vertical_align) = schema.vertical_align {
        match vertical_align.as_str() {
            "bottom" => {
                label.vertical_align = VerticalAlign::Bottom;
            }
            "middle" => {
                label.vertical_align = VerticalAlign::Middle;
            }
            "top" => {
                label.vertical_align = VerticalAlign::Top;
            }
            _ => {
                return Err(EmeraldError::new(format!(
                    "{:?} is not a valid vertical align value",
                    vertical_align
                )))
            }
        }
    }

    if let Some(horizontal_align) = schema.horizontal_align {
        match horizontal_align.as_str() {
            "center" => {
                label.horizontal_align = HorizontalAlign::Center;
            }
            "left" => {
                label.horizontal_align = HorizontalAlign::Left;
            }
            "right" => {
                label.horizontal_align = HorizontalAlign::Right;
            }
            _ => {
                return Err(EmeraldError::new(format!(
                    "{:?} is not a valid horizontal align value",
                    horizontal_align
                )))
            }
        }
    }

    world.insert_one(entity, label)?;

    Ok(())
}

#[cfg(test)]
mod tests {
    use super::FontResource;

    #[test]
    fn validate_font_resource() {
        let example_resource = r#"
            font = "Roboto-Light.ttf"
            size = 48
        "#;

        toml::from_str::<FontResource>(example_resource).unwrap();
    }
}