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

use emerald::{
    render_settings::RenderSettings,
    rendering::components::{ColorRect, Sprite},
    texture::TextureKey,
    *,
};

const RES_WIDTH: usize = 320;
const RES_HEIGHT: usize = 160;

pub fn main() {
    let mut settings = GameSettings::default();
    let render_settings = RenderSettings {
        resolution: (320 * 2, 160 * 2),
        ..Default::default()
    };
    settings.render_settings = render_settings;

    emerald::start(
        Box::new(MyGame {
            pos: Transform::default(),
            scale: 1.0,
            render_texture: None,
        }),
        settings,
    )
}

pub struct MyGame {
    pos: Transform,
    scale: f32,
    render_texture: Option<TextureKey>,
}
impl Game for MyGame {
    fn initialize(&mut self, mut emd: Emerald) {
        emd.set_asset_folder_root(String::from("./examples/assets/"));

        self.render_texture = Some(
            emd.loader()
                .render_texture(RES_WIDTH as usize, RES_HEIGHT as usize)
                .unwrap(),
        );
    }

    fn update(&mut self, mut emd: Emerald) {
        let delta = emd.delta();
        let speed = 150.0;
        let mut input = emd.input();

        if input.is_key_pressed(KeyCode::Left) {
            self.pos.translation.x -= speed * delta;
        }

        if input.is_key_pressed(KeyCode::Right) {
            self.pos.translation.x += speed * delta;
        }

        if input.is_key_pressed(KeyCode::Up) {
            self.pos.translation.y += speed * delta;
        }

        if input.is_key_pressed(KeyCode::Down) {
            self.pos.translation.y -= speed * delta;
        }

        if input.is_key_just_pressed(KeyCode::A) {
            self.scale *= 0.5;
        }

        if input.is_key_just_pressed(KeyCode::S) {
            self.scale *= 2.0;
        }
    }

    fn draw(&mut self, mut emd: Emerald) {
        emd.graphics()
            .begin_texture(&self.render_texture.as_ref().unwrap())
            .unwrap();

        let rabbit = emd.loader().sprite("bunny.png").unwrap();
        emd.graphics()
            .draw_color_rect(
                &ColorRect::new(WHITE, 500 * 500, 500 * 500),
                &Transform::default(),
            )
            .unwrap();
        emd.graphics()
            .draw_sprite(&rabbit, &Transform::default())
            .unwrap();

        emd.graphics().render_texture().unwrap();

        let mut screen_sprite = Sprite::from_texture(self.render_texture.as_ref().unwrap().clone());
        screen_sprite.centered = true;
        screen_sprite.scale.x = self.scale;
        screen_sprite.scale.y = self.scale;

        emd.graphics().begin().unwrap();
        emd.graphics()
            .draw_sprite(&screen_sprite, &self.pos)
            .unwrap();
        emd.graphics().render().unwrap();
    }
}