geng 0.17.2

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

use geng::prelude::*;

const SHADER_SOURCE: &str = "
varying vec2 v_uv;

#ifdef VERTEX_SHADER
attribute vec2 a_pos;

uniform mat3 u_projection_matrix;
uniform mat3 u_view_matrix;
uniform mat3 u_model_matrix;
void main() {
    v_uv = a_pos;
    vec3 pos = u_projection_matrix * u_view_matrix * u_model_matrix * vec3(a_pos, 1.0);
    gl_Position = vec4(pos.xy, 0.0, pos.z);
}
#endif

#ifdef FRAGMENT_SHADER
uniform sampler2D u_texture;
uniform vec4 u_color;
uniform vec4 u_border_color;
uniform float u_outline_distance;

float aa(float x) {
    float w = length(vec2(dFdx(x), dFdy(x)));
    return 1.0 - smoothstep(-w, w, x);
}

float read_sdf(sampler2D texture, vec2 uv) {
    return 1.0 - 2.0 * texture2D(texture, uv).x;
}

void main() {
    float dist = read_sdf(u_texture, v_uv);
    float inside = aa(dist);
    float inside_border = aa(dist - u_outline_distance);
    vec4 outside_color = vec4(u_border_color.xyz, 0.0);
    gl_FragColor = u_color * inside +
        (1.0 - inside) * (
            u_border_color * inside_border +
            outside_color * (1.0 - inside_border)
        );
}
#endif
";

struct State {
    geng: Geng,
    program: ugli::Program,
    texture: ugli::Texture,
    font: geng::Font,
}

impl State {
    fn new(geng: &Geng) -> Self {
        let font = geng::Font::new(
            geng.ugli(),
            include_bytes!("../crates/geng-font/src/default.ttf"),
            &geng::font::Options {
                pixel_size: 64.0,
                max_distance: 0.25,
                antialias: true,
                ..default()
            },
        )
        .unwrap();

        Self {
            geng: geng.clone(),
            program: geng.shader_lib().compile(SHADER_SOURCE).unwrap(),
            texture: font
                .create_text_sdf("Hello, Crabs", geng::TextAlign::CENTER, 64.0)
                .unwrap(),
            font,
        }
    }
}

impl geng::State for State {
    fn draw(&mut self, framebuffer: &mut ugli::Framebuffer) {
        ugli::clear(framebuffer, Some(Rgba::BLACK), None, None);
        let size = vec2(self.texture.size().map(|x| x as f32).aspect(), 1.0);
        ugli::draw(
            framebuffer,
            &self.program,
            ugli::DrawMode::TriangleFan,
            &ugli::VertexBuffer::new_dynamic(
                self.geng.ugli(),
                vec![
                    draw2d::Vertex {
                        a_pos: vec2(0.0, 0.0),
                    },
                    draw2d::Vertex {
                        a_pos: vec2(1.0, 0.0),
                    },
                    draw2d::Vertex {
                        a_pos: vec2(1.0, 1.0),
                    },
                    draw2d::Vertex {
                        a_pos: vec2(0.0, 1.0),
                    },
                ],
            ),
            (
                ugli::uniforms! {
                    u_model_matrix: mat3::scale(size),
                    u_texture: &self.texture,
                    u_color: Rgba::WHITE,
                    u_border_color: Rgba::GRAY,
                    u_outline_distance: self.font.max_distance() / 2.0,
                },
                geng::Camera2d {
                    center: size / 2.0,
                    rotation: Angle::ZERO,
                    fov: 3.0,
                }
                .uniforms(framebuffer.size().map(|x| x as f32)),
            ),
            ugli::DrawParameters {
                blend_mode: Some(ugli::BlendMode::straight_alpha()),
                ..default()
            },
        );
    }
}

fn main() {
    logger::init();
    geng::setup_panic_handler();
    Geng::run("Font", |geng| async move {
        geng.run_state(State::new(&geng)).await;
    });
}