coffee 0.4.0

An opinionated 2D game engine focused on simplicity, explicitness, and type-safety
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

use gfx_device_gl as gl;
use gfx_glyph::GlyphCruncher;

use crate::graphics::gpu::{TargetView, Transformation};
use crate::graphics::{HorizontalAlignment, Text, Vector, VerticalAlignment};

pub struct Font {
    glyphs: gfx_glyph::GlyphBrush<'static, gl::Resources, gl::Factory>,
}

impl Font {
    pub fn from_bytes(factory: &mut gl::Factory, bytes: &'static [u8]) -> Font {
        Font {
            glyphs: gfx_glyph::GlyphBrushBuilder::using_font_bytes(bytes)
                .depth_test(gfx::preset::depth::PASS_TEST)
                .texture_filter_method(gfx::texture::FilterMethod::Scale)
                .build(factory.clone()),
        }
    }

    pub fn add(&mut self, text: Text<'_>) {
        let section: gfx_glyph::Section<'_> = text.into();
        self.glyphs.queue(section);
    }

    pub fn measure(&mut self, text: Text<'_>) -> (f32, f32) {
        let section: gfx_glyph::Section<'_> = text.into();
        let bounds = self.glyphs.glyph_bounds(section);

        match bounds {
            Some(bounds) => (bounds.width(), bounds.height()),
            None => (0.0, 0.0),
        }
    }

    pub fn draw(
        &mut self,
        encoder: &mut gfx::Encoder<gl::Resources, gl::CommandBuffer>,
        target: &TargetView,
        transformation: Transformation,
    ) {
        let typed_target: gfx::handle::RenderTargetView<
            gl::Resources,
            gfx::format::Srgba8,
        > = gfx::memory::Typed::new(target.clone());

        self.glyphs
            .use_queue()
            .transform(
                Transformation::nonuniform_scale(Vector::new(1.0, -1.0))
                    * transformation,
            )
            .draw(encoder, &typed_target)
            .expect("Font draw");
    }
}

impl<'a> From<Text<'a>> for gfx_glyph::Section<'a> {
    fn from(text: Text<'a>) -> gfx_glyph::Section<'a> {
        let x = match text.horizontal_alignment {
            HorizontalAlignment::Left => text.position.x,
            HorizontalAlignment::Center => {
                text.position.x + text.bounds.0 / 2.0
            }
            HorizontalAlignment::Right => text.position.x + text.bounds.0,
        };

        let y = match text.vertical_alignment {
            VerticalAlignment::Top => text.position.y,
            VerticalAlignment::Center => text.position.y + text.bounds.1 / 2.0,
            VerticalAlignment::Bottom => text.position.y + text.bounds.1,
        };

        gfx_glyph::Section {
            text: &text.content,
            screen_position: (x, y),
            scale: gfx_glyph::Scale {
                x: text.size,
                y: text.size,
            },
            color: text.color.into_linear(),
            bounds: text.bounds,
            layout: gfx_glyph::Layout::default()
                .h_align(text.horizontal_alignment.into())
                .v_align(text.vertical_alignment.into()),
            ..Default::default()
        }
    }
}

impl From<HorizontalAlignment> for gfx_glyph::HorizontalAlign {
    fn from(alignment: HorizontalAlignment) -> gfx_glyph::HorizontalAlign {
        match alignment {
            HorizontalAlignment::Left => gfx_glyph::HorizontalAlign::Left,
            HorizontalAlignment::Center => gfx_glyph::HorizontalAlign::Center,
            HorizontalAlignment::Right => gfx_glyph::HorizontalAlign::Right,
        }
    }
}

impl From<VerticalAlignment> for gfx_glyph::VerticalAlign {
    fn from(alignment: VerticalAlignment) -> gfx_glyph::VerticalAlign {
        match alignment {
            VerticalAlignment::Top => gfx_glyph::VerticalAlign::Top,
            VerticalAlignment::Center => gfx_glyph::VerticalAlign::Center,
            VerticalAlignment::Bottom => gfx_glyph::VerticalAlign::Bottom,
        }
    }
}