tge 0.0.4

A lightweight cross-platform 2D game framework written in pure Rust and based on OpenGL 3.3+.
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

use super::Color;
use crate::math::Position;

#[derive(Debug, Copy, Clone, Hash, Eq, PartialEq)]
pub enum TextLayoutGravity {
    Start,
    Center,
    End,
}

impl Default for TextLayoutGravity {
    fn default() -> Self {
        Self::Start
    }
}

#[derive(Debug, Default, Clone, PartialEq)]
pub struct TextDrawParams {
    pub text_size: Option<f32>,
    pub char_spacing: Option<f32>,
    pub line_height: Option<f32>,
    pub line_spacing: Option<f32>,
    pub wrap_width: Option<f32>,
    pub wrap_height: Option<f32>,
    pub horizontal_gravity: Option<TextLayoutGravity>,
    pub vertical_gravity: Option<TextLayoutGravity>,
    pub origin: Option<Position>,
    pub color: Option<Color>,
}

impl TextDrawParams {
    pub fn text_size(mut self, size: f32) -> Self {
        self.text_size = Some(size);
        self
    }

    pub fn char_spacing(mut self, spacing: f32) -> Self {
        self.char_spacing = Some(spacing);
        self
    }

    pub fn line_height(mut self, height: f32) -> Self {
        self.line_height = Some(height);
        self
    }

    pub fn line_spacing(mut self, spacing: f32) -> Self {
        self.line_spacing = Some(spacing);
        self
    }

    pub fn wrap_width(mut self, width: f32) -> Self {
        self.wrap_width = Some(width);
        self
    }

    pub fn wrap_height(mut self, height: f32) -> Self {
        self.wrap_height = Some(height);
        self
    }

    pub fn horizontal_gravity(mut self, gravity: TextLayoutGravity) -> Self {
        self.horizontal_gravity = Some(gravity);
        self
    }

    pub fn vertical_gravity(mut self, gravity: TextLayoutGravity) -> Self {
        self.vertical_gravity = Some(gravity);
        self
    }

    pub fn origin(mut self, origin: impl Into<Position>) -> Self {
        self.origin = Some(origin.into());
        self
    }

    pub fn color(mut self, color: impl Into<Color>) -> Self {
        self.color = Some(color.into());
        self
    }
}